So, ich hatte letztes, letztes Wochenende, letzte Woche im Prinzip aufgehört,
bei der Vorstellung, wie jetzt negative Zahlen dargestellt werden.
Dazu kamen ja dann auch teilweise schon die ersten Übungsaufgaben im Rahmen der letzten Übung,
kamen dann also auch noch Fragen,
wie das dann jetzt eigentlich mit dieser Subtraktion durch Addition des Kompliments funktioniert,
weil ich hatte ja hier im Prinzip dann also hier relativ schnell war das nun irgendwie die letzten drei Folien waren.
Also im Prinzip, wenn diese Folien vorgestellt, wo das dann also darum geht,
wie jetzt im Prinzip das eine Kompliment beziehungsweise das Zweier-Kompliment funktioniert.
Dazu werde ich dann deswegen jetzt hier nur der Hinweis,
im nächsten Kapitel, wo es im Prinzip jetzt um die Arithmetik und die Funktion,
die man jetzt zum Rechnen braucht, geht,
nochmal ein bisschen genauer was vorstellen und da wird das, denke ich mal,
dann also nochmal relativ ausführlich und hoffentlich dann eben auch so,
dass dass sie das dann alle verstehen, entsprechend genauer vorgestellt.
Es gab ja dann also auch noch diese Folie mit der Veranschaulichung mit Zahlenkreisen.
Hier jetzt als Beispiel für 4B-Zahlen. Dies hatte ich jetzt auch nochmal ein bisschen überarbeitet,
beziehungsweise das wird dann eben in diesem Kapitel zur Arenthmetik dann eben auch nochmal entsprechend genauer vorgestellt,
wo es dann eben letztendlich darum geht,
dass man quasi diese Erklärung, warum Die Addition des Kompliments,
dann eben eine Subtraktion darstellt, sehr anschaulich dadurch eigentlich sich machen kann,
dass man das quasi jetzt immer in diesem Zahlenkreis,
also jetzt für ein Beispiel mit vier Bit-Zahlen,
sich veranschaulichen kann und das Ganze dann quasi über so eine Art Finkeladition dargestellt bekommt.
Gut, womit ich jetzt quasi neu erst mal weitermachen werde,
ist dann das Thema Gleitkomma-Darstellung, wo es dann letztendlich darum geht,
also wie man Große, beziehungsweise sehr kleine,
ich sag mal, wissenschaftliche Zahlen darstellen kann.
Also wenn man jetzt zum Beispiel sowas nimmt wie jetzt,
also irgendwie die Sonnenmasse,
was dann also 1,989 mal 10 oder 30 Kilogramm sein sollen oder die Masse eines Elektrons,
die Anzahl der Atome pro Mol,
wo ich also hier dann mal wirklich als Festkommazahl auch ausgeschrieben,
dann sieht man,
dass das so natürlich erstmal
vergleichsweise schlecht hanterbar ist
Nee, und wenn man sich jetzt überlegt, okay,
wie kriege ich das Ganze jetzt wirklich mal vernünftig umgesetzt.
Und ich arbeite jetzt also mit einem ganz normalen Stellenwertsystem,
also sprich mit einer Festkommadarstellung, wo dann jetzt eben,
wie man jetzt an diesem Beispiel sieht,
dann also gleichzeitig sowohl sehr kleiner als auch sehr große Zahlen notwendig sind.
Dann geht das entweder nur,
indem man also wirklich eine sehr hohe Zahl von Stellen vorsieht,
sowohl für Vorkomma als auch von Nachkommastellen.
Ist zwar theoretisch möglich,
also beispielsweise benutzt Java das,
also in der Java
Umgebung beziehungsweise Klassenbibliothek dann also für Koordinaten,
wo es dann also wirklich Festkommazahlen mit 256 Pits sind,
ist aber natürlich vergleichsweise sehr unpraktisch und sehr wenig handhabbar.
Hinzu kommt dann eben auch noch dieser Punkt,
der jetzt hier als letzter aufgezählt ist, wenn man sich jetzt eben wirklich ansieht,
wo kommen diese Zahlen her und beispielsweise jetzt, also zum Beispiel ein Thema,
was uns jetzt in unserem Bearbeitsbereich immer irgendwie ganz direkt betrifft.
Also Thema Robotik, wo man jetzt also irgendwelche Sensoren hat,
also Kamerasysteme, irgendwelche Abstandsmesssysteme, was auch immer. Dann kann man sagen,
okay, also wenn das jetzt also nicht irgendwelche mathematischen Umformungen sind,
sondern jetzt wirklich erst mal Sensorseitig irgendwelche Quellen,
wo ich jetzt also irgendwelche Messwerte aufnehme,
dann kann man eben sagen, dass diese Messwerte typischerweise,
also auch wenn sie jetzt mit irgendwelchen Zahlen mit 256 Stellen Genauigkeit dargestellt werden,
natürlich Einfach von der Aufnahmeseite her gar nicht diese Genauigkeit haben.
Nicht, dass sich das deswegen dann eben gar nicht lohnt, da solche vergleichsweise unpraktischen Zahlenformate zu benutzen.
Deswegen nimmt man für Gleitkommazahlen, dann sogenannte Halbbluger Rhythmische Darstellung,
die man dann in der Regel so oft teilt,
wie das dann also hier auch angedeutet ist, mich,
dass ich also getrennt ein Vorzeichen habe,
also plus oder minus eins, dann die Martiste,
also sprich jetzt irgendwie eine Zahl mit irgendwann komm mal irgendwo innen drin,
die jetzt ganz normal eine Zahl im Sinne Stellenwertsystem entspricht.
Und zusätzlich dann eben noch als Multiplikationsfaktor dann Basis hoch eines Exponenten habe,
wo ich das Ganze dann eben entsprechend jetzt in der Wertigkeit
dann noch entsprechend größer oder kleiner skalieren kann.
Dadurch erreicht man es,
dass man dann eben mit vergleichsweise wenigen Bits dann eben einen
sehr großen Wertebereich abbilden kann mit entsprechend handhabbaren Wertebereichen für Mantis
und Exponent und eben jetzt wieder zurück zu diesem Beispiel irgendwelchen Sensordaten.
Hier dann aber durch die stellende Mantesse dann immer noch mit einer,
ich sag mal, hinreichenden Genauigkeit arbeiten kann.
Theoretisch wäre es auch möglich, eine rein logarithmische Darstellung zu wählen,
wo ich jetzt also nur Basis hoch an Exponent wähle.
Wenn man sowas machen würde, habe ich dann aber das Problem,
dass Addition und so Fraktion als Operatoren,
also auf solchen Zahlensystemen, liebe ich,
schwierig umzusetzen sind und in der Regel eigentlich nur funktionieren,
wenn ich das jetzt erst mal wieder in ein Stellenwertsystem zurückrechne.
Gut, wie sieht jetzt so eine Gleitkomma-Darstellung im Dezimalsystem aus? Das ist das,
was wir eigentlich aus unserer täglichen Mathematik ja kennen,
wo ich jetzt eben sage, ich habe eigentlich ein Vorzeichenwert,
nämlich entweder ein Minusvorzeichen oder gar nichts,
habe dann eben eine Mathesa als Festkommandezimalzahl und dann eben Exponent
dann eben mal zehn hoch irgendeiner Ganzzahl
Nicht in den typischen Programmiersprachen,
also hier ist mal als Beispiel in See oder in Java,
wird das dann eben geschrieben, als Vorzeichen, Mathese,
dann abgetrennt durch den E für den Exponenten und dann eben die Zahl für den Exponenten.
Und wenn ich das jetzt also hier für diese beiden Beispiele mache,
die ich also vor zwei Folien gerade auflegen hatte,
nämlich also die Avogadro-Zahl, also die Anteilszahl der Atome pro Mool,
beziehungsweise die elementare Ladung eines Elektrons,
kann ich das dann eben entsprechend in dieser Schreibweise,
also 6,023 Mal oder dann eh 23, entsprechend dann direkt schreiben.
Nee, und damit kann man dann eben sehr einfach wohl große,
positive, also eben sehr kleine Zahlen entsprechend darstellen.
So, wenn man sich jetzt mal überlegt,
wie das mit den Zahlenbereichen aussieht, also sprich,
wie wähle ich jetzt Mantiste und Exponent passend aus.
Also hier jetzt eine Auflistung, die also aus dem Buch von Tarnbaum jetzt ist,
wo einfach mal aufgezeigt ist, wie das Ganze jetzt aussieht für
Die Anzahl der Stellen, jetzt für die Martesse bzw. für
die Anzahl der Stellen im Exponenten und was sich dann eben als kleinsten Wert bzw. als größten Wert darstellen kann. Wie gesagt,
das jetzt hier als Beispiel für dezimal dargestellte,
also sprich Zahlenbasis 10, Zahlen,
wo man dann eben sehen kann, also durch entsprechende Auswahlen,
also hier sieht man das sehr schön,
mit der Mantiste bleibe ich jetzt hier,
also meinetwegen bei drei Stellen,
also sprich von 0 bis 9099 und von Exponenten habe ich jetzt eben hier entweder eine,
zwei, drei oder vier Stellen und dem zuvor gehöre ich dann also hier entsprechend dann sehr schön.
Entsprechend kleine, beziehungsweise große Zahlen darstellen.
Wenn man sich jetzt die Historie ansieht,
wie jetzt generell die Entwicklung von solchen Fließkommerzahn verlaufen ist,
jetzt also bei Rechnern, beziehungsweise bei Computersystemen.
Also die ersten Fließkommadaten-Formate hatte also auch schon Konrad Zuse mit seinem noch mechanischen Rechner,
wo es also dann im Prinzip 22 Bit Glyde-Kommadaten-Format gab.
Nicht in den 50er Jahren,
wo die Berechnung ja auch immer noch eher an
speziellen Problemorientiert war
Weniger jetzt also universell einsetzbare Computer waren,
gab es dann eben auch schon für humerische Berechnungen entsprechende Fließkummer-Darstellungen.
Nicht dann bei der Umsetzung jetzt durch entsprechende Hardware,
1980, hat Intel also parallel zum 8086,
also quasi den ersten Co-Prozessorship eingeführt,
wo also durch entsprechende Hardware-Rechenwerke dann eben Fließkummer zahlen
Auch schon entsprechend unterstützt werden konnten. Vorher,
beziehungsweise wenn man jetzt so einen Co-Prozessor nicht hatte,
war es dann eben nur möglich,
die Fließkomma-Berechnung auf der ganz normalen Festkomma-CPU zu machen,
wobei dann eben letztendlich die Umrechnung der Zahlen beziehungsweise das,
was dann an arathmetischen Operationen notwendig war,
um jetzt mit Fließkomma-Zahlen zu rechnen,
dann eben über quasi Unterprogramme oder Makros
dann eben auf ganze Befehlsfolgen auf der normalen Festkomma-Rechnernheit
dann umgesetzt wurde
So, bis Mitte der 80er Jahre war es dann aber immer so,
dass eigentlich die ganzen Fließkomma-Formate noch überhaupt nicht standardisiert waren.
Das heißt also letztendlich hatte da dann auch jeder Hersteller beziehungsweise jeder Hersteller jetzt von irgendwelchen Computersystemen sehr unterschiedliche Formate,
was dann eben auch dazu führte,
dass eben auch irgendwelche Rechenvorschriften oder Algorithmen auch überhaupt nicht kompatibel oder austauschbar waren,
weil eben diese ganzen Fließkomma-Formate Rundungsvorschriften und alles,
was da dann letztendlich dranhängt,
dann eben auf ihnem Rechner eigentlich anders abgearbeitet werden.
Dann eben 1905, wo dann also dies i754-Format standardisiert,
also dieses Eye-Tribuli ist dann eben quasi sowas wie ein Normungsgremium,
also das,
was in Deutschland immer irgendwie so die Norm,
nicht deutsche Industrienorm ist
Was in diesem Fall jetzt also in Nordamerika dann federführend sowas durchsetzt. Und da,
wo dann eben ein quasi Fließkomma-Standard festgelegt und der ist inzwischen eigentlich auch der de facto Standard,
der jetzt also von allen Rechnersystemen und von allen Hardware-Systemen dann auch unterstützt wird.
Nicht teilweise ist das Ganze dann eben auch so weit gedient,
dass es eben auch in die Spezifikation von Programmiersprachen,
also beispielsweise von Java eben mit reingegangen ist, Und gut,
ansonsten, also hier diese unteren beiden Zahlen zur Historie,
da sieht man also jetzt auch nochmal so die Entwicklung.
Ich hatte ja, also als ich das,
den Abschnitt zu Moore's Law vorgestellt hatte,
das ja immer als Referenz genommen für die Rechenleistung von Supercomputern,
wird deswegen ja eben immer gerne gemacht, weil das,
wofür solche Systeme eingesetzt werden,
also sprich irgendwelche Vorhersagemodelle für Klima, für was weiß ich,
irgendwelche Crash-Tests, Strömungsmodelle von Schiffen oder von Flugzeugen,
wenn man sowas durchrechnet.
Das sind eben alles letztendlich letztendlich mathematische Gleichungssysteme, die alle
auf Fließkomma-Berechnung arbeiten. Und deswegen sind eigentlich diese Supercomputer,
mit denen man, also sowas, als Problemstellung angeht,
dann eigentlich auch immer auf Fließkomma-Performance quasi gezüchtet.
Und wenn man sich da jetzt, also mal die Leistung ansieht,
nicht, also quasi der erste Co-Prozesse,
wo Fließkomma-Berechnung in Hardware gemacht wurde, nicht, wo man sagt,
okay, also da erreiche ich also 50.000 Fließkomba-Operationen pro Sekunde.
Nicht, da war es dann eben so,
dass man also mit den 90er Jahre dann quasi die Marke von einem Terraflop,
also 10 auf 12, geknackt hat.
Nicht dann zwölf Jahre später, dann also wieder nochmal tausendmal schneller war.
Und inzwischen, also jetzt also im Prinzip hi,
aktuell dann etwas über 18 Peterflop letztendlich liegt
So, wenn man sich jetzt ansieht, wie können die
Zahlen mit Fließkomma zahlen oder mit diesem Fließkomma-Format dargestellt werden.
Da kann man im Prinzip sieben Zahlenbereiche unterscheiden.
Wenn ich jetzt also quasi ein Format nehme,
was Konformes zu diesem Standardformat, also sprich irgendwie Vorzeichen,
getrennt und dann eben den Betrag dargestellt als Matise
und dann Basis hoher Exponent
Dann sieht man natürlich, dass also aufgrund
dieser Betrag plus Vorzeichendarstellung generell erstmal der Zahlenbereich symmetrisch ist.
Das heißt, von null, sowohl in den Positiven als
auch in den negativen Bereich habe ich identische Darstellungen.
Dann werden quasi auf so einer Darstellung jetzt mit so einem Zahlenstrahl folgende Bereiche unterschieden.
Wenn ich jetzt also kleiner bin als jetzt die größte darstellbare Zahl,
habe ich dann eben einen negativen Überlauf.
Dann gibt es Dann also hier einen ganzen Bereich gültiger Zahlen,
die ich jetzt also als negative Zahlen darstellen kann.
Dann bei sehr kleinzahen,
also wenn man sich jetzt also hier für dieses Beispiel wahrnimmt,
also alles, was jetzt kleiner als minus 10 hoch, minus 100 ist.
Und von daher an bis zur Null gibt es dann etwas,
was dann im Englischen, also negativ, Underflow,
also negativer Unterlauf bezeichnet wird,
wo die Zahlen quasi so klein sind,
dass sie also mit diesem Format
nicht mehr dargestellt werden können
Nicht dann kennen explizit halt wieder die Null dargestellt werden und
in die positive Richtung gibt es dann eben im Prinzip genau das gleiche Verhalten.
Sehr kleine Zahlen, die nicht dargestellt werden können. Dann die,
die ihn hoffentlich groß im Bereich der Darstellwaren zahlen,
mit denen man dann rechnet und dann eben auch wieder ein Überlaufbereich,
wo die Zahlen an ihm so groß werden,
dass sie also mit einer festen Wortbreite bzw. mit diesen Formaten
dann eben nicht mehr dargestellt werden können
So war es jetzt,
Fließkomma-Zahlen generell, also aufgrund dieses Aufbaus natürlich erstmal auszeichnet,
was also hier mit diesen Punkten oder diesen Punktdichten letztendlich markiert ist,
ist, dass der relative Abstand benachbarter Zahn ähnlich bleibt.
Was ist damit gemeint? Wenn ich mir jetzt Integer-Zahn ansehe,
und ich zähle jetzt also rauf, 0-1,
2-3 und so weiter. Nicht,
dann habe ich quasi zwischen zwei benachbarten Zahlen immer als Differenz 1. Unabhängig davon,
ob es sich um kleine Zahlen handelt oder ob es sich um sehr große Zahlen handelt. Wenn ich Fließkomma-Darstellung habe,
wo ich ja quasi die Größe der Zahlen jetzt über den Exponenten skaliere,
führt das dazu, dass eben im Kleinzahlenbereich,
nämlich wenn sich die Matise jetzt um einen unterscheidet,
ich dann eben einen entsprechend kleinen Abstand habe,
während ich jetzt bei sehr großen Zahlen,
wo ich dann also beispielsweise jetzt hier im Bereich von 10 hoch 98 bin,
ich dann eben gar nicht mehr alle Zahlen darstellen kann,
sondern es da dann ja eben auch immer solche Lücken gibt nicht,
aber eben dieser relative Abstand dann eben in Bezug auf
die Zahl
ähnlich ist
Ein anderer wichtiger Begriff bei Gleitkomma-Darstellung ist dann immer noch der Begriff der normalisierten Darstellung.
Da geht es im Prinzip darum, dass man sagt,
wenn ich jetzt also so eine Zahl beispielsweise jetzt,
also als die zimalsazu darstelle, dann ist diese Darstellung erstmal nicht eindeutig.
Da kann ich sagen,
das ist beispielsweise jetzt für die Zahl 123,
123 mal 10 hoch 0 oder 12,3 mal 10 hoch 1
oder 1,2,3 mal 10 hoch 2,
beziehungsweise und so weiter und so
Deswegen gibt es da dann eben den Begriff der normalisierten Darstellung,
wo man jetzt eben sagt, der Exponent wird so angepasst,
bis die Mantise in einem bestimmten Wertebereich liegt und typischerweise ist
dieser Wertebereich jetzt eben genau zwischen 1 und der Basis.
Das heißt, ich habe genau eine einzige Vorkommastelle. Wenn ich das fordere,
Dann habe ich ihm immer eine eindeutige Darstellung. Und der Trick,
den man jetzt also auch noch bei diesen Fließkomma-Zahlen im Dualsystem anwendet,
ist das, wenn ich jetzt sage,
ich normalisiere die Zahlen und ich habe jetzt immer so eine normalisierte Darstellung,
dann weiß ich, weil im Dualsystem kann die Vorkommastelle,
wenn ich sie normalisiert habe,
nur eins heißen und nichts anderes.
Demzufolge kann ich eben auf diese eins in der Codierung der Zahl
auch schon komplett verzichten und lasse quasi jetzt bei der Angabe der Mantise,
die so Vorkommastelle weg und schreibe nur noch die Nachkommastellen.
Also eine Folge aus 0 und 1, weil ich automatisch weiß,
1, und das, was dann steht, folgt dann.
Dadurch gewinnt man quasi jetzt in dieser Codierung oder in dem,
was man da jetzt also an Bits für die Codierung aufwendet,
eben auch noch mal ein zusätzliches Bit.
Das einzige, was jetzt eben noch in den Fließkomma-Formaten beziehungsweise in diesem Eye-Triple i754-Format hinzukommt,
ist, dass man jetzt sagt, bei sehr kleinen Zahlen
Da gibt es dann eben noch einen Bereich,
der nicht normalisierten Zahlen, wo ich dann eben davon ausgehe,
diese erste Stelle muss dann auch mit explizit angegeben werden,
nicht aber damit erreiche ich dann,
dass ich dann auch noch kleinere Zahlen als jetzt 1,00 mal
und dann eben hier entsprechend hin kleinsten Exponenten angeben kann
Gut, wie sieht jetzt dieser Adrible E7154-Standard aus? Wie gesagt,
also bis 1985 gab es also sehr viele sehr unterschiedliche Fließkomma-Formate
mit unterschiedlichen Anzahlen in der Bits, sowohl für Mantise als auch für Exponent.
Die Exponenten wurden dann auch immer mit verschiedenen Basen dargestellt,
also je nachdem, also ob die es jetzt,
also irgendeine Kodierung war,
die jetzt also zum Beispiel aus dem Großrechnerbereich kam,
da war es also häufig noch üblich,
also auch zur Zahlenbasis 10
zu rechnen mit auch entsprechenden Zeichendarstellungen
Ich, dann gab es auch sehr unterschiedliche Algorithmen,
die letztendlich dann ja auch in die Hardware beziehungsweise in die Zahnformate einfließen,
wo es also um die Rundung geht.
Sprich, wie verhalte ich mich jetzt, wenn ich ihm
gerade jetzt an irgendwelchen Grenzen bin und irgendwelche Sachen nicht mehr darstellen kann?
Wann wird aufgerundet, wann wird abgerundet? Wie verfährt man da,
da war es also letztendlich eben so,
dass jeder Rechnerhersteller da seine eigene Variante verfolgt hat
Quintessenz und großer Nachteil. Alles, was nun also an
numerischen Algorithmen gemacht hat, war also überhaupt nicht portabel.
Heutzutage ist es eben glücklicherweise anders. Da kann man eben schon sagen,
es gibt also halt einen ganzen Satz von Standardverfahren und auch von Standard-Algorithmen,
die man eben heutzutage dann ja also auch in Softwarebibliotheken eben gießen kann.
Es muss nicht sein, dass also eben Bibliotheken oder DLLs
oder wie auch immer das Betriebssystem das Ganze da nennen mag,
wo dann eben Verfahren drin sind für jetzt bestimmte Aufgabenstellungen,
die dann eben spezifisch jetzt, also mit speziellen Zahlen,
Formaten arbeiten, beziehungsweise darf hingehend optimiert sind.
Und wenn ich dann eben wirklich mit einem Rechenalgorithmus arbeite,
kann ich eben davon ausgehen,
dass der jetzt eben auf einem, sagen wir mal,
Standard-PC mit Linux letztendlich genau das Gleiche liefert,
wie er es auf irgendeinem Großrechner mit AEX oder wie
also auf irgendeinem Apple mit MacOS
Gut, also mit dieser Publikation des Standards kam es dann
eben zur Vereinheitlichung in dem Standards sind dann eben auch
genau für diese Rundungsoperation entsprechende Regeln mit drin.
Und wie gesagt, inzwischen allgemein verbreitet.
Wenn sich da jemand also noch genauer schlau machen will,
deswegen dann immer hier die passenden Links. Also entweder in den Deutschen,
beziehungsweise hier jetzt Referenz auf die englische Wikipedia oder in der Quelle jetzt hier von Goldberg,
whatever computer scientist, should know about floating point.
Das schicke bei dem Ding ist, das ist quasi frei
verfügbar als PDF zum Runterladen. Das heißt also,
wenn sich da mal irgendwie noch vertiefen wollen,
beziehungsweise später vielleicht zwangsweise, weil man das eine Programmierung für irgendwas braucht,
da nochmal,
das wäre dann eben auch eine sehr interessante Referenz,
wo man da dann
eben nochmal nachsehen könnte
So. Gut, wir sehen jetzt diese standardisierten Formate aus.
Da gibt es im Prinzip zwei unterschiedliche Größen.
Einmal ein 32-Bit-Datenformat. Das nennt sich dann eben Float,
ist aufgeteilt quasi als ein Vorzeichenbett. Acht Bit für den
Exponenten und 23 Bild für die Mantiste und eben ein 64-Bit-Format
Mit doppelter Genauigkeit oder er dann eben Double benannt,
wo ich dann 52 Bitfree Montessse zur Verfügung habe und elf Bitfree einen Exponenten.
Und die Mantiste, also das,
was hier im Englischen dann eben Mafraction genannt ist,
ist dann eben beschrieben, in der Regel erstmals normalisierte Dualzahl,
das heißt eben eine Zahl größer gleich eins,
ein kleiner zwei,
wo dann eben genau diese eine Vorkommastelle
erstmal nicht mitgeschrieben wird
Exponent, wird dann in so einer Offset-basierten Darstellung,
also in so einer Exzess 127 beziehungsweise bei dem Double-Format-Exzess 1023 Codierung angegeben.
Das heißt, ich nehme ihm diesen Zahlenwert und ziehe da
von 127 ab. Das heißt,
beispielsweise jetzt bei Float wäre der kleinste darstellbare Exponent dann eben
quasi hier als Darstellung eine Null und dann null
10. Wäre dann eben 2 hoch minus 127. Wenn ich zusätzlich
gibt es dann eben noch bestimmte Sonderwerte. Zum einen,
um die Null zu kodieren, um irgendwelche Überlaufsituationen zu kodieren,
wobei jetzt da dann eben auch nur gesagt wird,
dass einer stattgefunden hat und wo dann also noch als zusätzliche Besonderheit es dann eben noch dieses NIN gibt,
not a number, womit im Prinzip für Fließkommerberechnung kodiert wird,
dass jetzt bei einer Berechnung irgendwas so grundsätzlich schief gegangen ist,
dass es also überhaupt nicht dargestellt werden kann.
Beispiele, wie das aussieht, beziehungsweise wofür man sowas dann
gleich braucht, folgen also auch gleich noch.
Ich denke mir, dann wird das Ganze dann auch noch
ein bisschen klarer. So, wie gesagt,
hier jetzt also die aktuellen Zahlenbereiche,
die jetzt mit den Fließkummer-Formaten dargestellt werden können für Float bzw. für Double,
wenn man sich das jetzt entsprechend nimmt und dann eben in das Dezimalsystem umrechnet.
Wie gesagt, hier einmal die Bittbreiten. Das war ja
also schon aus dem Folie vorher direkt an sichtbar.
Nicht der Exponent ist dann eben bei Float als Access.
127 kodiert. Er war Double Precession als Access 1021. Das,
was sie dann eben darstellen kann als Exponent,
ist dann im Prinzip von minus 1026 bis plus 127
bei Double dann eben die entsprechenden Wertebereiche
So, jetzt habe ich gerade eben bei der Erklärung vorher einen kleinen Fehler gemacht,
weil ich hatte da also zwei Hunden minus 127,
stimmt im Prinzip schon, kennzeichnet jetzt aber hier noch eine Besonderheit,
weil da gibt es eben noch diese Unterschiede zwischen normalisierten Darstellungen.
Das heißt, diese Darstellung,
wo ich immer 1 Komma, also die ist,
die 1 dann eben implizit mit drin habe und anschließend die Mantiste und das
wäre dann eben normalisierte Zahlen und Wenn ich als Exponenten null einsetze,
das heißt, 2 hoch minus 127, dann habe ich eine nicht-normalisierte Darstellung.
Und das heißt dann, in diesem Fall,
beziehungsweise dem Arthopo easy 754 Standard,
dass dann diese explizite 1 in der Mantesse eben nicht mehr vorhanden ist,
sondern dass die verbliebenen Bits in der Mantissen-Darstellung oder das höchstwertigste Bit in der Mantissen-Darstellung und dann eben diese eine Vorkommastelle ist.
Nicht damit kann man dann aber eben auch noch kleinere Zahlen darstellen,
was uns bei normalisierten Darstellungen nicht möglich wäre. Gut,
der Wertebereich, nicht wenn ich das jetzt also in Dezimalzahlen umsetze,
wäre dann eben im Prinzip jetzt bei so einer Normalschlot-Arithmetik ungefähr von 10 und minus 38 bis 10.38 Uhr.
Und wenn ich jetzt Double Precision ansetze, hätte ich dann eben hier einen entsprechend größeren Wert im Bereich zur Verfügung. So,
wenn man jetzt in seinen Algorithmen oder in seinen mathematischen Abläufen irgendwie noch größere oder noch kleinere Zahlen bräuchte,
was ja vielleicht auch irgendwann mal vorkommen kann,
dann muss man im Prinzip dann wirklich auf irgendwelche speziellen Bibliotheken zurückgreifen,
wo dann eben auch Zahlensysteme definiert sind,
wo ich dann eben entweder sowas wie Fließkomma-Darstellungen habe mit noch deutlich größeren Wertebereichen oder wo man also auch grundsätzlich andere Zahlen,
Darstellungen haben oder anwenden kann, beispielsweise jetzt über gebrochen rationale Zahlen oder ähnlich ist.
So, jetzt kommen hier eigentlich noch zwei Folien,
die beziehen sich jetzt eben auch auf etwas,
was ja so vor zwei Wochen schon mal kurz angesprochen hatte,
dass es also mal von dieser oder von dem Vorvorgänger jetzt,
also jeder Rechnerstruktur und Vorlesung damals konnte sich das dann also noch technische Informatik und war dann also auch noch über drei Semester aufgeteilt,
dass es da dann also nochmal sowas wie ein interaktives Skript gab,
was dann also auf Mattler basierte.
Und das ist dann also hier nochmal so ein Screenshot,
wo man dann eben sieht,
jetzt für so eine A-Triple E 754-Darstellung,
man konnte dann eben eine Zahl angeben und sah dann also direkt die entsprechenden Darstellungen,
nicht wo man das dann machen kann,
das Ganze ließ sich dann eben interaktiv entweder für normale Fließkommer oder eben für Double-Darstellungen durchführen.
Gut, im Prinzip, wenn sie Matlab zur Verfügung haben,
könnte man das also jetzt auch noch,
also die Referenz ist da ja mit angegeben, mit runterladen und ausprobieren.
Ansonsten auch ein Arzt Tipp war, sowas ist ja nun,
sag mal jetzt nicht grundsätzlich schwierig oder grundsätzlich neu. Nicht,
wenn man also mal eine Suchmaschine anwirft und dann also mal im Internet guckt,
finden sich eben solche Sachen wie Eitrib 754 um Rechner,
wo man dann eben zum Beispiel auch interaktiv
irgendwelche Werte eingeben kann
Und dann eben sieht, wie entsprechende Bitterstellungen in dem Float-Format beispielsweise aussehen würden.
Gut, hier nochmal zur Veranschaulichung jetzt auf Papier fest einige Beispiele.
Wie gesagt, in dem 32 Bit-Float-Format, sieht das jetzt ja immer so aus,
dass eine Zahl so aufgebaut ist. Ich habe ein Bit für mein Vorzeichen,
also S für Sign, dann 8 Bit für eine Exponenten,
in dieser Excess 127 Darstellung, das heißt,
eine Zahl ist dann eben minus 1 hoch S,
mal zwei hoch Exponent minus 127, mal 1 Komma,
sofern es sich also um eine normalisierte Darstellung handelt.
Und dann folgen ihm die 23 Bit der Matthisse. Und wenn man dann so eine Bit-Folge hat,
jetzt also hier angegeben, ich finde das jetzt also hier entsprechend aufteilt,
würde man an ihm feststellen, dass ich jetzt hier also negatives Vorzeichen habe,
also es handelt sich um eine negative Zahl,
dann habe ich jetzt hier im Exponenten,
als ganz normale Dualzahl 128, also zwei hoch eins,
also mal zwei, und dann habe ich jetzt hier beim Exponenten,
also in diesem Fall jetzt, also die obersten drei Bits gesetzt,
Die eins, also diese eine Vorkommastelle in der normalisierten Darstellung,
ist ja implizit sowieso immer mit drin.
Die obersten drei Bits wären dann eben 0,5, 0,2,
5,0,1, 2,5. Der Rest war jetzt hier mal null sein.
Das heißt also, diese Zahl entspricht dann der minus 3,75.
Und so kann man das Ganze dann eben jetzt vor verschiedene Beispiele durchspielen.
Also hier mal ein Beispiel einer positiven Zahl,
die dann eben auch entsprechend groß ist,
also in diesem Fall 2127 mal,
wenn ich dann Asien entsprechende Kombination in der Mantesse,
mal 1,07 421875 und wenn ich das dann ebenentsprechend umrechne in eine Dezimaldarstellung,
wäre das dann so was wie diese 1,95 und so weiter,
haben wir 10.38 Uhr.
Gut, das Ganze ist jetzt eben hier noch für
weitere Beispiele dargestellt, aber ich denke mal,
das ist also
relativ klar
Wie da eigentlich so eine Umrechnung stattfindet. Deswegen würde ich
das jetzt also hier nicht im Einzelnen jeweils vorbeten. Aber wie gesagt,
das können sich dann nochmal in Ruhe hier in den Unterlagen ansehen,
beziehungsweise sonst eben auch nur zu empfehlen mit solchen interaktiven Werkzeugen,
sich das dann selber mal ansehen. Ein anderes Beispiel,
was jetzt also auch noch nicht weiter verlinkt habe,
dann aber auch nochmal machen werde,
ist jetzt also hier so ein bisschen Java-Programm,
wo im Prinzip einfach eine Bitfolge übergeben wird
Und diese Bit-Folge wird dann quasi gepasst. Das heißt also,
entsprechend umgesetzt jetzt in diese Formatierung jetzt für so
ein Float-Format mit Vorzeichen, Bit, Exploit und mich.
Und dann wurde dann letztendlich umgerechnet in eine Zahlendarstellung,
die dann quasi als Text ausgegeben werden kann.
Und das ist jetzt also hier beispielsweise dann eben für einen
ganzen Satz von vorher fest eingegebenen Zahlen, da mal gemacht worden.
Und wenn man das Programm dann entsprechend durchlaufen lässt,
erhält man dann eben quasi zu diesen Bit-Folgen hier dann die entsprechenden Zahlen.
Ich denke mir, das werde ich dann also auch
noch mal auf die Webseiten stellen, beziehungsweise entsprechend verlinken.
Das hat also hier mein Vorvorgänger Norman Hendrich dann alles gemacht,
wo das Ganze dann entsprechend dargestellt ist,
dass Programm selber Wäre dann eben beispielsweise jetzt dieses Bits to Float.
Und Java, wo jetzt im Prinzip jetzt hier
... Untertitel der Amara.org
Untertitel der Amara.org
Untertitel der Amara.org-Community Untertitel der Amara.org
Untertitel der Amara.org Untertitel der Amara.org
Untertitel der Amara.org
23 Bits beziehungsweise von den 5 oder 52 Plätzen,
die es beim Double-Format gibt,
wirklich nur noch ein paar ganz wenige Stellen am Ende überbleiben.
Das heißt, das, was man dann als Resultat erhält,
wenn ich das Ganze dann wieder normalisiert habe,
hat dann eigentlich
nur noch
sehr wenige Bitsgenauigkeit
Gut, wie sieht das mit den anderen Grundrechenarten aus,
Multiplikation bzw. Division? Da hätte ich dann entsprechend die direkte Berechnung,
dass ich jetzt eben sage,
für Mathissen und Vorzeichen arbeite ich einfach direkt mit der Multiplikation,
nicht mehr Vorzeichen kann ich ja eben entweder nur Null oder eins jetzt für minus eins haben,
wenn ich das einfach direkt multipliziere,
erhalte ich eben demzufolge dann auch gleich das richtige Vorzeichen.
Das heißt also eine Multiplikation minus mal minus, würde dann eben auch wieder direkt Plus ergeben,
weil das Ergebnis da dann nämlich dann auch wieder positiv werden würde.
Manchesten wären direkt multipliziert und bei den Exponenten gilt dann eben,
dass sie dann bei der Multiplikation addiert würden.
Und bei der Division passiert das Ganze letztendlich analog dazu,
wobei ich da dann eben hier als Operation die Vision von Mantes und Vorzeichen machen würde.
Und die Exponentensubtrahiere. Ja, das ist das Gute,
was ich hier anfangs gesagt habe, das ist das Gute,
was da dann noch spezielle Kodierungen gibt für unendlich,
Infinity, also sprich irgendeine sehr große positive oder negative Zahl,
die ich aber sonst mit dem Format nicht mehr darstellen kann,
dann eben dieses not an number und eben die Null funktioniert oder kann ich es nicht mehr darstellen oder ist dabei also irgendwo ein Problem aufgetreten,
also beispielsweise, weil ich Telemoleitung ist von Marco und nicht am guten Eifer.
Also so müsste man nicht agieren, die charakteretischen Loperationen,
letztlich ins Kommerzial, also abfragt, habe ich erzählt,
das habe ich hier angeschaut, der Name ist der Fall, oder?
Und wie gesagt, sie werden mit Fetti,
asozialer WF, und endlich kann ihnen das Opfer,
wenn ich jetzt was dazu entsprechen will.
Marco liest noch schon ein paar Maßen, Son,
wenn jetzt also irgendwas mathematisch nicht definiert ist,
also wirst du aus einer negativen Zahl,
kann ich zumindest jetzt im Reellen nicht lösen.
Beziehungsweise wenn ich anfange, irgendwo mit Infinity, durch Infinity zu rechnen.
Auch das ist dann also nicht weiter definiert.
Als Rechenvorschriften kann man dann eben auch sagen, okay,
also mit das Rechnen mit diesem unendlich funktioniert im Prinzip normal
Während also aller arathmetischen Operationen, die mit diesem Wert Nordonambar stattfinden,
dann eben als Ergebnis dann eben auch nur wieder dieses liefern und
spätestens irgendwann am Ende, wenn man sein Gesamtergebnis hat,
sollte man dann eben auch abfragen,
ob ich da überhaupt eigengültigen Wert habe.
Gut, wie sind diese Zahlen oder diese Darstellungen kodiert?
Ich hatte ja schon gesagt, also normalisierte Darstellung sieht eben so aus.
Ich habe meinen Vorurzeichenwitt. Ich habe einen Exponenten,
Größer als null, bis zu der maximalen Darstellung,
also beispielsweise jetzt bei Flot von 1 bis 255,
weil ich habe ja 8 Plätze zur Verfügung.
Und ich habe dann eben als Mantiste hier,
also irgendeinen beliebigen Wert. Bei dieser nicht-normalisierten Darstellung hätte ich
dann eben als Exponenten quasi null.
Habe da demzufolge dann
eben mal 2 hoch minus
Und das, was dann eben hier als Bitmuster kommt,
enthält dann quasi an der ersten Stelle dann eben diese explizit schon diese eine Vorkommastelle,
die ich ja sonst nicht mitschreiben muss, bei den normalisierten Darstellungen.
Eine Null wird dadurch kodiert, dass sowohl der Exponent als auch die Mantissonull sind.
Unendlich wird dadurch kodiert, dass alle Witze in einem Exponenten gesetzt wird.
Aber in der Mantise quasi nur Nullen vorkommen und Not the
Number wird dann eben dadurch codiert,
dass sich quasi hier alle Bits gesetzt habe und da dann entsprechend irgendein hier irgendwas stehen habe,
was aber ungleich Null ist.
Nicht,
das heißt also im Prinzip mit dieser Unterscheidung über den Wertebereich des Exponenten,
wo ich eben quasi die Null als kleinsten Wert ausschließe für
nicht normalisierte Zahlen beziehungsweise für die Null und
diesen Maximalwert ausschließe,
um quasi Infinity und Nord
an Number
zu codieren
Unterscheide ich dann letztendlich, also diese fünf möglichen Codierungsformen in diesem Zahlenformat. Gut,
auch dazu gibt es dann so eine Demo,
die ich dann also entsprechend nochmal auf den Webseiten bereitstellen würde,
wo man dann eben quasi ein Programm hat,
was also letztendlich nichts anderes macht,
als jetzt hier bestimmte Ausdrücke zu berechnen und dazu dann die entsprechenden Ergebnisse zu liefern.
Und wenn ich das also laufen lasse, Kommt also genau das raus,
was dann eben auch hier jetzt entsprechend oft her Folie drauf ist,
also sprich null durch, null, Nord in Number,
irgendeine Zahl durch null liefert dann eben entweder plus oder minus Infinity,
eins durch Infinity liefert dann eben null.
Nicht wenn ich mit Infinity entsprechend jetzt irgendwie addiere,
beides positiv. Erst mal Infinity,
das plus minus Infinity
Gut, ist nicht entscheidbar, was dabei rauskommt.
Deswegen not in number. Mich infinity mal minus infinity
minus. Das heißt, damit wird normal gerechnet,
wenn ich ja sonst irgendwie jetzt mit Zahlen sinnvoll was rechne.
Gut, dann kommt natürlich das raus, was rauskommen soll.
Quadratwurzeln von minus eins, liefert dann eben auch als Beispiel Norton Number.
Und das ist jetzt also hier nur noch interessant,
weil oder deswegen hier nochmal extra gekennzeichnet, weil das,
sagen wir jetzt etwas ist, was dem der normalen Vorstellung vielleicht erst mal widerspricht.
Und zwar jetzt hier als Vergleichsoperation. Ich werde jetzt also
arathmetisch Vergleiche mache. Ich habe also irgendeinen Term, der
not a number liefert. Und ich frage dann eben gleich,
irgendein anderer Term, der not a number liefert,
dann liefert das als Ergebnis erst mal False,
um überhaupt jetzt festzustellen, dass wir irgendwas not a number rausgekommen ist.
Darf ich also jetzt hier nicht so,
beispielsweise jetzt in C mal einen Vergleich schreiben,
sondern da gibt es dann also spezielle Funktionen
Mit denen man das dann eben abfragt, die dann
eben sagen, okay, du hast not numbers Ergebnis.
Und genauso wäre jetzt eben ein Vergleich,
wo ich jetzt sage, Infinity größer, not number,
liefert dann eben auch erst mal als mutenwertvoll.
Ein falscher Haus. Gut, abschließend zu dem Gleitkomma von Zahnformat
werde ich also jetzt noch hier vorstellen,
den Begriff ULP, Unit in the Last Place.
Das ist quasi ein Maß für die Genauigkeit bei den Zahndarstellungen
Kann man sich letztendlich vorstellen, als die Differenz,
die zwischen den Birand Light-Kommazahlen jetzt dem am nächsten liegt,
was man also dann damit für die Darstellung noch machen kann.
Nicht, weil, wenn ich mir so jetzt so ein Zahlenformat ansehe,
nicht wo, unterscheiden sich letztendlich in der Genauigkeit zwei benachbarte Zahlen,
dadurch, dass also quasi an der niederwärtigsten Stelle der Mantise,
die sich genau um ein Bit unterscheiden, Echt?
Das heißt also, diese beiden unterscheiden sich hier entsprechend da
und das ist entsprechend dann eben der Fertigkeit, dieses niederwärtigsten Bits.
Und je nachdem, wie groß der Exponent ist,
habe ich dann eben unterschiedlich große Unit in the Last Places.
Das ist da dann eben ein Maß für die erreichbare Genauigkeit.
Was jetzt in dem Format für die arathmetischen Operationen noch mit definiert ist,
ist dann eben letztendlich eine Genauigkeit von 0,5 ULP für die Elementaren Operationen,
also die vier Grundrechenarten und die Quadratwurzel.
Das heißt, wenn ich zwei Gleitkommazahlen habe,
mit denen eine arathmetische Operation ausführe,
ich dann entspricht das Ergebnis in seiner Genauigkeit, dann eben so,
dass ich genau maximal nur eine halbe Stelle daneben liege.
Das heißt also, dies ist eigentlich dann auch ein Maß
für die Güte, wie jetzt, also ich hatte hier
In diesem Beispiel dann sowas, wo ich dann nie gesagt habe,
okay, bei einer festen Stellenanzahl wird, in diesem Fall jetzt hier gerundet.
Und wenn ich das jetzt also hier in diesem Falle im Dezimalsystem nehme und sage,
okay, 1,00266, ich habe jetzt nur drei Nachkommastellen,
dann wird das entsprechend zu 003 aufgerundet.
Und diese Unit in the Last Place bezeichnet jetzt quasi
den Unterschied zwischen diesem Wert und diesem Wert.
Ich und 0,5 heißt eben, dass ich hier maximal genau
eine Zahl auf oder Abrunde. Er scheint eigentlich logisch,
aber man hat es dann eben auch gerade jetzt bei anderen mathematischen Operationen so,
dass dadurch, dass sie dann zwischenzeitlich,
also den Zahlenbereich ganz verlasse, dann Effekte auftreten,
wo die Abweichungen dann eben deutlich größer werden kann.
Gut, wie gesagt, bei den Grundrechenarten können wir davon ausgehen,
dass sich eben letztendlich mit der normalen Rundung Thema als Ergebnis arbeite,
was wir also auch intuitiv uns vorstellen. Nicht,
wenn man sich jetzt also irgendwelche mathematischen Bibliotheken oder irgendwelche Mathematik-Software,
also was weiß ich,
Matlab-Maple oder wie auch immer sie heißen mögen, mir jetzt ansehe,
da garantieren diese Softwarepakete dann eben auch entsprechende Genauigkeiten für andere Funktionen.
Also sprich, wenn ich mir jetzt mit dem Logaretten
muss oder mit irgendwelchen Trigo-Nummern, Mozialfunktionen, also Sinus,
Co.,
sie mussten es weiter rechnen würde
Und teilweise gibt es dann eben auch in den Programmiersprachen entsprechende Bibliotheken,
wo ich dann eben zum Beispiel in Java sowas explizit dann abfragen kann, beziehungsweise benutzen kann. Das Problem der Rundungsfehler,
ich hatte es zu den Rundungsalgorithmen selber,
habe ich jetzt ja noch nichts weiter gesagt,
werde ich auch nicht weiter vorstellen, weil da kann man nur sagen,
Gut, wir leben jetzt erstmal mit dieser,
oder mit dem A-Triple, die 754 Standard dort,
ist das alles letztendlich festgelegt und für, sagen wir mal,
normalsterbliche Anwendungen funktioniert das dann auch eigentlich wunderbar und da muss man sich jetzt nicht weiter drum kümmern.
Bei, grundsätzlich ist aber diese Problematik mit den Rundungen und den Genauigkeiten,
die sich dabei ergeben können,
schone vergleichsweise komplizierte Sache und wenn man also beispielsweise jetzt mit Versicherungsmathematikern spricht,
die jetzt also da also relativ komplizierte Berechnungen oder Modelle jetzt irgendwo für irgendwas machen,
wo es also jetzt wirklich auch auf die Genauigkeit von Rundungsalgorithmen mit ankommt.
Das ist dann also schon ganz interessant. Wie gesagt,
also bei wirklich anspruchsvollen numerischen Algorithmen wird es dann schon essentiell,
dass man sich dann eben auch Gedanken über die Rundung macht.
Sprich, was passiert dann eben auch mit irgendwelchen Zwischenergebnissen? Weil das ist ja auch einfach so ein Problem,
was sie jetzt ja nicht weiter angesprochen haben,
aber wenn ich jetzt sage, ich rechne Was weiß ich,
hundertmal 200 mal 300 mal 400 mal 500 durch und dann wird das wieder irgendwo geteilt.
Dann kann ich natürlich sagen,
wenn ich das jetzt erst mal stumpf in dieser Reihenfolge von dem Algorithmus ausrechne und immer weiter erst mal multipliziere,
laufe ich eben Gefahr, dass ich also irgendwo die Zahlenbereiche sprenge und das Ergebnis also irgendwie völlig verfälscht wird,
nachher dadurch, dass ich aber wieder teile,
fahre ich dann quasi in der Genauigkeit oder in dem Wertüberreich dann wieder runter,
dass hier eigentlich beim ursprünglichen Wertebereich lande,
habe aber zwischenzeitlich eben eigentlich sehr viel an Genauigkeit verloren.
Und da geht das dann eben wirklich direkt an die oder essentiell an die Algorithmen,
wo man dann eben sagt, gut,
wenn ich jetzt eben solche ganzen Folgen von mathematischen Operationen mache,
wo ich dann eben in den Wertebereichen sehr stark springen kann,
dass man die dann eben beispielsweise,
indem ich sie jetzt also anders kodiere und sage,
ich mache jetzt die Operation an die Operation und die Operation,
dass man dann eben auch in meinen ähnlichen Wertebereichen landet,
man dann also auf einmal wieder deutlich genauere Ergebnisse erhalten kann.
Ja, aber wie gesagt, das ist also alles Vergleichsweise nicht ganz trivial,
aber wie gesagt, also da kann man dann noch einiges machen.
Gut, abschließend jetzt zu dem Kapitel Cefanons Zahn
noch ein bisschen was zu den Datentypen in der Praxis.
Nicht wenn ich jetzt sage, okay,
ich habe jetzt also irgendwo hier meine Intager-Darstellung,
also meine Festkommadarstellung, ich habe jetzt hier irgendwo meine Fließkummer-Darstellung.
Gut, inzwischen glücklicherweise auch irgendwo genormt
Wie werden die jetzt irgendwo auf der Hardware,
also sprich auf irgendwelchen Computersystemen umgesetzt? Ja,
da kann man eigentlich immer sagen, na gut,
also die meisten Rechner oder Rechnersysteme sind eben eigentlich für eine Wortlänge optimiert,
auch gerade hinsichtlich dessen,
was sie natürlich intern irgendwo an Hardware-Recheneinheiten zur Verfügung stellen,
wo ich jetzt eben nicht mit beliebig großen Zahlen rechnen kann,
sondern eben mit 32 oder mit 64 bezahlen
nur arbeiten kann
Und das ist dann eigentlich auch die, die prinzipiell erst mal typische Länge eines Engiter-Wertes.
Meistens werden diese Wortbehalten dann auch für die Speicheradressen mitbenutzt.
Wenn ich uns zusätzlich gibt es dann eben noch entweder Teile oder Vielfache der entsprechenden Wortlänge. Gut,
das, wo wir uns heute eigentlich bewegen, ist,
dass man sagt, na gut, also bis vor Sieben,
acht Jahren oder so waren eigentlich die Rechner,
jetzt von der Hardware-Ardmetik, noch in dem Bereich 32-Bit angelangt.
Nicht, das heißt,
also die Inji-Ji-Worte waren typischerweise 32-Bit, adressierbarer Speicher,
war dann eigentlich auch immer irgendwie 2 auf 32-Bit,
also 4. Gibi, byte, war es dann natürlich,
wenn ich jetzt also entsprechend speicher aufwendige Programme laufen lasse,
dann also
schon zu Problemen in der Adressierung
führen kann
Sagen wir jetzt seit fünf Jahren mindestens sind dann eigentlich die intern,
die Zahlendarstellung in den Rechnern dann schon auf größere Wortbreiten umgeschwenkt.
Das heißt, also derzeit ist eigentlich 64-Bit in der Rechner-Hardware-Standard. Zusätzlich,
was dann eigentlich auch noch mit hinzukommen muss, ist jetzt eben,
wie jetzt also solche Wortbreiten hinsichtlich der Software, also in diesem Falle seitens des Betriebssystems unterstützt werden.
Und das ist das, was wir jetzt eigentlich immer gerade erleben,
wo man sagt, naja gut,
also der Prozessor ist eigentlich immer identisch oder das Gleiche,
nicht, aber ich kann, je nachdem,
welchen Hauptspeicherausbau ich habe,
das Ganze dann eben mit einem 32 Bit Windows oder mit einem 64 Bit Windows beziehungsweise entsprechendes bei Linux oder wo auch immer oder was man da auch nimmt, betanken und laufen lassen.
Wobei es da dann aber eben die Einschränkungen gibt,
das, wenn ich jetzt eben mehr als vier GB-Hauptspeicher habe,
dass ich ihn dann eben quasi konsistent dann eigentlich eben
auch nur mit dem 64 Bit Betriebssystem richtig adressieren kann
Gut, alles, was hier vorher steht,
so 8 bis 16 mit und so weiter,
das ist inzwischen zumindest hier,
also so bei der normalen PC-Hardware natürlich überhaupt nicht mehr interessant,
wo sowas noch teilweise zum Einsatz kommt,
ist also bei irgendwelchen eingebetteten Systemen, sprich,
wenn ich irgendwo einen kleinen Mikrocontroller habe, der mir also,
was weiß ich, meine Waschmaschine steuert,
dann soll da also irgendwo so ein bisschen Programm machen und ich möchte vielleicht noch irgendwo eine Zeitvorwahl einstellen können und irgendwas,
aber ich brauche schon also keine 64 mit Wortbreite und keine Terabyte Hauptspeicher,
die ich adressieren muss,
sondern da läuft es sowieso eigentlich nur ein Standardprogramm.
Also jetzt ab fast dort irgendwo fest, in einem E-Prom reinkodiert ist,
was sich also sowieso nicht verändern kann oder zumindest nicht verändern sollte.
Nicht das heißt, da hat man dann eben auch noch teilweise deutlich kleinere Wortbrei.
Weswegen erwähne ich sowas eigentlich immer noch aus dem täglichen eigenen Programmieren,
kennen wir eigentlich so, dass man sagt, na gut,
also Computer oder das, was man so als Computersystem ansieht,
ist also irgendwo ein Laptop, ein Desktop oder was weiß ich,
was man sich sonst ausdennt.
Guten Smartphone oder ein Tabletgerät inzwischen also auch noch. Andererseits,
wenn man sich ansieht, wo wird irgendwas,
was ich sage mal jetzt als Rechner oder als Rechner Hardware bezeichne,
eingesetzt und wie viele von den Geräten gibt es,
dann ist das,
was wir eigentlich so als Rechner sehen,
der kleinste Teil
Ich war also deutlich mehr Geräte,
sind halt in Form von irgendwelchen eingebetteten Systemen irgendwo verbaut,
wo dann eben auch wirklich solche Probleme mit begrenzten Wortbreiten,
beziehungsweise mit deutlich anderen Wortbreiten zum Tragen kommen.
Und wie gesagt, typische Beispiele sind halt eben nicht,
also jedes blöde Haushaltsgerät, sagen wir mal,
hat ein oder mehrere Mikroprozessoren,
nicht also ein Standardmittel Klasse PKW, kann man sagen,
hat also ungefähr 40 Kontrollrechner drin.
Nicht, wenn man da jetzt also sagt,
also irgendwie irgendwie größere Geräte oder größere Autos, sondern irgendwelche anderen Systeme.
Also da wird also sehr viel an solchen eingewetteten Systemen eingesetzt,
dass also insgesamt die Anzahl der Rechner eigentlich dadurch bestimmt wird und eben nicht durch das,
was wir jetzt als PC oder als Computer jetzt von
unserem Verständnis her sehen
Gut, jetzt bei, ich sag mal so,
Standardprogrammiersprachen und bei irgendwelchen Sachen jetzt, also aus einem ganz normalen PC-Bereich.
Wie sieht das dort aus? Ja,
so bei den normalen Prozessoren habe ich eigentlich entsprechend viele Datentypen,
die dann in der Regel jetzt erstmal durch die Programmiersprache,
sah das, sie sah das, Java, was auch immer irgendwo festgelegt sind.
Nicht, dann habe ich dann zum Beispiel sowas wie in C,
also irgendwelche Zeiger, also sprich Speicheradressen, die ich noch irgendwo mit habe,
um zum Beispiel jetzt, also Wert aus dem Speicher zu holen,
um jetzt irgendwelche Sprünge festzulegen oder um irgendwas indirekt zu adressieren.
Und hier jetzt einfach nur mal wild aufgelistet,
also für die Standard-C-Datentypen, also Indiager, Long-Indager, Character,
Shortfloat, Double, Long Double oder eben so ein Speicher,
wie das Ganze jetzt also auf unterschiedlichen Hardware-System aussieht nicht,
also sowas wie Deck Alpha, gut, das war Workstation,
sagen wir so Mitte der 90er Jahre,
inzwischen nicht mehr interessant, das waren, sagen wir mal,
die ersten Rechner, die ja sowas wie eine 64-Bit-Adressierung,
beziehungsweise durchgängig auf 64 bis Datenfahrer unterstützt haben.
Nicht dann bei 32-Bit-Betriebssystemen beziehungsweise Systemumgebung habe ich dann die,
habe ich dann eben entsprechend hier die Wortbreiten,
dass eben ein Indiger dann eben genau diese 32-Pit,
also sprich 4-Byte umfasst, Long-Inager dann auch,
Charakter dann eben einbahrt und so weiter und so fort.
Bei, jetzt noch ein bisschen spezieller Intel-Ia, 32-Architektur,
also sprich der 32-Pit X86, hätte ich dann hier die entsprechenden Speicher wortbreiten.
Und noch ein bisschen extremer ausgeführt, also da ist jetzt hier
auch nur zum Selber nachschlagen oder nachsehen, mal aufgelistet.
Ist sowas, also hier aus so einer Untersuchung,
die man also hier entsprechend dann also auch runterladen kann,
wo es also im Prinzip um Untersuchung geht, wie jetzt auf Maschinenebene unterschiedliche Datentypen abgebildet wird. Und das,
was man hier sieht, und das ist eigentlich das Einzige,
was ich jetzt hier quasi als Information Ihnen erst mal nur mitgeben will,
also auch wenn man jetzt immer sagt,
ich arbeite mit her und der Programmiersprache und ich arbeite mit den und den Standards,
dass ich doch immer noch Bewusstsein sollen,
dass es immer noch gewisse Abhängigkeiten gibt,
wo eben Eigenheiten der Hardware, also sprich des Prozessors,
Eigenheiten des Betriebssystems und teilweise auch noch Eigenheiten des Verwendeten Compile, lass mit reinschlagen.
Nicht und hier wurde es also jetzt wirklich mal untersucht,
jetzt mit, also C-Datentypen, die dann also auf 16,
32 und 64 Bit-Maschinen oder unterschiedlichen Compilern und unterschiedlichen Betriebssystemen untersucht worden sind,
wie viele Beid,
da dann also jeweils benutzt wurden.
Und wie gesagt, also es gibt da einfach erstmal Unterschiede.
Also auch das sollten sie dann beide Programmierungen später irgendwo nochmal
im Hinterkopf behalten.
Eine Frage
Also wenn ich die Frage jetzt richtig verstanden habe,
ging es jetzt darum, ob die Arithmetik dann gleich ist und dann
nur Over- und Underflow können sich dann eben entsprechend diesen Wortbreiten anders verhalten.
Gut, da denke ich mal, das wird sich,
oder da werden sich sicherlich also entsprechend den unterschiedlichen Wortbreiten verschiedene Ergebnisse einstellen,
wo ich jetzt eben zum Beispiel sage, Beispielsweise,
wenn ich... Wo haben wir jetzt hier mal irgendwo ein Beispiel,
wo sich jetzt mal irgendwie wirklich was unterscheidet?
Das ist jetzt wieder nichts motiviert. Also hier irgendwie gerechnet
wird. Also hier sind White-Charakter, der jetzt,
also hier zum Beispiel unter Linux,
also anders dargestellt wird, also auch im 64-Bit-Modus,
als jetzt also zum Beispiel jetzt bei irgendwelchen Windows-Betriebssystemen bzw. Compilern
Gut, also hier gibt es zum Beispiel einen Signifikan-Unterschied,
wo ich jetzt natürlich sage, also sowas wie ein Long-Double auf einer 64-Bit-Maschine,
wenn ich jetzt also den Microsoft-Komparat,
C-Komparla nehme oder ob ich jetzt den Intel-LC-Compiler nehme,
sind die unterschiedlich breit.
Wenn ich damit rechne, Hätte ich natürlich dann schon das Problem,
dass ich dann, also was weiß ich,
mit Microsoft Compiler in der Overflow-Situation oder anderslos Situation reinkommen kann,
wo ich jetzt also mit einem anderen Compiler letztendlich noch weiterrechnen kann.
Das heißt, halten Sie dann mit Ihrer Frage, entsprechend da dann also natürlich rein.
Aber grundsätzlich muss ich auch immer sagen, also das,
was ich eigentlich immer ein bisschen erschreckend finde bei solchen Untersuchungen,
was ja auch gerade dieses Beispiel zeigt, ist,
dass ich jetzt sage, ich habe hier einen 64. Betriebssystem.
Und ich habe in diesem Fall auch noch das gleiche Betriebssystem.
Ich habe den Compiler von zwei unterschiedlichen Näherstellern. Hinter einer Hersteller sagt,
okay, beim BMC-Compiler ist der Datentyp eben so und so
definiert ein anderer Hersteller, macht das eben anders.
Wie gesagt, ich denke mir also auch solche Untersuchungen sind letztendlich
immer nur sowas wie eine Momentaufnahme und irgendwann Im halben Jahr
oder in einem Jahr kann das dann also auch schon wieder ein bisschen anders aussehen.
Ich denke mir, also man muss sich da dann eigentlich immer nur gegenwärtig sein,
dass es da also solche Effekte durch Betriebssystemen oder Compiler-Varianten geben kann.
Und dass man sich dann eben wirklich,
wenn man programmiert, auch jedes Mal angucken muss,
wie wären meine Datentypen jetzt von meiner Programmierumgebung,
die ich jetzt gerade verwende, dargestellt oder was kann da auftreten?
Noch eine Frage. Wir sprachen zum Beispiel ja bei dir
eine ganz bestimmte Lenkung
Ja, zum Beispiel, sobald zwei Weihnachtsgeschoren und so weiter.
Nee, das ist genau einer der Vorteile von Java.
Also die Frage war jetzt, also wie wirkt sie so aus Perjava aus?
Das ist genau einer der Vorteile, dass es dort letztendlich
im Sprachstandard fest definiert ist, dass Datenformat sieht so und so aus.
Und jede Java-Implementation, also egal welches Betriebssystem,
welche Maschine dahinter liegt, muss das auch irgendwo umsetzen.
Was sich dann eben nur auswirken kann,
ist jetzt einfach von der, sagen wir mal, Ausführungsgeschwindigkeit,
wenn ich das jetzt zum Beispiel kompiliere und dann also als Compile-Code ausführen lasse,
dass es natürlich jetzt Je nachdem,
also was da an die Hardware-Leiste dann eben mal schneller läuft,
mal langsamer war das dann eben mehr Leist macht,
aber im Prinzip die Wortbreiten und die Ergebnisse sind dort,
also wirklich in der Sprache definiert.
Und da kann man sagen, also Java-Code, damit bin ich wirklich unabhängig.
Also hier dieses Beispiel bezieht sich jetzt noch explizit auf die Programmiersprache C. Weißt du,
wie der Java, der Bilder von Java,
dass wir wissen, was der Macht ist?
Wenn ich dort sehe, was der Wort zeigt,
Nee, also da muss ja dann quasi der Interpreter,
beziehungsweise wenn ich das jetzt irgendwie kompiliere,
in irgendwas der Mechanismus dafür sorgen, dass, um jetzt,
also beispielsweise also diese Wortbreite von 64 Bits zu gewährleisten,
das dann eben in entsprechend viele Einzeloperationen aufgespalten wird.
Und wenn die Hardware oder jetzt also irgendeine Umgebung,
also das nicht leistet,
na gut,
dann werden da halt
eben 20 Organisationen angestoßen
Ergebnis erzeugt. Ich weiß nicht, zudem jetzt,
sagen wir mal, Agipas, falls ihr ja gerade eben gesagt hattet,
wo dann also die Performance natürlich dann noch stark unterschiedlich sein kann.
Aber hinterher soll das alles erstmal identische Ergebnisse liefern.
Da war noch eine Frage, dass ein Leben mit vier
Beinen von dir ist, aber noch nicht auf.
Ja, das ist jetzt hier wieder aus der Historie,
wie jetzt eigentlich AAC ist ja nun schon ein bisschen älter.
Und da kann man jetzt eben sagen, okay,
also auf so einem 32-Bit-Prozess oder sind da 32-Bit-Architektur,
ist inzwischen auch zu einem kompletten Maschinenwort aus 32-Bit geworden,
beziehungsweise nicht eigentlich bei längeren Maschinenwortbreiten.
Heutzutage müsste ein Unint eigentlich auch aus wie ein Long-Int,
also schon aus Achtbait bestehen, weil internen Maschinenwort,
also schon immer 64 Pits sind.
Nicht, dass es eigentlich jetzt eher historisch zu sehen,
dass man sagt, na gut, also in den 80er Jahren,
als das also irgendwo mit C losging,
da hatte man also irgendwie 16-Bit-Prozessoren.
Da waren in 16-Bit und dann Long-in 32-Bit. Also das
ist jetzt eher noch so ein bisschen so über die Historie.
Also wie gesagt, was sind jetzt auch erstmal nur so
exemplarisch rausgesuchte Beispiele
Gut,
damit bin ich jetzt mit diesem Kapitel Ziffern und Zahn soweit fertig,
da sich das jetzt also hier irgendwie mit den letzten drei Minuten nicht mehr so richtig lohnt,
also hier noch was Neues anzufangen,
werde ich dann also am Freitag dann nochmal eben speziell dieses Kapitel zur Arithmetik machen,
wo dann eben auch gerade nochmal diese Rechenvorschriften mit dem Kompliment
ein bisschen genauer ausgeführt werden.