Algorithmen Teil IV (Software-Spielereien)

  • Abt. Der .-zigste 6 aus __ Tippgenerator
    =========================

    HP255G7:Win10pro2.004,4*AMD Ryzen3200U@2.60GHz,6+2GB-RadeonVega/237GBSSD:intlDVDRW,3xUSB3 ext4TB-HDX,XProfanX3+Xasm/Xpse

    • Anzeige

    Hallo!

    Wenn du gerade an deiner Website arbeitest oder dein aktuelles Hosting überdenkst: Wir betreiben mit NetzLiving eine Hosting-Plattform, die speziell auf Performance, Sicherheit und einfache Verwaltung ausgelegt ist.

    • ✔️ Schnelle Ladezeiten (optimiert für WordPress, WoltLab & Co.)
    • ✔️ Deutsche Server & DSGVO-konform
    • ✔️ Persönlicher Support (kein 0815-Ticket-System)

    Mehr erfahren

  • Abt. Lehrreich...
    ------------------
    Nachdem openBVE, eine doofe Zugsimulation, auf Win7-64 nicht klappen wollte, folgte ich einer Empfehlung auf der Installationsseite und lud mir .NET 4.0. Dieses Ding wollte sich dann sofort 4 große Updates holen, was ich dummerweise zugelassen habe. Sehr schlecht!: Mitten im Bootvorgang blieb mein Computer danach mehrfach stecken. Blanke Nerven, jeweils 5-Sekunden-Ausknopf und Wiedereinschalten führten dann irgendwann zur Frage "Starthilfe?" - sowas wie eine Art "Protected Mode" früherer Systeme. Geklickt, versucht sich das System dann zu reparieren, was eine gefühlte Ewigkeit dauert und dazu führt, daß eine funktionsfähige Uralt-Version nun wieder läuft. Selbstverständlich sind alle Programicons des letzten Monats, viele Favorites sowie zahlreiche Updates verschwunden, und Avira liefert einen Ausnahmefehler. Auch den deutschen Keyboardtreiber musste ich in der Systemsteuerung soeben nachinstallieren und wieder auf Deutsch schalten.
    Puh... ich hoffe, damit ist das gröbste überstanden. In diesem Falle saß der Error aber tatsächlich 40 cm vor dem Schirm...

    Lehre: Stets Haltepunkte anlegen. Regelmäßige Backups machen. Neues und Updates immer nur Schritt für Schritt, unter Prüfung, ob alles noch funktioniert...

    HP255G7:Win10pro2.004,4*AMD Ryzen3200U@2.60GHz,6+2GB-RadeonVega/237GBSSD:intlDVDRW,3xUSB3 ext4TB-HDX,XProfanX3+Xasm/Xpse

  • Abt. Adressierungsarten von Intel- und AMD Prozessoren
    ===================================
    Hier meine Übersetzung aus dem Intel-Handbuch betreffend die verschiedene Arten, wie CPUs Speicheradressen ansprechen können. Diese zeigen sich dann auch durch verschiedene Syntax bei der Assemblerprogrammierung.

    Relativer Versatz (Offset)
    -----------------------------
    Der Offset-Teil einer Speicheraddresse kann direkt angegeben werden als
    konstanter Versatzwert (relativ zum aktuellen Instruction Counter-Wert), oder aber durch eine Adressberechnung durch die CPU selbst, bei der folgenden Elemente verwendet werden können (aber nicht müssen):

    * Basis — Ein Wert in einem angegebenen General Purpose Register x) der CPU.
    * Index — Ein weiterer Wert in einem General Purpose Register
    * Skalenfaktor — Ein Wert 2 oder 4 oder 8. Dieser wird mit dem Index multipliziert.
    * Versatz — ein 8-, 16-, or 32-bit Wert.

    x) General Purpose = Allzweckregister. Sind seit der Urform des Prozessors vorhanden.


    Die i32 bzw. i64-Adressierung stellt sich somit folgendermaßen dar:

    [ Basiswert in EAX / EBX / ECX / EDX / ESI / EDI / (EBP) / (ESP) ]
    + [ Indexwert (in EAX / EBX / ECX / EDX / ESI / EDI / (EBP) )
    mal [ Skalenfaktor ( 1 / 2 / 4 / 8 ) ]
    ]
    + Versatz [0 oder ein direkt angegebener 8bit-/16bit-/32bit-Wert ]

    Der Wert, der dann aus dieser Berechnung erfolgt, ist die sog. effektive Adresse.

    Alle obengenannten Elemente, ausgenommen der Skalenfaktor, können entweder
    positive oder aber negative Werte (im 2er-Komplement) enthalten.

    Anmerkung: Die Verwendung von General Purpose Registern als Basis- oder Index-Register
    unterliegen folgenden Beschränkungen:

    - Das ESP register kann nicht als Indexregister genutzt werden.
    - Bei Nutzung des ESP- oderr EBP-Registers als Adressbasis wird der Wert im
    SS-Segmentregister als Segment-Basisadresse addiert. In allen anderen Fällen wird
    im 32bit-Modus das DS Segmentregister als Segmentadresse verwendent.


    Basis, Index und Versatz können ansonsten in jeder Kombination verwendet werden,
    und jedes dieser Elemente kann auch weggelassen werden. Die Verwendung eines
    Skalenfaktors ist natürlich nur sinnvoll, wenn auch ein Index verwendet wird.


    Häufige Adressierungsarten:
    --------------------------------
    - Versatzwert alleine
    Ein Versatz allein stellt einen direkten, unberechneten Zugriff auf eine Speicherstelle
    relativ zur nächsten aktuellen Befehlsadresse dar. Da der Versatz direkt in den Befehl
    integriert ist, wird diese Adressierungsform oft auch "Statische Adressierung" genannt.
    Auf in der Regel unveränderliche Einzelwerte kann so rasch zugegriffen werden.

    - Basisregister alleine
    Eine Basisangabe alleine erzeugt einen indirekten Zugriff auf den Speicherbereich des
    Operanden. Da der Wert im Basisregister sich ändern kann, wird diese Adressierungsart oft für den Zugriff auf dynamisch wechselnde Variablen und Datenstrukturen verwendet.

    - Basisregister plus Versatz
    Ein Basisregister und ein Versatz können für zwei unterschiedliche Zwecke verwendet werden:

    - 1) Als Index in an Byte-Array, wo die Elementgröße also nicht 2, 4, or 8 bytes beträgt.
    Der Versatz zeigt damit statisch auf den Beginn des Arrays, das Basisregister als General-Purpose Register enthält den berechneten Versatz zu einem bestimmten Element im Array (also umgekehrt als die Bezeichnungen es zuerst vermuten lassen!).

    - 2a) Um auf ein Datenfeld in einem Record zuzugreifen:
    Das Basisregister enhält hier die Addresse des Record-Anfangs, während der Versatz die statische Distanz in das einzelne Feld beinhaltet.

    - 2b) Ein wichtiger Spezialfall dieser Kombination ist der Zugriff auf Parameter in einem Record zum Starten einer Procedur. So ein Prozedurstart-Record stellt am Task Stack den Eintrittsrecord dar. In diesem Sonderfall wählt man am besten das EBP-Register als Basis, weil dann automatisch auch das SS-Register verwendet wird, das auf das Task-Stack Segment zeigt. Dadurch kann diese Aufgabe in kompakter Form programmiert werden.


    - Indexregister * Skalenfaktor + Versatzwert
    Mit dieser Adressierungsart bietet sich ein effizienter Weg, in ein Statisches Array (Liste) mit
    Elementen der Größe 2, 4 oder 8 Byte zu verweisen:
    * Der Versatz (er steht in einer Speicheradresse im RAM) zeigt auf den Anfang des Arrays.
    * Der Index (im GPU-Register) enhält die Nummer (beginnend bei 0) des gesuchten Elements,
    * und der Processor multipliziert den Wert gemäß Skalierungsfaktor 2, 4 oder 8.


    - Basisregister + Indexregister + Versatzwert
    Zwei GPU-Register zu verwenden unterstützt folgende Zugriffsarten:
    * Zweidimensionale Arrays (Versatz = Beginn des Arrays) oder
    * eine von mehreren Instanzen eines Arrays von Arrays (Der Versatz verweist auf das entsprechende Array innerhalb des ersten Arrays)

    - Basisregister + (Indexregister * Skalierungsfaktor) + Versatzwert
    Durch Verwendung aller Adresselemente gemeinsam kann effizient auf zweidimensionale Arrays mit Elementen in der Größe von 2, 4 oder 8 bit zugegriffen werden.


    Besonderheiten der Adressierung im 64-bit Modus
    ---------------------------------------------------------
    Die effektive Adresse wird hier wie folgt ermittelt:
    Wieder kann der Offset-Teil der Speicheradresse einerseits direkt als statischer Wert angegeben werden, andererseits durch Adressberechnung, die folgende vier Komponenten berücksichtigt:

    - Basisregister: Der Wert in einem 32-bit (bei REX.W-Präfix: 64-bit) General-Purpose Register.
    - Indexregister: Der Wert in einem 32-bit (bei REX.W-Präfix: 64-bit) General-Purpose Register.
    - Skalenfaktor: 2 oder 4 oder 8. Wird vor Zugriff mit dem Indexregisterinhalt multipliziert.
    - Versatzwert: Ein 8-bit, 16-bit, or 32-bit Wert.

    Basis- und Indexregister-Werte können in den meisten Fällen durch alle sechzehn verfügbaren General-Purpose-Registern der CPU dargestellt werden. Im Einzelnen bitte die Angaben im Befehlsmanual beachten!

    Die folgende zusätzliche Kombination von Adresskomponenten ist im 64bit-Modus möglich:

    - "Relative Addressierung" RIP + Versatzwert
    RIP ist der 64bit-Befehlszeiger, der auf den jeweils nächsten auszuführenden Befehl zeigt. Ein 32-bit Versatzwert (positiv oder negativ) kann zur Relativen Adressierung verwendet werden.


    Assembler- und Compiler-Adressierungsarten
    ---------------------------------------------------
    Auf Maschinenprogrammebene kann eine ausgewählte Kombination aus Versatz, Basisregister, Indexregister und Skalenfaktor in den Befehlscode aufgenommen werden. Alle Assembler erlauben es dem Programmierer, sämtliche zulässigen Kombinationen von Adressierungselementen einzusetzen. Hochsprachencompiler wählen in der Regel geeignete Kombinationen dieser Elemente aus, um Programmkonstrukte zu realisieren.


    I/O Port Addressierung
    --------------------------
    Angaben zu Adressierungsarten wären nicht vollständig ohne Hinweis auf die
    I/O Port Addressierung: Intel- und AMD Prozessoren für PCs erlauben es, einen separaten Ein/Ausgabe-Adressraum von bis zu 65.536 Byte (a 8 bit), realisiert mit I/O-Portbausteinen, anzusprechen.

    Aber auch Ports mit 16bit oder 32 bit Adressbreite können mit bestimmten Befehlen
    geschrieben und gelesen werden. Dabei werden Ports entweder direkt mit ihrer Hardwareadresse angesprochen, oder indirekt über einen Wert im DX-Register. Mehr dazu zeigt Kapitel 13 "Input/Output" des Programmierhandbuches.


    Gruss

    Quelle: Intel Programming Manuals

    HP255G7:Win10pro2.004,4*AMD Ryzen3200U@2.60GHz,6+2GB-RadeonVega/237GBSSD:intlDVDRW,3xUSB3 ext4TB-HDX,XProfanX3+Xasm/Xpse

  • Abt. XPIA/JWasm unter Win7-64bit
    ======================
    Nach dem (neuerlichen) Aufsetzen von XPIA unter Win7-64 (bei mir nach einem Bootfehler) machte der Linker polink.exe wieder mal den bekannten Fehler "pelle´s länkare funktioniert nicht mehr". Doch diesmal half auch kein Entfernen aller Schreibschutzattribute, entfernen der Internet-Herkunftswarnung und setzen sämtlicher Berechtigungen, keine Anforderung des Adminlevels (um die englischsprachigen User-Berechtigungen in Kraft und die 32-bit-Umleitungen außer Kraft zu setzten). Auch die diversen Kompatibilitätsmodi mit Win-XP brachten keine Abhilfe. Diese sah dagegen folgendermaßen aus:

    Aus dem aktuellen Masm32-Paket von hier nehme man link.exe, kopiere diese Datei nach xpia_dir/bin/ und benenne polink.exe nach polink_orig.exe um, anschließend link.exe nach polink.exe. Weiters hat es sich bewährt, die mspdb50.dll aus dem masm/bin Verzeichnis ebenfalls nach xpia_dir/bin/ zu kopieren, sodaß die Linkerfunktionen lokal unabhängig sind und mit sämtlichen Berechtigungen versehen werden können. Dann klappts endlich wieder...

    HP255G7:Win10pro2.004,4*AMD Ryzen3200U@2.60GHz,6+2GB-RadeonVega/237GBSSD:intlDVDRW,3xUSB3 ext4TB-HDX,XProfanX3+Xasm/Xpse

  • Abt. Fermatzahlen sind nicht alle Primzahlen
    ============================
    Pierre de Fermat, französischer Jurist, Physiker, "Denksportler" und Mathematiker (geb. vermutlich Ende 1607, gest. 1665), trug auch zu wesentlichen Fortschritten der Zahlentheorie bei. Dabei dachte er u.a., einen Algorithmus zur Erzeugung großer Primzahlen gefunden zu haben nach der Formel

    n. Fermatzahl = 1 + 2 ^ (2 ^ n)

    Weiters erfand er mit seinem "Kleinen Fermat´schen Satz" einen wichtigen Primzahlentest.
    Genau dieser Fermat´sche Satz hätte ihm allerdings rasch zeigen können, daß seine Annahme, alle Fermatzahlen seien Primzahlen, nicht stimmt. Denn schon die 5. Fermatzahl, 4294967297, ist ohne Rest durch 641 teilbar, also keine Primzahl. Das fand allerdings erst Leonhard Euler im Jahre 1732 heraus - 67 Jahre nach Fermat´s Tod.

    Es stimmt irgendwie tröstlich, daß sich auch große Geister manchmal grausam irren können...

    Gruss

    HP255G7:Win10pro2.004,4*AMD Ryzen3200U@2.60GHz,6+2GB-RadeonVega/237GBSSD:intlDVDRW,3xUSB3 ext4TB-HDX,XProfanX3+Xasm/Xpse

  • Abt. Adressierungsarten, praktisch ausprobiert
    =============================

    HP255G7:Win10pro2.004,4*AMD Ryzen3200U@2.60GHz,6+2GB-RadeonVega/237GBSSD:intlDVDRW,3xUSB3 ext4TB-HDX,XProfanX3+Xasm/Xpse

  • Hm, meinen PrimTurbo-ASM hätte ich hier in verkürzter Form:

    Code
    CLS:Declare Daten#,ZahlenAnzahl&,PrimAnz&,Code#:Dim Code#,164:Clear Code#:Long Code#,0=1397791846,1448563281,35048,-1959228672,12977264,21022208
    Long Code#,24=37799424,54576640,71353856,88131072,104908288,121685504,16827904,16859334,441,-834977536,-796187532,311087363,1946286720,-1047834384,-487075445,-1957113717,-958790696,-788332285
    Long Code#,96=-210315461,29087723,-1962934272,63013832,-150736757,225955387,-1048374902,16416770,-347868555,63474671,428425679,1499094878,-1654237093,321731,-854261760,-1957165221,49920
    Input ZahlenAnzahl&:Dim Daten#,ZahlenAnzahl&+5:Long Daten#,0=ZahlenAnzahl&:Long Daten#,4=(Sqrt(ZahlenAnzahl&)+1)\1:WhileLoop 0,SizeOf(Code#)-4:If Long(Code#,&loop)=123456789:Long Code#,&loop=Daten#
    EndIf:EndWhile:Call(Code#):Print Str$(@Long(Daten#,ZahlenAnzahl&+1)):Dispose Code#:Dispose Daten#:WaitKey



    Ist aber immernoch ziemlich lang. Ich kloppe dann mal was schnarchlahmes zusammen... ;)


    Gruß
    Jonathan

  • Geht auch ein Vierzeiler? :)

    Code
    CLS:Font 2:set("decimals",0):Declare Z!:Print " Ab Zahl: ";:input Z!
    Declare notprim%,f!,ewig%:Repeat:notprim%=0:WhileLoop 2,int(z!/2):f!=z!/&Loop
    if f!=int(f!):notprim%=1:break:endif:EndWhile:if notprim%=0:print z!
    if %csrlin>22:waitinput 7000:cls:endif:endif:z!=z!+1:Until ewig%


    Hier die etwas ausführlicher erklärte Darstellung (Algorithmus gemäß Schulbuchdefinition):

    Die Verifizierung wird so ab dem Wert 1 Mio recht schwierig, deshalb hier ein
    Link zur Überprüfung der Ergebnisse!

    HP255G7:Win10pro2.004,4*AMD Ryzen3200U@2.60GHz,6+2GB-RadeonVega/237GBSSD:intlDVDRW,3xUSB3 ext4TB-HDX,XProfanX3+Xasm/Xpse

  • Ok, ich wusste nicht, dass du mit "kurz" "einfach" meinst. Da wir ja jetzt ein einfaches Programm haben, kommt hier nochmal was richtig kurzes :D

    Bloß 152 Zeichen:

    Code
    Declare A&[],B&,D&:CLS:Input B&:A&[B&]=0:WhileLoop 2,B&:D&=&loop:IfNot A&[D&]
    Print D&:WhileLoop D&^2,B&,D&:A&[&loop]=1:EndWhile:EndIf:EndWhile:WaitKey



    Und hier in lesbarer Form:



    Wer bietet weniger? ;)


    Gruß
    Jonathan

  • Elegant! Meine Hochachtung!

    Weiss jemand, warum genau bei 46349 Schluß ist, sowohl im Compiler als auch im Interpreter-Modus? Oder hat mein Laptop ein Speicherproblem?
    Gruss

    HP255G7:Win10pro2.004,4*AMD Ryzen3200U@2.60GHz,6+2GB-RadeonVega/237GBSSD:intlDVDRW,3xUSB3 ext4TB-HDX,XProfanX3+Xasm/Xpse

  • Unglaublich, lief gerade compiliert bis mindestens 10 Mio! Gratulation, hervorragendes Re-Design!

    HP255G7:Win10pro2.004,4*AMD Ryzen3200U@2.60GHz,6+2GB-RadeonVega/237GBSSD:intlDVDRW,3xUSB3 ext4TB-HDX,XProfanX3+Xasm/Xpse

  • Abt. XPIA-Falltüren
    ---------------------
    !!Achtung!! Ebenso wie 'Fn' ist auch 'Test' in XPIA/JWasm ein reserviertes Wort!!!
    Nach einer halben Stunde Fehlersuche steht jetzt fest: AsmStart Test ....... AsmEnd endet stets mit einer Fehlermeldung. Auf Test1 umbennen, schon klappt alles.
    Gruss

    HP255G7:Win10pro2.004,4*AMD Ryzen3200U@2.60GHz,6+2GB-RadeonVega/237GBSSD:intlDVDRW,3xUSB3 ext4TB-HDX,XProfanX3+Xasm/Xpse

  • + Das Ende einer Ära +
    ===============
    "Jack Tramiel, founder of Commodore Business Machines and later the owner of Atari, died Easter Sunday 2012. He was 83. He undoubtedly changed the computing landscape by bringing low cost computers to millions of people, and he started a price war that saw dozens of large companies leave the market. He also took a bankrupt Atari and managed to wring almost another decade out of it. The 6502 microprocessor would have withered on the vine if it weren't for Tramiel's support. Could anyone else have done all of that?"
    Quelle: Slashdot

    HP255G7:Win10pro2.004,4*AMD Ryzen3200U@2.60GHz,6+2GB-RadeonVega/237GBSSD:intlDVDRW,3xUSB3 ext4TB-HDX,XProfanX3+Xasm/Xpse

Jetzt mitmachen!

Sie haben noch kein Benutzerkonto auf unserer Seite? Registrieren Sie sich kostenlos und nehmen Sie an unserer Community teil!