Gut, jetzt zu den weiteren Aufgaben.
Also unter Aufgabe 9 ging es ja darum, spizzieren Sie,
dass den ROBDD für die Bullshit-Funktion X und Y und Z
nicht ROBDD reduced ordert binary ecision diagram
Da hatte ich in der Vorlesung soweit erstmal nur vorgestellt,
jetzt aber noch nicht irgendwie zwingend, eine Konstruktionsvorschrift oder sowas beschrieben.
Das heißt, das,
was man dann hier eigentlich machen würde,
ist letztendlich erstmal nichts anderes,
als dass ich mir
die Funktionstabelle aufschreibe
Das heißt also, jetzt für meine Variablen, X,
Y und Set. Die Funktionstabelle von dem Nen,
mit drei Eingängen, wäre in einem einzigen Fall,
nämlich wo alle drei Eingänge in der Eins sind,
erhalte ich eine Null.
In anderen,
allen anderen Fällen erhalte ich
Als Ausgabe eine Eins. So ausgehend von der Funktionstabelle habe ich
mir jetzt eigentlich erst mal im ersten Schritt erst mal einen vollständigen Baum aufgezeichnet.
Das heißt, also jetzt in der Reihenfolge XYZ,
also eigentlich dann so ein Baum, wo ich sage,
okay, also X,
ihr dann immer jeweils unterteilt nach Null und Eins
Musik So, und das,
was da jetzt eben rauskommt, ist in dem Fall
hier eine Null
Und in allen anderen Fällen. Eine Eins? Nein,
das, was man jetzt eben immer machen kann,
ist ähnlich wie das, also dann hier in der Beschreibung,
da muss ich das jetzt wieder finden. Entscheidungsbäume,
ähnlich wie das dann also hier quasi in dieser Beschreibung drin ist,
dass ich sage, okay, wenn ich jetzt das gleiche,
Endknoten habe, die jetzt also im Prinzip identische Werte haben,
wie hier diese 0-0 oder hier diese 1-1,
dann kann ich das Ganze letztendlich minimieren.
Also dieses hier zum Beispiel ist unabhängig davon,
ob ich hier eine Null oder eine 1 habe.
Das heißt also, das könnte man dann
zu so einem... Zu einer Kante minimieren,
hier genauso hier genauso
Also auch hier habe ich da jetzt Dana 1. So,
dann ist dieses hier eigentlich unabhängig davon, wie das jetzt hier mit dem Set aussieht.
Und ich kann also quasi hier runter jetzt schon zu der Eins minimieren. Und wenn man das dann auch,
sagen wir jetzt nochmal,
also ich da jetzt hier noch irgendwie weiter die Zeichnung für Hunze,
entsprechend zusammenfasst, kann ich eigentlich sagen,
wenn ich ein X habe und der erste Wert ist eine Null,
dann habe ich am Ausgang eine Eins,
was sich also hier einfach dadurch zeigt,
dass ich also hier bei all diesen Fällen unabhängig von allem anderen hier eine Eins habe,
also kann ich sagen, Eingang Null,
da habe ich eine Eins.
So anschließend, abhängig von Y kann ich jetzt sagen,
wenn Y habe, der hier war jetzt also auch komplett wegminimiert.
Und ich habe dann eine Null,
ist das unabhängig von Set, das heißt,
das auch hier habe ich dann mit einer Null,
diese Kante zu der Eins.
Und hier habe ich jetzt eben mit dem Eingang Null,
danke hierhin, mit dem Eingang ein.
Ja, ist gang 0 und das wäre dann XYZ,
sodass, was dann so ein ROB, DDD dazu wäre.
Eine Frage. Die Funktion war ja, wie wir jetzt müssten,
war wie nur noch die einzige Vertraute sein.
Nee, also die ist negiert,
da habe ich hier eigentlich in der Funktionstabelle ja
schon mit drin
Was? Nicht, also das, das,
das spiegelt sich dann eigentlich, also hier schon in dem Bau,
beziehungsweise hier dann also eigentlich schon richtig wieder,
beziehungsweise ich kann sagen, wenn es nicht negiert wäre,
dann müsste ich,
das müsste ich also hier 0 und 1 vertauscht haben,
nicht, also dadurch, dass ich immer sage,
also nach links habe ich den, den,
den Fahrten mit der 0,
lande da dann aber bei der 1,
also so könnte ich das also
auch mit der Negation interpretieren
Ja. Gut, dann, wenn es jetzt
keine Fragen mehr gibt, also jetzt zur Aufgabe, 10
Da war er also im Prinzip hier ein Zustandsdiagramm,
beschrieben ein Automat. Und da ging es jetzt also darum,
erst mal unter Aufgabenteil A ist das ein Moor oder ein Milli-Automat.
Da muss man einfach Wissen gelernt haben, letztendlich,
was ist Moore, was ist Milli-Modell?
Und die Unterscheidung formal ist halt eben, dass ich sage,
oder hier aus sieht man es eigentlich ein bisschen einfacher.
Beim Mooreautomat hängt die Ausgabe, also die ist Y,
nur von dem aktuellen Zustand ab.
Beim Milli-Automat von Zustand und Eingabe
Beziehungsweise formal gesehen. So der Folgezustand hängt bei beiden Automaten
auch jeweils vom Zustand und Eingabe aus. Da ist also identisch,
aber wenn ich das sehe, in so einer Funktionsschreibweise habe,
Moormodell, Ausgabe, also die Slam oder die Ausgabefunktion Lamda,
hat als Argument eben wirklich nur den Zustand,
wenn man Miliautomatzustand und Eingabe.
So, wenn ich so ein,
das Ganze jetzt also in einem Zustandsübergangsdiagramm zeichne,
Sieht man das, da haben wir es, dadurch,
dass ich quasi beim Moorautomaten die Beschreibung der Ausgabe in den Zustand mit reinsetze.
Das heißt also, in diesem Kreis, wo ich sage,
das ist mein Zustand, da habe ich auch gleich die Eingabe mit notiert.
Und an den Kanten, also an den Pfeilen,
habe ich dann eben Nee, da habe ich die Ausgabe mit notiert, sorry.
Und an den Kanten, an den Pfeilen,
da habe ich dann eben die Eingabe unter der,
ich einen entsprechenden Zustandsübergang irgendwie mache. Das heißt,
dadurch kann man direkt in der Art und Weise,
wie das dort aufgezeichnet ist, sagen, ist das in Moore oder ein Medienmodell.
Beim Moore-Modell kann ich eben immer sagen,
Ausgangswert oder Ausgangsvektor hängt eben nur vom Zustand ab,
demzufolge, da ist er da eben auch entsprechend dran notiert.
Beim Mili-Automaten, wird das eben immer so notiert,
dass ich also in diesem Kreis,
also in dem Zustand immer nur die Beschreibung oder Kodierung
des Zustands habe und dann an den Kanten dranhängen habe,
eingangs Vektor und dann eben mit einem Slash oder wie auch immer irgendwie getrennt,
dann den jeweiligen Ausgangsvektor.
Das heißt, da kann man dann direkt aus der
Art und Weise, wie das skizziert ist,
sehen, habe ich einen Moor oder ein Mili-Modell
So in dem Fall hier im Pooltipp mal wegklicken, so.
In dem Fall hier habe ich da also jetzt eindeutig ein Moorautomat,
weil könnte man jetzt eben noch gleich mit dazu schreiben,
nicht Moorautomat, weil Ausgang hängt nur vom Zustand ab.
Nicht von der Handhabung her, wenn man das Ganze nachher beschreibt oder entwirft,
ist und Moorautomat immer ein bisschen einfacher, von dem,
was die Automaten letztendlich ausdrücken oder berechnen können,
wenn ich das jetzt also in die Theorie quasi übersetze
, sind beide Automatenmodelle gleichmächtig. Es kann aber sein,
dass man dann eben bei bestimmten Beschreibungen quasi für ein Millimodell
ein Äquivalentes Moormodell macht, was dann eben mehr Zustände benötigt.
Gut, das ist aber Automatentheorie, also wie gesagt,
hier kann ich jetzt einfach direkt ablesen, Moorautomat,
weil Ausgang hängt nur vom aktuellen Zustand an.
Gut, dann war unter B gefragt, tragen Sie Ausgabewerte? Für die Zustandsübergangsfunktion,
also das heißt also hier für das, was die Stale dann nachher ist,
also die Beschreibung jetzt von den Sets war Z1 plus und für die Ausgabefunktion,
das was also formal in die Funktion Lamda ist,
für das Y dann also quasi hier mit ein,
das kann man dann eben direkt aus dem Automaten heraus.
Ablesen, das heißt, jetzt hätte man das irgendwie vorbereiten sollen,
also neu. Gut, ich bin jetzt mal faul,
dass wir haben alle, hoffe ich.
Weil dann will ich zumindest, also den Tag hier nämlich
schon mal recyceln
Musik Gut, Funktion, wie gesagt,
also direkt aus dem Automaten ablesen
So, was man in diesem Automaten hier jetzt letztendlich hat,
ist, dass man sieht, okay, da hat drei Zustände.
Der Zustand 0-0 kommt gar nicht vor. Das heißt,
dieser Teil und dieser Teil hier ist nicht weiter spezifiziert.
Dafür benutze ich dann eben immer so einen Don Kerl als Sternchen,
weil das kann ich dann nachher bei der Minimierung im KV-Diagramm
irgendwie entsprechend
irgendwas Passendes erträumen
Ja. Gut, und dann muss sie jetzt eben quasi
für die Zustände gucken. Wie sind da die Übergänge?
Wie sind die Ausgänge? Fangen wir erst mal bei
den Ausgängen an, weil das ganz einfach ist.
Also bei 0-1 ist der Ausgang 0.
Das ist hier, und das ist hier,
und in allen anderen Fällen ist der Ausgang
Dann habe ich hier die Zustandsübergänge, also fange ich hier an mit 0
-1. Egal ob null oder eins am Eingang anliegt.
Ich habe einen Zustandsübergang nach 1-1. Das heißt,
ich habe hier 1-1 und jeweils 1-1
-1 zu tragen.
Dann für den Zustand 1-
0 Eingang
Übergang nach 0-1, Eingang 1,
Übergang nach 1-1. Das heißt, hier habe ich 0-
1 und hier hätte ich 1-1 drin stehen.
Und in dem Zustand 1-1,
mit Eingang 0, ein Übergang nach 1-0,
mit Eingang 1 bleibt er in diesem Zustand.
Also 1-0 und 1-1. Das ist also
einfach Nur Fleißarbeit. Das ist also irgendwie sauber abzuschreiben,
sich da hoffentlich nicht mit irgendwas zu vertun.
Aber von der Idee her, keine besondere Schwierigkeit.
Sollte es sein. Dass du mit dem Bund herrschen müsstest,
oder auf dem Kerstin, oder dürfen wir da auch wahlgerecht
entspricht und machen bald den Zufällen ja gar nicht existieren.
Und deswegen auch gar keine Nachfolge zu. Gut,
also man kann dort natürlich also auch sagen, okay,
also da trage ich sowas ein und streiche das komplett raus.
Die Sache ist ja, wenn im nächsten Aufgabenteil jetzt nach
irgendwelchen Realisierung für die Schaltfunktionen gefragt ist. Nicht,
dann habe ich ja im Prinzip so was wie ein KV-Diagramm
und will da dann ja also irgendwo in der Schaltfunktion was minimieren.
Und da kann ich jetzt natürlich sagen, gut,
ich lasse das dort komplett weg und betrachte dann wirklich nur das,
was ich an Nullen und Einsen hier drin stehen habe.
Bloß damit verschenkt man sich dann ja einfach jetzt Minimierungsmöglichkeiten, die man vielleicht hat.
Und dafür ist ja eigentlich genau dieses Konzept dieser Don't Care Star,
dass ich sage, das ist eben eine Eingabe oder ein Zustand,
der normalerweise nicht auftaucht und um daraus jetzt möglichst klein,
Schaltalgebrachen Ausdruck zu gewinnen, habe ich eben dieses Konstrukt der Don't Cars,
wo ich dann eben sagen kann, ja gut,
da baue ich mir eben irgendwie was hin, dass ich das also möglichst sinnig in eine Schleife einbauen kann.
Nicht weil rein praktisch, also spätestens wenn ich jetzt sagen würde,
also dieser Automat wird irgendwo in Hardware dann irgendwas umgesetzt,
habe ich natürlich an der Stelle, also logische Funktionen,
wo ich dann also logische Null oder eine logische Eins habe,
nicht und dann deswegen sollte man das dann eigentlich dann so auch entsprechend nutzen.
Gut, wie gesagt, das Ganze ist jetzt hier in entsprechende KV-Diagramme zu übertragen.
Das heißt jetzt hier für zwei plus Z1 plus
Und... Hier für Y. Gut,
und das war es dann also hierbei rauskommt, ist,
wenn ich das jetzt hier
einfach entsprechend abschreibe
Gut,
ich habe jetzt hier die Beschriftung nicht mehr dran,
ist aber im Prinzip genau das,
wie also auf dem Aufgabenzelt hätte man dann
eben entsprechend diese Werte dann da dran stehen
Gut, dann war in D dazu,
geben Sie die minimalen Ausdrücke für die Schaltfunktionen an.
Also versuche ich mir jetzt hier wieder entsprechend möglichst minimal meine
Schleifen zu bilden. Hier hat man jetzt im Prinzip,
wobei das also vom Aufwand her eigentlich auf das Gleiche hinausläuft,
die Möglichkeit zu sagen, also entweder ich mache das Jetzt über irgendeine...
Schleifen und ihm normal irgendeine disunktive Form oder ich kann auch sagen, also hier zum Beispiel in einem zweiten Beispiel sieht man das ganz gut. Ich habe hier Don't Cass,
ich habe hier lauter Einsen,
ich habe hier eine einzige Null,
nicht also in dieser Fall kann ich dann natürlich also auch hier die konjunktive Form quasi jetzt einfach von einer Null nehmen,
also den entsprechenden Max-Term, der sich hier dahinter verbirgt,
nicht und hier Wenn ich das jetzt also hier quasi mal andersrum mache und sage,
okay, ich mache Wörters jetzt, also hier mit Schleife,
also im Prinzip kann ich das hier auch Marksthermen machen und auch eine Schleife entweder hier rüber bilden oder in der konjunktiven,
ja,
Corny und Kim Form ja quasi hier und hier meine Schleifen bilden.
Und dann hätte ich da demzufolge dann als Ausgangswert,
so jetzt muss ich nochmal gucken,
weil das hatte ich nämlich bei mir gerade auch noch falsch,
dass ich das anders habe
Also diese Schleife hier wäre. Set 1. Und dieses hier
unten wäre X, also Z1 oder X. Und hier könnte
ich eben entweder sagen,
ich bilde hier eins,
Ja, also eins, zwei, drei Schleifen.
Oder war es dann also mathematisch auf das genau das Gleiche hinauskommen.
Ich beschreibe direkt hier diesen Marktsterm,
dann habe ich hier quasi X oder...
Setz zwei nicht. Oder... Sind eins. Nicht.
Sind alle links bei der dritten Seite,
bei X
Äh... Wo jetzt? dritte Zeit. Ja, genau,
dieses wieder eins. Ich dachte, das ist der Film
. Ähm... Nee. Ähm, das ist...
Ich bin im Zustand. Ich bin im Zustand 1-
Und im Zustand 1.0 ist meine Ausgabe 1. Ah, ich dachte,
es geht für mich folgend zu sagen, alles klar.
Nee, also Y ist ja die Ausgabe. Also Folgezustände
sind ja die beiden und das hier ist die Ausgabe.
Und deswegen müssen die also logischerweise auch identisch sein,
weil das ist ja so beim Ruhrautomat unabhängig von der Eingabe.
Nicht beim Mili-Automat würde ich dann sehen, da sind diese Teile nämlich nicht identisch. Nein,
müsste ich also hier dann auch entsprechend noch eine,
die dritte Variable mit hinzufügen,
die dann hier quasi auch schon rausoptimiert ist, weswegen man da natürlich,
also allein schon wegen dieser Vorgabe von dem KV-Diagramm,
also auf Idee kommt, dass also hier das Y ja,
also irgendwie unabhängig von der Eingabe X ist,
war es ja dann immer auf Walk and Watch schließen lässt.
Gut, ach so,
genau, jetzt hatte ich hier natürlich noch,
also dies ganz schwierige Teil mit dem Y vergessen,
also das wäre in dem Fall dann einfach Z2. Ich habe
quasi eine Schleife hier unten
Gut,
das zu den Automaten bzw. hier zu dieser Automatenaufgabe
Dann Aufgabe 11. Ich vergebe es jetzt auch wieder so
ein bisschen um die... Gut, hier auch nochmal.
Also, geben Sie einen Code mit 4 Codewardern an,
der ein paar weiser Hemming-Distanz mindestens 4 ist.
So, Hemming-Distanz war ja immer Für zwei Worte,
an wie vielen Bits oder an wie vielen Stellen unterscheiden die sehe ich?
So, und jetzt ist hier so ein bisschen das Problem,
als ich am Freitag da saß und gesagt habe,
na gut, also überlege, wie würdest du das angehen?
Habe ich natürlich gesagt, okay, naiv,
würde ich eigentlich so und so und so anfangen.
Bin dann also auch zu einer von unendlich vielen möglichen Lösungen gekommen,
weil also auch das ist also eine von den Aufgaben,
wo man eigentlich beliebig viele Lösungen zur Verfügung hat
Wo man als Ergebnis zu der Aufgabe dann eigentlich auch nur eine von diesen Lösungen hinschreiben kann,
die dann aber nicht zwingend weiter kommentieren muss,
sondern einfach nur schreibt, okay, das so und so kodiert.
Und dafür gilt das dann eben. Ich habe mir da nochmal versucht,
irgendeine Art systematische Herleitung zu überlegen,
also wie man jetzt also mit irgendeinem systematischen Verfahren,
also dazu zu irgendeiner Lösung kommt,
beziehungsweise war das die Aufgabe, hat ein Kollege erarbeitet,
hat die die Nummer gefragt, dann meinte er aber,
und der ist also mathematisch,
also deutlich besser drauf als ich.
Also auch er hat da leider jetzt kein Verfahren,
also von daher Und bleiben wir jetzt also bei dem naiven Ansatz.
Also wir brauchen vier Codewörter mit ein paar Weiser Hemming Distanz 4.
So, um jetzt eine Hemming Distanz 4 hinzukriegen,
brauche ich also als Mindestwortlänge oder Bittlänge,
also quasi schon mal vier Bit.
Das heißt, da kann ich sagen,
ich mache ein Codewort mit 4-0.
Ein zweites Codewort mit 4-1, hurra,
zwei Wörter Hemming Distanz 4.
So, damit haben wir zwei Wörter.
So, wie machen wir daraus jetzt
vier Wörter
Und das, deswegen, also naive Lösung,
haben wir gedacht, naja gut, also jetzt hier,
wenn ich irgendwas anderes hier drin mache,
vertausche das Haut nicht hin.
Das heißt also, das Ganze muss erst mal länger werden.
So einfachster Ansatz, das also einfach länger zu machen,
ist zu sagen, ich klebe dann also noch mal irgendwie ein paar Bit dahinter.
Die mache ich hier irgendwie alle null. Das gilt ja
immer noch. Und dann kann ich jetzt sagen,
gut, dann mache ich also gleich einen Trick hier eben
noch mal
Indem ich die jetzt nehme und hier hinten dann eben jeweils Einzeln stehen habe.
Das heißt, null, null, null.
Null. Mit hier 4-1 und... Und Hurra,
die Aufgabe ist gelöst. Deswegen meine ich, gut,
das ist, wie gesagt, ein naiv geträumter Ansatz.
Ich kann also beliebig viele Wörter machen, die können,
es ist auch nicht zwingend vorgegeben, dass die acht Bit haben.
Die können also auch länger sein. Irgendwann möchte man
die Aufgabe nun mal abgehakt haben und deswegen sollte man jetzt
also irgendwie keine 100 Stellen hinschreiben
Nicht? Und die Sache ist, es ist ja
eben auch gefragt nach ein paar Weise Hemming-Distanz mindestens vier.
Also diese beiden Worte haben Hemming-Distanz acht, diese beiden auch. Nicht,
aber es geht ja nicht darum,
jetzt also eine möglichst kurze, irgendwie super optimale Lösung hinzukriegen,
sondern geben Sie einen Code mit vier Code-Code-Worten an,
deren paar Weise Hemming-Distanz mindestens vier ist, ja,
das ist hier gegeben, fertig.
Also muss man jetzt also nicht ganz so heftig und viel überlegen,
sondern einfach irgendwie was hinschreiben,
dann eben nur gucken,
ist dieses Ding mit dieser Hemming-Distanz
letztendlich gegeben
Also es gibt sicherlich also auch andere Verfahren,
wie man das noch kürzer und schöner und schlauer
und vielleicht auch noch ein bisschen systematisch hellen kriegt.
Aber das, was mir also als erstes so eingefallen ist,
ist also irgendwie sowas. Deswegen hat er jetzt gesagt,
naiver Ansatz. Gut, dann war jetzt unter B gefragt,
wie viele Bittfehler innerhalb eines Codeworts lassen sich aus ihrem Code erkennen.
Wie viele Bittfehler innerhalb eines Codewortes lassen sich mit ihrem Code richtig korrigieren. So,
da muss er jetzt natürlich nicht so einen super genialen Code haben oder irgendeinen anderen,
den sie sich ausgedacht haben,
sondern da muss man eigentlich nur Jetzt Wissen für diese Codierung beziehungsweise für die Korrektur von kurz,
dass... Genau, hier haben wir Hemmingabstand, das also im Prinzip diese Formeln gelten.
Fehlererkennung funktioniert eben bis zu dem minus eins stellen.
Fehlerkorrektur bis zu dem minus eins halbe stellen,
beziehungsweise dann in der entsprechenden ganz zahligen Untergrenze.
Das heißt, wenn ich ein Hemming des Abstand von vier
habe, geht demzufolge eine Fehlererkennung.
In dem Fall dann also bis zu drei Stellen
Und eine Fehlerkorrektur für eine Stelle. Nicht wahr,
da müsste ich an mich rechnen, trage ich zwei,
ist anderthalb, ganzzahlige Untergrenze wäre eine Stelle.
Nicht, das ist eigentlich alles,
was man jetzt hier für diese Aufgabe entsprechend benötigt.
So, da wollte ich endlich mal
was Ladekabel mit
Ja. Gut, in Aufgabe 12 war jetzt eine von diesen Beliebten Assembler Routinen,
wobei ich dann also auch schon in Bezug auf die Oder
Semmler-Aufgaben auch schon in Bezug auf die Klausur sagen kann.
Ich denke, das hatte ich ja auch schon in der Vorlesung gesagt.
Es geht jetzt ja nicht darum, also irgendwie möglichst gut und perfekt Assembler-Code zu schreiben.
Demzufolge wird also keine Aufgabe drankommen, wo es heißt,
also hier ist ein Algorithmus oder eine Formel und schreiben Sie das mal eben schnell in Assembler.
Weil dazu müsste man jetzt wirklich einzeln. Und genau die Befehle wissen und so weiter. Also das wird hier nicht verlangt, das soll nicht passieren. Nicht das,
was wir hier eigentlich bei Assembler machen oder weswegen ich das eben in der Vorlesung drin hatte,
ist, dass man also grob diese Abarbeitung von Assembler-Befehlen auf der Hardware,
auf der Maschine hat und versteht und dann im Prinzip also die Umsetzung von bestimmten Sachen,
wie eben beispielsweise Parameterübergabe über einen Stack, also dieses Stack-Prinzip,
nicht nur ansonsten, also die Art und Weise,
wie jetzt also hier irgendwelche Sachen mit Assembler-Code beschrieben sind,
dass sie dann eben als vergleichsweise einfache Sachen,
wo der X-86 Assembler eigentlich auch so ein bisschen missbraucht wird,
weil das, was hier eben an Code ist,
sie liest sich eben eher mehr wie ein Quote für eine Maschine,
aber nicht für das, was also eigentlich,
also im X86-Befehlsatz,
sonst noch alles mögliche ist.
Gut, deswegen solche Assembler-Aufgaben sind dann eben in der Regel so wie hier.
So ein paar einfache Befehle und man soll dann also
vielleicht grob verstehen, was macht der Algorithmus?
In dem Fall ist es hier also schon beschrieben.
Oder wie dann hier gefragt, den Code so ein bisschen
Was jetzt hier nicht der Fall ist,
was jetzt also in der Klausur da jetzt also auch nicht drin stehen habe,
ist, dass die einzelnen Assembler-Befehle nochmal irgendwie in ihrer Funktion,
also sprich formal beschrieben sind, was die machen.
Da gehe ich jetzt eigentlich davon aus,
das ergibt sich mehr oder minder aus dem Namen,
wenn sonst Unklarheiten sind oder sein sollten.
Dafür springen wir dann bei der Klausur auch immer noch rum,
kann man also nochmal nachfragen,
was macht dieser Befehl da eigentlich
Und solange das, also jetzt nicht, also nicht,
also was macht der Algorithmus? Okay, das werden wir ja nicht beantworten.
Also wenn danach gefragt ist, aber im Prinzip so ein paar Hilfestellungen kann man machen. Ansonsten kann man einfach sagen,
bei diesen Assembler-Befehlen ist es so, hier in den Vorlesungsunterlagen dazu,
weil da ist da nämlich eigentlich auch schon alles mit beschrieben,
was man dazu bräuchte, wenn man da also jetzt nochmal reinguckt,
habe ich im Prinzip also einmal diese Sache,
wie das, also mit dieser Adressierung,
der Pressberechnung geht und dann eben so die einfachen,
wie näheren Operationen, wo ich dann eben wissen muss,
okay, ich habe hier jetzt also irgendwelche Additionen,
Subtraktionen, Source Destination und es wird dann eben immer gerechnet.
Zweites Argument, Operation, erstes Argument und das Ergebnis
landet dann eben hier wieder im zweiten Argument.
Das ist eigentlich bei allen diesen Befehlen identisch und identisch aufgebaut
Komme ich leicht drauf zurück. Unäre Operationen selbst erklären und das,
was man dann eben noch braucht, ist,
also die Sache mit diesem Kontrollfluss, dass man eben sagt,
gut, also mit den arathmetischen und mit den logischen Operationen setze ich direkt irgendwelche Flex,
beziehungsweise nicht, also beispielsweise hier mit so einer Addition,
der setzt dann eben halt die vier Flex.
Dann habe ich noch als speziellen Befehl dieses Compare war es im Prinzip
nichts anderes rechnet als zweites Argument, minus erstes Argument,
das heißt, es ist eigentlich nichts anderes als so ein Subtraktionsbefehl,
nur dass das Ergebnis nicht hier landet,
sondern eben nur die Flex gesetzt werden.
Das taucht dann eben hier auch in dem Algorithmus auf,
dass also quasi mit diesem Compare jetzt also irgendwie im ersten Schritt
die Flex gesetzt werden und dann im nächsten Schritt kommt dann eben irgendeiner von diesen Jump befehlen,
wo die Flex dann abgefragt oder abgefragt werden und dann eben gesprungen oder nicht gesprungen werden.
Nicht, das sage ich, sagen wir mal so,
Grund, die Grundart und Weise, wie jetzt also irgendwelche bedingten Sprünge in dem SM-Blakot funktionieren. Nicht,
das sind dann im Prinzip diese Sachen und wie gesagt,
die Addition, Supraktion, das entspricht dann eben hier sowas,
beziehungsweise Subfraktion vielmehr und bei den logischen Operationen,
das heißt, bei diesen End- und Orbefehlen,
die sind quasi Äquivalent zu dieser Testanweisung,
die setzen dann eben Zero on Sign
Nicht nur dieses Test ist im Prinzip ja dann genau das Gleiche wie so ein Bidvises.
Und nur dass das Ergebnis daran nicht irgendwo landet.
Gut, das also zu dem... Zu der Funktionsweise. Gut,
dann geht es jetzt darum, also hier quasi den Code zu kommentieren.
Ja, und da kann man sich eben immer merken,
bei den dieser ganzen Assembler-Programmierung, so wie das ja also
auch in den Vorlesungsunterlagen immer irgendwie so aufgebaut ist, grundsätzlich gilt.
Ich habe bei irgendwelchen Funktionen erstmal irgendwie so ein Teil Setup,
ein Teil, wo gerechnet wird, ein Teil Finish.
Dieses Setup und dieses Finish, das tritt immer und genauso
und bei allen Funktionsaufrufen mehr oder männer identisch auf. Da geht es nämlich darum,
die Art und Weise, wie die Funktion aufgerufen werden,
spricht das, was hier unter Funktions- und Prozeduraufruf,
also die ist Scall und Return über den Stack,
was hier beschrieben ist, dass das im Prinzip genau dort stattfindet.
Genauer beschrieben ist,
dass dann also im Prinzip hier dann also irgendwie so ab diesen Folien,
nicht wo dann also im Prinzip drin ist,
was dort passiert, was man dann eben gegebenenfalls noch wissen muss,
ist jetzt also von diesen Registern ESP fassen wir nicht an,
das ist der Stackpointer, der wird automatisch von Push und Pop mit verwaltet.
EBP, als Register ist dieser Basepointer. Damit wird quasi der Bereich,
in dem eine aufgerufene Funktion rechnet oder Beginn dieses Bereichs quasi gekennzeichnet.
Das heißt, das ist also nach dem Call der Begehen des Stacks,
wo dann also die Funktion, in der ich jetzt gerade rechne, ist nicht.
Und wenn die jetzt innen drin irgendwas rechnet oder irgendwas auch
mit Pop auf dem Stack tut, wächst eben entsprechend dieser Stackpointer.
Aber im Prinzip diese beiden Register sind dann eben noch speziell zur Handhaben.
Dann ist es eben so, dass die in der Regel die Konvention ist,
dass in dem Register EAX der Returnwert zurückgegeben wird.
Nicht und ansonsten bei diesen Registan, hier ist dann eben noch
zu unterscheiden, ist zwischen Callers Safe und Corly Safe.
Was ist damit gemeint? Also diese Register sind außen vor.
Ich habe noch sechs Register zur Verfügung. Die benutze ich
irgendwie jetzt munter in meinem Programm, rufen unter Programmen auf.
So und die Frage ist jetzt, wenn das unter Programm,
was er vielleicht auch irgendwie mit Registern rechnen möchte,
wer sorgt jetzt dafür, dass also irgendwelche Inhalte gesichert werden und zurückgeschrieben werden,
das unter Programm aufgerufen, beziehungsweise beendet wird,
damit die aufrufende Funktion dann quasi hier wieder die Werte sieht,
die sie ursprünglich da mal reingeschrieben hat.
Nicht, weil das möchte ich ja eigentlich erreichen. Während diese Konvention zwischen Caller und Cordy safe ist jetzt eben,
dass man sagt, Caller safe heißt, eine Funktion,
die jetzt irgendwo rechnet und diese drei Register benutzt,
irgendwann später eine Unterfunktion aufruft und hinterher dann wieder mit diesen Registern weiterrechnen muss,
Die muss selber, deswegen Caller,
weil das ist ja die Aufrufende Funktion,
die muss selber diese Register auf den Stack sichern und nachher wieder zurückschreiben.
Im Gegensatz dazu, Cally safe, heißt,
wenn eine Funktion aufgerufen wird,
die bei ihrer Berechnung irgendwas von diesen Registern braucht und mit eigenen Werten überschreibt,
dann muss diese Funktion quasi zu Beginn dieser Register,
also typischerweise sowas wie EBX zum Beispiel,
sichern auf den Stack, kann sie selber jetzt irgendwie rechnen.
Und hinterher dieses EBX wieder vom Stack zurückholen, weil die ist dann dafür verantwortlich,
dass die aufrufende Funktion quasi ihr altes EBX wiederfindet.
Nicht, das ist eben der Unterschied zwischen Caller, Safe und Cally, Safe.
Gut, das ist dann eben gegebenenfalls noch zu berücksichtigen.
Hier in dem Fall passiert das jetzt nicht. So,
und was man dann hier in einem Code hat,
ist eben am Anfang erstmal dieser Initialisierungscode von der Schleife.
Am Ende genau. Also das,
was ich in den Beispielen dann immer mit Set-up bezeichnet habe,
am Ende dann eben das, was dann immer als Finish-gekennzeichnet wird,
nämlich genau die Schritte, die vorher hier gemacht wurden,
in umgekehrter Reihenfolge wieder zurückmachen und hier innen drin von hier bis hier tobt dann das Leben.
So, und das ist jetzt also hier entsprechend zu kommentieren,
so bevor ich das jetzt hier in meiner christlichen Schrift,
also irgendwie an die Tafel bringe,
Das ist also der einzige Teil,
den ich also außer hier halbwegs sauberen Abschrift für heute vorbereitet habe.
Werde ich das jetzt mal...
Hier einmal. Alles fertig, laden
Ja. So. Gut, also über die Art und Weise,
wie ausführlich oder nicht ausführlich man das macht,
kann man sich jetzt also auch immer noch irgendwie streiten.
Wie gesagt, ich habe das jetzt hier vergleichsweise ausführlich,
aber im Prinzip irgendwie sowas in der Art oder der Komplexität empfiehlt sich.
Das heißt also deswegen auch der Kommentar in der Übungsaufgabe,
nicht also hier soll man jetzt nicht sagen,
naja gut, also ich rechne dieses und rechne jenes,
sondern man sollte dann eben schon so ein bisschen sagen,
was sich da eigentlich passiert.
Gut,
also Setup-Code
Hier von oben im Prinzip als erstes immer Push Long oder Push EBP
. Das heißt, der alte Framepointer, das heißt,
das, was die aufrufende Funktion als EBP hat,
wird mit dem Push auf dem Stack gesichert.
Das passiert immer, wird auch in allen Beispielen,
hoffe ich doch zumindest,
auch in genau dieser Form immer als erste Anweisung auftauchen
Nicht dort ist dann also auch nochmal grafisch beschrieben, was sich dann dahinter verbirgt.
Da sieht man das dann eigentlich ganz gut. Und als zweite Anweisung,
auch die wird immer genauso auftauchen, move long, ESP,
EWP, da wird dann nämlich quasi der neue Basepointer dann auf den aktuellen Stackpointer gesetzt. Nicht,
das heißt also, der Wert des Stacks, ja,
ja, also sprich, EWP gleich ESP,
wenn ich also jetzt in so einer Schreibweise bin,
also das heißt, In dem, ich habe hier meinen Stack,
habe hier irgendwie das Call, nicht anschließend macht,
also hier die aufrufende Funktion dann eben Push Long, EBP,
das heißt also hier habe ich dann den quasi alten Frame Pointer gespeichert,
der also irgendwo bei der aufrufenden Funktion,
also meinetwegen hier oben mal hingezeigt hatte,
Wegen anschließend.
Wenn ich in Anschließend kommt eben diese Anweisung. Move long,
ESP, nach EDP. Und dann habe ich hier nämlich quasi stehen ESP,
der hier der alte Wert, also der,
der quasi hierhin zeigt, das ist ja dann diese Adresse.
Und der anschließend wird dann eben EBP gleich ESP gesetzt,
das heißt anschließend zeigt, EWP dann eben auch auf diese Adresse.
Und hier ist dann quasi das Unterprogramm,
was dann also anfängt, irgendwo hinzurechnen.
So, dann kommt Movelong.
Mit Offset 8 wird nach EDX kopiert. EBP wurde jetzt
gerade hierhin gesetzt. EBP plus 4 ist quasi dieser Teil des Decks.
Das ist die Return-Adresse, das heißt der Programmzähler,
wo die aufrufende Funktion quasi nach dem Return weiterläuft.
Das wurde automatisch Aufruf, also beim Call quasi gesetzt und
unter plus 8 wird hoffentlich die aufrufende Funktion.
Das Argument A hinterlegt haben auf dem Stack und mit EBP plus 8
wird auf A zugegriffen. Das Ergebnis wird nach EDX geschrieben,
also letztendlich EDX gleich A. Das heißt, das Argument wird
vom Stack gelesen. Wenn ich jetzt mehrere Argumente hätte,
würde ich dann eben EBP Plus 12, EBP plus 16,
die dann also sukzessive mir da alle irgendwie erst mal runterlutschen.
Gut, dann wird das Register ECEX, ECEX war eins von den Caller-Safe-Registern.
Das heißt, da muss hier nichts gemacht werden.
Das kann hier einfach intern in dieser Funktion benutzt werden,
weil da muss die aufrufende Funktion,
wenn sie das mit irgendwas beschrieben hat und weiterverwenden möchte,
muss die dann also dafür gesorgt haben, dass das gesichert wurde.
Da wird es einfach die Der Emidiate-Wert 32, reingeschrieben,
funktional ist das nichts anderes, also die 32,
als die Laufvariable für die Schleife, weil ihr als Argument habe ich einen 32-Bit-Wert.
Und ich würde jetzt also irgendwie, oder Bitwort,
und ich werde jetzt also irgendwie einzeln für die Bits anfangen abzuprüfen,
ob da was, ob sich da was tut.
Das Ding muss ich halt mit 32 initialisieren, 132 mal durchzulaufen.
So, Move long
Setzt dann eben ERX, also auf den Emidiertwert null.
ERX ist dann auch das Register, dem nachher dann das Ergebnis stehen wird.
Das wird mit null initialisiert, in dem Register fange ich
dann nämlich eigentlich auch schon nachher an zu zählen.
Letztendlich, wie viele einzeln ich drin stehen habe in ERX.
Gut, dann kommt da durchs eine Label,
das hatte ich hier jetzt mal nicht kommentiert,
kann man weglassen,
behaupte ich dann also auch mal für die Klausur
Kommt diese Compare-Anweisung, das ist eben im Prinzip als Test,
EDX minus 0, da würden aber eigentlich ins erste 0 Flex gesetzt.
So in EDX hatte ich mein Argument A reingelesen,
also in EDX steht Adrin.
Und jetzt habe ich anschließend Drumgreater Equal hierhin.
Ein Sprung, wenn EDX größert, leichen wollen.
Nicht, das ist das,
was letztendlich diese beiden Anweisungen machen
Wenn EDX größert gleich null, rechne ich hier weiter,
wenn EDX nicht größert gleich null, also sprich kleiner null,
springe ich nicht, dann wird diese Anweisung ausgeführt.
So, und das ist jetzt eigentlich der ganze Trick dabei,
was passiert dort? Ich habe hier irgendwie meine 32 Bezahl.
Wenn EDX größert gleich null ist, springe ich,
wenn EDX kleiner null ist, sprenge ich nicht.
So, EDX, das ist jetzt eine Zahl,
die interpretiere ich quasi als Zahl im Zweier-Kompliment.
So, wann ist eine Zahl im Zweier-Kompliment kleiner als null?
Genau dann, wenn das höchstwertigste Bit, most significant Bit, MSB.
Gleich eins ist. Dann habe ich eine negative Zahl.
Wenn das MSB gleich null ist, ist die Zahl größer gleich null.
Das heißt, letztendlich ist der Trick hier, dass ich mit dieser Abfrage,
ob Das größte Gleichnull ist eigentlich das höchstwertigste Bit-Up-Frage.
Und wenn das höchstwertigste Bit null ist, springe ich,
da tut sich nichts. Wenn das höchstwertigste Bit 1 ist,
weil ich will ja die einzelnen zählen,
wie der Algorithmus andeutet, wird EAX um einen inkrementiert.
Das heißt, da rechne ich eher x plus 1. Gut,
dann bin ich jetzt, dass ich hier bei diesem Label No Ad,
dann kommt jetzt als Anweisung AdLong, EDX, EDX.
Was dort also gerechnet wird, ist Eigentlich funktional gesehen.
EDEX, gleich EDX, plus EDX. Oder auch EDX,
mal zwei. Wenn ich eine Binärzahl habe, die mal zwei rechne,
das war dann wieder bei diesen Tricks da rein,
mit diesen Schiebeoperationen, mal zwei rechnen,
ist dann eigentlich nichts anderes,
was um einen nach rechts schieben,
hinten in Null reinschieben
Also wenn ich die Zahl habe, mal zwei rechne,
ist das Ergebnis, höchstwertigste Bit fällt raus und hier hinten kommt eine Null rein.
Das heißt, eigentlich habe ich hiermit nichts anderes gemacht,
wenn auch nur ein bisschen umständlich ausgedrückt,
als jetzt eben irgendwie so ein Schieben um ein Bit.
Ja. Gut, dann wird dieser Schleifenzähler,
das war dieses ECX, quasi die Laufvariable über die Wortlänge,
dekrementiert,
also ECX zur Fraktion
um eins
Dann wird geguckt, Testanweisung und wieder so ein entsprechendes Trump,
Jump, Nord Equal in diesem Fall. Also sprich,
wenn ECX gleich null ist, dann springe ich nicht,
wenn ECX und Live null ist, ja,
das habe ich hier natürlich wieder gerade falsch beschrieben,
also Sprung, wenn ECX.
Ungleich null. Und bei Gleich null wird nicht gesprungen.
Also. So, also das weiß ich immer, das Ungleich neu sein.
Gut, also sprich beim Ungleich null springe ich.
Ansonsten bin ich fertig. Dann habe ich nämlich 32 Bit
bearbeitet und bin 32 mal durch die Schleife durchgelaufen.
So, Sprung heißt es eben wieder,
ich fange jetzt hier wieder bei Loop an.
Vergleich wieder das höchstwertigste Bit
Und so weiter und so fort. Und mit diesem Trick,
mit dem EDX gleich zweimal EDX, also mit dem Links schieben,
habe ich ja letztendlich ein Bit weitergeschoben und kann dann eben das nächste Bit vergleichen.
Und das Ganze läuft dann eben entsprechend durch. Das ist also jetzt
die Art und Weise, wie diese Funktion letztendlich funktioniert.
Gut, und hier unten kommt jetzt eben noch der entsprechende Finish-Code.
Das heißt, gut, in dem Fall habe ich hier
jetzt Bräuchte ich den jetzt hier nicht,
weil da ist jetzt nichts weiter passiert.
In der Regel wird man aber sowas auch immer finden.
Nicht also angenommen, hier inzwischen würde noch irgendwo was mit
dem Stack gemacht. Dann bleibt EBP an dieser Stelle.
ESP wächst hier irgendwie weiter. Dann habe ich immer diese Anweisung,
move long, EBP nach ESP.
Das heißt, da wird ESP dann eben wieder hierhin zurückgesetzt.
Nicht anschließend mache ich ein Poplong von EBP,
das heißt ESP
Zeigt dann wieder hier drauf. Und in EBP
habe ich dann eben hier wieder den alten Framepointer,
den ich hier auf dem Stack abgelegt habe.
Das heißt also eh, VP zeigt anschließend wieder hierhin.
Und mit dem Return passiert dann eben nichts anderes als das ESP,
ESP zeigt nach diesem Pop,
also hier nach dieser Anweisung,
dann ja schon quasi hier auf die Rücksprungadresse
Nicht und nach dem Return oder beim Returnwörtern eben quasi das,
worauf ESP dann eben entsprechend zeigt, dann eben in den Programmzähler
geladen und dann bin ich wieder bei der aufrufenden Funktion.
Gut, Das jetzt zu dieser Aufgabe gibt es dazu noch irgendwelche Fragen,
weil das ist einmal eine der wenigen,
wo man noch so ein bisschen eine Prixerei und Assembler quotet und so,
vielleicht Schwierigkeiten hat.
Wir speichern ja den Wert von ESP im IBB,
also ich setze die ja jetzt unseren neuen Stackpointer.
Warum können wir Also wir verändern ja, dass Register ESP in unserem Programm nicht.
Können wir da nicht direkt den Werten ESP lassen? Ich meine,
er kriegt, wenn wir später noch Unterfunktionen aufrufen wollen.
Nee, sorry. Also das,
was hier ja erst mal passiert, ist,
dass EBP leicht im Stackpointer gesetzt wird, also nicht umgekehrt.
Ja, so meinte ich das auch.
Aber wir sichern ja quasi den Wert von ESP in EBP.
Ja. Aber wir könnten doch direkt auf ESP zugreifen,
weil wir diesen Wert nicht verändern
Ja, also könnte man auch und im, sagen wir
mal, im Sinne einer Ausknotsch-Minimierung ist das natürlich richtig.
Also was hier jetzt einfach immer mit drin ist,
ist eben irgendwo diese implizite Konvention, dass ich halt eben immer sage,
ich habe hier meine aufrufende Funktion und ich habe dann hier meine aufgerufene Funktion und egal was,
dass ich jetzt also auch mit dem Stackpointer passiert,
der Beginn,
der aufgehört berufenen Funktionen wird quasi mit EBP gekennzeichnet.
Denn ist natürlich völlig richtig. Eigentlich kann ich auch sagen,
naja gut. Also hier drauf kann ich eigentlich verzichten.
Und in dem Fall nicht, wenn ich mir das Argument hole,
kann ich das natürlich also auch einfach direkt relativ zu dem Stackpointer mir rausholen.
Mich aber das ist eben irgendwo so eine implizite Konvention,
dass also zwischen EBP und ESP dann immer quasi der Kontext
der gerade laufenden Funktionen irgendwie definiert ist.
Und das würde dann eben nicht gelten,
wenn ich das jetzt also nicht damit mache
In dem Fall, hier kriegt man damit sicherlich jetzt eben keine Probleme.
Da könnte man natürlich schon einiges rausnehmen oder raus optimieren,
wo man sowas dann aber letztendlich nachher braucht, ist,
oder vermute ich zumindest stark, dass man das also dann zwingend braucht,
ist, wenn ich also rekursive Funktionen habe und die Aufrufe mache.
Wobei gut, also auch da könnte ich jetzt natürlich,
aber da muss ich wieder wissen,
wie viele Argumente das sind,
war sich da dann natürlich dann also entsprechend diese Offsets zu ESP,
also jetzt führtest du den Argumenten dann noch ändern,
aber im Prinzip kann man das also vielleicht also auch
noch entsprechend
Anders machen. Aber gut,
da muss er jetzt eben sagen, gut,
das ist Standardkonvention, die Compiler, also egal,
also ob das jetzt, gut, ich kann jetzt,
dass ich jetzt hier nur für die Linux-Conpala reden, aber egal,
also ob das jetzt die Genug Compiler Chain oder der Klang ist,
die machen das eigentlich beide immer genau,
so nach diesem Schema
Gut, ja, das,
jetzt also hier zu dieser Aufgabe kommentieren Sie den Code,
dann war jetzt also unter B gefragt,
wie viele Zahlen mit Bitcount Adleich 1 und mit Midcount.
Adleich 2. Gibt es? Okay, da muss man jetzt
eben so ein bisschen... Eigentlich die Kombinatorik. Wir wissen
nun kennen und sagen, hui, also für...
Also für Bitcount 1 kann ich jetzt eben sagen,
gut, ich habe eine Zahl mit 32 Stellen
Bitcoin 1 habe ich genau dann,
wenn er eine einzige Eins drin ist und alles andere ist null,
also habe ich da.
Genau, 32 Möglichkeiten. So, für Bitcoin A,
gleich zwei
Das ist jetzt also das einzige,
wo ich jetzt hier also nochmal Schulmathematik gefragt ist,
muss ich dann eben letztendlich wissen,
ich habe dann im Prinzip 32 über zwei Möglichkeiten,
sprich, man kann sich das immer vorstellen,
für die erste Eins habe ich 32 Möglichkeiten,
für die zweite Eins habe ich 31 Möglichkeiten.
Nicht, das heißt, da könnte man jetzt natürlich rechnen, wunderbar.
32 mal 31. Ist jetzt aber nur die halbe Wahrheit,
weil ich da jetzt also immer Fälle doppelt mit drin habe,
weil die einzelnen jetzt erstmal nicht unterschieden werden.
Nicht demzufolge muss ich das dann noch durch in minus Kfakultät teilen.
In diesem Fall also da nochmal das Ganze durch zwei rechnen.
Und das sind dann Koffer, eine schwache Adamriese,
400 irgendwas
496. Möglichkeiten, die dabei dann rauskommen. Also es reicht
irgendwie 2, Vers 15 zu 2. Ja. Naja,
gut, also mal 31 mal 16,
kann man also im Zweifelsfall auch noch mit,
nicht mit Zwischenergebnis auf dem Papier rechnen,
also... Denk mal,
das lässt sich ja
noch machen
Gut, dann... Warum setze ich mal auf?
Zur letzten Aufgabe, Aufgabe 13. 460. Damals,
ich war der Fall. Also, vergleichen Sie eine...
Vergleichen Sie eine Stackmaschine und eine Drei-Adressmaschine mit Low-Store-Befehlssatz,
wobei für beide eben Dieser Ausdruck zu berechnen ist.
Gut, letzte Aufgabe, zehn Minuten Konzentration noch,
dann machen wir auch Schluss. Zumindest mit dem Teil. Also,
wenn ich jetzt hier entsprechend die Befehle Hier für die Steckmaschine
zur Verfügung habe, um den Ausdruck zu berechnen.
Kann man jetzt eben immer nur sagen, gut, alles,
was ich mir irgendwo aus dem Speicher hole, mache ich eben mit Push-Befehlen.
Ich muss den Ausdruck dann eben nur entsprechend so zerlegen,
dass du dann quasi wie so eine UPN-Notation,
also sprich Operanten auf den Stack schieben,
dann eben das atometische Ergebnis,
quasi abgearbeitet wird oder die atometische Operation dann quasi abgearbeitet wird.
Das heißt, um so einen Ausdruck zu beschreiben,
fängt man also bei diesen Stack-Maschinen in der Regel von hinten nach vorne an.
Das heißt, hier würde ich jetzt eben machen,
Forscht C, sie landet auf dem Stack.
Also wenn ich da hier nochmal so ein Stack irgendwie mit einzeichne,
hätte ich da jetzt C drin, dann als nächster Befehl.
Nochmal Push C. Dann habe ich die hier beide drauf
Gut. Dann sage ich, Moll,
die ist das erste Argument, verschiebt den Stack,
tut das in den Temporär wert.
Multipliziert das Ganze und legt das Ganze auf den Stack ab.
Das heißt, anschließend habe ich hier C-Quadrat.
Dann würde ich rechnen, ProSpe, gut,
in diesem verlasse ich jetzt einfach mal
den Stack
Wachsen. Ich hätte hier B. Push A.
Er hätte hier anschließend A, B und C Quadrat
auf dem Stack
Könnte dann jetzt eben rechnen.
Ed hätte dann anschließend A plus B als erstes Element.
Und dann C Quadrat. Könnte anrechnen. So,
etwa dann A plus B. Minus
C-Quadrat.
Auf dem Stack
Und würde dann eben machen. Hop weh um das Ergebnis dann wieder NW zurückzuschreiben.
So wie wir allen diesen Aufgaben ist das nicht zwingend eindeutig,
also gerade dann nachher bei den zwei Adress oder drei Adressbefehlen,
kann ich mir da unendlich viele Algorithmen ausdenken.
Deswegen hatte ich eben auch so ein bisschen gestürzt.
Ich habe jetzt nämlich was anderes aufgeschrieben als das,
was ich hier habe. Ich kann natürlich also auch sagen,
also ab dieser Stelle nach der Multiplikation und dem Push,
ich rechne dann also erst b-quadrat.
Das heißt, ich würde also eben nach dem Push B dann gleich das Sub machen.
Ich würde dann wieder ein Push A machen und dann das Ed.
Geht genauso, kommt genau das gleiche heraus.
Also da gibt es dann auch immer unterschiedliche Möglichkeiten.
Da ist also auch nicht zwingend eine die richtige,
sondern das, was rauskommen soll, ist das Ergebnis.
Das ist dann eben letztendlich das Problem derjenigen,
der die Aufgabe nachsieht, dass der das dann nachvollziehen muss.
Nicht also hier ist es noch einfach,
aber dann so bei diesen drei Adress befehlen kann oder drei
Adressmaschinen kann ich ja jetzt natürlich belieben wie viele Algorithmen,
wie er da also irgendwie zurechtschreiben, wie das Ganze letztendlich machen.
Dies hier mit dem Stack hatte ich hier jetzt also auch
nur zwecksveranschaulichung jetzt hier für die Erklärung mit aufgeschrieben.
Auch das wird in der Klausur nicht verlangt,
wenn dort noch Stack-Maschine befragt ist,
nicht sondern da will man wirklich nur so eine Abfeuerwehr von entsprechenden Befehlen drinstehen haben.
Gut, für den Ja. Im Zweiten Befehl saß jetzt also hier diese drei Adressmaschine,
nicht da kann ich jetzt eben wirklich relativ frei sagen,
farblosb-cquadrat, nicht arbeite ich das von links nach rechts ab oder von rechts nach links oder sowas,
nicht also bei dem Stack empfiehlte es sich immer irgendwie quasi so rum vorzugehen,
bei allem anderen, sage ich dann auch immer,
naja gut,
also man nimmt einfach gewohnt von links nach rechts zu lesen und dann eben noch entsprechend den arithmetischen Sachen da jetzt Also irgendwie seine Präferenzen zu legen,
eigentlich,
aber im Prinzip gar nicht, also jetzt.
Beliebige Sachen mir da jetzt zurechtnehmen, also beispielsweise,
wenn ich das jetzt von links nach rechts mache,
also irgendwie sowas wie Lord.
Janull. Lord.
Wie? Muss man mal sowas auf großen Kleinschreiben machen? Ja,
gut,
also... Um da jetzt also irgendwie alle... Gemüter zu beruhigen,
würde ich das dann schon so schreiben,
wie es da ist und nicht wie der Forder Andreas das jetzt hier schreibt.
Also dann ist es natürlich alles groß geschrieben.
Also das ist jetzt hier
Muss man jetzt abstrahieren, dass sie jetzt alles groß geschrieben.
Nein, aber ich denke mir,
also auch da würden wir bei der Korrektur sagen,
ja, das ist eigentlich eindeutig, der Algorithmus ist nachvollziehbar.
Und das ist das Entscheidende. Nicht deswegen, gut,
bevor ich weitermache. Gib mir eine Klausur, vielleicht eine feste Beginnung,
die jeweiligen Adressmus steht angegeben sind oder müssen wir die auswendig machen?
Nee, nee, nee, also das muss auf
alle Fälle mit angegeben werden. Ich war also,
war also gerade solche Sachen wie, Wo lande das Ergebnis,
wenn ich in Subtraktion mache, was wird wovon abgezogen?
Das ist ja nicht zwingend eindeutig. Nicht,
also da kann ich auch sagen, also Subtraktion mit drei Elementen,
nicht das Erste ist eigentlich immer das, wo es landet.
Also hier ist es das Letzte, das ist doch eigentlich unsinnig.
Also ich hätte den Buffet, das hat es jetzt auch
irgendwie andersrum geschrieben. Nein, das muss natürlich dran stehen.
Nicht, weil sonst ist es ja nicht nachvollziehbar.
Gut, also was wollen wir jetzt machen?
In diesem Fall jetzt null
Ja, eins. Und gut, jetzt ist auch mal die Frage nicht,
also spare ich jetzt Register oder bin ich da großzügig, nicht?
Also auch da gibt es keine weder Präferenz,
noch Sonderpunkte, wenn man das so oder so macht.
So kann ich es also großzügig sagen, R2,
eigentlich kann ich aber natürlich,
da ist eher sowohl A als auch B nicht mehr weiter
benutzt und natürlich auch irgendwie eins von denen da als weiteres Argument nehmen.
Das ist eigentlich völlig schnorzi. Anschließend würde ich dann eben sagen,
Load. Ähm... Ja, null. C. Moll.
Ja, null. Ja, null. Ja, null
, nicht? Dann habe ich jetzt hier Quadrat berechnet.
Ja, und dann konnte ich dann eben noch sagen
... So.
Ja, zwei
Ja, null. Für uns sind wir wieder R1. Wo ich dann also
jetzt im Prinzip A plus B minus C Quadrat rechne.
Und dann müsste ich dann eben noch ein Star.
R1. Aber man darf C doch nicht in der Müll laden.
In der Aufgabe steht die Wertung in der Fresse,
A, B und C sollen vom Programm nicht modifiziert werden.
Ja, die dann lässt, dass sie wieder freischlagen lassen
Ja. Also bei den Registern ist ja egal.
Also ich soll jetzt, also hier nicht zwischenzeitlich in den Speicher schreiben.
Das werde ich bei einer Drei-Abress-Maschine nicht machen,
aber bei einer Ein-Adress-Maschine würde ich also dann zum Beispiel,
also auch irgendwie munter noch mit dem Speicher rechnen.
Das kann man munter mit dem Register rumbauen. Ja,
ja, also in den Registern kann ich beliebig was überschreiben.
Aber wie gesagt, das ist letztendlich, also wie gesagt,
für diesen Algorithmus kann ich jetzt nicht sagen,
das ist der richtige oder der Beste.
Da geht es nur darum, dass man sagt,
okay, hinterher kommt das richtige Ergebnis raus
Und was immer gerne vergessen wird,
auch nur als Typ nicht, wenn gefragt ist.
Also das Ganze soll dann unter W auch wieder im Speicher abgelegt werden.
Ebenso ein finales Pop bzw. dieses finale Storms. Nicht,
aber das ist eigentlich alles, was dann also bei
so einer Art von Aufgabe irgendwo dann zu beachten ist.
Gut. Damit... Passt dort halt,
aber dann gehört das jetzt auf die Sterne.
Achso, ja gut, das äh kann sein,
dass ich das jetzt hier gerade
Genau wie der Fallschirm gemacht habe und dass
die Semantik da natürlich dann also auch eine andere ist.
Völlig richtig. So. Gut, dann sind wir jetzt hier
mit der besprechende Probeklausur mit nur anderthalb Stunden Verspätung fertig.
Jetzt, ja, jetzt habe ich ja noch quasi geblockt,
drüben unten
F1032, also da den größeren Raum, wo wir dann also,
oder wo ich jetzt im Prinzip jetzt heute noch von 3 bis 5 und morgen auch noch den gesamten Nachmittag,
also sprich von 13 bis 17 Uhr, dann also noch in Anführungszeichen Fragetutorium mache. Das heißt,
wenn jetzt also zu irgendwelchen von den Übungsaufgaben zu irgendwelchen Sachen,
zu irgendwelchen Themenstellungen noch Fragen sind,
also ich habe dort jetzt nicht explizit,
also nochmal irgendeine weitere Probeklausur oder irgendwas vorbereitet, sondern wirklich,
wenn sie jetzt noch Fragen haben oder wenn irgendwas noch beim Lernen unklar geblieben ist,
dass man das dann nochmal in Ruhe durchspricht,
beziehungsweise ich das versuche, dann nochmal irgendwie so anders zu erklären,
dass dann da eigentlich klar wird, wie das dann funktioniert.
Gut, damit dann, ja,
jetzt erstmal Schluss für heute und sonst gegebenenfalls gerne drüben
noch weiter