Nächstgrößere Primzahl ausgeben [gelöst]



  • @Francesco sagte in Nächstgrößere Primzahl ausgeben [gelöst]:

    Da ich im Nachhinein den Code in Maschinensprache (Von Neumann-Rechner) übersetzen möchte

    Darf ich als Laie fragen was das heißt? Wo findet man wirklich in der Lehre verwendete Sprachdefinitionen für sowas?



  • @Swordfish sagte in Nächstgrößere Primzahl ausgeben [gelöst]:

    Darf ich als Laie fragen was das heißt? Wo findet man wirklich in der Lehre verwendete Sprachdefinitionen für sowas?

    Ist das jetzt eine rhetorische Frage? Denn das ist absolutes Basiswissen und mittlerweile ist die Harvard-Architektur verbreiteter.



  • @john-0 Ist eine ganz normale Frage:

    Gibt es in der Lehre verbreitete, gängige nicht unbeding real existierende Beispiele für Harvard- und Von-Neumann-Architektur und dazugehörige Befehlsreferenzen?



  • @Swordfish sagte in Nächstgrößere Primzahl ausgeben [gelöst]:

    Gibt es in der Lehre verbreitete, gängige nicht unbedingt real existierende Beispiele für Harvard- und Von-Neumann-Architektur und dazugehörige Befehlsreferenzen?

    Es geht nicht um Befehlssätze sondern um das grundlegende Design wie die Daten im System verarbeitet werden: Processing Unit, Control Unit, Memory, Mass Storage, IO. Eine Von-Neumann-Architektur erlaubt selbstmodifizierenden Code, weil Programmcode und Daten im selben Speicher abgelegt werden. Eine Harvard-Architektur erlaubt genau das nicht. Es gibt Artikel auf Wikipedia auf denen das genauer erklärt wird.



  • @john-0 Wenn du nochmal liest wirst du erkennen daß ich nicht wissen wollte was architektur x ausmacht.



  • @Swordfish
    Du spielst auf so Dinge wie MIX und MMIX an?



  • @john-0 Ja, nach sowas habe ich gefragt. Aber auch, was aktuell wirklich an Universitäten und Fachhochschulen "bei uns" verwendet wird.



  • @Swordfish Also ich studiere als Nebenfach Informatik und dort ist der Von-Neumann-Rechner, also das grundlegende Prinzip vieler Rechner, im Teile der Theorie der Informatik eines unserer ersten Themen. Unsere Uni hat uns dazu einen Emulator erstellt und es wird vorrausgesetzt, dass wir die Basics und die Art und Weise der Befehle anwenden können. Ich hoffe das meintest du mit deiner Frage. 🙂



  • @Francesco sagte in Nächstgrößere Primzahl ausgeben [gelöst]:

    Ich hoffe das meintest du mit deiner Frage.

    Ja, das meine ich.

    @Francesco sagte in Nächstgrößere Primzahl ausgeben [gelöst]:

    Unsere Uni hat uns dazu einen Emulator erstellt und es wird vorrausgesetzt

    Irgendwie öffentlich zugänglich? Doku?



  • Ja, hier ist der Link zum Emulator. Die Befehlsliste kann ich dir leider nicht weiterleiten.
    https://github.com/Funzinator/von-neumann-emulator/releases
    Liebe Grüße



  • Yay, danke!

    @Francesco sagte in Nächstgrößere Primzahl ausgeben [gelöst]:

    Die Befehlsliste kann ich dir leider nicht weiterleiten.

    Naja, die kann man sich aus der Dokumentation zusammenkratzen.



  • @Swordfish sagte in Nächstgrößere Primzahl ausgeben [gelöst]:

    Fachhochschulen

    Nichts. Von der Harvard-Architektur hatte ich bisher nichts gehört, oder konnte mich zumindest nicht dran erinnern. Von Neumann wurde in allen möglichen Vorlesungen mal erwähnt, kannte ich aber auch schon als Schüler. Deswegen war ich grad auch etwas überrascht zu hören, dass die Harvard-Architektur sogar weiter verbreitet ist.

    Wir hatten sowas wie eine "Rechnerarchitektur" Vorlesung, da ging es aber vor allem um solche Sachen wie Branch Prediction, out of order execution usw., aber da wurde sowas wie Von Neumann Architektur höchstens am Rande erwähnt.



  • @Francesco

     0: ini         { input -> AC }
     1: sta 0       { AC -> cell 0 }
     2: ena 2       { AC = 2 }
     3: sta 1       { AC -> cell 1 }
    { begin loop }
     4: ena 1       { AC = 1 }
     5: ada 0       { AC += cell 0 }
     6: sta 0       { AC -> cell 0 }
    { if cell 0 == 2 --> done }
     7: ena -2      { AC = -2 }
     8: ada 0       { AC += cell 0 }
     9: azj,eq 27   { if AC == 0 (cell 0 == 2) then jump 27 }
    { if cell 0 < 2 --> restart loop }
    10: azj,ls 4    { if AC < 0 (cell 0 < 2) then jump 4 }
    { if cell 0 % 2 --> restart loop }
    11: lda 0       { cell 0 -> AC }
    12: mda 1       { AC %= 2 }
    13: azj,eq 4    { if AC == 0 (cell 0 % 2 == 0) then jump 4 }
    { initialize counter }
    14: ena 3       { AC = 3 }
    15: sta 2       { AC -> cell 2 }
    { begin division loop }
    16: lda 2       { cell 2 -> AC }
    17: mua 2       { AC *= cell 2 }
    18: sba 0       { AC -= cell 0 }
    19: azj,gr 27   { if AC > cell 0 (cell 2 * cell 2 > cell 0) then jump 27 }
    { if cell 0 % cell 2 == 0 restart loop }
    20: lda 0       { cell 0 -> AC }
    21: mda 2       { AC %= cell 2 }
    22: azj,eq 4    { if AC == 0 (cell 0 % cell 2 == 0) then jump 4 }
    { increment counter (cell 2) }
    23: ena 1       { AC = 1 }
    24: ada 2       { AC += cell 2 }
    25: sta 2       { AC -> cell 2 }
    26: ujp 16      { restart division loop }
    { output cell 0 and stop }
    27: lda 0       { cell 0 -> AC }
    28: oui         { AC -> output }
    29: stp
    


  • @Mechanics sagte in Nächstgrößere Primzahl ausgeben [gelöst]:

    Deswegen war ich grad auch etwas überrascht zu hören, dass die Harvard-Architektur sogar weiter verbreitet ist.

    https://en.wikipedia.org/wiki/Modified_Harvard_architecture



  • @Mechanics sagte in Nächstgrößere Primzahl ausgeben [gelöst]:

    Deswegen war ich grad auch etwas überrascht zu hören, dass die Harvard-Architektur sogar weiter verbreitet ist.

    Genau genommen ist die modifizierte Harvard-Architektur weitverbreitet. Es gibt bei normalen CPUs faktisch keinen Prozessor mehr, der keinen getrennten L1 Cache für Daten und Instruktionen hat. Selbst modifizierenden Code (das war einmal der Stein der Weisen beim Programmieren) kann man wegen der Caches auch nicht mehr sinnvoll nutzen, weil das die spekulative Ausführung ad absurdum führt. Dazu verfügen die neusten CPUs zwar über einen gemeinsamen Speicher für Daten und Instruktionen, machen aber den Programmcode durch spezielle CPU-Erweiterungen nicht mehr veränderbar, so dass Exploits unwahrscheinlicher werden.



  • @Swordfish sagte in Nächstgrößere Primzahl ausgeben [gelöst]:

    Naja, die kann man sich aus der Dokumentation zusammenkratzen.

    AC ... Akkumulator
    BZ ... Befehlszähler
    SR ... Rücksprungadresse
    
    NullaryOperation
    
      HLT: halt.
        Beendet die Rechnung irregulär und git eine Fehlermeldung aus.
    
      NOP: keine Operation.
        Es wird wie bei allen Rechenbefehlen der Inhalt des BZ um 1 erhöht.
        Ansonsten geschieht nichts.
    
      PRIM: Primzahltest.
        Lade den AC mit 1, wenn der Inhalt des AC, interpretiert als Festpunktzahl,
        einer Primzahl entspricht. Sonst lade den AC mit 0.
    
      SRR: Subroutine Return.
    
      STP: Stop.
        Beendet die Rechnung regulär.
    
      ConvertOperation
      
        ENTIER: Ganzzahlfunktion.
          Der Inhalt des AC wird als Gleitpunktzahl interpretiert. Dann wird die
          größte ganze Zahl, die kleiner oder gleich der Zahl ist, bestimmt und
          in Festpunktdarstellung im AC gespeichert.
    
        IRE: Festpunktzahl in Gleitpunktzahl umwandeln.
          Der Inhalt des AC wird als Festpunktzahl interpretiert und dann in
          Gleitpunktdarstellung gebracht.
    
        RIN: Gleitpunktzahl in Festpunktzahl umwandeln.
          Der Inhalt des AC wird als Gleitpunktzahl interpretiert und dann in
          Festpunktdarstellung gebracht. Falls der Inhalt des AC interpretiert als
          Gleitpunktzahl keine darstellbare ganze Zahl ergibt, so stoppt die
          Rechnung mit einer Fehlermeldung.
    
      InputOperation
      
        INB: Bitfolge einlesen.
          Lies vom Eingabemedium eine Bitfolge ein, bestimme eine und speichere
          diese im AC ab. Der Inhalt des Eingabemediums wird dabei um das einge-
          lesene Datum gekürzt. Falls das Eingabemedium leer oder das erste Datum
          keine Bitfolge war, bricht die Rechnung mit einer Fehlermeldung ab.
        
        INI: Festpunktzahl einlesen.
          Lies vom Eingabemedium eine Festpunktzahl mit Vorzeichen ein, bestimme
          eine nächstgelegene darstellbare Zahl und speichere diese in Festpunkt-
          darstellung im AC ab. Der Inhalt des Eingabemediums wird dabei um das ein-
          gelesene Datum gekürzt. Falls das Eingabemedium leer oder das erste Datum
          keine Festpunktzahl war, bricht die Rechnung mit einer Fehlermeldung ab.      
        
        INR: Gleitpunktzahl einlesen.
          Lies vom Eingabemedium einen Dezimalbruch mit Vorzeichen ein, bestimme
          eine nächstgelegene darstellbare Zahl und speichere diese in Gleitpunkt-
          darstellung im AC ab. Der Inhalt des Eingabemediums wird dabei um das ein-
          gelesene Datum gekürzt. Falls das Eingabemedium leer oder das erste Datum
          kein Dezimalbruch war, bricht die Rechnung mit einer Fehlermeldung ab.
    
      NegateOperation
    
        FNG: AC := -AC.
          Multipliziere den Inhalt des AC (float) mit -1.
    
        NGA: AC := -AC.
          Multipliziere den Inhalt des AC (int) mit -1.
        
        NOT: AC := NOT AC.
          Negiere den Inhalt des AC bitweise.
    
      OutputOperation
    
        OUB: Bitfolge ausgeben.
          Verlängert den Inhalt des Ausgabemediums um den Inhalt im AC. Dabei wird
          der Inhalt des AC als Bitfolge interpretiert und als Bitfolge ausgegeben.
    
        OUI: Festpunktzahl ausgeben.
          Verlängert den Inhalt des Ausgabemediums um den Inhalt im AC. Dabei wird
          der Inhalt des AC als Festpunktzahl interpretiert und als Festpunktzahl
          mit eventuellem Vorzeichen ausgegeben.
    
        OUR: Gleitpunktzahl ausgeben.
          Verlängert den Inhalt des Ausgabemediums um den Inhalt im AC. Dabei wird
          der Inhalt des AC als Gleitpunktzahl interpretiert und als Dezimalbruch
          mit eventuellem Vorzeichen ausgegeben.
    
    UnaryOperation
    
      ENA b: AC := b.
        Lade AC mit Festpunktzahl b.
    
      ENAR b: AC := b.
        Lade AC mit Gleitpunktzahl b.
    
      IndexregisterOperation
    
        ADI b: Inhalt(IRb) := Inhalt(IRb) + AC.
          Lade Indexregister b mit der Summe des Inhalts von Indexregister b und
          des AC.
    
        ENAI b: AC := Inhalt(IRb).
          Lade AC mit dem Inhalt von Indexregisters b.
        
        ENI a,b: Inhalt(IRa) := b.
          Lade das Indexregister mit der Adresse a AC mit Festpunktzahl b.
        
        ENIA b: Inhalt(IRb) := AC.
          Lade Indexregister b mit dem Inhalt des AC.
    
        SBI b: Inhalt(IRb) := Inhalt(IRb) - AC.
          Lade Indexregister b mit der Differenz des Inhalts von Indexregister b und
          des AC.
    
      IndirectOperation
    
        ControlOperation
        
          UJP b: goto b.
            Trage die Programmadresse b in den BZ ein.
    
          SRJ b: Springe zu Unterprogramm in Zeile b.
            Trage die Programmadresse b in den BZ ein. Trage die um 1 erhöhte
            Adresse, an der der Befehl SRJ steht, in SR ein.
    
          STA b: Inhalt(b) := AC.
            Speichere den Inhalt des AC in derjenigen Zelle, die durch Adresse b
            gekennzeichnet ist.
    
          CompareOperation
          
            AZJ,EQ b: if AC = 0 then goto b.
              Trage die Programmadresse b in den BZ ein, falls der Inhalt des AC,
              interpretiert als Festpunktzahl, gleich 0 ist. Sonst erhöhe den Inhalt
              des BZ um 1.
            
            AZJ,GE b: if AC >= 0 then goto b.
              Trage die Programmadresse b in den BZ ein, falls der Inhalt des AC,
              interpretiert als Festpunktzahl, größer oder gleich 0 ist. Sonst er-
              höhe den Inhalt des BZ um 1.
    
            AZJ,GR b: if AC > 0 then goto b.
              Trage die Programmadresse b in den BZ ein, falls der Inhalt des AC,
              interpretiert als Festpunktzahl, größer als 0 ist. Sonst erhöhe den
              Inhalt des BZ um 1.
            
            AZJ,LE b: if AC <= 0 then goto b.
              Trage die Programmadresse b in den BZ ein, falls der Inhalt des AC,
              interpretiert als Festpunktzahl, kleiner oder gleich 0 ist. Sonst er-
              höhe den Inhalt des BZ um 1.
            
            AZJ,LS b: if AC < 0 then goto b.
              Trage die Programmadresse b in den BZ ein, falls der Inhalt des AC,
              interpretiert als Festpunktzahl, kleiner als 0 ist. Sonst erhöhe den
              Inhalt des BZ um 1.
            
            AZJ,NE b: if AC != 0 then goto b.
              Trage die Programmadresse b in den BZ ein, falls der Inhalt des AC,
              interpretiert als Festpunktzahl, ungleich 0 ist. Sonst erhöhe den
              Inhalt des BZ um 1.
    
        FloatOperation
        
          FAD b: AC := AC + Inhalt(b).
            Addiere den Inhalt der Zelle mit der Adresse b zum Inhalt des AC und
            behalte dabei das Ergebnis im AC. Dabei sind die Inhalte als Gleitpunkt-
            zahlen zu interpretieren.
          
          FDV b: AC := AC / Inhalt(b).
            Dividiere des AC durch den Inhalt der Zelle mit der Adresse b und be-
            halte dabei das Ergebnis im AC. Dabei sind die Inhalte als Gleitpunkt-
            zahlen zu interpretieren.
          
          FMU b: AC := AC * Inhalt(b).
            Multipliziere den Inhalt der Zelle mit der Adresse b mit dem Inhalt
            des AC und behalte dabei das Ergebnis im AC. Dabei sind die Inhalte
            als Gleitpunktzahlen zu interpretieren.
          
          FSB b: AC := AC - Inhalt(b).
            Subtrahiere den Inhalt der Zelle mit der Adresse b vom Inhalt des AC
            und behalte dabei das Ergebnis im AC. Dabei sind die Inhalte als Gleit-
            punktzahlen zu interpretieren.
    
        IntegerOperation
        
          ADA b: AC := AC + Inhalt(b).
            Addiere den Inhalt der Zelle mit der Adresse b zum Inhalt des AC und
            behalte dabei das Ergebnis im AC. Dabei sind die Inhalte als Festpunkt-
            zahlen zu interpretieren.
    
          DVA b: AC := AC DIV Inhalt(b).
            Dividiere den Inhalt des AC durch den Inhalt der Zelle mit der Adresse b
            und behalte dabei das Ergebnis im AC. Dabei wird zuerst der Quotient der
            Inhalte berechnet, und dann werden die Nachkommastellen abgeschnitten.
            Diese Zahl wird als Ergebnis im AC gespeichert.
    
          MDA b: AC := AC MOD Inhalt(b).
            Berechne den Rest der beim Befehl DVA b ausgeführten Division, so dass
            gilt: Divident = ganzzahliger Quotient * Divisor + Rest. Speichere den
            Rest in Festpunktdarstellung im AC.
    
          MUA b: AC := AC * Inhalt(b).
            Multipliziere den Inhalt der Zelle mit der Adresse b mit dem Inhalt des
            AC und behalte dabei das Ergebnis im AC. Dabei sind die Inhalte als
            Festpunktzahlen zu interpretieren.
    
          SBA b: AC := AC - Inhalt(b).
            Subtrahiere den Inhalt der Zelle mit der Adresse b vom Inhalt des AC und
            behalte dabei das Ergebnis im AC. Dabei sind die Inhalte als Festpunkt-
            zahlen zu interpretieren.
    
          LDA b: AC := Inhalt(b).
            Lade AC mit dem Inhalt derjenigen Zelle, die durch die Adresse b ge-
            kennzeichnet ist.
    
        LogicOperation
    
          AND b: AC := AC AND Inhalt(b).
            Führe mit dem Inhalt der Zelle mit der Adresse b und dem Inhalt des AC
            die bitweise Und-Operation AND aus und behalte das Resultat im AC.
    
          OR b: AC := AC OR Inhalt(b).
            Führe mit dem Inhalt der Zelle mit der Adresse b und dem Inhalt des AC
            die bitweise Oder-Operation OR aus und behalte das Resultat im AC.
    
          XOR b: AC := AC XOR Inhalt(b).
            Führe mit dem Inhalt der Zelle mit der Adresse b und dem Inhalt des AC
            die bitweise ausschließendes-Oder-Operation XOR aus und behalte das
            Resultat im AC.
    

    Wozu das Ding überhaupt Indexregister hat erschließt sich mir nicht ganz, weil sowieso keine relative Addressierung direkt möglich ist.



  • @Swordfish Bei mir ist es zwar nicht so platzsparend und elegant, aber es tut was es soll 🙂

    0: STA 0 {Zwischenspeicher anlegen}
    1: ENA 1 {AC mit 1 laden}
    2: STA 1 {In Speicherzelle 1 speichern}
    3: ENA 2 {AC mit 2 laden}
    4: STA 2 {In Speicherzelle 2 speichern}
    5: INI {Eingabe einlesen}
    6: STA 3 {In Speicherzelle 3 speichern}
    7: ENI 1,2 {Indexregister 1 mit Wert 2 anlegen}
    8: LDA 3 {Eingabe in AC}
    9: AZJ,LE 42 {Falls die Eingabe <=0 gehe in Zeile 33}
    10: SBA 1 {AC-1}
    11: AZJ,EQ 42 {Falls 0 gehe in Zeile}
    12: LDA 3 {Eingabe in AC}
    13: SBA 2 {AC-2}
    14: AZJ,EQ 39 {Falls AC=0 gehe in Zeile 36}
    15: LDA 3 {Eingabe in AC}
    16: ADA 1 {AC+1}
    17: STA 3 {In Speicherzelle 3 Speichern}
    18: LDA 3 {Eingabe in AC}
    19: MDA 2 {AC%2}
    20: AZJ,EQ 15 {Falls AC=0 gehe in Zeile 12}
    21: ENAI 1 {AC mit Indexregister 1 laden}
    22: ADA 1 {AC+1}
    23: ENIA 1 {Wert des AC im Indexregister 1 speichern}
    24: STA 0 {In Speicherzelle 0 speichern}
    25: LDA 3 {Eingabe in AC}
    26: MDA 0 {AC%Zwischenspeicher}
    27: AZJ,NE 32 {Falls ungleich null gehe in Zeile 29}
    28: ENAI 1 {Indexregister 1 in AC}
    29: SBA 3 {AC-Eingabe}
    30: AZJ,EQ 36 {Falls AC=0 gehe in Zeile 33}
    31: UJP 8 {Gehe in Zeile 8}
    32: ENAI 1 {Indexregister 1 in AC}
    33: SBA 3 {AC-Eingabe}
    34: AZJ,EQ 36 {Falls AC=0 gehe in Zeile 33}
    35: UJP 20 {Gehe in Zeile 18}
    36: LDA 3 {Eingabe in AC}
    37: OUI {Ausgabe}
    38: STP {Stopp}
    39: ENA 3 {AC mit 3 Laden}
    40: OUI {Ausgabe}
    41: STP {Stopp}
    42: ENA 2 {AC mit 2 Laden}
    43: OUI {Ausgabe}
    44: STP {Stopp}



  • @Swordfish Hast du das selbst verfasst oder gibt es dafür online eine Seite mit verschiedenen Anwendungen?



  • @Francesco nene, schon selbst geschrieben. Das ist so ein Nieschenprodukt ... ich find' den "Emulator" auch nicht besonders gelungen. Warum fragst Du? Ich bin einfach nur stur meinen C++-Code durchgegangen.

    @Francesco sagte in Nächstgrößere Primzahl ausgeben [gelöst]:

    Hast du das selbst verfasst

    oder meinst Du nicht meinen Code sondern die Befehlsreferenz die ich gepostet habe?



  • @Swordfish Nein ich meine den Code, ich frage nur, weil man im Netzt kaum Programme dazu findet.


Anmelden zum Antworten