Gut, heute werde ich also noch mal jetzt zu
diesem Teil Zahndarstellung bzw. Kodierung abschließend was zur Arrathmetik sagen.
Denk mir, damit sind dann auch alle Fragen jetzt
zu den letzten Übungsaufgaben dann hoffentlich so weit geklärt,
dass sie das dann also auch ohne größere Probleme lösen können.
Jetzt hier auf den Folien kommt erst mal relativ viel Wiederholung wieder.
Also sprich, Stellenwertsystem, also das,
was ganz normale Radiksdarstellung ist, hatte ich ja schon vorgestellt.
Das heißt, als Zahnbasis B haben wir eben entweder Dezimarsystem,
10, Hexadizimarsystem oder eben für Rechner dann entsprechend Ahlen.
Das Dualsystem mit den Ziffern dann eben von null bis basisminus eins.
Und für einen ganz normalen Stellenwert, Codierung gilt dann,
dass eben der Betrag der Zahl letztendlich die Summe von AI mal W hoch IS.
Und ich finde das dann eben entsprechend der Anzahl erstellen.
Viele koeffizienten A sind. Gut, wenn man sich jetzt ansieht, wie jetzt wirklich bei Rechnern oder ein Rechner Arithmetik Zahlen und Zahlentypen dargestellt werden. Ich hatte ja als Abschluss,
jetzt vorgestern, also schon ein bisschen was zu Wortbreiten bei Rechnern bzw. zu Zahlendarstellung gesagt,
dann ist es eben wirklich so, dass in der Programmiersprache C,
das Ganze dann eben wirklich vom Betriebssystem vom Compiler,
von was weiß ich, von der Art des Rechners abhängig ist,
beispielsweise also beim Linux-System gibt es dann also immer irgendwo unter User Include,
die da Teillimits Punkt H, wo dann im Prinzip vordefiniert sind,
welche zum Beispiel jetzt für einen Datentyp Long, also 64 BitWord-Breite,
typischerweise am Ballsystem, was ist dann die kleinste,
was ist die größte darstellbare Zahl,
wie sieht das dann bei Anzahl-Darstellungen aus,
dass das eben entsprechend definiert es.
Ich bloß, wie gesagt, das kann dann eben abhängig von
der Architektur bzw. auch vom Betriebssystem sich dann also ändern.
Und man hat dann eben typischerweise entweder Zweierkomplimentszahlen,
also sprich normale Sign-Darstellungen oder eben ganz Zahlen,
also das, was dann anzahlt, ist,
jetzt auch nochmal vielleicht in Bezug auf die Aufgaben,
da war ja teilweise dann auch etwas,
wo es also zum Beispiel darum ging,
also im B-1-Kompliment zu rechnen,
also sprich bei also dann im Eins-Kompliment.
Ich wäre das also nachher auch nochmal kurz an einem Beispiel,
weil da denke ich mir noch ein paar Unklarheiten waren, erläutern.
Ansonsten aber wirklich in Bezug auf arathmetische Einheiten in Rechnern,
kann man immer sagen,
dort wird also ein B minus Eins-Kompliment eben nicht benutzt,
sondern da hat man eben eigentlich immer entweder Science-Darstellung,
die dann also im Zweier-Kompliment kodiert ist oder quasi Anzahlen als
ganz Alterstellung
Was anderes findet sich dann nicht. Gut,
das hatten wir ja letztens mal dann eigentlich auch schon durch eine Zwischenfrage festgestellt,
also im Prinzip bei Java, sich die Welt ein bisschen rusiger aus,
weil da gibt es dann zwar auch 16,
32 Bit, 64 Bit,
Zweierkompliment-Zahlen und entsprechend dann eben über ein Wrepper-Klassen sowas wie Indija,
Long und Short definiert,
dass es da dann aber eben wirklich Teil des Sprachstandards und deswegen dann auch wirklich maschinenunabhängig irgendwo definiert.
Und da sich hier nun mal so als Beispiel oder kleiner Ausschnitt
dann eben die entsprechenden Definitionen jetzt hier zum Beispiel jetzt,
also für ein Integer. Nicht, also sprich eine 32 Bezahl,
Kleinster darstellbarer Wert, größter darstellbarer Wert. Also das,
was also nach ganz normaler Zweierkompliment-Darstellung letztendlich möglich ist,
mich fühle von Long, also sprich 64 Bit-Darstellung,
wäre das dann der kleinste Wert und so weiter und so fort.
Gut, zu den arentmetischen Operationen, hatte ich ja auch schon vorgestellt,
also auch diese Folie ist jetzt so eine Wiederholung,
also Addition im Dualsystem, ist klar,
wird eigentlich ganz normal wie im Dezima-System entsprechend gerechnet,
also spartenweise aufsummieren, entsprechend Überträge bilden.
Wenn man sich jetzt ansieht, was passiert bei der Addition jetzt von Unzahlen,
da sind also zum Beispiel in dem Lehrbuch von Brian und Raileron,
also hier mal entsprechende Visualisierung, wo quasi hier jetzt dargestellt ist,
auf den Achsen X bzw. Z, die beiden Operanten.
Also sprich, dies X. Und Y, die dann also
in diesem Fall jetzt hier also vier Bit breit sind.
Das heißt also von 0 bis 15. Nicht Zahlenbereich in diesem Fall
oder generell ist also da natürlich jetzt bei Unsigned 0 bis 2
hoch wie minus 1. Wenn wir die Wortbreite ist und für
das Resultat ergibt sich dann quasi ein Bereich von Null.
Bis 30 in diesem Fall, also das heißt also von 0 bis 2 hoch
W plus 1, minus 2, nämlich sprich,
wenn ich genau als größte Zahl diesen Wert nehme,
mal zwei, erhalte ich genau diesen Ausdruck.
So, jetzt ist dabei ja schon Folgendes aufgetreten,
dass also quasi bei der Operation die Wortbreite größer geworden ist,
nämlich von 4 Bit auf 5 Bit
Da macht das noch Sinn. In der Regel habe ich aber bei einer Rechnerarenthmetik,
also egal ob ich jetzt also mit einer 32-Bit oder mit einer 64-Bit Alu-Rechne,
eben genau diese Eigenschaft nicht, sondern die Wortbreite ist letztendlich irgendwo auf,
Entschuldigung, ups, auf die Maschinenwortbreite begrenzt. Das heißt,
wenn ich jetzt eben sage, nicht nur bei den Operanten,
sondern auch beim Resultat habe ich eine Wortbreite weh,
dann habe ich eben genau den Effekt,
dass, wenn das Resultat eben größer wird als zwei,
auch wie minus eins, ich einen Überlauf habe,
sprich das oberste Bit völlig verloren geht und ich dann also auf einmal hier wieder mit sehr kleinen Zahlen lande,
beziehungsweise dann eben, je nachdem, mit welchen Operanten ich rechne,
da dann also entsprechend größere Werte, aber eben letztendlich dann falsche Werte erhalte.
Hier ist das Ganze dann nochmal entsprechend veranschaulicht,
also sprich für die Wortbreite W. Habe ich jetzt eben normal meine Zahlendarstellung von Laborans,
nur noch zwei auch wie Minus 1,
nicht Zahlenbereich des Resultats wäre jetzt eigentlich, dieses hier, dadurch,
dass die Werte aber jetzt wieder in diesem Bereich von 0 bis 2 auch wie minus 1,
also sprich das,
was sich da so mit dieser Wortbreite überhaupt nur darstellen kann,
abgebildet werden, passiert eben, dass alle Werte,
die größer sind,
letztendlich hier darauf abgebildet werden und ich dann also falsche Ergebnisse erhalte.
Gut, für die Subtraktion,
was gilt dort
Wie gesagt, normale Subtraktionen, wenn ich jetzt das erste Mal rechne,
im Dualsystem könnte ich eigentlich genauso rechnen,
wie ich das aus dem Dualsystem mache,
also sprich stellenweise einfach voneinander abziehen und gegebenenfalls werden dabei dann eben,
also hier null minus eins, eins und eben ein Überlauf,
der dann eben zu berücksichtigen ist, generiert.
Du hattest ja schon gesagt, damit wird nicht gerechnet,
sondern man nutzt eben das Kompliment aus und rechnet statt
der Subtraktion eben die Addition des B-Kompliments
Warum funktioniert das, wenn ich jetzt genau mit dieser festen Stellenanzahl arbeite?
Dann gilt, zum Beispiel jetzt beim B-Kompliment oder nach Definition,
dass er eben im Prinzip das so beschrieben ist,
dass das Kompliment der Zahl addiert mit der Zahl,
genau B hoch N ergibt.
Da ich in diesem Fall eine feste Stellenanzahl N habe,
ist genau B hoch N nicht mehr darstellbar.
Das heißt, das Ergebnis von B-Kompliment plus Zahl ist gleich null. So,
und wenn ich jetzt sage, Zahl und irgendwas anderes ist gleich null,
dann ist es ja quasi vom normalen Verständnis,
wie wir das ja auch im Dezimalsystem haben, die negative Zahl dazu.
Nämlich das, was sich dazu addieren muss, damit als
Ergebnis null rauskommt. In dem Zufolge kann ich eben sagen,
durch diese Ersetzung mit dem B-Kompliment kann ich das eben durch die Addition ersetzen. Das heißt,
für eine Subtraktion X minus einer beliebigen Zahl Y,
die kann ich eben ersetzen durch die Addition mit dem entsprechenden Kompliment von Y. Gut,
für das B-1-Kompliment ist im Prinzip ähnlich,
nur dass da dann eben quasi noch dieser Offset mit drin ist,
weil also dort die Summe nicht B hoch N,
sondern B hoch N minus 1 ist,
nicht denen zuvor gegeht an x-y,
wäre dann x plus B-1-1-Kompliment von y plus
Gut, wie sieht das jetzt bei der Addition aus,
wenn ich das jetzt eben auch wieder auf eine feste Wortbreite abbilde und dann eben entsprechend visualisieren.
In diesem Fall ist es ja natürlich auch für den vergleichsweise
unsportlich kleinen Zahlenbereich von 4Bit. Dann sieht man eben auch,
dass es also hier so einen gewissen Bereich gibt,
wo ich also im Prinzip normal mit negativen bzw. positiven Zahlen rechnen kann.
Ich war für die Zahlen selber gilt,
die darstellbaren Zahlen, also jetzt im Zweierkompliment,
jetzt eben genau von minus zwei auch wie minus eins bis zwei
hoch wie minus eins, minus eins.
Und für das Resultat ergibt sich dann eben als maximaler Kleinster oder als kleinster Wert,
also sprich dieser Wert mal zwei,
dem zufolge minus zwei hoch weh und als allergrößter wird dieser Wert mal zwei,
zwei hoch wie minus zwei.
Wenn ich hier dann auch wieder diese Wortbreitenbeschränkung habe,
auf, in diesem Fall ist also vier Bit,
Habe ich dann eben auch genau den Effekt.
Das ist also hier ein positiven Überlauf oder hier
einen negativen Überlauf gibt. Demzufolge dann eben die Aussage,
Überläufe sind beim Zweier-Kompliment dann eben in beide Richtungen möglich.
Wenn man das jetzt hier wieder auf diese Grafik anwendet,
kann ich jetzt eben sagen, okay,
für das Resultat ergibt sich als gültiger darstellbarer Bereich jetzt eben
genau dieser Wertebereich und ich habe eben einen positiven Überlauf,
wenn das Resultat eben größer Größergleich.
Zwar auf W minus 1 wird. Nämlich also sprich größer als das,
was sich hier maximal darstellen kann. Und das Ergebnis,
was dann also letztendlich rauskommt, beziehungsweise was man dann nach
der Addition sieht, ist dann eben eine negative Zahl.
Das heißt, da wird dann eben hier bei diesem positiven Überlauf
das Ganze dann eben im Prinzip eine negative Zahl abgebildet.
Oder ich habe eben den negativen Überlauf. Das heißt,
wenn das Resultat dann eben kleiner wird als minus zwar auch we minus eins,
erhalte ich dann eben eine positive Summe und das wird hier in diesem positiven Wertebereich abgebildet.
Gut, wie kann man jetzt so eine Überlaufsituation erkennen,
weil das ist ja das, was einen dann, sagen wir jetzt,
von der Art Metik her dann auch noch irgendwo interessiert,
weil man programmierte also irgendwelche Munder irgendwas vor sich hin und jetzt ist da eigentlich ein Überlauf aufgetreten.
Beim Zweierkompliment gilt letztendlich, wenn beide Operanten gleiches Vorzeichen haben
und sich Dann aber das Vorzeichen des Resultats davon unterscheidet.
Also das ist, sagen wir mal, Umgangssprachlich ausgedrückt,
das, was quasi jetzt hier durch diese Abbildung mit diesem Dunkelgrauen bzw. hellgrauen Überläufen passiert.
Und wenn man das jetzt also beispielsweise in Java codieren würde,
ließe sich das dann im Prinzip jetzt durch so einen Ausdruck abfangen,
dass ich eben quasi sage,
Summe ist gleich A plus B und ein Überlauf ist aufgetreten,
wenn Dieser Ausdruck hier wahr wird, der wird genau dann wahr,
wenn A und B identische Vorzeichen haben.
Und wenn dann eben jetzt noch gilt, dass,
meinetwegen jetzt A, kleiner Null ist, also sprich,
als muss significant Bitner 1 hat und das ungleich dem höchstwertigsten Bit,
also sprich ungleich dem ist, dass das Ergebnis Null ist.
Also das heißt, damit ist genau ausgedrückt,
dass sich die Vorzeichen des Resultats und in diesem Fall
jetzt von einem von den beiden Operanten unterscheiden.
Und genau dann habe ich letztendlich einen Überlauf.
Eine Frage. Ja, also bei Java kann man das
natürlich dann also direkt über Acception Handling machen.
Also da muss man sich jetzt also nicht wie hier in
dem Beispiel jetzt selber irgendwie an drum kümmern.
Ansonsten in anderen Programmiersprachen ist das dann nicht der Fall und
dann müsste man das machen
Dieses Java-Code-Beispiel ist jetzt also hier nur deswegen in dieser Sprache
genommen, weil das dann also einmal vielleicht bekannt ist.
Aber in dem Fall bräuchte man jetzt,
dass das jetzt nicht, also das stimmt schon.
Gut, das ist jetzt ja hier Überlauf oder Überlauferkennung für Zweierkomplimentszahlen.
Also sprich, wenn ich jetzt also mit einer Science-Zahndarstellung arbeite,
was ich hier jetzt noch nicht vorgestellt habe,
Was ich also jetzt auch nicht als Übungsaufgabe gefragt habe.
Deswegen aber vielleicht mal als Frage in die Runde.
Wie könnte man im Prinzip einen Überlauf bei einer Ansight-Darstellung feststellen?
Das heißt, wenn ich diese Situation habe,
dass ich hier den Zahlenbereich verlasse, Ideen, Also eine,
also es ist eine Zahl größer als... Gut,
also maximal darstellbare Zahl wären also zwei hoch wie minus eins
Oder zwei, wo minus eins, minus eins.
Ja, würde funktionieren. Das wäre sicherlich
eine Lösung.
Gut, das heißt also, wenn,
ich will jetzt gerade überlegen,
also größer als der Kleinste oder größer als der größte Somant.
Ob man das ja nicht dahingehend auch noch einschränken müsste,
aber... Gut, aber wenn ich jetzt also letztendlich feststelle,
die Summe ist kleiner als der Kleinste,
so meint,
Doch, dann hatte ich natürlich logischerweise auch einen Überlauf.
So, die Frage kriegt man jetzt also wirklich,
dass das dann nicht auch anders noch.
Ne, stimmt, doch,
würde funktionieren,
Ja, das würde also genauso gelten. Also im Prinzip,
dass ich dann sage,
entweder die eine oder die andere Zahl und nee,
da war das, was ich mir dann nämlich vorhin nochmal überlegt hatte,
als ich mir gedacht hatte, Mensch,
du fragst die Leute ja mal, sind dann natürlich auch so Sachen,
wo ich jetzt eigentlich eher schon auf irgendwelchen Bittricksereien ausgewiesen will.
Also sprich, wenn ich sage, wann kann letztendlich ein Überlauf auftreten?
Überlauf kann nur genau dann auftreten, wenn mindestens eine der
beiden Zahlen an einer höchstwertigsten Stelle eine Eins hat.
Weil wenn beide Zahlen an der höchstwertigsten Stelle keine Eins haben,
dann kann ich erstmal gar keinen Überlauf haben,
weil dann passen die immer in den Zahlenbereich.
Das heißt also, entweder von der Einzahl oder von der
anderen Zahl muss das höchste Bild eine Eins sein.
Und wenn ich dann ein Ergebnis habe, wo das höchste
Bit eine Null ist, dann habe ich eben einen Überlauf gehabt.
Das ist aber letztendlich, denke ich mal,
zu so einer Abfrage, wo ich das Ergebnis mit den
beiden einzelnen Zahlen vergleiche,
eigentlich identisch
Also von daher nicht. Also gut,
im Prinzip mit Trickserei lässt sich sowas dann auch abfangen.
In der Regel muss man natürlich dann sagen, na gut,
also in Java habe ich jetzt eben glücklicherweise die Möglichkeit,
dass also über Acceptions direkt durch die Laufzeitumgebung abzufangen.
Das heißt, da muss ich mich jetzt nicht drum kümmern. Gut,
in anderen Programmiersprachen ist es dann eben wirklich so, also dass man sich,
gerade wenn man jetzt mit beschränkten Wortbreiten arbeitet, dann Gedanken machen muss.
Ansonsten Kann man natürlich dann auch immer sagen, okay,
viel hilft, viel. Ich nehme halt möglichst lange Worte
und oder von der Zahndarstellung und weiß erstmal meine Zahlen sind, klein genug,
dass es also irgendwie immer reinpasst und ich muss mich da nicht drum kümmern.
Dass so ein Vorgehen natürlich hochgradig gefährlich ist und kein guter Programmierstil ist,
dazu habe ich dann nämlich gleich ein Beispiel, wo sowas dann also zum Vergleichsweise teuren Softwarefehler geführt hatte.
Gut, Also das wäre jetzt also im Prinzip, also Überlauferkennung. Ja, Subtraktionen mit iON-1 und 2er-Kompliment. Ich hatte ja eben schon mal gesagt,
also zu der Sache,
also warum jetzt also überhaupt die Subtraktion durch Additionen des Kompliments funktioniert,
mit dieser eingeschränkten Darstellung geht eben natürlich im Prinzip dadurch,
dass sich das jetzt hier über diese Definition mir überlege oder ansehe,
Andere Möglichkeiten, wie das funktioniert,
beziehungsweise wie man sich dann auch überlegen kann,
also wieso das Ganze jetzt, also Arendt Medisch dann noch dazu führt,
dass es also zum Beispiel jetzt für die Rechenwerke in Computern dann also keinen Unterschied macht,
also ob ich mit einer Signed oder mit einer Unsigned-Arendt-Medik rechne,
sondern die sind eigentlich so identisch.
Da kann man dann im Prinzip Folgendes machen,
dass man sich das dann eben anhand dieser Zahlkreise,
die ich dann auch in dem letzten Foliensatz da schon mit drin hatte, nochmal überlegt. Wie gesagt,
hier vorneweg, das war jetzt also nur nochmal die Definition,
wie also Komplimentarstellung beschrieben ist, aber wie gesagt,
das hatte ich ja gerade eben auf den Folien schon gesagt,
also sprich, dass B-Kompliment, B hoch-n-z,
für Z und gleich 0 und für Z gleich 0 wäre es dann eben null und beim B minus 1 Kompliment,
eben B hoch-n-z,
niederwärtigste darstellbare Stelle.
Wenn ich jetzt also keine Nachkomma stellen hätte,
wäre das dann eben genau nochmal minus eins
Gut, bei begrenzten Wortbreiten kann man ja im Prinzip so
die Zahlen oder verschiedenen Zahlendarstellungen dann eben auch nochmal in solchen Zahnkreisen,
also in diesem Beispiel jetzt, also hier mal für vier bezahlen,
sich aufzeichnen.
Da sieht man jetzt also hier quasi ganz normal Betrag plus Vorzeichen.
Das wollen wir also jetzt hier gleich wieder vergessen,
weil damit kann ich jetzt also hier überhaupt nichts zeigen,
weil damit kann man also keine Arithmetik machen für einer oder Zweierkompliment,
kann ich dann aber im Prinzip die arathmetischen Operationen
einfach als Winkeladition
mir überlegen
Und zwar folgendermaßen, also wenn ich hier zum Beispiel im Zweier-Kompliment rechne und ich rechne jetzt also als Zahl 2 plus 4,
hätte ich dem zuvor jetzt hier also einmal diesen roten Vektor,
jetzt quasi für die 2,
nehme dann also den entsprechenden für die 4,
das quasi hier als Winkeladition drauf,
lande dann also auch hoffentlich richtig bei der 6,
wenn ich dann eben rechne, 4 plus 5,
war es dann also im Prinzip jetzt hier dieser Zweite Fall ist,
hätte ich eben diesen Vektor oder diesen Winkel, plus den Winkel hier.
Hier lande dann eigentlich, wenn ich jetzt also nicht im Zweier-Kompliment wäre,
bei dem Arranmetisch richtigen Ergebnis von neun,
nämlich also der Codierung 1, 001,
bloß mal ein Zweier-Kompliment ist,
dass natürlich die Darstellung für eine minus sieben,
wo ich dann eben genau diesen Überlauffall habe,
wo dann eben in diesem Fall jetzt also die beiden hier
als Most-Significant Bit eine Null haben und das Ergebnis hat dann
eben als höchstes Bit
Was dann dementsprechend anders ist. So,
und die Subplaktion könnte ich jetzt eben hier genauso machen,
dass ich jetzt eben sage, okay, ich habe jetzt hier also einmal die sechs,
was dann also hier dieser Vektor ist, davon sollen jetzt letztendlich zwei abgezogen werden, was eigentlich dem hier entsprechen würde.
Nicht, womit ich dann eigentlich bei der vier lande,
kann ich aber eben dadurch ersetzen,
dass ich eben jetzt das Kompliment von der zwei nehme,
das ist dann eben als minus zwei jetzt eben genau der Wert 1,
1, 1, 0. Und wenn ich dessen Winkel quasi jetzt hier auf die Sechs,
das, was da hier mit dieser gestrichelten Linie angedeutet ist,
hinzu addiere, laufe ich zwar hier einmal über die Null rüber weg,
aber ich lande dann eben eigentlich genau bei dem richtigen Ergebnis 4. So,
das Ganze funktioniert genauso auch für negative Zahlen.
Also hier als Beispiel einmal die Zahl minus zwei.
Ist also hier dieser irgendwie in Rötlich gezeichnete Vektor oder Winkel
Da dann den entsprechenden für die minus 3 hinzugefügt. Das wäre dann also quasi das,
was dann hier in diesem Grün angedeutet ist und man landet dann eben auch genau bei der minus 5. Und wenn ich das jetzt eben mache,
als minus 2 plus minus 7,
also in diesem Fall diesem 1001,
wäre arathmetisch gesehen minus 9,
habe ich in diesem Zahlensystem nicht drin und ich lande dann eben hier,
wenn ich jetzt also quasi hier die minus 2 habe und dann irgendwie das als Blauer da eben den entsprechenden Winkel jetzt für die minus sieben nehme,
dann eben auch auf Arme hier bei einer positiven Zahl demzufolge dann falscher Wert.
Und hier wäre dann eben als letztes Beispiel dann nochmal,
also minus zwei, plus sechs,
und man hält dann eben als Ergebnis hier die vier.
Goodbye, Eins-Kompliment, wenn man sich jetzt das ansehen würde,
nicht also immer nur noch mal zu der Frage, Mensch,
warum brauche ich denn jetzt hier bei irgendwelchen Rechnungen mit dem Eins?
Komplimente, die ist komisch,
diesen komischen Rap-Around Carry
Nicht, wenn man sich das jetzt also hier anhand dieses Zahnkreises überlegen würde,
sieht man also im Prinzip jetzt hier bei positiven Zahlen oder
gleiche Sachen verhält sich das also so erstmal genauso.
Wenn ich jetzt hier rechne,
jetzt entsprechend sechs plus oder ja, also sechs minus zwei,
was ja dann also quasi auch immer dieses Beispiel wäre,
wo ich dann also logischerweise hier bei der vier landen müsste,
wäre das dann
eben hier sechs
Plus der Darstellung der Minus 2, also diesem Mector hier,
womit ich dann genau letztendlich hier lande und es fehlt dann eigentlich
noch eben diese eine niederwärtigste Stelle, also dieses eine plus 1.
Man kann sich das hier dann eigentlich auch immer dadurch vorstellen,
dass hier quasi diese eine Stelle letztendlich nicht besetzt ist und
da dann eben auch genau diese eine Winkelübertrag letztendlich fehlt.
Das heißt, wenn ich hier über die Null überlaufe,
habe ich dann hier diese eine 1 vergessen.
Gleiches gilt eben genauso für den Bereich,
wenn ich jetzt hier mit minus zwei rechne und da dann eben hier über die Null hinweg laufe,
dann muss ich dann eben auch im entsprechend hier nochmal eine Eins beziehungsweise da eine Eins,
was nase ich hier mit diesen Winkeln angedeutet ist, hin zu agieren.
Eine Frage. Ja, damit ist jetzt hier eigentlich nur angedeutet gewesen,
dass ich hier im Prinzip jetzt noch irgendwie diese eine Lücke mit drin habe.
Also in der ersten Zeichnung oder in der ersten Version,
die ich gemacht hatte, hatte ich da also noch irgendwie Minus Null stehen.
Bis sie dann festgestellt haben, na gut,
also wenn ich hier schon anfange, irgendwelche Definitionen zu geben,
so wie dieses hier, dann gibt es keine Minus Null,
sondern dann fehlt da einfach was.
Gut, und dann war das jetzt einfach,
sagen wir mal, nur ein Copy- und Paste-Problem,
weil also die Grafik hatte ich jetzt quasi von dem Betrag und Vorzeichen mitgenommen,
wo dann also auch der Strich nochmal verlängert war,
um das also jetzt wirklich ganz zu tränen.
Aber hier macht das jetzt, also letztendlich darüber sehen,
dass man dann eben sagt, okay, wenn ich da rüberlaufe,
müsste ich jetzt eben nochmal genau diese plus eins hinzuaddieren.
Also als Merkhilfe. Ansonsten ist das also wirklich
nur irgendwie so eine beliebige Darstellung. Also wie gesagt,
das mit dem Zahnkreis ist einfach immer nur so ein bisschen so eine Veranschaulichung,
dass man einfach jetzt auch erstmal sieht,
zumindest für kleine Zahlen oder kleine Beispiele,
zweier Kompliment,
wie funktioniert das
Also das ist da dann eigentlich immer noch ganz sinnvoll.
Nicht ansonsten, ich meine, man rechnet damit nichts,
man macht nichts. Wie gesagt, das mag also
vielleicht noch interessant gewesen sein, zu zeiten.
Also als man zum Beispiel jetzt, also Rechenmaschinen mechanisch aufgebaut hat,
dass man darüber dann jetzt wirklich, also mit Winkeladitionen arbeitet.
Aber so ist das eigentlich jetzt eben nur eine Veranschaulichung für die entsprechenden mathematischen Grundlagen dazu.
Gut, in Wie sie das ja sonst jetzt also noch
aus in Signed und Unsign-Zahlen in Programmiersprachen.
Also wie gesagt, in Java ist das ja nun
relativ strikt und auch vergleichsweise konsistent festgelegt.
In C sieht das eigentlich so aus,
dass man also in der Regel erstmal alles,
was sich jetzt also irgendwie als In-Short-Long oder wie auch immer deklariere,
das sind eigentlich immer Unsign-Zahlen mit entsprechenden Wortbreiten
Äh, ne Blödsinn, Science Zahn, also zwei Komplimentzahlen mit entsprechenden Wortbreiten.
Und wenn ich mit Anzahlen, Zahlen rechnen will,
muss ich das eben explizit dann also nochmal kennzeichnen,
wobei man das dann oder sagen wir mal solche Anzahlenzahlen dann eben benutzt,
beispielsweise jetzt für irgendwelche Hardware an Arenmetik oder wenn man jetzt selber anfängt,
also mit eigenen Arenmetik, irgendwas zu beschreiben.
Nachteil meistens ist dadurch,
dass die gesamte Rechnerarentmetik in der Regel immer auf Zweierkompliment eigentlich ausgelegt ist,
dass teilweise eben solche Sachen mit irgendwelchen Anzahlen,
Darstellungen vom Compiler schlecht unterstützt werden oder teilweise auch inneeffizient sind.
Nicht wobei bei C dann immer noch so dieser Effekt hinzukommt,
dass man da dann also auch gerne,
also gerade bei der Atometik dann anfängt mit irgendwelchen Bitschieberreihen,
sich da was zurechtzutricksen.
Dazu werde ich dann also nachher auch noch ein paar Beispiele beziehungsweise diese Woche nicht mehr,
aber nächste Woche dann also wohl noch bringen, wo dann sowas ist.
Hier nur nochmal so als Hinweis, Also wie gesagt,
mit, dadurch, dass ich da jetzt also keine Exceptions
habe und in Cesar haben wir jetzt also auch keine wirklich strikte Typbindung da ist,
muss man also vorsichtig sein. Also wenn ich jetzt,
also hier mit irgendwie solchen Beschreibungen arbeite,
nicht wo ich also jetzt hier irgendwie sage, okay,
Unsight Enter-J.E., nicht der, und Zähler,
die sind irgendwie deklariert,
das I wird hier jetzt mit irgendwas initialisiert und ich benutze
das dann also als Index,
um jetzt also irgendwo in einem RAI zu arbeiten
Also diese Indizes sind zwar im Prinzip an seinen Zahlen,
weil ich aber hier bei diesen Zuweisungen oder so ist schon mal nicht garantiert oder abgefragt,
also ob ich hier mit Count minus zwei jetzt überhaupt nach meinem Wertebereich bin.
Damit kann es dann also sein,
dass ich letztendlich dann hiermit eigentlich eine entsprechend negative Zahl hätte,
das Ganze jetzt natürlich dann irgendwo bei einer Anzahl-Darstellung als sehr große positive Zahl
da ist und ich dann also hier mit meinen Araces also auf einmal irgendwo in irgendwelche Speicherbereiche hinein adressiere,
wo man also nicht reinlaufen darf oder kann oder die ich
ja so vorher sowieso nie aluciert habe.
Nicht, dass du dann also immer so die berühmten Fehler,
wo man dann eben zur Laufzeit dann Segmentation-Violation bekommt,
wo man eben im Prinzip das Betriebssystem dann also festgestellt hat,
der geht da irgendwo hin, wo er eigentlich nichts zu suchen hat.
Gut, genauso dann auch die Sache,
also was man uns hier dann auch teilweise macht,
sind dann eben irgendwelche Regeln,
um jetzt also explizit Typen zu benennen
Nicht, also sprich sowas wie dann eben solche Casting-Regeln.
Letztendlich führen die erstmal ja dazu, dass eine Zahl nur anders interpretiert wird.
Die Repräsentation der Zahl wird dabei überhaupt nicht verändert. Das heißt,
die auf Bit-Ebene, wenn ich mir das jetzt also
als Bit stringe, nehme, bleibt das wirklich identisch.
Gut, bei positiven Zahlen habe ich da letztendlich keine Effekte.
Wenn ich aber jetzt irgendwelche negativen Werte habe und die dann also über so ein Casting irgendwo reinbringe,
nicht also angenommen, ich hätte jetzt hier ein Short Entager,
Der wird jetzt hiermit als Ardinitialisiert anzahlen, Short Entager,
der dann quasi zu über so einem Casting,
von dem ich mir irgendwie zugewiesen wird,
dann hätte ich jetzt hier mal einen positiven Wert,
Wahl der entsprechenden Darsteller,
aber ist keine Änderung.
Ich finde, das sitzt hier aber eigentlich eine negative Zahl
ist und die interpretiere ich jetzt aber als Anzahl-Short,
dann hätte ich hier nämlich auch auf Amazon Überlaufsituationen.
Das ist also wirklich völlig abgebildet wird. Was man da dann teilweise auch noch macht,
sind dann also für Konstanten, also entsprechende Schreibweisen,
wo ich dann eben sage, okay,
wenn ich nichts weiter angebe, dann sind Konstanten erst mal Zahlen.
Nicht nur wenn ich explizit also eine Unscience-Zahl haben möchte,
gibt es eben noch irgendwelche, so Fixe,
wo ich dann eben beispielsweise dann eben Uda hinterschreibe für Unscience.
Nicht womit dann also klar ist, aus welchem Wertebereich. Das heißt also,
sprich aus welcher Wortlänge diese Zahl jetzt herauskommt und eben dann eben auch,
dass das dann als Anzahlzahl zu interpretieren ist.
Nicht ansonsten habe ich eben durch diesen Effekt jetzt bei dem Casting dann eben auch immer irgendwo so ein Überlauf,
dass ich sage, nicht,
wenn ich also unsigned insigned abbilde, also sprich ein Zweier-Kompliment,
das dann eben die entsprechend großen Zahlen auf einmal zu negativen Zahlen werden,
beziehungsweise umgekehrt, wenn ich jetzt eben Zweier-Kompliment abbilde in Unsigned,
das war genau dieses eine Beispiel eben,
das dann also aus dieser negativen Zahl dann hier auf einmal was Positives wird.
So, das führt dann eben dazu,
dass man teilweise bei arrethmetischen Ausdrücken dann eben in,
sagen wir mal, solche Fahlen hineinläuft, wo ich jetzt,
also jemals Beispiel jetzt für eine Wortbreite von 32 Bits und ein paar Vergleichsoperationen gemacht habe.
Nicht generell kann man jetzt erst mal sagen,
wenn ich eine Signed und eine Arnscience-Zahl miteinander vergleiche,
dann wird die Auswertung erstmals ansigned dargestellt, das heißt designed wird entsprechend interpretiert.
Das heißt, wenn ich jetzt hier also abfrage,
null, in diesem Fall jetzt zweier Companion-Kompliment gleich anzahlen,
nur dann ist es, mache ich jetzt eben eine Ansight-Auswertung,
das Resultat WR1. Wunderbar, ist er noch richtig.
Nicht, wenn ich aber jetzt also frage, minus eins,
kleiner Null, das sind jetzt also jeweils Side-Ausdrücke,
wenn da nichts dahinter steht, gilt auch noch.
Aber wenn ich jetzt eben frage, minus eins, kleiner Null,
unsigned, dann habe ich jetzt leider folgendes Problem dadurch,
dass ich also hier in dem Ausdruck,
die Zahl expliziter als Anzahlen deklariere,
wird dieser Gesamtausdruck dann noch als Ansigned ausgewertet.
Nicht nur aus dieser Minus 1, wird dann auf einmal
eine sehr große positive Zahl und das Ergebnis wäre dann eben nicht eins,
sondern null. Genauso dann eben hier nun auch Beispiele,
wo ich dann eben hier auch Unsigned größer diesem hier dann
also auch ein falsches Ergebnis bekomme,
weil dann eben die Auswertung quasi in dem falschen Zahnsystem stattfindet
Nicht das sind dann eben so Fehler, die man also da
zumindest in der Programmiersprache zieht, sehr schnell einbauen kann.
Ich dem zufolge sollte man das dann zumindest im Hinterkopf haben,
dass wenn man jetzt irgendwo explizit konstanten als Unsigned bezeichnet,
beziehungsweise hier mit irgendwelchen Typecasts arbeitet,
dass man da dann eben für solche Operationen dann auf einmal so eine implizite Umwandlung erzeugen kann,
die dann eben zu falschen Ergebnissen führt.
Eine Frage
Das führt jetzt dazu, also das ist hier zwar eigentlich
eine Ansign-Zahl, die ich auch noch entsprechend darstellen kann.
Entschuldigung. Dadurch, dass ich hier mit diesem Typecast
das Ganze dann aber im Prinzip in einen Integer bringe
Und diese Zahl eigentlich genau eins zu groß ist für den
32 Bildwertebereich oder Größerarzte, maximal darstellbare Wert,
entspricht dieses dann hier nämlich eigentlich schon einer negativen Zahl.
Und ich habe dann einen Überlauf. Also im Prinzip
erzeuge ich hiermit aus dem ganzen Nasen eine negative Zahl.
Und das Ganze wird aber da jetzt sowohl dieses,
oder da ich quasi jetzt hier mit diesem Typecast dies anzeigt,
überschreibe, ist dieses hier eine Science-Zahl, hier steht nichts,
das ist Saunes-Science-Zahl, also wird dieser gesamte Ausdruck quasi als Zweierkompliment dann eben behandelt.
Und dieses wäre dann dementsprechend umgerechnet, die größte negative Zahl,
die ich darstellen kann
Gut, generell, wenn ich jetzt also mit Zahlen arbeite,
unterschiedlichen Wortlängen und dann sage, okay,
ich habe jetzt also irgendwo eine Zahl oder eine Zahlendarstellung und möchte jetzt also mit einer Zahl,
mit einer anderen Wortlänge zusammen verrechnen, dann kann es eben sein,
dass ich eine Science Extension machen muss.
Das heißt also, ich habe jetzt also irgendwie ein Wortbreite,
eine Englischter Zahl X, mit Webit und die soll jetzt eben um eine Anzahl K-Stellen erweitert werden.
Und ich möchte dann eben quasi in dem Zahnsystem,
was dann eben W-Plus-Karrstellen hat, die Zahlen mit dem gleichen Wert haben.
Das passiert eben genau dadurch, dass ich sage,
dieses hier ist meine Ausgangszahl,
also sprich X-0 bis X-W minus 1. Und wenn ich das dann ebenentsprechend erweitere,
nimmt man im Zweier-Kompliment eben genau die höchstwertigste Stelle und ergänzt damit dann also entsprechend die fehlenden Ziffern.
Das heißt also für eine Vierbit, sein Darstellung,
also jetzt als Zahl oder der Darstellung der Dezimalzahl 6,
wäre das dann eben 0-1-1-0,
wenn ich daraus acht bin oder 16 bin, mache,
würde ich dann eben entsprechend viele Nullen davor setzen müssen.
Nicht nur, wenn ich das jetzt also hier für
eine Vierbit-Zahl-Darstellung von einer minus zwei mache und daraus dann
eben acht Bild oder 16 wird dann eben entsprechend dieses MSB,
also hier die 1,
Gut, auch mit solchen Sachen kann man dann also irgendwie
durch Veränderungen jetzt in der Wortbreite, bösartige Fehler generieren.
Manuel, das sind jetzt ja sicher natürlich alles relativ stark zusammengesuchte Beispiele in diesem Fall,
also aus einem Buch von Bloch und Gafter,
Java Pazlas,
Traps,
Pitforce and Corner Cases
Wo dann einfach mal so alle möglichen Sachen in der Richtung dann zusammengestellt und beschrieben wird.
Also hier jetzt als Beispiel habe ich jetzt eben die Ausgabe dieser Summe,
also quasi jetzt hier einmal diesen Hexadezimal-Vektor 1, 0,
0, 0, 0, 0, 0,
0, 0, 0, 0,
als Songzahl nehme,
also 64 Bit und den Wert 0-X-CAAF-E-B-A-B-E-E nehme und Frage
ist jetzt,
wie sieht diese Summe aus
Und das, was dort nämlich passiert, dadurch,
dass diese Zeit jetzt hier als Longzahl gekennzeichnet ist,
entspricht das also quasi hier dieser 64-Bezahl aus dieser Zahl hier,
die jetzt also erstmal kein Long ist,
sondern ganz normale Science-Darstellung, also 32-Bit,
wird jetzt also quasi per Science-Extension der entsprechende Long gemacht.
Dadurch, dass hier beim C das höchstwertigste Bit gesetzt ist,
wird das entsprechend Für vielfältig, das heißt, da kommen noch 32,
wird hinzu, wo jeweils die Eins gesetzt ist.
Das heißt, da ist ein entsprechend langer weckt oder
also in diesem Fall dann aus acht mal F.
Und wenn ich das Ganze addiere,
habe ich dann eben hier entsprechende Übertragung und erhalte dann eben
dieses Ergebnis und nicht etwas, wo ich dann sage,
ich habe hier 0X1 und dahinter genau dieses hier.
Das heißt also,
diese Eins hier ist dann eigentlich letztendlich verschwunden
Gut, zu dem Problem oder zu der Problematik mit der Berechnung,
mit begrenzten Wortbreiten, was man dann ja immer gerne nimmt,
der erste Flug der Ariane 5-Rakete. Schon ein bisschen her. Juni 1966,
wo die Rakete sich dann also letztendlich irgendwann beim Start oder in der Startphase quasi dann automatisch selbst zerstört hat,
weil nämlich festgestellt wurde, dass also eine instabile Fluglage vorlag,
also sprich die ganzen Sensoren haben gesagt, ich stürze gerade ab,
ich stürze gerade ab und demzufolge wurde dann Asia-Rakete, bevor sie irgendwo aufprallt, dann also quasi in der Luft gesprengt.
Wie ist es dazu gekommen? Also der Hersteller hat natürlich gesagt,
na gut, also wir haben also quasi vom Vorgängermodell,
der ARNE 4,
also hier bei unserer gesamten Steuereinheit und unserer gesamten Rechenwerke und die Sensoren und haben das dann quasi jetzt in den nächstgrößeren Raketentyp,
der jetzt also Was weiß ich, irgendwie zehnmal so viel Nutzlast,
also raufschießen kann, entsprechend übertragen,
was sie dabei eben nicht mit berücksichtigt haben, dadurch,
dass also die Ariane 5 also irgendwie deutlich stärkere Triebwerke hatte,
weil sie ja nochmal auch ein bisschen mehr Nutzlast,
also irgendwo in den Weltraum bringen sollte,
war die natürlich schon auch um einiges schneller in der Startphase und was dort passiert ist,
dass also quasi jetzt irgendwelche Sensoren Ein 64-Bitgler.
Ein 64-Bitgleit-Komma-Welt für die horizontale Geschwindigkeit ausgegeben haben. Dadurch,
dass also quasi die Bordrechner intern, also sowieso Mitleidkomma,
will man da nicht so gerne rechnen,
dass also irgendwie umgewandelt haben in Integer-Wert,
da man vorher eigentlich immer irgendwelche Werte gehabt hatte,
die also in einem Wertebereich von, was weiß ich,
wie lagen,
jedenfalls so,
dass sie also im Prinzip problemlos in diesen 16-Bit-Enteger-Welt reingepasst haben
Jetzt auf einmal bei einem deutlich stärkeren Tal, es dazu kam,
dass also dort dann eben bei dieser Umwandlung dann eben einen Überlauf aufgetreten ist und dann eben auf einmal festgestellt wurde,
von dem Messsystem, ich habe hier auf einmal irgendwie eine negative Beschleunigung,
das kann nicht sein, da ist der Sensor kaputt,
da sind die Systeme kaputt, dann nützt es einem dann also auch nichts,
wenn jetzt also irgendwie solche Systeme da jetzt mehrere redundante Rechner haben,
die dann quasi per Mehrheitsentscheid sagen, na gut,
wenn sich einer verrechnet, interessiert das nicht,
weil die haben letztendlich alle genauso falsch gerechnet,
War dann also nachher also quasi erstmal die Konsequenz in der Flugsteuerungslogik,
das passe ich und man ist da gerade am Absturz,
na gut, obwohl das Ding gesprengt,
hat dann also letztendlich irgendwie so 370 Millionen Dollar,
also erstmal versenkt.
Gut, wie gesagt, also das nur zu dem Thema,
also wenn man jetzt also irgendwo was programmiert und sagt,
ich arbeite mit den und den Wertebereichen und mit den und den Zahlen und das,
das passt schon,
man sollte es Zumindest für sich selber oder für andere dann auch dokumentieren,
dass man eben so wirklich solche impliziten Einnahmen damit anbaut.
Und so meinen modernen Programmiersprachen kann man da ja dann eben wirklich
entsprechende Abfragen zur Laufzeit dann also auch als Acception-Händler damit reinbringen.
Nicht bloß,
wenn ich da jetzt wirklich vergleichsweise Hardware nah mit einfacheren Konzepten arbeite und sage,
das hat immer gepasst, also irgendwie so eine zusätzliche Testroutine,
die kostet sowieso erstmal nur Zeit,
deswegen lasse ich die mal weg
Dann kommen eben genau solche Fehler,
dass also irgendwie drei Jahre später jemand anders sagt,
Mensch, wunderbar, da gibt es einen Algorithmus,
der funktioniert ja, den nehme ich jetzt.
Und dadurch, dass dann also wirklich so andere Randbedingungen gelten,
hinsichtlich der Werte, auf einmal knallt das dann,
also in der Aren Medikans gewaltig.
Gut, soviel also erst mal zu Signed Unsigned, Addition.
Wie sieht das aus mit der Multiplikation?
Die Folie hatte ja auch schon drauf liegen,
also im Prinzip im Dualsystem,
genau wie im Dezimalsystem
Wird da entsprechend gerechnet, indem ich jetzt eben einfach sage,
ich habe hier Stellenwert gewichtet an meine Therme und muss die
dann eben auch nur entsprechend dann spaltenweise aufsummieren.
Also diese Folie hatte ich ja auch schon,
auffliegen, wo ich dann sage,
ich habe ihm hier diesen Wert jetzt für die 199,
das war mit 13 multipliziert werden und dem zuvor gab ich dann Anfang je den Wert.
Mit der eins multipliziert, um eingeschoben,
das Ganze mit der eins multipliziert um eingeschoben,
das mit der Null multiplizierten, als letzte Stelle,
das dann eben entsprechend um vier Stellen geschoben.
Wieder mit der 1 multipliziert, sondern muss sich eben alles,
diese vier Zahlen hier aufsummieren,
habe da dann eben auch noch beliebig viele Überträge und so weiter,
kommen dann aber im Prinzip dann zu genau dem richtigen Ergebnis.
Gut, das war jetzt Science-Multiplikation, wie sieht das Ganze jetzt unsigned aus?
Wenn ich jetzt eben eine Wortbreite von Webit habe für die Operanten,
dann ergibt sich also im Prinzip erstmal an Signed Oder eben von den Zahnbereich des Resultats,
dass ich dann eben sage,
ich laufe daran eben von null bis zweimal der größte Operant,
also zwei hoch wie minus eins zum Quadrat.
Wäre dann entsprechend nach pinomischer Formel aus, multipliziert,
zwei hoch zwei W minus zwei hoch W plus eins,
plus eins.
Das heißt, letztendlich brauche ich dann eben die doppelte Anzahl
der Stellen für die Multiplikation
So, in den Programmiersprachen ist das Ganze dann eben dadurch,
dass ich natürlich dann in der Regel auch erst mal,
wenn ich da jetzt nicht irgendwie spezielle arathmetische Bibliotheken mitbenutze,
ist man da natürlich entsprechend eingeschränkt.
Das heißt, beispielsweise eben in C erhalte ich im Resultat
da dann eigentlich erst mal nur die unteren Webit meines Elements,
meines Resultats und muss letztendlich vorher schon wissen,
dass das Ergebnis also in diesem Wertebereich passt.
Ansonsten wird eben alles andere Weggelassen. Gut, in Java
gibt es sowieso keine Angstside-Entager, da habe ich dann nur Science-Zahlen. Bei Hardware-Multiplizierern,
also wenn man das jetzt also wirklich auf unterer Ebene in der Hardware umsetzt,
da gibt es dann teilweise noch zwei getrennte Register,
wo dann also wirklich dann also auch entsprechend diese doppelte Wortbreite realisiert werden kann,
dass es aber dann wirklich letztendlich davon abhängig,
also ob das jetzt gebraucht wird,
beziehungsweise ob man da diesen Zusatzaufwand entsprechend betreiben möchte
Goodbye, sinn, Multiplikation, das heißt, wenn ich
dann eben auch entsprechende negative Zahlen zur Verfügung stellen möchte.
Wie sieht das da aus? Wie gesagt,
die Operanten von minus auch minus bis 2 auch wie minus 1,
minus 1, das ist ein ganz normaler Wertebereich.
Nicht das hier einmal verdoppelt, beziehungsweise das hier entsprechend verdoppelt.
Nicht auch hier gilt eigentlich identisch. Ich brauche die doppelte
Anzahl der Bits, also für eine vernünftige Darstellung des Ergebnisses
Sowohl in C- als auch in Java erhalte ich da dann eben
auch jeweils nur die unteren Webits und irgendwie sowas wie ein Überlauf, wird dann eben ignoriert.
Das heißt, wenn ich jetzt eben als Integer werde,
sowas wie 100 mal 200 Matran und mal 400 berechnen würde,
wir kämen in meiner Arts Ergebnisse,
also auf einmal eine negative Zahl,
weil das dann eben letztendlich nicht mehr in den Wertebereich von
32 Bit in Tücher hineinpasst
Gut, letztendlich entspricht das Ganze sowohl signed als auch an seinen Multiplikationen, sind da identisch. Das heißt,
eigentlich genau wie bei der Addition muss ich auch bei der Multiplikation jetzt nicht unterscheiden,
also ob ich jetzt mit Signed oder mit Unscience-Saalen rechne,
sondern von der Hardware-Teil, der dann also eigentlich die Operation ausführt,
sind Science-Multiplikationen und Anzahlen, Multiplikationen,
beziehungsweise Scient und Ansight, Additionen, eigentlich identisch.
Gut, auch dazu, nur um zu zeigen,
dass man also auch, nur um zu sagen,
dass man da also auch in Java immer noch einiges falsch machen kann,
also hier auch nochmal so ein Beispiel, also von diesem Java-Pazlas-Buch.
Hier habe ich jetzt Multi Keine Berechnung, wo jetzt also einmal
die Mikrosekunden pro Tag und einmal die Millisekunden pro Tag ausgerechnet werden.
Die sind hier deklariert als feine Long.
Das Ganze wird dann quasi ausgedruckt als Mikroproduct durch Millipaday.
Und wenn man das jetzt also hier von den Formen her
erstmal sieht, kann man sagen, na gut,
kürzlich entsprechend alles weg und es sollte tausend rauskommen.
Wenn man das ausführt oder berechnet, kommt leider nicht tausend
raus, sondern fünf.
Woran liegt das
Daran, dass zwar eigentlich das Ergebnis,
also hier in Longya reinpassen würde, das ist es ja nicht,
dass bloß quasi die Typkonvertierung oder die Umrechnung jetzt in eine Long-Arstellung
erst bei der Zuweisung des Ergebnisses passiert und nicht bei den arithmetischen Operationen hier vorne.
Das heißt, hier wird erstmal nur ganz normal mit 32 Bit gerechnet
Und erst, wenn das dann also hier auf diese Variable,
die dann also quasi als Typ Long deklariert wurde, zugewiesen wird,
wird eben die entsprechende Vorzeichenvergrößerung, also seinen externen, ausgeführt.
Das ist eben genau diese Aussage. Ein Herztrick oder als Workeround kann ich eben letztendlich erzwingen,
dass eigentlich diese Operationen schon auf Long-Zahn ausgeführt werden,
wenn ich dann eben quasi jetzt hier die Argumente dann auch explizit über so einen Suffix,
also entsprechend Kennzeichen.
Wenn ich das quasi dann mit so einer Long-Konstante rechnen würde,
dann würde auch in dem Fall dann das richtige Ergebnis bei rauskommen.
Gut, Multifikation, wie sieht es mit der Division aus?
Hatte ich bislang noch nicht vorgestellt, beziehungsweise nicht als Division im Dualsystem.
Im Prinzip funktioniert das genau wie beim Dezima-System.
Das heißt, ich habe also irgendwie den Divisor der dann
quasi als Vielfaches jetzt von irgendeiner Zahl abgezogen werden muss.
Wobei dann eben auch so dieses sukzessive Stellenversetzen passiert. Also sprich genau,
wie wir das eigentlich eben Dezimasystem auf dem Papier auch machen würden.
Nachteil ist bloß, weil das, da sagen wir mal jetzt,
also auch nicht ganz so einfach ist,
beziehungsweise für Masara noch gleich an den Beispielen sehen,
die Vision jetzt wirklich als elementare Operation wird,
Von den meisten Hardware-Rechenwerken eben nicht oder nur teilweise unterstützt.
Nicht deswegen ist eigentlich eine Division dann eigentlich nochmal deutlich langsamer als eine Multiplikation,
wenn man das jetzt mal beispielsweise mit Benchmarks untersucht.
Gut, als Beispiel nochmal, wie das im Prinzip erstmal läuft.
Wenn ich jetzt das hier rechnen würde, 100 durch 3,
also die 100 im Dualsystem dargestellt wäre, diese Zahl 3 im Dualsystem dargestellt,
eben 1-1. Jetzt gucke ich quasi auch beginnt hiermit am weitesten links stehenden Stelle
Wann habe ich genug Stellen zusammen, dass ich die drei überhaupt erst mal abziehen kann? Nicht,
wenn ich die erste Stelle nehme, passt es noch nicht,
wenn ich die zweite Stelle nehme, habe ich genau 1-1,
da kann ich also einmal die drei abziehen,
notiere mir hier also dann in dem Zufolge hier dann,
also das erste Mal, es ging nicht,
die erste 1 und erhalte als Rest null.
Diesen Rest nehme ich, nehme dann die nächste Stelle,
hätte hier quasi 0-0,
da kann ich noch nichts von abziehen,
den zufolge wird hier eine null notiert,
nehme jetzt
die nächste null
Habe immer noch null, kann nichts von abziehen,
notiere das dann im Ergebnis.
Anschließend kommuniziert also die nächste Stelle eine Eins,
von einer Eins kann ich die drei immer noch nicht abziehen.
Demzufolge hätte ich jetzt hier die dritte Null notiert.
Anschließend nehme ich jetzt also hier die nächste Stelle.
Erhalte also 1-0. Da kann ich immer noch keine Drei abziehen.
Das ist dann in dem Zufolge dann diese Null.
Und irgendwann habe ich dann also letztendlich,
bis ich dann also hier quasi alle Vorkommastellen abgearbeitet habe,
1-0-
Davon kann ich jetzt endlich mal wieder eine Drei abziehen.
Das ist dann eben hier hinten die Eins und es bleibt eine Eins als Rest.
Denn wenn wir jetzt anschließend noch anfangen würden, Nachkommastellen zu berechnen,
würde man dann eben entsprechend weiter verfahren und da dann eben wieder eine Null dahinter schreiben und so weiter und so fort.
Nicht, das ist im Prinzip dann die Division im Dualsystem,
hier noch ein anderes Beispiel, 91 durch 13. Diesmal geht es auf. Als Ergebnis kommt dann sieben raus. Und die 91 im Dualsystem wäre dann eben dieser String durch 13,
also auch hier würde ich dann eben quasi gucken,
wann habe ich das erste Mal, also irgendwas,
also in diesem Fall diese 1, 0, 1,
1, was groß genug ist,
wo ich den abziehen kann, hier passt es noch nicht,
muss ich also noch eine Stelle hinzunehmen,
dann hätte ich also quasi hier 1, 0, 1,
1, 0, davon kann ich jetzt diese Zahl endlich mal abziehen,
erhalte dieses hier als Rest, also 1, 0,
0, 1, Das ist die erste Eins,
anschließend kommt die nächste Stelle, davon kann ich es wieder abziehen,
erhalte das dann hier als Rest, lokaliere hier die Eins,
dann kommt die Arzthallen zu, das ist dann genau die Zahl selber erhalten,
das Rest Null und das Ergebnis wäre dann die Sieben.
Also im Prinzip ist das wirklich genauso wie im Dezima-System,
ist, sagen wir jetzt immer nur wegen der vielen Stellen
erstmal ein bisschen unübersichtlich zu lesen.
Gut, wie sieht das mit anderen mathematischen Funktionen aus?
Das ist im Prinzip alles,
was dann wirklich so höhere mathematische Funktionen sind,
also irgendwie Wurzel-Logarithmus,
Exponentialfunktion,
irgendwelche Winkelfunktionen
Da wird das dann also wirklich insofern schwierig,
wenn ich das jetzt also wirklich direkt in Arrethmetik in Rechner,
Hardware bzw. in anderen Zahlensystemen ausdrücken möchte,
dass man da dann eigentlich die Funktion immer über verschiedene mathematische Verfahren versucht anzunehmen.
Also häufig hat man also so irgendwelche Polynom-Approximationen,
also im Prinzip über Taylor-Reihe,
wo man dann mit teilweise auch schon vorberechneten Werten arbeiten kann
Teilweise habe ich dann eben auch irgendwelche Ernährungsverfahren,
die das Ganze dann quasi iterativ feststellen.
Wenn ich also beispielsweise für Quadratwurzel oder für Reziprog fährt,
also eins durch X. Und letztendlich geht es aber immer darum,
jetzt also je nachdem, was ich hier an Funktion berechnen möchte,
umzusetzen in irgendeine Approximationsvorschrift,
in der ich dann also wirklich nur mit den Grundrechenarbeiten
arbeiten kann
Ne, und gut, da bietet einem natürlich die Mathematik dann also verschiedene mehr oder minder gut funktionierende Verfahren.
Also als Beispiel zum Beispiel, also die für den Reziprogwelt,
da sich immer die iterative Berechnung von 1 durch X durch eben Sonierungsformel,
wo ich sage, okay,
also Y oder 1 durch X nähere ich quasi jetzt über so eine Folge an,
indem ich dann also sage,
Y von i plus 1 ist gleich Y i mal Zwei minus x mal y i,
beziehungsweise hier dann eigentlich die Zahnbasis.
Wenn ich jetzt einen vernünftigen Start werde für Y-0 habe,
da muss man natürlich auch erstmal irgendwie ansetzen muss,
sieht man also hier, was das Verfahren beispielsweise erzeugt,
wenn ich jetzt also hier versuche,
ein Drittel zu berechnen, dann sage ich, okay,
als Startwert, ja, also ein Drittel,
das wird irgendwie kleiner als eins sein, nehme ich erstmal 0,5.
Das heißt, das wäre dann also mein Startwert Y0,
eingesetzt in die Formel, erhalte ich dann also Y1,
das ist 0,5, mal 2, minus 3 mal 0,5. Wäre dann also 0,25.
Damit verfahre ich dann entsprechend weiter. Er hatte dann 0,3125 und
so weiter und so fort nicht. Und wenn man sieht,
also hier, sprich nach sechs Iterationen hat man dann schon,
gut, das würden hier entsprechende Nachkommastellen noch weitergehen,
aber da dann eben noch relativ gut angenäherten Wert von einem Drittel.
Ich aber letztendlich bei allen diesen Verfahren muss man eben immer sagen,
das hängt dann also wirklich immer sehr stark von dem mathematischen Verfahren ab,
was ich da einsetze und eben teilweise also auch davon,
dass ich, also wie jetzt,
also hier in so einem Beispiel natürlich dann auch mit sinnvollen Startwerten arbeiten kann,
was ähnliches wäre, also zum Beispiel Berechnung der Quadratwurzeln,
da gibt es dann auch so ein Annäherungsverfahren, wo ich dann eben sage,
okay, ich nähere das dadurch an, dass ich dann Y von N plus 1 als Y von N plus.
X durch Y N halbe, wenn ich also im Prinzip,
wo ich dann also eine Ernährung über so eine Quadrat,
Abweichung mache, wo ich das dann also mittel ausrechne,
wenn ich dann vorausgesetzt, ich habe ihm einen halbwegs vernünftigen Startwert,
funktioniert das Verfahren ganz gut, wenn ich keinen vernünftigen Startwert habe,
funktioniert das nicht so gut.
Gut, ich weiß nicht, also wie viele Mathematiker jetzt
noch hier dabei sind oder mit Nebenfach Mathematik nicht.
Also da kann man immer sagen, gut,
da gibt es noch das und das und das Verfahren.
Nicht, aber das Ganze ist dann eben wirklich immer davon abhängig, was möchte ich berechnen, beziehungsweise was gibt es da. Gut,
glücklicherweise kann man immer sagen,
wenn ich das jetzt also irgendwie in Programmiersprachen benutze,
beziehungsweise mit irgendeinen anderen Sachen,
das,
was dann eigentlich letztendlich da passiert ist,
dass ich mich also auf irgendwelche Funktionen aus Bibliotheken berufe und
in diesem Bibliotheken dann eigentlich schon eben genau solche iterativen Verfahren entsprechend umgesetzt oder implementiert sind und ich mich dann eigentlich dann eben darauf verlasse,
dass das in dem Fall dann eben Leute gemacht haben,
die sich damit auskennen und die wissen, mit denen Staatwerten bzw. unter den Bedingungen erhalte ich dann eben auch vernünftige Ergebnisse.
Man muss sich da dann also da nicht selber um solche mathematischen Verfahren kümmern.
Gut, relativ am Eingang, also im vierten Kapitel hatte
ich ja schon mal so vorgestellt, die Begriffe zur Informationsverarbeitung.
Und da ist also ja auch diese Folie dann hier schon mal aufgetaucht,
wo es dann im Prinzip jetzt um die Informationstreue geht.
Nicht, wo ich gesagt habe, okay,
welche mathematischen Eigenschaften gelten jetzt also irgendwie? Nicht,
wo ich jetzt eben gesagt habe, na gut,
gilt eben irgendwie immer sowas wie x Quadrat, ist größer, gleich, null.
Und wenn wir uns jetzt also im Prinzip die Zahlendarstellung für Sign-Darstellung beziehungsweise für Fließkomma-Darstellung nehmen und sagen,
okay, ich arbeite jetzt eben mit A-Treppe,
i754 bzw. mit irgendwelchen 32 Bit oder 64 Bits, R-Kompliments zahlen.
Nicht damit erklären sich dann eben genau diese Aussagen,
wo ich dann eben wirklich sage, gut,
für Fließkommazahlen gilt eben immer, eine Zahl zum Quadrat ist,
wo es der gleichen Null bei Science-Zahlen kann ich eben genau diesen Überlaufeffekt haben, dass das eben nicht gilt.
Nicht das heißt, da ist dann eben diese Informationstreue nicht gegeben. Andersrum habe ich eben den Effekt,
dass ich bei Fließkomma-Berechnungen jetzt eben entsprechend der Klammerung es erreichen kann,
dass letztendlich hier als Ergebnis nicht 3,14 rauskommen,
sondern wenn ich das jetzt eben falsch klammere,
als Ergebnis genaue Null rauskommt,
weil also hier bei dieser arathmetischen Operation jetzt einfach hier der Unterschied im Exponenten so groß ist,
dass also quasi diese 3,14 in der Mantise,
wenn das angeglichen wird,
letztendlich rausgeschoben werden und eben hier als Ergebnis dann eben genau diese Zahl überbleibt.
Wenn ich das dann, die beiden dann artiere,
ich dann zum falschen Ergebnis komme. Gut,
abschließend sind jetzt also hier noch einige mathematische Eigenschaften zusammengefasst,
die jetzt also für Rechnerarentmetiken gelten. Wo ich jetzt sage,
wenn ich jetzt eben solche Artentmetiken habe mit begrenzten Wortbreiten,
das ist da dann eigentlich immer noch der entscheidende Satz dazu,
dann gilt jetzt eben für eine Unsigned-Arentmetik,
die Ernstzeit Arrethmetik selber ist im Prinzip erstmal eine kommutative Gruppe.
Das heißt also, es gelten jetzt als Gesetze, die Abgeschlossenheit.
Das heißt, ich bleibe eigentlich immer in den Zahlenbereich.
Das einzige, was sein kann, ist,
ich überlaufen habe dann also ein falsches Ergebnis, aber ich bleibe im Zahlenbereich.
Komutativgesetz gilt, assoziativgesetz gilt, ich habe ein neutrales Element, logischerweise die Null.
Und es gibt dann eben sowas wie ein Inverses,
was dann eben genau jetzt wie dann auch beim Zweier-Kompliment ja dann also deklariert ist,
dann eben zwar auch wie minus A,
was sich dann eben als minus A bezeiten.
Nicht für die Signed Arreth Medic, im Prinzip genau das Gleiche,
beziehungsweise was man eben sagen kann eigentlich,
das ist eine Isomath für Algebra zur Unsigned Arreth Metic.
Das heißt, auf Bit-Ebene unterscheiden die sich nicht,
also ob ich jetzt eine Signed oder Unsigned Arreth Meeting mache,
das ist ja eigentlich auch genau der Grund für das,
was ich also vorhin schon mal gesagt habe
Für irgendwelche Hardware-Recheneinheiten, die nachher also wirklich im Computer drin sind.
Da wird nicht geguckt, rechne ich mit Zahlen, rechne ich mit Anzahlen,
sondern da geht eine Folge von 0 und Einzeln rein.
Und da kommt also ein Ergebnis raus. Und das ist
dann eigentlich jetzt nur von der Interpretation hinterher abhängig.
Also ob ich sage, das ist jetzt eine Unsignal, eine Science-Saal oder Rechnung gewesen, so. Gut, auch hier gilt eben entsprechend, das Ganze ist kormutative Gruppe mit entsprechenden Definitionen. Nicht das einzige,
wo sich das sowieso nur von der Unsigned Art Metik unterscheidet,
ist, dass bei der Deklaration des Inversen,
dass ich da eben sage, okay,
also für die eine größte, nein, oder andersrum,
für die kleinste darstellbare Zahl in meiner Sign-Arret-Meeting,
nämlich also genau minus zwei Hochweh, minus eins,
da gibt es also jetzt kein Äquivalent mehr jetzt,
also im positiven Zahlenbereich,
das kann ich da nicht mehr darstellen und da ist das Kompliment dann eben,
wenn ich jetzt also das als Inverses Karriere dann eben diese Zahl auch selber,
führt eben genau dazu,
dass wenn ich damit an ihm rechne,
beziehungsweise die Zahl dazu addiere ich ihm auch genau als Ergebnis eben nur null Vektor erhalte und dann eben eine Eins als Überlauf.
Gut, was gilt bei der Multiplikation,
Begrenzung der Wortlänge auf Webit wieder? Das Ganze ist,
wenn ich das jetzt eben insichtige der Wortlänge begrenze,
so was wie so eine Moduluarithmetik, das heißt A Unsign multipliziert,
mit B eingeschränkt, jetzt eben auf Webit,
ist letztendlich A, mal B, Modulo 2 Hochweh.
Also ich bebrachte jetzt immer nur die unteren Webit.
Und eben die Multiplikation zusammen mit der Addition bilden dann eben einen kormutativen Ring.
Das heißt, die Addition ist eine kormutative Gruppe.
Das hatten wir eben schon. Für die Multiplikation gilt dann eben auch,
Abgeschlossenheit, Kommodativgesetz, Assoziativgesetz, es gibt ein neutrales Element,
nämlich also die Eins und für beide Operationen zusammen gilt dann eben,
was wir auch kennen, Distributivgesetz, also sprich A mal,
Klammer auf B plus C ist gleich A mal B plus A mal See.
Gut, bei der Scient Arreth Metic,
nicht auch da kann man sagen, Scient Ansign Multiplikationen sind auf Begebene identisch,
das heißt letztendlich sind Signed und Unsigned zu einem,
also Addition und Multiplikation zueinander, sogenannte Isomorphe Argebrenn.
Das heißt, die verhalten sich jeweils gleich.
Wobei ich jetzt also hier immer sage, also mit Signed
meine ich jetzt immer das Zweierkompliment, sehr explizit.
Denn das Ganze ist dann eben auch noch Isomorph zum Ringen der ganzen Zahlen,
Modulu 2 hoch V. Das ist eben genau diese Bereichseinschränkung. So,
und das war es jetzt eben nur dieser Rechneraren-Meting eigentlich unterscheidet von der normalen Schulmathematik,
wo wir jetzt sagen,
also wir arbeiten quasi im Ring der ganzen Zahlen,
ist dann letztendlich die Ordnungsrelation, nämlich,
dass ich also in der rechten Arrethmetik Überläufe haben kann.
Nicht, weil für ganze Zahlen gilt,
wenn ich weiß, A ist größer null,
dann gilt A plus B ist auf alle Fälle größer als B.
Denn das habe ich in der Rechnerarbeit im Meeting nicht,
weil da kann ich einen Überlauf haben und auf einmal ist
das Schurke überhaupt eine kleinere Zahl.
Genauso dann eben A, größer null, größer Null,
dann gilt eben A, Mahl B, ist größer Null.
Und auch das habe ich da dann nicht. Das heißt,
eben diese Überlaufproblematik, das ist dann eben das,
was dann eigentlich jetzt bei Rechnerarbeiten-Meeting da noch hinzukommt.
Gut, vergleicht man das jetzt? Wie gesagt,
das waren jetzt alles Unsigned beziehungsweise zweier Kompliment, also oder normale Sign-Darstellung.
Darstellung, wie sieht das dann mit Gleitkommandoberechnung aus?
Hier jetzt eigentlich nur noch mal kurz die mathematischen Eigenschaften aufgelistet
Abgeschlossenheit gilt, Kommutativgesetz gilt auch, assoziativgesetz gilt nicht,
weil da kann ich eben genau solche Überläufe und Rundungsfehler in der Addition erreichen,
indem ich jetzt eben sage, je nachdem wie ich das klammer,
verschwindet dann eben der eine Operant.
Das war ja genau dieses eine Beispiel, was ich hier habe,
wo im Prinzip die Klammerung entscheidend ist, was das Ergebnis nachher wird.
Es gibt ein neutrales Element, die Null, Es gibt ein inverses Element,
außer für Not and Number, beziehungsweise für Infinity.
Und bis auf die beiden gilt dann eben auch die Monotonie,
also sprich diese Ordnungsrelation.
Und bei der Multiplikation, wie sieht das da jetzt aus?
Da kann ich eben auch sagen, Abgeschlossenheit gilt,
Kommutativgesetz gilt, assoziativgesetz, habe ich eben auch wieder dieses Problem,
je nach Klammerung kann ich da eben Überläufe und Rundungsfehler mir generieren.
Als neutrales Element in der Multiplikation,
Auch nichts grundlegend Neues. Distributivgesetz gilt eben nicht,
weil ich da dann natürlich auch immer den Effekt habe,
ob ich nun A mal,
Klammer auf B plus C rechne oder A mal B plus A mal C,
kann dann eben auch aufgrund der Rundungsfehler dann schon deutlich unterschiedliche Ergebnisse liefern.
Und eben, wie gesagt, die Monotonie gilt dann entsprechend.
Gut, damit bin ich jetzt mit diesem Teil zur Rechnerarentmetik
durch.
Dann schönes Wochenende