So? Nee, ich mache mal im Happen.
Hab mal ein bisschen lauter gemacht. Also ich hoffe,
man versteht mich. Leider hat mich ein bisschen
die Erkältung erwischt, wie man also unschwer hört.
Und ich muss da sehen, wie lange die Stimme durchhält.
Ansonsten weiter nach vorne. Ich kann hier noch
ein bisschen lauter drehen. Entsprechend Bescheid sagen. Ja,
ich hatte am Mittwoch ja im Prinzip vorgestellt,
zum einen die Darstellung für negative Zahlen,
die war also typischerweise ein Zahlensystem haben,
nämlich Betrag und Vorzeichen
Dann Access-Darstellung und als die Standarddarstellung für Zahlen dann eben Zweierkompliment.
Ja. So, ja, also
Wie gesagt, negative Zahlen dann,
was man ja typischerweise bei der Berechnung braucht,
wenn man eben sehr große oder sehr kleine Zahlenbereiche hat,
halb lugarithmische Darstellung, was dann im Computer,
also sprich mit einem Binärsystem oder ein Dualsystem als Basis aufgebaut,
dann eben das Fließkomma-Format ist,
was jetzt eben seit,
ich sag jetzt mal,
den 70er Jahren dann
eben fest als Atribley 754
standardisiert ist
Gut, neben diesen Verbreiteten 32 Bild- und 34-Bit-Formaten gibt es dann eben auch noch andere unterschiedlich lange.
Und ich hatte dann ja auch schon kurz vorgestellt,
die Zahlen werden immer so dargestellt, dass man sagt,
ich habe ein Vorzeichenbild, also sprich von daher sowas wie Betrag und Vorzeichen.
Ich habe beim 32-Bit-Format 8-Bit für einen Exponenten,
der Exponent, ist kodiert als Exzess 127 Darstellung.
Und dann verbleiben noch 23 Bit für die Mantiste,
wobei man da eben noch diesen Trick macht, normalisierte Zahlendarstellung,
das heißt, Die Zahlen werden eben so lange hinsichtlich des Exponenten verschoben,
bis sich eben eine Eins vor dem Komma habe.
Die wird dann auch nicht mehr explizit kodiert. Das heißt,
es gilt dann immer 1, Komma und dann eben noch die 23 Nachkommastellen.
Vorausgesetzt, ich habe keine sogenannte nicht-normalisierte Zahl. Das kann dann bei sehr kleinen Zahlen noch vorkommen. Bei den Exponenten,
ich habe vorhin, als ich das durchgesehen habe,
hier nochmal die Folien kurz erweitert, ist es eben so,
dass die beiden Codierung, lauter Nullen und lauter Einsen,
nicht in der normalen Darstellung mit drin sind,
sondern das sind dann eben quasi die Zahlen von Eins bis 254,
die dann also quasi jetzt die normalen,
normalisierten Darstellungen sind,
Null und dieser Eins-Vektor wird uns dann eben noch begegnen bei den Sonderwerten,
die dann also dort noch entsprechend auftauchen.
Werde ich dann auch gleich noch kurz vorstellen. Gut,
damit kann man dann eben wie hier in den Beispielen angegeben, entsprechend seine Zahlen kodieren.
Ja, als letztes hatte ich dann ja noch vorgestellt,
wie im Prinzip arathmetische Operationen bei solchen Fließkomma-Formaten aussehen.
In diesem Fall Addition hatte ich dann also kurz an der Taflan zum Beispiel skizziert,
wo man dann eben wirklich sehen kann,
was muss man machen, dass man also quasi erstmal,
wenn die Exponenten unterschiedlich sind,
die entsprechend anleicht.
Das heißt, dann bei den Mantissen entsprechend beim betragsmäßig kleineren
das Ganze passend verschiebt
Und anschließend, wenn die Exponenten identisch sind,
dann eben entsprechend ganz normal die Adizone Mantisten.
Es kann dabei dann vorkommen, dass an der ersten Stelle wieder ein Überlauf stattfindet.
Das heißt, dann hätte ich sowas wie eine Nicht-Normalisierte Zahl.
Demzufolge musste ich hinterher nochmal normalisieren. Sieht man hier auf diesem,
in diesem Beispiel, also auch nochmal, jetzt nicht binär,
sondern im Dezimalsystem, nicht wo man dann eben sagt,
ich habe hier zwei Zahlen,
9,725 mal 10.07 und 3,016 mal 10.06.
Die sollen addiert werden. Das,
was man eben macht, ist das also
quasi der betragsmäßig
Oder die betragsmäßig kleinere Zahl hinsichtlich des Exponenten angepasst wird.
Das heißt, hieraus wird dann eben auch eine Darstellung mit 10 auf 7 gemacht.
Demzufolge wird, das kann man dann dementsprechend verschoben. Anschließend wird dann
eben ganz normale Addition dann eben bei den Mantisen durchgeführt.
Und wie gesagt, dieses Beispiel ist es natürlich so gewählt,
dass dann also hier nochmal etwas nicht Normalisiertes entsteht und man
dann hinterher das Ganze dann nochmal entsprechend normalisieren muss.
Und gegebenenfalls, wenn also jetzt hier im Nachkommabereich noch Stellen
hinzugefügt worden sind, dann noch rundet bzw. dort noch Anpassung macht.
So das Ganze ist nicht Informationstreu
Warum? Es gibt eigentlich zwei Arten von Problemen. Zum einen,
wenn die Exponenten eben wirklich sehr stark unterschiedlich sind,
dann wird die kleinere Zahl hier in diesem Schritt ja quasi so weit skaliert,
dass, wenn ich nicht mehr genügend Nachkommastellen zur Verfügung habe,
die einfach quasi entsprechend raus waren dann.
Das ist dann eben zum Beispiel der Fall, wenn ich sowas rechnen würde.
Also jetzt hier dezimal geschrieben, aber jetzt quasi binär gerechnet.
1,0 mal 10 hoch 20 plus 3,14159 und das Ergebnis wäre dann Eben diese Zahl,
weil wenn ich dieses hier dann also auf 10 hoch 20
entsprechend drauf skaliere und ich dann jetzt nicht sehr viele Nachkommastellen zur Verfügung habe,
sondern bei diesen Standardfließkomma-Formaten, die beispielsweise 32 Mitgenauigkeit bleibe,
nicht dann wird von diesen Stellen hier nichts mehr überbleiben.
Der zweite Fall ist, wenn die Exponenten gleich sind und die Mantisen fast gleich.
Also als Beispiel, wenn ich irgendwas habe,
wie ich mache es jetzt wieder im Dezimalsystem,
weil dann ist erst mal ein bisschen anschaulicher
2,014, 6, 8. 1, 2, mal 10 hoch.
Fünf meinetwegen. Und hier habe ich jetzt 1,9 Arm.
Blödsinn. Auch 2,014, 6, 8. 2,
1 mal 10.5. So, und die sollen jetzt voneinander abgezogen
werden.
Wunderbar. Exponenten
Sind identisch, da muss ich nichts machen. So,
und wenn ich jetzt einfach die Mantisen gegeneinander verrechne, in diesem Fall,
also voneinander abziehe, habe ich hier eben überall identische Ziffern.
Das heißt,
von meinen 23 oder 56 Nachkommastellen bleibt in diesem Fall dann eben kaum noch was nach,
wo ich dann also hier letztendlich sowas dann wie 1,9 und
hier noch irgendwo eine Zahl habe und alles hier vorne wäre jetzt quasi identisch,
dann eben mit lauter Nullen besetzt,
wenn ich in dem Zufolge habe ich hier von so und
so vielen Nachkommastellen hinterher dann nur noch irgendwie drei Nachkommastellen über
Nicht, das kann man dann auch entsprechend natürlich,
oder würde man dann wieder entsprechend normalisieren, aber da habe ich dann eben genau das Problem,
dass ich also letztendlich fast alle Bits der Mathese auslöschen und dies Resultat,
weil mir hier natürlich die Stellen fehlen dann also entsprechend wenig Genauigkeit nur noch hart.
Nicht, das sind also die Probleme,
die jetzt bei der Berechnung von oder mit Fließkommazahlen auftreten und das ist dann eben auch immer so eine Sache,
wenn sie jetzt also irgendwas programmieren in der Programmiersprache mit Fließkommazahlen rechnen,
dass man sich da dann eben eigentlich immer bewusst macht,
es ist nicht beliebig genau,
sondern in der Computerarathmetik hören eben letztendlich bei den Zahlen Darstellungen, die und die Probleme auftreten.
Und wenn ich jetzt eben noch mehr Genauigkeit brauche,
wenn ich irgendwelche Auslöschungen habe,
es gibt dann eben entsprechend noch längere Fließkomma-Formate oder man muss
generell über zusätzliche externe Programmierbibliotheken dann also andere Zahlen,
Formate nehmen,
wo man also einige von diesen Effekten
dann eben entsprechend vermeiden kann
Das ist eben erstmal etwas, was man also letztendlich im Hinterkopf behalten sollte.
Aufgrund dieser begrenzten Zahlendarstellung. Gut, ja, das war
jetzt zum Thema Addition, Subtraktion, Multiplikation und Division.
Würde dann eben eigentlich auch relativ direkt umgesetzt werden können.
Ich habe meine Zahlen ja quasi so kodiert, sein Bit, Martissen und Exponenten.
Und dann gilt einfach entsprechend der rechten Regeln. Das Scien Bit,
Die müssten quasi jetzt miteinander verglichen werden, wo ich dann einfach sage,
nicht minus mal minus ist plus und plus mal plus ist,
plus und die beiden anderen Kombinationen plus mal minus bzw. minus mal plus ist negatives Vorzeichen.
Technisch gesehen kann ich dann eben sagen, ich multipliziere,
diese beiden sein wird es,
wenn ich jetzt im Binärsystem bin bzw. das,
was dann eigentlich dahinter verbirgt, sich verbirgt als Funktion,
ist ein sogenanntes Exklusiv-Oder, wird es dann in einem späteren Kapitel,
wo es dann eigentlich um die technische Umsetzung von solchen Rechenwerken geht,
dann noch weiter begegnen.
Also deswegen jetzt keine Angst, wenn ihm die XO jetzt also
noch nichts weiter sagt. Gut, also das heißt,
die Vorzeichen werden multipliziert, die Mantisen dann auch einfach ganz normal,
wie ich das also sonst mit Kommazahlen auch immer machen würde, entsprechend multipliziert.
Und die Exponenten werden addiert. Nicht das,
was ich dann wieder als Resultat habe,
muss ich logischerweise dann jedenfalls natürlich auch noch normalisieren.
Aber da kommen jetzt also keine weiteren Schritte mehr hinzu,
beziehungsweise da passiert dann nichts weiter. Für die Division würde dann quasi das Entsprechende gelten,
wobei, wie gesagt,
also die Vision dann auch schon ein bisschen aufwendiger ist,
jetzt nicht nur bei Gleitkommazahlen,
sondern generell in den Rechenwerken der Computer will ich dann im nächsten Kapitel auch noch mal ganz kurz drauf eingehen.
So, in diesem A-Treppe-Easy-Mann 54-Format gibt es dann ja noch spezielle Werte für unendlich.
Nord-Enammbar und die Kodierung der Null. Wofür braucht man jetzt
also neben der Null? Da ist natürlich Slaven gebraucht,
aber diese beiden Werte. Wenn ich jetzt einen arathmetischen Ausdruck habe,
also beispielsweise, also irgendwie sowas wie Berechnung der Forna Schemas,
wo ich also sage, XN mal Basis, Klammer zu,
Basis plus XN minus 1 und so weiter.
Nicht also einen ganzen längeren Geklammerten Ausdruck. Dann können natürlich jeweils nach jedem der Rechenschritte irgendwelche Effekte auftreten,
dass entweder, ich meine, Zahnbereich verlasse,
quasi in das Infinity reinlaufe oder, gut,
also bei solchen Additionen Multiplikationen nicht, aber bei anderen Operationen,
dass ich also quasi sowas wie Nordde Number rauskriege,
dass man damit dann entsprechend dann auch nicht weiterrechnet.
Was man jetzt da nicht machen möchte, man kann das Ganze natürlich abfragen,
dass man Wenn ich einen Ausdruck habe, nach jeder Rechenoperation,
Abfrage ist dieses passiert ist, jenes passiert und das Ganze dann irgendwie abbricht,
sondern dieser Ausdruck soll zumindest erst mal so weit zu Ende berechnet werden oder ganz am Ende,
wenn ich jetzt also mein Ergebnis habe,
nicht dass ich dann eben sage, okay,
ist dabei jetzt irgendwo in diesem Ausdruck oder in dieser Funktion was schiefgegangen?
Und dafür hat man dann eben diese Werte Infinity für unendlich,
entweder in den positiven oder in den negativen Bereich,
ergibt sich eben beispielsweise, wenn ich durch Null teile,
Einen Argustang, wenn es von Pi nehme, als Funktion,
wenn ich und eben sowas wie Nord in Number ergibt sich dann eben,
wenn ich sowas wie ungültige Operationen mache,
also sprich im regelwertigen Wurzel aus einer negativen Zahl,
Kehrwert vom Sinus, der jetzt größer als eins ist,
Infinity irgendwie durch sich selber zahlen würde,
was weiß ich.
So, hier ist jetzt nochmal dargestellt, wie die Codierung dazu aussehen.
Das, was bislang in den Beispielen immer war,
waren sogenannte normalisierte Zahlen, das sind also quasi immer genau diejenigen,
die also diese eine Vorkommerstelle haben mit dieser impliziten eins.
Und wo der Exponent eben Als Bitmuster, nicht aus
lauter Nullen oder als lauter Einsen besteht. Die Null,
beziehungsweise plus Null und Minus Null, da wird aber nicht unterschieden,
wird dargestellt durch einen Exponenten Null und hier als Mantise,
ein Vektor ausnullen,
eine denormalisierte Zahl hätte dann also hier als Exponenten eine Null und hier ein Bitmuster,
war es jetzt nicht aus lauter Nullen besteht.
Das heißt, damit kann man jetzt eben nochmal etwas kleinere Zahlen darstellen,
da nämlich diejenigen,
wo ich dann also quasi hier diesem Bittmuster keine Eins mehr stehen habe,
sondern da wird dann eben 0, und dann eben dieses hier noch folgen.
So, Infinity und Nord in Number sind dann eben kodiert
als Exponenten, als Vektor aus lauter Einsen.
Und hier in Vektor aus Nullen bzw. weckt er aus Einsen und irgendwas Ungleich Null.
Da ist es egal, was hier steht.
Das ist dann nämlich eigentlich auch wieder der Trick in der
arathmetischen Berechnung, wenn man damit weiter rechnet.
Das läuft erstmal wie eine ganz normale Zahl durch.
Nicht zwischenzeitlich wird dann eben nur der entsprechende Exponent dann,
also gegebenenfalls also umgesetzt
Gut, wie dann der Heirat damit gerechnet wird,
die Freien technisch, braucht uns jetzt in dem Sinne nicht zu interessieren,
aber das ist eigentlich das, wie in gängigen Programmiersprachen, Fließkommazahlen behandelt werden.
Das, was ich nachher auch immer noch so ein bisschen als Beispiele habe,
sind zum einen Java-Code, zum anderen C-Code,
ich vermute mal in Softwareentwicklung wird mit Java gearbeitet.
Wie gesagt, es wird jetzt nicht zwingend vorausgesetzt,
dass sie also alle programmiert oder die Programmiersprachen hier dann schon komplett können.
Also wenn ich jetzt hier Beispiele habe, gerade sowas kann ich immer sagen,
das gilt eigentlich unabhängig von der Programmiersprache dann auch,
weil das eben auch beliebige andere Programmiersprachen betrifft,
weil die dann eben auch entsprechende Fließkomma-Darstellung genauso haben und eben auch genauso benutzen.
Wie gesagt, das ist der Riesenvorteil von so einem internationalen Standard,
dass man sich dann auch wirklich drauf verlassen kann, dass das dort alles gilt.
So, hier sind es nochmal ein paar Beispiele.
Du warst jetzt eben bei arathmetischen Berechnungen mit Fließkommazahlen passiert oder passieren kann,
also wie gesagt, wenn ich null durch null teile,
komm not a number raus, wenn ich irgendwas anderes durch null teile, entweder plus oder minus unendlich.
Wie gesagt, das sind einfach so Rechenregeln,
wo jetzt also letztendlich drinsteht, was da alles passieren kann,
dass also hier für so ein paar Krudefälle,
wo man nur aufpassen muss, ist bei irgendwelchen Vergleichsoperationen,
also wenn ich jetzt vielleichte not a number, ist das gleich not a number,
dann gibt sich da jetzt eben nicht True, sondern Falls,
weil Wie gesagt, diese Kodierung von Nordde-Namen war das,
was eigentlich bei dem Vergleich passiert ist, ein Bitvisor-Vergleich.
Ist auch das Vorurzeichen. Und hier dieses Bitmuster kann dann
eben auch unterschiedlich aussehen. Von der Kodierung her,
in der Regel sollte das dann aber auch eigentlich generell,
also False ergeben, weil, wie gesagt,
die können unterschiedlich dann sein, Infinity größer als Nordde-Namen war,
auch da muss man sagen, macht der Vergleich keinen Sinn.
Auch da kommt dann anders als vielleicht intuitiv gedacht,
nicht unendlich groß, ist immer unendlich groß,
ist immer größer als alles andere, stimmt eben nicht,
sondern Da kommt dann auch Falls raus.
Gut, was man manchmal in irgendwelchen Datenblättern oder irgendwelchen Beschreibungen von Zahlendarstellungen
auch noch findet als Begriff, ist dann ULP, Unit in the Last Place.
Da geht es dann so ein bisschen um diese ganzen Sachen mit den Rundungen und den Genauigkeiten, die mit dir man da erreichen kann. Nicht,
wenn ich jetzt sage,
ich habe hier eine Fließkomma-Zahl und ich schneide nach so und so vielen Stellen ab,
dann wird man da typischerweise,
egal, also ob das jetzt im Dezimalsystem ist,
wird es hier in der Tafel oder im Dualsystem,
also spreche ich mit Nullen und Einsen, also eine Art Treppe,
die 754 Fließkommazahl, dass ich dann eben einfach sage,
wenn ich hier an einer bestimmten Stelle abschneide,
ich gucke, ich ist das,
was ich vielleicht noch an zusätzlichen Stellen habe,
im Dezima-System dann eben größer gleich 5 im Dualsystem,
würde ich dann eben gucken,
ist das 0 oder 1 und könnt dann,
also vielleicht noch entsprechend,
wenn das 1 wäre,
dann nochmal plus 1
irgendwie rechnen
So, diese Unit in The Last Place
ist dann eben letztendlich die Stellenwertigkeit der niederwärtigsten Stelle,
die ich jetzt in einer gegebenen Zahlendarstellung noch habe.
Das heißt, bei diesem Attribute,
Fließkomma-Format wird das dann sowas sein, wie dann in der Mantise,
dass niederwärtigste Bit hier in diesem Bittenmooster,
das wäre dann eben entsprechend diese Unit in The Last Place
So, und das, was dann eben jetzt hier nur gelten muss,
war es dann also letztendlich da auch in dem Standard auch noch festgelegt ist,
dass für die Standardoperation, Addition, Subtraktion,
Multiplikation und Division, eine Genauigkeit von 0,5 ULP eingehalten wird.
Das heißt, das, was die Rechenwerke machen, ist,
dass sie dann also quasi in der Berechnung noch ein paar
zusätzliche Stellen mit bereitstellen und dann ganz am Ende nach der Normalisierung runden,
weil dadurch wird dann überhaupt erst sichergestellt,
dass sich diese Unit eine Last Place erreiche.
Und wie gesagt, bei einigen anderen Operationen, Quadratwurzelsort, das eben auch noch entsprechend gelten.
Bei einigen mathematischen Softwarebibliotheken beziehungsweise entsprechenden Programmen wird das dann eben auch gewährleistet für andere Funktionen,
also Logarithmus, Sinus, Cosinus und so weiter,
weil also auch da ist natürlich immer die Frage,
wenn ich damit Wasser habe, damit irgendwie rechne,
wie genau kriege ich diese Zahlen dann entsprechend dargestellt,
wenn ich damit rechne,
wie genau ist dann das Ergebnis oder wo
treten da
irgendwelche Rundungseffekte auf
Teilweise kann man das in den Programmiersprachen, zum Beispiel auch abfragen,
also in Java kann ich dann also irgendwie Langmart,
Will P, nicht,
dann kriege ich da einen Double-Wert raus,
der dann also quasi diese Unit in the Last Place explizit angibt.
Ansonsten kann man eben sagen, bei Handlung von Rundung Fehlern ist es essentiell.
Damit müssen wir uns glücklicherweise in dem Fall jetzt nicht rumschlagen,
sondern das ist eben Rundungsalgorithmen etwas,
was jetzt also in diesem Standard definiert ist
Wenn man selber jetzt in die Verlegenheit kommt mit eigenen Daten,
Formaten, eigenen Fließkomma-Formaten zu arbeiten,
wenn jetzt andere Anforderungen in Bezug auf die Genauigkeit sind,
dann ist das also wirklich schon entscheidend,
dass man sich dann also auch nochmal wirklich Gedanken macht,
also wie rundig, mit welchen Algorithmen, das heißt,
drohen die schon bei Zwischenrechnung, rundig erst ganz am Ende,
wie viele zusätzliche Stellen brauche ich gegebenenfalls noch,
weil das sind eben irgendwo so Sachen,
wo man jetzt sagt, naja,
wenn ich jetzt hier irgendwie So ein paar einfache Sachen mache und hier aus den Übungsaufgaben,
also irgendwie so eine Textaufgabe, wo jetzt,
also irgendwie was mit drinsteht, mit Speicherkapazität in was weiß ich waren,
dann ist das egal nicht,
dann kann ich das nach drei oder vier Nachkommastellen runden.
Das interessiert nicht weiter. Wenn ich damit also irgendwie,
was weiß ich, in einer Frankfurter Börse die Aktienverwaltung programmiere,
dann soll da also jetzt nicht irgendwie ganz großzügig gerundet werden,
sondern dann soll das also schon extrem genau rechnen.
Und da gelten dann eben entsprechend ganz andere Anforderungen und
eben auch entsprechende Anforderungen beziehungsweise in dem Fall dann sogar
Zertifizierung für solche Rundungsalgorithmen
Gut, fehlt dann in dem Bereich der numerischen Mathematik.
Von daher, so ist das letzte gewesen sein. Gut,
jetzt zu den Zahlen, Zahlendarstellungen auch noch so ein bisschen was,
was wird jetzt eigentlich in der Praxis verwendet?
Dazu muss man eher sagen, dass die meisten Rechner,
also sprich die Hardware, die CPU ändern,
die da also verbaut ist, auf eine bestimmte Datenwortbreite optimiert ist.
Das, was war so im PC-Bereich, haben, sind inzwischen 64 Bit-Maschinen,
das heißt also 64 Bit als Datenworte für die entsprechenden Darstellungen mit entsprechenden Rechenwerken.
Früher waren das also 32 Bit. So war es wie kleinere Datenworte,
8 bis 16 Bits,
sind allerdings auch noch durchaus gang und gäbe,
weil wenn ich jetzt nicht die Rechenleistung brauche,
wenn ich irgendein kleines eingebettetes System habe,
war es jetzt also wirklich nur die Steuerung von der Kaffeemaschine übernimmt,
dann genügt ja also irgendein 8 mit Mikrocontroller,
der also nicht mehr als 15 Cent kosten darf
Weil der eigentlich nur abfragen soll, wird ein Taster gedrückt oder wird er
nicht gedrückt und ist noch Wasser im Wassertank oder war es das.
Und da kommt man dann eben auch mit sehr kleinen Mikrocontrollern dann eben entsprechend schon mit hin.
Wie gesagt, inzwischen sind wir hier wahr. 64 Betrechner. Gut,
was ich hier jetzt eigentlich nochmal so ein bisschen zeige,
beziehungsweise zeigen möchte, ist,
Wir kennen das jetzt natürlich von irgendwelchen Programmiersprachen und gerade in Java hat man also den Vorteil,
dass es dort also auch in der Sprache oder im Sprachstandard definiert ist,
wie welche Datentypen definiert sind.
In manchen anderen Programmiersprachen ist das aber nicht so,
also sprich beispielsweise NC, das ist also auch einer der Nachteile da jetzt,
also von der Sprache in anderen Programmiersprachen in der Regel auch nicht,
wo man dann eben auch sagen muss, je nachdem auf welchem,
welcher Computerhardware ich arbeite, habe ich unterschiedliche Zahlen- oder Zahlenformate.
Also in C habe ich zum Beispiel so als Datentyp sowas wie Entager,
Long-Intager, Character, also sprich ein Byte, Short,
das sollen dann also 16 Bits sein, das normale Fließkomma-Format 32 Bit 64 Bit.
Sowas wie Speicheradresse oder Adressen. So,
und bei 64 Bit-Architekturen, also das,
was also früher mal so ein Deck Alpha war,
sieht man dann eben, okay,
ein Entager ist also vier Byte lang,
32 Bit
Long Enteiger 8 byte, 64-Bit. Das,
was dann, sagen wir mal,
bis vor zehn Jahren irgendwie noch so mit aktuell war,
x, 86-Architektur, das waren 32-Bit-Rechner.
Da ist ein Integer 4 byte lang, ein Long-Integer aber auch.
Und auch bei den Speicheradressen sieht man,
also hier sind das 64-Bild, hier sind das 32-Bild.
Nicht inzwischen sind wir also hier bei x,
86 Architektur, IA 32 bzw. jetzt IA 64.
Nicht, dass ich das dann hier auch wieder anders aus. Das heißt,
Wenn solche Sachen jetzt nicht wie in Java irgendwo in der Programmiersprache definiert sind,
können sich die Datentypen also wirklich stark voneinander unterscheiden.
Und das ist eben nicht nur bei CSO,
sondern es ist also auch bei vielen anderen Programmiersprachen auch noch so.
Muss man wissen. Wird noch schlimmer,
weil es gibt also nicht nur Abhängigkeiten innerhalb der Programmiersprache,
sondern es gibt also auch noch abhängig,
also jetzt sprich auf welchen Prozessor oder welche Rechnerarchitektur ich das rechne,
sondern ich habe noch Abhängigkeiten von Betriebssystemen von Compiler
Wer sowas mal nachschlagen will, es gibt ja ein etwas
längeres Dokument, was man da also entsprechend runterladen kann.
Hier nur eine Tabelle davon. 16 Bit, 32 Bit, 64 Bit-Architektur.
Das Ganze jetzt hier einmal unter Microsoft, Windows, einmal unterm Linux-Betriebssystem.
Hier dann jeweils mit den jeweiligen Compilern und was man dann eben auch sehen kann,
ist, dass wirklich teilweise abhängig vom Compiler,
das heißt, wenn ich den Intel-Windows-Compiler nehme,
dann ist ein Long-Double 16 Wald lang,
wenn ich den Microsoft-Compiler nehme, also Visual Studio,
dann ist ein Long-Double nur noch 8 Byte lang.
Nicht, das heißt, ich kann jetzt nicht einfach mal eben sagen,
ich nehme meinen Code, habe den auf der Leichen Hardware,
mit dem Compiler kommt das raus,
mit dem anderen Compiler kommt was anderes raus.
Das heißt also, das sind wirklich so Abhängigkeiten, wo man sagen kann,
in der Regel ist der Code natürlich so, dass es da,
dass man da also jetzt nicht in irgendwelche Überlaufprobleme oder irgendwas mit reinläuft.
Aber es kann eben solche Fälle geben und das kann eben
wirklich also auch schon in irgendwelchen Eigenheiten von Compiler oder Compiler-Einstellungen liegen,
dass da dann also selbst, wenn ich identische Hardware nehme,
irgendwie was mache.
Das spricht jetzt natürlich eigentlich wieder so ein bisschen gegen das,
was wir gerne haben möchten, nämlich, dass unsere Algorithmen portabel sind. Das heißt,
ich schreibe mein Programm in einer Programmiersprache und wenn es jetzt eben nicht Java ist,
sondern wenn das jetzt beispielsweise C ist, kann es sein,
dass das eben auf dem einen Rechner so rechnet,
auf dem anderen Rechner,
vielleicht falsch oder
eben gar nicht läuft
Nicht, also auch das etwas, was dann also auf solchen Effekten beruht,
wo man da so ein bisschen aufpassen muss. Nicht,
deswegen sollte man dann typischerweise immer nachgucken,
sofern sowas angegeben wird, wie das dann eben entsprechend aussieht,
wie solche Vorarbeiten definiert sind oder was weiß,
wie das ist,
findet sich dann eben in der Regel immer in einer Dokumentation von der Software,
also in diesem Fall dann von den Compiler.
Gut, jetzt werde ich nochmal In diesem Kapitel also
relativ schnell. Hier ist auch vergleichsweise viel Wiederholung drin auf
die eigentliche Berechnung jetzt eingehen, wie man das macht,
was da vielleicht also jetzt auch noch an Problemen auftreten kann.
Also in diesem Fall jetzt über Lauf, über Lauf jetzt
gar nicht bei Fließkomma, sondern erstmal nur bei Intager-Darstellung.
Also wir haben Tradix-Darstellung, das heißt eben Zahlenbasis B,
beispielsweise an zwei, Ziffern dann eben 0 und 1,
sind betragener Zahl,
wo dann eben quasi definiert als
so eine Summe
Und damit wären dann eben meine Zahlen oder Zahlenbereiche definiert.
So, und was dort dann interessant ist, ist,
wie groß ist die Anzahl der Stellen. Also das,
was ihr gerade in der Folie eben hattet,
war ja dann also quasi Anzahl der Bytes,
beziehungsweise kann ich dann ja auch umrechnen, Anfall der Bits.
Nicht dem zuvor kann ich dann immer sagen,
ich habe hier dann eben 32 Bit oder 64 Bit zur Verfügung,
je nachdem, also ob das ein Int oder ein Long-End wäre.
Gut, bei Java Erstmal das Gute, habe ich gesagt,
da ist das Ganze in der Sprache fest definiert.
Da habe ich jetzt also auch nicht diese Abhängigkeiten von Compiler und Betriebssystemen.
Da gibt es dann also im Prinzip nur Zweierkomplimentzahlen,
die entweder 64, 32 oder 16 Bit lang sind.
Und wo man dann also im Prinzip immer abfragen kann,
was jetzt Max Value und Min Value von irgendwelchen Zahlen entsprechend ist.
Also beispielsweise, wenn ich ein 32 Bit Engiture habe,
Als zweier Komplimentszahl wäre jetzt eben eine kleinste Darstellware wert.
Die ist hier der größte darstellbare Wert dies hier.
Und entsprechend kann ich das dann also hier direkt abfragen. In anderen Programmiersprachen,
also wie gesagt, hier jetzt als Beispiel in C,
sieht das dann eben so aus,
dass das Plattform abhängig und gegebenenfalls also auch noch Compiler abhängig ist.
Dort wird unterschieden zwischen zweier Kompliment und Ganzzahldarstellung. Das heißt,
da gibt es nicht nur die Interpretation als Zwei-Komplimentszahl,
sondern also auch eine Interpretation als vorzeichnlose Zahl,
also sprich von 0 bis zwei hoch.
Anzahl der Stellen, minus eins. In bei Betriebssystemen wie Linux
kann ich sowas beispielsweise immer abfragen. Da gibt es dann
also irgendwie sowas für so eine Header-Datei, wo dann also Werte definiert sind.
Nicht, das entspricht dann letztendlich sowas hier,
wo ich dann eben immer in meinem Programm abfragen kann,
wie groß ist dieses, wie groß ist jenes.
Kann ich hier mal Kurz in der Hoffnung, dass ich jetzt mich hier nicht gleich reinreiße. So,
dass wir jetzt also hier irgendwie so eine Datei,
wo das dann also irgendwie alles definiert ist,
wo dann eben beispielsweise dann drin steht, wie groß die Wortgrößten sind,
das kann es dann auch über so bedingte Kompilierungen,
wo ich dann eben sage, entweder ich bin auf dem 64-Bit-System,
dann wäre eben Long Marks, diese Zahl,
wenn ich in, wenn dieses hier nicht zutrifft,
dann bin ich auch schon 32-Bit-System und wäre das dann eben diese Zahl.
Welchen Darüber habe ich dann eben quasi konstant definiert,
die ich in meinen Programmen benutzen könnte,
um jetzt solche Wertebereiche irgendwie abzufragen, beziehungsweise um da dann?
Irgendwie mir sowas anzusehen. Gut, die Sau noch mal,
Wiederholung vom letzten Mal, Addition im Dualsystem, wie gesagt,
funktioniert genau wie im Dezimalsystem, stellenweise entsprechend, ich rechne es aus.
War jetzt auch gerade in Übungsaufgaben drin, von daher
können wir das überspringen. Gut, was passiert dabei,
wenn ich jetzt begrenzte Wortbreiten habe, weil das ist jetzt das,
also worum es jetzt also in diesem Kapitel so ein bisschen geht.
Also ich habe, in diesem Fall ist das mal visualisiert für Vierbit,
mit Vierbit Unsigned, kann ich Zahlen von null bis 15 darstellen.
Das heißt, wenn in diesem Fall jetzt die Wortbreite weh ist,
dann sind meine Operanten von null bis zwei hoch weh minus eins groß.
Wenn ich die addiere, kann das Resultat wem zuvorgase von null bis zwei hoch
we plus eins minus zwei groß sein. Sprich,
größte Zahl hier wären 15, größtes Ergebnis,
was ich daraus bekommen kann, wären 30.
So, was man jetzt natürlich sieht, ist,
dass beim Ergebnis die Wortbreite größer wird, logischerweise um eine Stelle.
So, was passiert jetzt, wenn ich diese Stelle nicht habe?
Das heißt, ich innerhalb einer Wortbreite oder einer Größe in der Rechnung bleibe.
Das ist hier angedeutet, also die Wortbreite der Operanten und des Resultatses weh.
Und das, was passiert, ist, dass ich eben,
wenn ich größer werde, als jetzt die größte darstellbare Zahl,
Ich quasi ein Ergebnis als Überlauf bekomme,
wo quasi jetzt hier dieses oberste Bild verloren geht.
Und ich dann also beispielsweise sowas rechne,
wie 15 plus 1 beispielsweise, das Ergebnis wäre 16,
dieses Bild habe ich hier aber nicht mehr zur Verfügung.
Und das, was dann als Ergebnis rauskommt,
ist eine Null
Nicht, das heißt, da sieht man dann eben,
dass es dann in der Arathmetik,
also in diesem ganzen Bereich oder Kombination von Zahlen gibt,
wo ich dann also letztendlich Überläufe habe.
Diese Grafik, ich denke, sollte eigentlich klar sein,
ist einfach nur so, dass man sagt,
also hier in die entsprechenden Werte, hier der eine Operant,
jeder andere Operant und je nachdem, was ich dann also miteinander berechne,
würde sich dann also hier irgendwie das Ergebnis ergeben.
Beziehungsweise hier nochmal abgebildet, dass was passiert ist,
dass sich, wenn ich jetzt also hier Mein Ergebnis in
dem gültigen Wertebereich habe, ist das in Ordnung.
Wenn das Ergebnis größer wird, dann landet es eben wieder
entsprechend hier in diesem Wertebereich. Nicht, das ist also das,
was man dann hier unten noch irgendwo als Fazit hat,
dass eben Werte größer gleich zwei hoch der Wortbreite dann eben
in diesem Bereich von 0 bis zwölf Wortbreite minus 1 abgebildet werden.
Gut, das war jetzt erst mal nur anzahlend.
Wie sieht das jetzt mit der Subtraktion
aus,
Hatte ich ja vorgestern vorgestellt,
wird in der Rechnerarentmetik eigentlich gemacht als Addition des Zweier-Kompliments,
wo ich dann eben einfach dieses entsprechend zweier Kompliment bilde,
wo dann eben letztendlich gilt,
dass ich quasi die Subtraktion hier ersetzen kann,
indem ich dann eben dieses Kompliment nehme,
addiere,
dadurch,
dass die oberste Stelle da dann nicht mehr da ist,
habe ich dann eben entsprechend
mein richtiges Subtraktionsergebnis
So, und was man an der Stelle dann hart ist,
wenn ich jetzt also mit einer festen Wortbreite arbeite,
dass ich Überläufe nicht nur in die eine Richtung nach oben hin,
sondern also auch in die andere Richtung nach unten hin habe.
Das heißt, wenn ich sowas habe, wie jetzt vier Bit,
dann kann ich damit darstellen letztendlich Werte von minus acht bis plus sieben.
Nicht, und wenn ich jetzt eben rechne, minus acht minus eins,
Wasser minus neun wäre. Auch das würde dann eben nicht funktionieren,
sondern da würde dann eben entsprechend dann ein negativer Überlauf rauskommen.
Und das Ergebnis wäre dann in dem Fall dann also auf einmal die Sieben.
Nicht, das heißt, auch hier habe ich dann,
haben wir in die positive Richtung die Überläufe,
aber dann eben genauso auch in die negative Richtung die Überläufe.
Beziehungsweise, dass es dann hier dargestellt,
also dieses hier ist der darstellbare Wertebereich in einer festen Wortlänge weh
Und positive Überläufe würden quasi dann als negative Zahlen sich äußern, negative Überläufe würden sich dann als positive Zahlen äußern. Wie gesagt,
was dabei dann passiert,
also auch das wird dann nochmal in Übungsaufgaben, gegebenenfalls irgendwie drankommen,
ist, dass man dann eben einfach sagt, dadurch,
dass sich eben hier eine feste Wortbreite habe und damit jetzt also irgendwie irgendeine andere Zahl meinetwegen jetzt von abziehe,
Beziehungsweise, dass ein Kompliment dazu addiere,
dass ich dann also irgendein Ergebnis bekomme,
wo ich dann also hier irgendwo einen Überlauf habe,
was dann eben dazu führt,
dadurch,
dass ich den quasi wegfahren lasse und nur das hier als gültige Witz am Ende betrachte,
ich da dann eben genau in so einem falschen Wertebereich lande.
So,
wie kann man
Überläufe erkennen
Im Prinzip kann man das also relativ einfach machen,
indem man sagt, also wenn beide Operanen das gleiche
Vorzeichen haben und das Resultat ein anderes Vorzeichen hat.
Also ich addiere zwei positive Zahlen und kriege eine negative Zahl raus.
Offensichtlich, da muss irgendwas schiefgelaufen sein. Genauso,
wenn ich jetzt also zwei negative Zahlen addiere,
beziehungsweise eine große positive Zahl von einer negativen Zahl abziehe,
dann sollte das Ergebnis natürlich auch negativ bleiben,
ist es dann aber nicht mehr.
Und genau dadurch lässt sich
das machen
Kann man in Programmiersprachen, also hier so als Java-Code-Beispiel,
dann eben auch einfach dadurch abfragen,
dass sich das also quasi diesen Ausdruck dann hier in so eine logische Bedingung umsetze,
wo ich dann eben quasi hier von meinen Operanten A und B die Summe berechne und hier dann also quasi abfrage,
wenn A negativ ist,
wie negativ ist, die hier identisch,
also sprich gleiches Vorzeichen haben und dann das Vorzeichen von A und leichtem Vorzeichen der Summe ist,
Dann hätte ich eben genau diese Überlaufbedingungen.
Also das ist jetzt einfach irgendwie als Programmiersprachlicher Ausdruck letztendlich,
also das, was da hier textuell drinsteht. Gut,
diese Folie hatte ja also auch schon mal aufliegen,
wo man dann also im Prinzip diese Subtraktion nochmal hat durch Addition des B-Kompliments bzw. Zweier-Kompliments,
die Grafik gab es letzten Termin auch schon.
Was man an dieser Grafik nochmal sieht,
das ist jetzt nämlich nochmal so ein bisschen gemacht,
also diese Addition bzw. Subtraktion in zwei Komplimentarstellungen lässt sich
quasi interpretieren wie eine Winkeladition
Also will ich jetzt das auch nur ganz kurz am Beispiel mal zeigen,
können sich dann also in Ruhe nochmal nachvollziehen, wird als Übungsaufgabe oder Klausuraufgabe nicht drankommen, sowas zu zeichnen.
Also ich habe hier beispielsweise, wie gesagt, darstellbar jetzt, also bei vier Bit von minus 8 bis plus 7, der Zahlenbereich. Ich habe hier quasi eine Berechnung von zwei plus vier Ergebnisse,
so logischerweise sechs sein,
nicht der Winkel von zwei wäre bis hier,
der Winkel von vier bis hier,
wenn ich das also hier jetzt quasi als Winkeladition drauf tue,
dann lande ich eben genau hier bei der sechs und der Überlauf äußert sich dann eben dadurch,
dass dann also quasi hier in der Winkeladition das Ganze so groß wird,
dass ich dann hier also auf einmal in diesen negativen Bereich laufe,
wenn ich also beispielsweise jetzt vier plus fünf rechne,
dann wäre das Ergebnis natürlich neun,
die neun wäre auch an dieser Stelle,
wenn ich jetzt nicht ein Zwei-Kompliment hätte und da ist dann,
also diese Zahl,
die dann also in dem Fall dann zwei Kompliment-Darstellungen,
die minus sieben ist
Gut,
hier das Ganze jetzt nochmal für Überrechnung mit negativen Zahlen,
auch da gilt das im Prinzip mit der Winkeladition,
wobei ich da dann eben immer so weit rumlaufe,
dass ich dann jetzt also bei gültigen Additionen von negativen Zahlen eben wieder hier in diesem Bereich lande,
wie jetzt also hier beispielsweise minus zwei plus minus drei und das Ergebnis ist dann also hier diese minus fünf,
was dann also hier ist, dass ich sage,
minus zwei ist dieser Winkel Minus 3 ist dann nochmal dieser Winkel drauf und dann lande ich also wieder hier,
aber dann eben auch wieder in dem gültigen Bereich.
So, und da kann man sich das jetzt eben
so in einigen Beispielen nochmal so ein bisschen darstellen.
Gut, hier ist es ganz nochmal mit einer Kompliment,
das will ich jetzt aber auf Sideground hier in diesem Folge hier überspringen.
Wird also auch nicht weiter irgendwo nochmal nachgefragt. Gut,
jetzt im weiteren geht das eigentlich nochmal so ein bisschen auf
einige Eigenheiten von Signed und Unsigned-Darstellung in Programmiersprachen
Drauf oder möchte da nochmal ein bisschen drauf eingehen,
weil auch wenn das jetzt also hier ein C, mit sie vielleicht eine Programmiersprache ist,
die sie jetzt also nicht zwingend erstmal NSE kennenlernen werden oder noch nicht kennen.
Es ist aber eben schon so, dass bei vielen Programmiersprachen,
also wie gesagt, Java ist also eine löbliche Ausnahme,
es eben so ist, dass gerade so mit solchen Datentypen,
mit solchen Sachen doch einiges an Programmfehlern entstehen kann,
die sich also wirklich so aus ganz trivialen,
einfachen Sachen in der Arthmetik ergeben,
wo man also auf den ersten Blick immer denkt,
das ist doch einfach das Programm und warum rechnet das falsch?
Und wie gesagt, dazu werde ich dann also jetzt hier nochmal so ein paar Sachen zeigen oder vorstellen,
die sich ja so jetzt bei der Berechnung mit Unsigned, wie gesagt, in Java gibt es das direkt nicht, aber beispielsweise ein C ergeben können. Zum einen,
wo man dann eben immer aufpassen muss, ist Beispielsweise,
wenn ich jetzt sowas habe, ich habe jetzt wirklich ein Unsight-Intager,
das gibt es in C,
das ist ja also quasi 32 Bezahl habe und die dann also auch komplett als Unsight interpretiere,
was ich da natürlich nicht machen darf,
dass ich jetzt von irgendeinem Wertcount,
der was weiß ich wie initialisiert ist,
zwei abziehe und ich jetzt gar nicht vorher abgefragt habe,
ist Count wirklich größer, gleich zwei und was dann passieren kann,
ist, dass wenn Count jetzt eben beispielsweise nur eins ist,
Diese arrometische Operation findet also quasi ganz normal statt.
Addition 2er Compliment, das, was sich dann eigentlich rauskriegen würde als Ergebnis,
wäre jetzt ja beispielsweise ein Countlight 1, das ist eine Minus 1.
Die Minus 1 ist in,
wenn ich die jetzt den Bit-Vector nehme und mir gucke,
den jetzt als Antsign zu interpretieren,
ist dann aber auf einmal eine sehr große Zahl.
Nicht was dann dazu führen kann,
dass ich hier beispielsweise in so einer Schleife dann über irgendwelche Re-Elemente iteriere,
die es gar nicht gibt oder da so irgendwelchen anderen,
irgendwelche anderen Programmfehler reinlaufe
War es mal dann also in einigen Programmiersprachen auch noch hat,
eben, wie gesagt, hier im Beispiel C,
sind sogenannte Casting-Regeln,
wo ich also jetzt quasi explizit über so einen Cast,
also so eine Typanpassung sage, wie jetzt irgendwas interpretiert werden soll.
Und wenn ich jetzt in einer Sprache sowohl Zeit als auch Unside habe,
eine Zahl nehme, die jetzt aber quasi anders interpretiere,
dann kann es natürlich sein,
dass ich einen anderen arathmetischen oder einen anderen Zahnwert daraus bekomme
Also sprich, wenn ich jetzt einen Short-Entager habe,
den jetzt als Unsigned interpretiere, da ändert sich nichts.
Wenn dieser Short-Entager aber eine negative Zahl ist und ich den als Amtszeit interpretiere,
erhalte ich also eben auf einmal eine positive Zahl,
weil im Unsigned-Zahlenbereich habe ich ja dann noch deutlich mehr
positive Zahlen zur Verfügung.
Das, was bei einer Signe beziehungsweise bei einer Zwei-Kompliment-Darstellung
ja dann die negativen Zahlen sind
Ich weiß ja nicht, ob das jetzt irgendwie klar ist,
worauf ich hinaus wollte. Kann man sich hier an
dem Zahlenkreis veranschaulichen, also hier für vier Bit.
Nicht bei einer Science-Zahlendarstellung habe ich ja hier positive Zahlen und
dieser Tal, hier sind dann die negativen Zahlen.
Bei einer Ansign-Darstellung hätte ich dann ja hier von null bis 15
nur positive Zahlen. Und dieser Fehler,
da eben dieses Beispiel war jetzt eben,
dass ich quasi eine negative Zahl nehme,
die dann also auf einmal als Sign-Interpret-Anzahl interpretiere und dann wäre
es eben entsprechend große positive Zahl
Gut, hier jetzt nur Constant Nancy,
wenn nichts angegeben wird, Sein zu interpretieren,
wenn dann U dahinter steht, wäre es eben eine Ansign-Zahl.
Hier ist dann eben auch nochmal abgebildet, dieser Effekt,
was passiert, wenn ich von Unsign-Darstellung in Zweier-Kompliment gehe oder umgekehrt.
Nicht, dass wenn ich, also hier eine entsprechend große Ansign-Zahl habe,
die sind zwei Komplimenten nicht, dann wird es eben eine negative Zahl.
Umgekehrt, wenn ich im Zweier-Kompliment eine negative Zahl habe,
das Ganze als Ansight interpretiere, erhalte ich dann eben eine entsprechend große,
positive Zahl. Hier sieht man jetzt nochmal,
wo man sich gerade so bei rathmetischen Ausdrücken und bei Abfragen,
also sprich bei Vergleichsoperationen, also relativ schnell irgendwelche Fehler einhandeln kann.
Also gerade dadurch, dass ich jetzt also hier unterschiedliche Darstellungen habe,
wie gesagt, das ist jetzt also nur in Programmiersprache C,
bei Java ist es also, habe ich dieses Problem nicht,
weil da gibt es also keinen Ansignt-Zahlen in dem Sinne.
Nicht aber, dass ich hier also Effekte haben kann,
dass wenn ich jetzt also ein Vergleich habe, mit gemischten Operanen,
dann wird er eben immer als Unsigned ausgewertet. Und ich habe jetzt also hier minus eins,
kleiner als Null, diese Null, das war also eine Konstante,
die ist so explizit als Ansigne gekennzeichnet, ist ein gemischter Vergleich,
also in dem Fall zweier Kompliment und Unsigned,
wird jetzt also auf einmal jetzt also als Signed Entsprechend ausgewertet,
die minus eins inside, ist aber eine sehr große Zahl,
demzufolge ergibt sich hier dann als Ergebnis oder als Unside ist dann eine sehr große Zahl, ergibt sich dann eben hier als Ergebnis eine Null und nicht.
Also sprich False und nicht das, was es eigentlich sein sollte, nämlich dass diese Ausdruckdruckur ergibt. Und wie gesagt,
das sind jetzt natürlich,
also irgendwie hier immer so ein bisschen rausgesucht, irgendwelche akademischen Fälle,
weil in der Regel wird man sowas natürlich so jetzt,
dass es vielleicht nicht so programmieren, aber dass man einfach nur sieht,
Da muss man eben schon aufpassen, beziehungsweise Quintessenz,
also eine Lehre, die man da vielleicht draus ziehen kann,
ist, man sollte in seinem Programm jetzt nicht sehr viele sehr unterschiedliche Datenformate,
Signed und Unsigned und irgendwas miteinander mischen, sondern sich ein Zahlenformat nehmen,
also typischerweise nicht in den Java, ist das ja so,
würde ich eben sagen, ich nehme eine Science-Zahlen-Darstellung, also Zweier-Kompliment,
alle Zahlen und auch alle Konstanten sind zwar ja Kompliment,
damit rechne ich und dann habe ich damit erstmal kein Problem,
außer vielleicht über oder Unterläufen, aber eben sowas wie hier,
wo wirklich, also relativ triviale Vergleichsoperationen,
also erstmal gefühlt falsch gehen,
war ich dann also hier mit Typecast und wissen muss,
wann wird was,
wie interpretiert.
Das wird dort dann also letztendlich dann nicht auftreten. Gut,
was in dem Zusammenhang dann auch immer noch wichtig ist,
wie sieht das aus, wenn ich jetzt unterschiedliche Zahlenformate hinsichtlich der Wortlänge habe?
Also ich habe jetzt eben einen Injure, der hat klein wie stellen.
Und der soll jetzt also beispielsweise länger gemacht werden.
Also das heißt, ein, um Karstellen erweitert werden,
soll aber logischerweise natürlich numerisch den Leichen wert behalten.
Und das, was man da immer macht,
ist etwas, was sich dann Science Extension nennt.
Das heißt, dieses hier wäre meine ursprüngliche Zahl.
Und das, was ich mache, ist,
dass sie dann dieses Moos significant bit oder hier jetzt Vorzeichen mit genannt.
Das ist natürlich kein Vorzeichen in dem Sinne Betrag und Vorzeichen,
sondern also wirklich so das höchstwertigste Bit.
Bei zwei Kompliment kann ich das aber oder bezeichne ich das also auch dann immer mal als Vorzeichen,
weil ich da dann eben auch immer sagen kann,
wenn das null ist, ist die Zahl größer gleich null.
Wenn das A1 ist, ist es eine negative Zahl.
Gut, jedenfalls, also ich nehme dieses Bild und vervielfache das.
Nicht das heißt, die Zahl 6 in Vierbit,
Zahlendarstellung, ist dieser Vektor, 8bit, 16bit,
nicht das heißt, da werden jetzt null vorgeschrieben.
Und das, was jetzt eben wichtig ist, kann man sagen,
ja gut, da schreibe ich immer null vor. Nein,
das, was jetzt wichtig ist,
jetzt eben bei zwei Komplimentarstellungen, dass ich,
wenn ich hier eine Eins habe und es soll jetzt eben auch wieder logischerweise eine negative Zahl bleiben,
dann kaufe ich da jetzt eben natürlich keine Nullen vorschreiben,
sondern muss ich nicht eins davor schreiben.
Das ist also das, was dann hier mit dieser Silent Extension gemeint ist,
dass ich dieses Bit da nehme und dann eben entsprechend hier damit vergrößer.
Auch damit kann man sehr schnell in irgendwelche Programmierfehler reinlaufen,
also hier auch nur so ein etwas notorisches Beispiel,
wo man auch sagen kann,
also das ist aus so einem Buch Java Pazlas,
Wo ich ja auch sage, das sind zwei Konstanten.
Diese Zahl, Hexadezimal, eins, und da kommt ein
ganzer Satz von Nullen als Long, plus Hexadezimal, C-A-F-E-B-A-B-E.
So, und jetzt würde man natürlich sagen, okay, was kommt dabei raus?
Nicht, wenn ich jetzt also irgendwie die Stellen nehme,
dann wäre das eins und dann C-A-F-E und so weiter.
Und das ist eben falsch. Weil das,
was hier passiert bei dieser Addition, das ist eine Long-Zahl,
dass aus dieser Zahl hier auch eine Longzahl gemacht wird.
Diese Zahl hier, Hat aber als Most Significant Bit eine Eins.
C, Hexa dezimale ist eins, also der Vector 1, 1, 00.
So, diese Eins wird dann also auch entsprechend persalen Extension vervielfach. Das heißt,
wenn ich hier raus eine Long mache, habe ich diesen Vector,
der dann hier vorne lauter Fs hat und wenn ich da jetzt die Eins hinzu addiere,
kommt das raus und nicht das,
was man jetzt,
also als erstes denkt,
wo also quasi jetzt hier an dieser Stelle
eine Eins steht
Das heißt also, auch da passieren Fehler,
ansonsten passiert das ja nun auch gestanden in größeren Firmen und professionellen Entwicklern,
dass also irgendwie bei Zahlendarstellungen, Arithmetiken Probleme auftreten,
eines der berühmtesten oder teuersten Beispiele war also der Erstflug der Ariane 5,
also die, markiert ja schon ein bisschen länger her nun,
die Juni 1996 im Prinzip abgestürzt ist,
beziehungsweise sich dann selbst irgendwann zerstört hat,
weil die Rakete der Meinung war,
dass sie gerade am Abstürzen ist und irgendwo aufbewohntes Gebiet oder irgendwo runterfällt.
Und in dem Fall war es halt eben so,
dass beträchtlicher Schaden standen ist. Und letztendlich, ja,
was ist passiert? Man hat die Software von einem Vorgängermodell übernommen.
Jariane 5 war jetzt natürlich also deutlich größer, leistungsfähiger,
schneller, hat aber die gleiche, die gleichen Programme oder Programmbestandteil.
Und das, was passiert ist, war also intern,
es wird also 64 Bit Lightcomma, Wert für,
in diesem Fall jetzt also für die horizontal, aber eben eigentlich für alle anderen Geschwindigkeiten irgendwo genommen.
Der wird irgendwann nachher in der Berechnung in ein Indie-Charme mit relativ begrenzte Wortlänge 16 mit in diesem Fall umgesetzt. So,
und dadurch, dass jetzt hier bei dem neuen Modell,
das eben sehr viel schneller war, dass diese Zahl entsprechend größer war,
kam es also dann bei dieser Umwandlung dann eben zum Überlauf,
der vorher also nicht aufgetreten ist, war es dann dazu führte,
dass In dem Fall die Steuerungssoftware der Rakete,
also hier auf einmal keine positiven,
sondern irgendwie eine negative Zahl bekommen hat und gesagt hat,
ich habe keine vernünftigen Sensorwerte mehr, ich habe hier irgendwelche negativen Beschleunigungen,
ich falle irgendwie runter, ehe jetzt sonst nicht Schlimmeres passiert,
zünde ich also irgendwelche Explosionsladung und ja,
das ist dann eben letztendlich das, was dabei passiert ist.
Wie gesagt, kann man also auch irgendwo nochmal nachlesen. Wurde also relativ aufwendig dann also aufbereitet und nachgemacht. Aber wie gesagt,
das sind so die Fehler,
die also letztendlich dann bei solchen Systemen vorkommen und vorkommen können,
wo man dann eben auch immer sagen muss,
auch das, denke ich mir,
werden sie also in SE ja sicherlich auch lernen als gute Programmierpraxis,
also Programme entsprechend sauber zu dokumentieren,
irgendwelche impliziten Annahmen über irgendwelche Argumente, über irgendwas,
also vernünftig mit anzugeben und so weiter und so fort,
weil Wie gesagt,
sowas ist natürlich also irgendwie so ein klassischer Fehler,
dass man sagt, naja,
bei dieser Konvertierung hätte ich jetzt irgendwo mit reinkodiert in eine Abfrage,
dass dieser Gleitkommawert nicht größer sein darf als das und das,
wäre dieser Fehler gar nicht aufgetreten.
Aber dadurch, dass dieser sehr große Wert beispielsweise vorher eben
ja nie erreicht worden ist, auch nie getestet worden ist,
hat man gesagt, wunderbar, funktioniert, nehme ich.
Und in dem Fall war dann eben so eine implizite Annahme,
Werte größer als gehören jetzt in diese Art von der Umrechnung gar nicht benutzt werden,
dann eben nicht im Programmquoten mit drin. Gut,
ja, soviel zu den Operationen, Additions- und Fraktionen,
Multiplikation, hatte ich also auch schon kurz vorgestellt,
passiert, also Binersystem beziehungsweise Science-Unscience-Darstellung eigentlich genauso wie im Dualsystem,
nicht wo ich dann eben entsprechend das Ganze irgendwie ausrechne,
stellenweise dann eben immer meine Zahlen, wenn ich jetzt also hier Das habe multipliziere mit dem entsprechenden Teil des Multiplikators und dann eben aufsummiere.
Ich war ja noch gerade in allen Übungsaufgaben gefordert. Gut,
wie sieht das jetzt aus, wenn ich also auch bei
der Multiplikation jetzt mit festen Wortbreiten arbeite?
Was kann da passieren? Also Zahlenbereich der Operanten,
wenn ich jetzt unsigned bin, von 0 bis 2 hoch
w minus 1, Zahlenbereich des Resultats, kann dann also
sein von 0 bis 2 hoch w minus 1 Quadrat,
binomische Formel, habe ich sowas hier, was man hier sehr schön sieht.
Der Zahlenbereich kann also entsprechend doppelt so groß sein.
So, wie gehen Programmiersprachen damit um? Gut,
Java brauchen wir es darum, nichts zu kümmern.
Da gibt es gar keine Angst seinen Zahlen.
In C sieht das eben so aus,
die Argumente müssen klein genug sein, weil das Resultat nur die untersten Bits enthält.
Also auch da ist dann immer etwas,
dass man sich also quasi jetzt überlegen muss,
in seinen Algorithmen, wie groß werden meine Zahlen,
wie groß werden die Ergebnisse,
habe ich dadurch dann also auf einmal
solche Überlaufsituationen
Hardware seid, ich beziehungsweise teilweise auch gerade so bei eingebetteten Systemen,
gibt es dann sogar noch arathmetisch richtige Ergebnisse,
weil dann gibt es also eigentlich zwei Teilergebnisse,
nämlich einmal die höherwertigen und die niederwärtigen Bits des Resultats.
Beim Zweier-Kompliment, Berechnung, also zwei Komplimente ist dann quasi immer entsprechend Design-Darstellung.
Auch da gilt natürlich, dass sie die Wortbreite verdoppeln kann. Und das,
was dann eben passiert, egal welche Programmiersprache ich nehme,
das Resultat enthält, Immer nur die unteren Bild und Überläufe werden ignoriert.
Und das ist eben der Grund dafür,
das hatte ich ja also schon mal so als Beispiel,
ganz am Anfang, als ich Motivation hatte, Rückwirkungen von den unteren Ebenen,
nicht was kann sich da irgendwie auswirken, wo man sagen kann,
okay, wenn ich hundertmal, 200 mal 300 rechne,
dann kann ich das noch als 32 Bezahl darstellen.
Wenn ich das Ganze jetzt aber hundertmal,
200 mal 300 mal 400 rechne,
habe ich einen Überlauf bei einer Science-Darstellung oder halt als Ergebnis
dann auf einmal
eine negative Zahl
Gut, auch bei sowas kann man dann immer sagen.
Selbst in Programmiersprachen, wo man jetzt meint,
da ist einiges, also irgendwie sicher und problemlos möglich.
Sollte man sich dann immer noch so ein bisschen Gedanken machen,
was wird eigentlich gerechnet?
Also hier ist ein, als Beispiel auch aus diesem Buch
Mikrosekunden pro Tag
24 Stunden, mal 60 Minuten, mal 60 Sekunden,
mal tausend, mal tausend, dann habe ich Mikrosekunden,
Millisekunden wäre dieser Ausdruck.
So, wenn ich die durcheinander teile,
dann sagt einem die Schulmathematik wunderbar, Kürzen, Kürzen,
Kürzen, Kürzen, als Ergebnis kommt tausend raus.
Wenn ich das ausrechne, kommt da fünf raus und nicht tausend.
Jetzt habe ich ja gesagt, ja, das ist jetzt hier,
soll ein Long sein, also mit der Sprechner Genauigkeit,
warum passiert das da
immer noch
Und da ist jetzt wieder das Gemeine,
da muss man am Ende eben auch wieder jetzt irgendwie in
die Sprachen gucken und sehen, wie sind dort Datentypen deklariert.
Wie ist diese Mantik hinter diesen Datentypen? In diesem Fall nennt sich,
ist dieses Jahr als Feindlung, das heißt,
es wird erst gerechnet und am Ende wird dieses Ergebnis eine Longzahl.
Diese Berechnung hier findet aber noch nicht mit der großen Wortbreite statt,
sondern in diesem Fall jetzt noch mit 32 Bit und
dadurch kommt es dann zu diesem Effekt
Sowas könnte man jetzt umgehen, indem man also künstlich eine dieser Zahlen explizit dann als Long-Kennzeichnet,
weil dann wird also auch die gesamte Arrandmetik schon in 64 Pit gemacht.
Also auch das ist wieder so ein bisschen gemein,
da muss man jetzt eben wissen, konstanten,
ohne explizite Elfe Long sind erstmal nur 32 Bit in Java und wenn ich das so mache,
kann da eben so ein Problem auftreten.
Gut, wie gesagt,
das sind jetzt natürlich immer entsprechend so ein bisschen herausgesuchte akademische Fälle,
nicht aber einfach nur, um zu zeigen,
dass also bei vielen Sachen wo man sagt, naja,
Programmierung ist ganz trivial, man da dann doch schnell in irgendwelche Probleme laufen kann.
Und wie gesagt, hier mit Konstanten ist es natürlich kein Problem.
Wenn diese Zahlen jetzt aber selber das Ergebnis irgendeines Funktionsaufrufs
sind oder von irgendeiner anderen Prozedur her generiert werden,
nicht dann sollte man oder dann können eben solche Effekte dafür sorgen,
dass es da also zu Problemen gibt.
Gut, hier ist dann nochmal Kurz beschrieben,
die Vision im Dualsystem, wie das letztendlich gerechnet wird.
Auch da muss man sagen, funktioniert eigentlich genauso wie im Dezimalsystem.
Ich werde das jetzt also auch relativ schnell jetzt überspringen.
Was man vielleicht jetzt nur wissen muss für eigene Programme oder Programmierung.
Division mit Hardware-Unterstützung ist dann schon nicht mehr ganz so gängig,
wie jetzt also irgendwie eine Multiplikation, also Addition, Subtraktion, okay, das ist klar.
Multiplikation haben inzwischen eben auch die meisten Prozessoren als spezielle Rechenwerke,
die das also wirklich direkt machen und jetzt nicht,
wie ich das hier an der Tafel machen würde,
mit Talsummen bilden, verschieben auf agieren und so weiter.
Damit kann ich das natürlich mit einer ganz normalen Addition machen,
aber in der Regel haben die CPUs bzw. die Kerne in den aktuellen Prozessoren dann eben auch schon spezielle Hardware,
die dann also eine Multiplikation dann eben schon direkt in einem Schritt machen kann,
bei der Division ist das dann aber jetzt eben wirklich noch vergleichsweise sehr selten der Fall,
wenn überhaupt, deswegen muss man auch immer sagen, im Hinterkopf behalten.
Also die Vision ist in der Regel langsamer als eine Multiplikation. Gut,
ansonsten, genau eigentlich wie im Dezimalsystem gewöhnt,
wenn ich also jetzt hier diese Zahl durch drei teilen würde,
würde ich dann eben auch gucken, ich nehme die erste Stelle,
die kann ich nicht durchhalten, teilnehmen nun die ersten zwei Stellen,
hoah, die kann ich durch drei teilen,
beziehungsweise kann davon die drei abziehen,
wo wir das machen, halt als Ergebnis null,
wenn ich dem zufolge,
kann ich das ja einmal von abziehen,
hier konnte ich es
noch nicht
Von der Null kann ich nichts abziehen, von 0-0, immer noch nicht.
Dann habe ich hier eine Eins und irgendwann hier hinten,
wenn ich jetzt also diese 1-0-0 habe,
dann kann ich davon eben jetzt hier wieder die Dauer abziehen und erhalte dann
noch eins als Rest und in dem Fall war das jetzt,
also hier diese Null die letzte Stelle war,
ist das dann letztendlich mein Ergebnis.
Ist im Prinzip genau das Gleiche, wie ich das,
das im Dezimasystem auch mache.
Ich nehme jetzt also quasi immer eine bestimmte Anzahl von Stellen.
Gurke kriege ich vielfache von meinem Dividenden
davon abgezogen
Und rechne dann also mit dem Rest weiter und nehme dann
eben wieder neue Stellen des Divisors dann hier mit dazu.
Nicht hier das Ganze nochmal für ein etwas größeres Beispiel,
also wo ich dann also 91 durch 13 berechne.
Ich würde dann eben sagen,
wenn ich jetzt hier die ersten vier Bit nehme,
1001, davon kann ich das noch nicht abziehen,
hätte hier also erstmal eine Null,
dann nehme ich die Null noch mit hinzu von diesem
dieser Zahl kann ich das abziehen,
würde das also hier berechnen
Hätten Asias Ergebnisse eine Eins,
würde dann eben mit dem Rest und der nächsten Stelle hier
dann also quasi weiterrechnen und in diesem Fall geht das Ganze dann auf,
weil 13 mal 7 ist dann 91. Gut,
wie sieht das jetzt mit komplexeren oder höheren mathematischen Funktionen aus?
Also Wurzel, Logarithmus, Exponentialfunktionen, die ganzen arrithmetrischen Funktionen.
Da kann man immer nur sagen,
das was im Prinzip bei den Berechnungen gemacht wird,
ist, dass man da in der Regel irgendwelche Approximationsfunktionen nimmt.
Das heißt also, irgendwelche Methoden, um beispielsweise über Polynome
diese Funktion dann anzunähern. Und je nachdem,
je nachdem, um welche Funktion es sich handelt,
habe ich dann eben entsprechend unterschiedliche Verfahren zur Verfügung
Wie gesagt, das fällt dann jetzt also in den Bereich
der numerischen Mathematik. Da muss man sagen,
das muss glücklicherweise natürlich auch nicht irgendwie selber programmieren,
sondern in der Programmierung habe ich dann also ja irgendwo meine Funktion Sinus,
die ich jetzt also aus irgendeiner Bibliothek einfach aufrufen kann mit dem Argument.
Und der liefert mir dann eben entsprechend den Sinus. Und das,
was ich dann logischerweise dahinter verbirgt, aus dieser Bibliothek,
ist dann eben so eine, wie auch immer,
geartete Approximationsfunktion, die dann also quasi entsprechend diesen Sinus berechnet.
Und dann eben diese Funktion, also Wurzel ziehen,
Logarhythmus und was auch immer, zurückführt auf die vier grundreichen Arten.
Weil das ist das, was die Computer können.
Additionssubtraktion, Multiplikation und eben, wie gesagt,
mit so ein bisschen Einschränkung oder eigentlich eben auch noch Division.
So und alles andere wird irgendwie dann immer auf diese vier Grundrechenarten zurückgeführt.
Gut, hier sind jetzt nur so Beispiele über solche Approximationsfunktionen.
Wie gesagt, also auch das etwas, was wir dann
also im Zweifelsfall jetzt so erstmal nicht wissen müssen.
Also in diesem Fall hier zum Beispiel sowas wie Kehrwert,
also eins durch X,
kann man iterieren
Durch so eine Folge, wo ich dann also Y von iPlus 1 berechne,
Y von i mal 2, minus x mal Y i,
vorausgesetzt, ich habe einen geeigneten Startwert, also einen Schätzwert.
Hier einmal ein Beispiel, x soll 3 sein,
also es soll ein Drittel berechnet werden. So,
jetzt sage ich natürlich nicht, also mein Ergebnis ist 0,3 Periode,
sondern ich weiß das ja noch nicht, sondern sage,
okay, das ist irgendwie im Bereich 0,5.
Und wenn ich damit jetzt also hier rechne und das einfach stumpf über mehrere Iterationen laufen lasse,
dann sieht man, dass das also hier in der sechsten Iteration,
also hier schon ganze Folge von dreien,
also quasi als Nachkommastellen irgendwo erzeugt hat.
Und je nachdem, wie genau ich jetzt also mein Ergebnis brauche,
beziehungsweise meine Funktion,
habe ich dann eben 10 oder 20 oder 30 Schritte und sage,
okay, jetzt ist das eben hinreichend genau nicht.
Und damit habe ich dann eben sowas wie den Reziprogwert berechnet.
Gut, und wie gesagt, in der numerische Mathematik
gibt es eben sowas für alle möglichen Funktionen.
Also hier auch nochmal so ein anderes Beispiel.
Berechnung der Quadratwurzel über so einen Ausdruck,
wo man dann eben auch sagen kann, vorausgesetzt,
ich starte hier mit einem vernünftigen Startwert, konvergiert das Ganze relativ schnell.
Nicht also auch da muss man sagen,
gibt es dann also relativ viele Methoden,
die sowas dann also irgendwie vernünftig machen und lösen in der Regel
sehen wir davon natürlich nicht,
sondern das ist aus irgendwelchen Programmbibliotheken dann quasi dort vorgegeben
Gut, dann hatte ich ja in einem zweiten Kapitel,
als es also um diese Begriffe Informationen ging,
ja nochmal geschrieben, welche mathematischen Eigenschaften gelten eigentlich jetzt bei
der Informationsverarbeitung im Computer in Bezug auf die Repräsentation.
Wie gesagt, der Begriff Information, das abstrakte Wissen,
Repräsentation, dann eben die Darstellung,
die ich gewählt habe,
um das letztendlich irgendwie darzustellen
Ich war dort ja so relativ genau beschrieben. Und da hatte ich
also dieses hier quasi einmal auch aus Folien mit aufgelegt,
nicht wo man sagt, gilt, x Quadrat größer gleich null.
Bei Fließkomma-Zahlen ja. Bei Scient-Darstellung nicht,
weil wenn ich da eben eine begrenzte Wortbreite habe, also genau das,
was, sagen wir jetzt hier vor einer halben Stunde irgendwie als Folie auflag,
kann ich eben entsprechend einen Überlauf haben und demzufolge Dann auf einmal statt einer großen,
positiven, eine negative Zahl erhalten.
Andere Sache, so war es wie das assoziativ Gesetz. Auch das Standort, also quasi als Frage, war Intergior-Berechnung gilt es? Bei Fließkomma-Berechnung eben nicht. Das war genau das,
womit ich heute noch so ein bisschen angefangen hatte,
nämlich also die Möglichkeiten, was passiert ist bei Fließkomma-Berechnung hinsichtlich,
den Zahlendarstellungen und in diesem Fall ist es dann eben so,
dass man sagen kann, okay,
wenn ich hier die Klammern verschiebe und die beiden Zahlen addiere,
kriege ich also arethmetisch dann auch wirklich sauber eine Null raus und als Ergebnis die 3,14,
wenn ich die beiden berechne, dadurch,
dass die Exponenten so stark unterschiedlich sind und sich dann nicht genügend Zeichen habe,
um das in der Mantesse darzustellen,
wäre das Ergebnis von dieser Addition dann eben auch minus eins,
Marceno 10 hoch 20 und dem zuvor gewähre dieses Ergebnis dann eben Null.
Gut, Jetzt hier auf den verbleibenden Folien dieses Kapitels
sind noch ein paar Begriffe jetzt dargestellt,
also eigentlich jetzt zu den mathematischen Eigenschaften, die sich da ergeben.
Also das, was gilt,
wenn ich jetzt eine Ansigned-Arrithmetik habe mit einer begrenzten Wortbreite,
dann ist das eine kommunitative Gruppe.
Das heißt, ich habe die abgeschlossenheit,
das heißt unter einer additiven Operation gilt,
dass A plus B
eben immer in diesem Wertebereich sind
Was natürlich sein kann, ist, dass ich quasi Überlaufsituationen
habe und also nicht mehr das richtige athmetische Ergebnis habe.
Es gelten Kommutativ und Assoziativgesetz. Es gibt ein neutrales Element,
die Null. Und es gibt eben sowas wie ein Inverses,
nämlich das, womit ich also normalerweise sonst das Zweier-Kompliment bilde,
nämlich die Zahl, die ich dann einfach dazu addiere,
sodass das Ergebnis dann, beziehungsweise diese Zahl dann,
es war auch weminus A ist.
Und wenn ich das dazu addiere, erhalte ich als Ergebnis die Null.
Bei der Scient-Artmetik Genau das Gleiche, beziehungsweise auf Bit-Ebene sind Signed und Unsigned
auch identisch. Gilt genauso, Abgeschlossenheit, Kombotativgesetz assoziativgesetz.
Es gibt ein neutrales Element, es gibt ein Inverses.
Hierhin da ist das Inversum dann eben wirklich das,
was wir auch als Darstellung jetzt im Zweierkompliment der Zahl eigentlich typischerweise kennen.
So, hinsicht in der zweiten Operation der Multiplikation kann ich
eben sagen, Unsigned Arrethmetik, Wortbreite auf Wie begrenzt.
Das Ganze beschreibt dann quasi was wie eine Modulo-Artmetik,
also einmal B-Modulo 2 hoch weh, weil ich ja gesagt habe,
wenn ich zwei Zahlen miteinander multipliziere,
würde das Ergebnis eigentlich die doppelte Wortbreite benötigen.
Dadurch, dass sie nur die einfache habe,
dass es eben genau dieses Modulo 2 auch weh,
erhalte ich dann im Ergebnis nur die unteren Bilds, die dann überbleiben.
So, und wenn ich jetzt Multiplikationen, Additionen zusammennehme,
also das soll jetzt hier eine Multiplikation, das soll eine Addition sein,
dann ist das eben ein sogenannter Kommutativer Ring.
Das heißt, Die Addition als eine komputative Gruppe.
Auch die Multiplikation ist abgeschlossen, auch für die Multiplikation gilt
das kombutativ Gesetz und das Assoziativgesetz.
Es gibt neutrales Element, die Eins. Und mit den
beiden zusammen gibt es dann eben Distributivgesetz. Das heißt,
einmal B plus C ist gleich A, mal B plus A, mal C.
So, bei der Scient Arithmetik kann man eben sagen,
Scientre und Ansign ist auf Bit-Ebene identisch.
Und auch da ist das Ganze letztendlich auch identisch zu dem,
was ich hier war, der Unside-Hardmetik habe. So,
wo man da jetzt nur aufpassen muss, ist eben wegen dieser Überlaufproblematik,
wenn ich jetzt mathematisch gesehen normales Zahlensystem nehme und sage,
das ist als mathematische Struktur ein Ring,
dann habe ich da eine bestimmte Ordnungsrelation auch mit drauf, nämlich,
wenn A eine Zahl größer als Null ist und ich diese Zahl zu einer Zahl hinzuaddiere,
dann wird insichtlich dieser Ordnungsrelation gelten, dass das Ergebnis größer als diese Zahl ist.
Spitzenweise, wenn ich zwei positive Zahlen oder zwei Zahlen größer null habe,
die multipliziere, dass dann das Ergebnis größer als null ist.
Das gilt bei der Rechenarthmetik. Ihm nicht,
weil ich da eben genau diesen Überlauf habe und ich gegebenenfalls,
wenn ich da jetzt also quasi in den Überlauf hineinkomme,
hier also auf einmal eine entsprechende negative Zahl habe,
beziehungsweise hier beim Ergebnis sich das Vorzeichen ändern kann
So, demzufolge gilt für Fließkomma-Berechnung. Die Operationen sind abgeschlossen,
sie sind kombotativ. Ich habe aber Überlauf- und Rundungsfehler,
das heißt assoziativ Gesetz gilt nicht.
Das war ja genau dieses eine Beispiel hier.
Ich habe die Null als neutrales Element und bis auf Nordden
Name und Infinity gibt es natürlich auch ein inverses Element
Gut, und wie gesagt, bei der,
so eine Monotonie, auch für Nord-and-Number und Infinity mal ausgenommen,
würde das dann eben entsprechend auch gelten. Gut,
damit ist dieses Kapitel zur Arithmetik, jetzt also eigentlich auch soweit durch,
damit verlassen wir jetzt eigentlich die Zahlendarstellung und Zahnsysteme und ich
würde dann nächste Woche mit der Darstellung von Zeichen den gängigen Zeichensatzkodierung und mit den Arithmetischen Operationen,
die dann sich dann nachher dann noch anschließen oder,
Quatsch, den Operationen, die sich dann eben darauf anschließen,
dann entsprechend weitermachen.
Gut, dann ein schönes Wochenende und bis nächsten Mittwoch