Algorithmen Teil IV (Software-Spielereien)

[p. specht]

Willkommen zur 4. Expedition ins Reich des technologischen Wahnsinns.
An dieser Stelle folgen später rechts ein paar Links, und - weil ich es bin: ein Postscriptum.
Gruss

P.S.: Da ist es. Übrigens: Der ursprüngliche Titel hieß "Programmieren bis der Arzt kommt". Danke an die Zensurbehörde. Es wird wieder sehr leer-reich - soviel kann ich mich versprechen.

[p. specht]

Abt. Bedingt beweglich
===============

WindowTitle "Assemblertrainer --- Kapitel 2. Bedingte MOV-Befehle"
Font 2 : randomize : cls rnd(8^8)
var xf!=0.797:var xr%=(%WinRight- %WinLeft-width(%Hwnd))+1
var yf!=0.72 :var yr%=(%WinBottom-%WinTop-height(%Hwnd))+1
var u%=640: var v%=200
Window (u%-xr%)*xf!+xr%,(v%-yr%)*yf!+yr%
SetWindowPos %HWnd= 0,0 - u%,v%    '(%maxx-u%)/2,((%maxy-v%)/2) - u%,v%
AppendMenubar 10,"Befehl eingeben. Register/Speicherbereiche sind hier noch egal."
declare a$[]
a$[]=explode("\
CMOVA r16,r/m16  ; Bewege falls über (CF=0 und ZF=0)#\
CMOVA r32,r/m32  ; Bewege falls über (CF=0 und ZF=0)#\
CMOVAE r16,r/m16  ; Bewege falls über oder gleich (CF=0)#\
CMOVAE r32,r/m32  ; Bewege falls über oder gleich (CF=0)#\
CMOVB r16,r/m16  ; Bewege falls unterhalb_von (CF=1)#\
CMOVB r32,r/m32  ; Bewege falls unterhalb_von (CF=1)#\
CMOVBE r16,r/m16  ; Bewege falls unterhalb_von oder gleich (CF=1 oder ZF=1)#\
CMOVBE r32,r/m32  ; Bewege falls unterhalb_von oder gleich (CF=1 oder ZF=1)#\
CMOVC r16,r/m16  ; Bewege falls CF-Übertrag (CF=1)#\
CMOVC r32,r/m32  ; Bewege falls CF-Übertrag (CF=1)#\
CMOVE r16,r/m16  ; Bewege falls gleich (ZF=1)#\
CMOVE r32,r/m32  ; Bewege falls gleich (ZF=1)#\
CMOVG r16,r/m16  ; Bewege falls größer (ZF=0 und SF=OF)#\
CMOVG r32,r/m32  ; Bewege falls größer (ZF=0 und SF=OF)#\
CMOVGE r16,r/m16  ; Bewege falls größer oder gleich (SF=OF)#\
CMOVGE r32,r/m32  ; Bewege falls größer oder gleich (SF=OF)#\
CMOVL r16,r/m16  ; Bewege falls kleiner (SF<>OF)#\
CMOVL r32,r/m32  ; Bewege falls kleiner (SF<>OF)#\
CMOVLE r16,r/m16  ; Bewege falls kleiner oder gleich (ZF=1 oder SF<>OF)#\
CMOVLE r32,r/m32  ; Bewege falls kleiner oder gleich (ZF=1 oder SF<>OF)#\
CMOVNA r16,r/m16  ; Bewege falls nicht über (CF=1 oder ZF=1)#\
CMOVNA r32,r/m32  ; Bewege falls nicht über (CF=1 oder ZF=1)#\
CMOVNAE r16,r/m16  ; Bewege falls nicht über oder gleich (CF=1)#\
CMOVNAE r32,r/m32  ; Bewege falls nicht über oder gleich (CF=1)#\
CMOVNB r16,r/m16  ; Bewege falls nicht unterhalb_von (CF=0)#\
CMOVNB r32,r/m32  ; Bewege falls nicht unterhalb_von (CF=0)#\
CMOVNBE r16,r/m16  ; Bewege falls nicht unterhalb_von oder gleich (CF=0 und ZF=0)#\
CMOVNBE r32,r/m32  ; Bewege falls nicht unterhalb_von oder gleich (CF=0 und ZF=0)#\
CMOVNC r16,r/m16  ; Bewege falls nicht CF-Übertrag (CF=0)#\
CMOVNC r32,r/m32  ; Bewege falls nicht CF-Übertrag (CF=0)#\
CMOVNE r16,r/m16  ; Bewege falls nicht gleich (ZF=0)#\
CMOVNE r32,r/m32  ; Bewege falls nicht gleich (ZF=0)#\
CMOVNG r16,r/m16  ; Bewege falls nicht größer (ZF=1 oder SF<>OF)#\
CMOVNG r32,r/m32  ; Bewege falls nicht größer (ZF=1 oder SF<>OF)#\
CMOVNGE r16,r/m16  ; Bewege falls nicht größer oder gleich (SF<>OF)#\
CMOVNGE r32,r/m32  ; Bewege falls nicht größer oder gleich (SF<>OF)#\
CMOVNL r16,r/m16  ; Bewege falls nicht kleiner (SF=OF)#\
CMOVNL r32,r/m32  ; Bewege falls nicht kleiner (SF=OF)#\
CMOVNLE r16,r/m16  ; Bewege falls nicht kleiner oder gleich (ZF=0 und SF=OF)#\
CMOVNLE r32,r/m32  ; Bewege falls nicht kleiner oder gleich (ZF=0 und SF=OF)#\
CMOVNO r16,r/m16  ; Bewege falls nicht Überlauf (OF=0)#\
CMOVNO r32,r/m32  ; Bewege falls nicht Überlauf (OF=0)#\
CMOVNP r16,r/m16  ; Bewege falls nicht Geradzahligkeit (PF=0)#\
CMOVNP r32,r/m32  ; Bewege falls nicht Geradzahligkeit (PF=0)#\
CMOVNS r16,r/m16  ; Bewege falls nicht Vorzeichen (SF=0)#\
CMOVNS r32,r/m32  ; Bewege falls nicht Vorzeichen (SF=0)#\
CMOVNZ r16,r/m16  ; Bewege falls nicht Null (ZF=0)#\
CMOVNZ r32,r/m32  ; Bewege falls nicht Null (ZF=0)#\
CMOVO r16,r/m16  ; Bewege falls Überlauf (OF=0)#\
CMOVO r32,r/m32  ; Bewege falls Überlauf (OF=0)#\
CMOVP r16,r/m16  ; Bewege falls Geradzahligkeit (PF=1)#\
CMOVP r32,r/m32  ; Bewege falls Geradzahligkeit (PF=1)#\
CMOVPE r16,r/m16  ; Bewege falls Geradzahligkeit even (PF=1)#\
CMOVPE r32,r/m32  ; Bewege falls Geradzahligkeit even (PF=1)#\
CMOVPO r16,r/m16  ; Bewege falls Geradzahligkeit odd (PF=0)#\
CMOVPO r32,r/m32  ; Bewege falls Geradzahligkeit odd (PF=0)#\
CMOVS r16,r/m16  ; Bewege falls Vorzeichen (SF=1)#\
CMOVS r32,r/m32  ; Bewege falls Vorzeichen (SF=1)#\
CMOVZ r16,r/m16  ; Bewege falls Null (ZF=1)#\
CMOVZ r32,r/m32  ; Bewege falls Null (ZF=1)#\
FCMOVB ST(0),ST(i)  ; Bewege falls unterhalb_von (CF=1)#\
FCMOVE ST(0),ST(i)  ; Bewege falls gleich (ZF=1)#\
FCMOVBE ST(0),ST(i)  ; Bewege falls unterhalb_von oder gleich (CF=1 oder ZF=1)#\
FCMOVU ST(0),ST(i)  ; Bewege falls Nicht-Zahlenbereichs-zugeordnete (PF=1)#\
FCMOVNB ST(0),ST(i)  ; Bewege falls nicht unterhalb_von (CF=0)#\
FCMOVNE ST(0),ST(i)  ; Bewege falls nicht gleich (ZF=0)#\
FCMOVNBE ST(0),ST(i)  ; Bewege falls nicht unterhalb_von oder gleich (CF=0 und ZF=0)#\
FCMOVNU ST(0),ST(i)  ; Bewege falls nicht Nicht-Zahlenbereichs-zugeordnete (PF=0)#\
","#")
var n&=sizeOf(a$[])
declare b$[],c$[n&],d$[n&]
n&=n&-2
WhileLoop 0,n&
b$[]=explode(a$[&Loop],"  ;")
c$[&Loop]=b$[0]
d$[&Loop]=b$[1]
clear b$[]
'print c$[&Loop],,
EndWhile
clear a$[],b$[]

Declare i&,a$
Repeat
i&=rnd(n&)
print d$[i&]
Input a$
print c$[i&]
print
WaitInput
case %csrlin>4:cls rnd(8^8)
EndWhile

WaitInput

[p. specht]

Abt. Klaneun statt Klavier
================
Für mehr Tonumfang benötigt man eine Klaviatur mit 108 Tasten.

WindowTitle "Klaviatur"
declare x1&,y1&,x2&,y2&,sc&,breite&,spalt&,wlaenge&,slaenge&,yy&
Cls rgb(0,0,90)

sc&=30
breite&=sc&
wlaenge&=sc&*4
slaenge&=sc&*3
spalt&=sc&/4
WHILELOOP 0,2:yy&=&Loop*sc&*4.5
WhileLoop 0,20
UsePen 1,5,rgb(100,100,100):UseBrush 1,rgb(100,100,100)
Roundrect &Loop*breite&+1, (10+wlaenge&+yy&) - ((&Loop+1)*breite&-spalt&-1), 14+wlaenge&+yy&;sc&/6;sc&/6
UsePen 1,5,rgb(255,255,255):UseBrush 1,rgb(255,255,255)
Roundrect &Loop*breite&,10+yy& - ((&Loop+1)*breite&-spalt&),10+wlaenge&+yy&;sc&/6;sc&/6
EndWhile
WhileLoop 0,20
select &Loop
caseof 0,1,3,4,5,7,8,10,11,12,14,15,17,18,19
UsePen 1,5,rgb(0,0,0):UseBrush 1,rgb(40,40,100)
Roundrect &Loop*breite&+breite&/2+spalt&/2,5+yy& - ((&Loop+1)*breite&+breite&/7),5+slaenge&+yy&;sc&/6;sc&/6
UsePen 1,3,rgb(0,0,0+4*&Loop):UseBrush 1,rgb(50,50,50)
Roundrect &Loop*breite&+breite&/2+spalt&/2 , 5+slaenge&*32/40+yy& - ((&Loop+1)*breite&+breite&/7),5+slaenge&+yy&;sc&/6;sc&/6
UsePen 0,2,rgb(220,220,200)
Line &Loop*breite&+breite&/2+spalt&/2, 5+yy& - (&Loop*breite&+breite&/2+spalt&/2),(5+slaenge&*4/5+yy&)
endselect
EndWhile
ENDWHILE


WaitInput
End

P.S.: Eine leichtere Mausbedienung als bei der Ärgernismaschine aus Teil III ist in Arbeit.

[p. specht]

Abt. Verbreitung von XProfan
==================
Ranking empfohlen vom Papst der Algorithmen, Prof.em. Don Knuth (74, Stanford), bekannt durch sein Buch "The Art of Computer Programming")
Gruss

P.S. Frage: Sollte man denen mal sagen, daß es XProfan gibt?

[p. specht]

Abt. Bildschirmreinigung
===============
Fettschlieren sieht man am besten in seitlichem Licht bei ausgeschaltetem LCD-Schirm. Leider sind Ausschaltknöpfe aber oft nicht sehr bedienungsfreundlich angeordnet. Für kurze Zeit, z.B. 15 sek, kann man den Schirm mittels des nachstehenden Progrämmchens schwarz schalten. Zeitablauf oder Maus-/Tastenklick beenden den Spuk.

WindowStyle 16 | 64
Window %maxx,%maxy
cls 0
WaitInput 15000

[Jonathan]

Huch, das mit der Dauer bei WaitInput ist ja gar nicht dokumentiert - woher weißt Du denn das?

Da sieht man's mal wieder, XProfan ist viel besser als RGH zugibt


Gruß
Jonathan


P.S.: "Programmieren bis der Arzt kommt" hat mir als Titel irgendwie besser gefallen...

[p. specht]

Danke Jonathan, ich dachte schon es gibt keine weiteren Käseliebhaber hier.
Und gleich noch ein Dank an dich: Durch deine Superturbo Assembler-Primzahlsuche konnte ich "Specht´s Primel" stark erweitert darstellen. Ist aber immer noch potthässlich - das liegt wohl an der Definition der Primzahlen, nämlich: "Sei nie ein ganzz. Vielfaches von dem was schon mal da war". (Um den Quelltext hier reinzustellen, bräuchte ich Dein OK, u.a. deinen Assemblerteil zu verwenden).

Specht´s Primel
Deterministische 2D-Darstellung eines Linienzugs mit den 8 Richtungen der Windrose, wobei die jeweilige Primzahllücke mod 8 den nächsten dargestellten Punkt auf der Ebene bestimmt. Die Farbe wird dabei pro Punkt ebenfalls weitergeschaltet, damit man Überlappungen erkennen kann.

P.S.: Die Darstellung ginge noch viel schneller, wenn es "setpixel" auch als Assemblerbefehl gäbe. Kenne aber derzeit keine solche Möglichkeit...

[Frabbing]

Arbeite doch mit DIBs.

[p. specht]

Kann der das? Ist er hier im Board? Suche ergab: Ja, hat irgendwas mit der Grafikkarte zu tun.
Aber was? Google fand ein Assemblerprogramm, wo der Begriff drin vorkam... hier

[Frabbing]

DIBs sind spezielle Bitmaps, die auch Infos der benutzten Grafik bereitstellen. Man kann also die Grafikdaten fast direkt im Speicher ändern und diese geänderten Daten später für die Bitmap übernehmen, was sehr schnell geht. In reinem XProfan ist der Zeitgewinn allerdings minimal, weil auch Byte-Befehle langsam arbeiten. In Assembler allerdings...

[Jonathan]

Zitat von p. specht

Um den Quelltext hier reinzustellen, bräuchte ich Dein OK, u.a. deinen Assemblerteil zu verwenden

Ach was, den Quälcode darfst Du gerne verwenden... Und jeder Andere auch

Zitat von p. specht

P.S.: Die Darstellung ginge noch viel schneller, wenn es "setpixel" auch als Assemblerbefehl gäbe. Kenne aber derzeit keine solche Möglichkeit...

Idee: Du kannst doch auf einem Speicherbereich "malen" (also jedes Byte ein Pixel und so) und das ganze danach auf den Bildschirm malen...


Gruß
Jonathan

[p. specht]

Aha.. Danke für die Info.
Hier erst mal der bisherige Primelcode, schnellere Varianten mögen folgen:

$P-
'PrimTurbo in Assembler
'
'Eine Primzahlensuche, die abgeht wie sonstwas...
    WindowStyle 1 | 8 | 16
    cls
Declare Daten#, ZahlenAnzahl&, StartZeit&, JN$, PrimAnz&
'Erstellt mit dem XProfan Datengenerator, (C) Frank Abbing
'Datei: C:\Users\Jonathan\Desktop\JWASM\PrimTurbo_Hauptschleife.BIN (originale Dateigröße: 162 Bytes)
Declare Code#
Dim Code#,164
Clear Code#
Long Code#,0=1397791846,1448563281,35048,-1959228672,12977264,21022208
Long Code#,24=37799424,54576640,71353856,88131072,104908288,121685504
Long Code#,48=16827904,16859334,441,-834977536,-796187532,311087363,1946286720
Long Code#,76=-1047834384,-487075445,-1957113717,-958790696,-788332285
Long Code#,96=-210315461,29087723,-1962934272,63013832,-150736757,225955387
Long Code#,120=-1048374902,16416770,-347868555,63474671,428425679,1499094878
Long Code#,144=-1654237093,321731,-854261760,-1957165221,49920

Print "Primzahlen finden bis: ";
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
Print "Primzahlen werden gesucht..."
StartZeit& = &gettickcount
@Call(Code#)
Dispose Code#
Print ""
Print "Benötigte Zeit: " + @Str$((&gettickcount - StartZeit&) / 1000) + " Sekunden."
Print "Gefundene Primzahlen: " + @Str$(@Long(Daten#, ZahlenAnzahl& + 1))
Print ""



' Statt Ausgabeteil adaptiert auf Darstellung einer Primel by P. Specht
' SetPixel ist leider immer noch verdammt langsam!
Print "Primzahlen als S-PRIMEL darstellen (J/N)? ";
Input JN$
If @Upper$(JN$) = "J"
 declare x&,y&,c%,ri&,xx&,yy&,scale&
 Window 0,0 - %maxx,%maxy-52
 cls @rgb(207,207,207)
 xx&=width(%hwnd)*3/5
 yy&=height(%hwnd)*2/7
 c%=rgb(255,0,0)
 x&=0:y&=0:scale&=10  ' Maßstab 1 : scale&
 WhileLoop 2, ZahlenAnzahl&
    IfNot @Byte(Daten#, &loop)
      setpixel xx&+x&/scale&,yy&+y&/scale&,c%
      ri&=(ri&+1) mod 8
    EndIf   
    Select ri&
        caseof 0:inc x&
        caseof 1:inc x&:dec y&
        caseof 2:dec y&
        caseof 3:dec x&:dec y&
        caseof 4:dec x&
        caseof 5:dec x&:inc y&
        caseof 6:inc y&
        caseof 7:inc x&:inc y&
    endselect
  inc c%
  EndWhile
EndIf
Dispose Daten#
Print "\n Fertig! "
WaitInput
End
$MAKE CLE

[p. specht]

Abt. Diät für Hacker
=============
The Hacker's Diet by John Walker, now CH, Mitbegründer von AutoDesk, der Firma die den Industriestandard AutoCAD vertreibt und regelmäßig alle Konkurrenten im 3D-Bereich aufkauft...

[p. specht]

Abt. Assemblertrainer - Kapitel 3: FPU-Befehle
=============================

WindowTitle "Assemblertrainer --- Kapitel 3. Befehle der FPU-FloatingPoint Unit"
'(D)Demo. Keine Haftung. Verwendung auf alleiniges Risiko des/der Anwender/s/in!
Font 2 : randomize : cls rnd(8^8)
var xf!=0.797:var xr%=(%WinRight- %WinLeft-width(%Hwnd))+1
var yf!=0.72 :var yr%=(%WinBottom-%WinTop-height(%Hwnd))+1
var u%=%MaxX: var v%=200
Window (u%-xr%)*xf!+xr%,(v%-yr%)*yf!+yr%
SetWindowPos %HWnd= 0,0 - u%,v%    '(%maxx-u%)/2,((%maxy-v%)/2) - u%,v%
AppendMenubar 10,"Befehl eingeben. Register/Speicherbereiche sind hier noch egal."
print " *** Bei Umsetzung auf das korrekte FINIT zu Beginn (und ggf. EMMS am Ende) achten! ***"
Declare a$[]:a$[]=explode("\
F2XM1  ; Ersetze ST(0) mit (2ST(0) – 1)#\
FADD m32fp  ; Addiere m32fp nach ST(0) und speichere Ergebnis in ST(0)#\
FADD m64fp  ; Addiere m64fp nach ST(0) und speichere Ergebnis in ST(0)#\
FADD ST(0),ST(i)  ; Addiere ST(0) nach ST(i) und speichere Ergebnis in ST(0)#\
FADD ST(i),ST(0)  ; Addiere ST(i) nach ST(0) und speichere Ergebnis in ST(i)#\
FADDP ST(i),ST(0)  ; Addiere ST(0) nach ST(i), speichere Ergebnis in ST(i), und ziehe Wert vom Stack#\
FADDP  ; Addiere ST(0) nach ST(1), speichere Ergebnis in ST(1), und ziehe Wert vom Stack#\
FIADD m32int  ; Addiere m32int nach ST(0) und speichere Ergebnis in ST(0)#\
FIADD m16int  ; Addiere m16int nach ST(0) und speichere Ergebnis in ST(0)#\
FBLD m80dec  ; Wandle BCD Wert nach Gleitkomma und schiebe ihn auf den FPU Stack.#\
FBSTP m80bcd  ; Speichere ST(0) in m80bcd und ziehe_Wert_vom ST(0).#\
FCLEX  ; Lösche Gleitkomma AusnahmeFlags nach Überprüfung auf wartende un-ausgeschaltete Gleitkomma Ausnahmeflags.#\
FNCLEX*  ; Lösche Gleitkomma AusnahmeFlags ohne prüfen auf wartende un-ausgeschaltete Gleitkomma Ausnahmeflags.#\
FCMOVB ST(0),ST(i)  ; Bewege falls unterhalb_von (CF=1)#\
FCMOVE ST(0),ST(i)  ; Bewege falls gleich (ZF=1)#\
FCMOVBE ST(0),ST(i)  ; Bewege falls unterhalb_von oder gleich (CF=1 oder ZF=1)#\
FCMOVU ST(0),ST(i)  ; Bewege falls Nicht-Zahlenbereichs-zugeordnete (PF=1)#\
FCMOVNB ST(0),ST(i)  ; Bewege falls nicht unterhalb_von (CF=0)#\
FCMOVNE ST(0),ST(i)  ; Bewege falls nicht gleich (ZF=0)#\
FCMOVNBE ST(0),ST(i)  ; Bewege falls nicht unterhalb_von oder gleich (CF=0 und ZF=0)#\
FCMOVNU ST(0),ST(i)  ; Bewege falls nicht Nicht-Zahlenbereichs-zugeordnete (PF=0)#\
FCOM m32fp  ; Vergleiche ST(0) mit m32fp.#\
FCOM m64fp  ; Vergleiche ST(0) mit m64fp.#\
FCOM ST(i)  ; Vergleiche ST(0) mit ST(i).#\
FCOM  ; Vergleiche ST(0) mit ST(1).#\
FCOMP m32fp  ; Vergleiche ST(0) mit m32fp undziehe_Wert_vom Register stack.#\
FCOMP m64fp  ; Vergleiche ST(0) mit m64fp undziehe_Wert_vom Register stack.#\
FCOMP ST(i)  ; Vergleiche ST(0) mit ST(i) undziehe_Wert_vom Register stack.#\
FCOMP  ; Vergleiche ST(0) mit ST(1) undziehe_Wert_vom Register stack.#\
FCOMPP  ; Vergleiche ST(0) mit ST(1) undziehe_Wert_vom Register-Stapelspeicher zweimal .#\
FCOMI ST,ST(i)  ; Vergleiche ST(0) mit ST(i) und setze Status Flags entsprechend #\
FCOMIP ST,ST(i)  ; Vergleiche ST(0) mit ST(i),set Status Flags entsprechend , undziehe_Wert_vom Register stack#\
FUCOMI ST,ST(i)  ; Vergleiche ST(0) mit ST(i), check für/auf ordered values, und setze Status Flags entsprechend #\
FUCOMIP ST,ST(i)  ; Vergleiche ST(0) mit ST(i), check für/auf ordered values, setze Status Flags entsprechend , undziehe_Wert_vom Register stack#\
FCOS  ; Ersetze ST(0) mit its cosine#\
FDECSTP  ; Verringere TOP field in FPU Status word.#\
FDIV m32fp  ; Dividiere ST(0) um/durch m32fp und speichere Ergebnis in ST(0)#\
FDIV m64fp  ; Dividiere ST(0) um/durch m64fp und speichere Ergebnis in ST(0)#\
FDIV ST(0),ST(i)  ; Dividiere ST(0) um/durch ST(i) und speichere Ergebnis in ST(0)#\
FDIV ST(i),ST(0)  ; Dividiere ST(i) um/durch ST(0) und speichere Ergebnis in ST(i)#\
FDIVP ST(i),ST(0)  ;Dividiere ST(i) um/durch ST(0), speichere Ergebnis in ST(i), undziehe_Wert_vom d. Register stack#\
FDIVP  ; Divide ST(1) um/durch ST(0), speichere Ergebnis in ST(1), und ziehe_Wert_vom Registerstack#\
FIDIV m32int  ; Dividiere ST(0) um/durch m32int und speichere Ergebnis in ST(0)#\
FIDIV m16int  ; Dividiere ST(0) um/durch m64int und speichere Ergebnis in ST(0)#\
FDIVR m32fp  ; Dividiere m32fp um/durch ST(0) und speichere Ergebnis in ST(0)#\
FDIVR m64fp  ; Dividiere m64fp um/durch ST(0) und speichere Ergebnis in ST(0)#\
FDIVR ST(0),ST(i)  ; Dividiere ST(i) um/durch ST(0) und speichere Ergebnis in ST(0)#\
FDIVR ST(i),ST(0)  ; Dividiere ST(0) um/durch ST(i) und speichere Ergebnis in ST(i)#\
FDIVRP ST(i),ST(0)  ; Dividiere ST(0) um/durch ST(i), speichere Ergebnis in ST(i), undziehe_Wert_vom d. Register stack#\
FDIVRP  ; Divide ST(0) um/durch ST(1), speichere Ergebnis in ST(1), undziehe_Wert_vom d. Register stack#\
FIDIVR m32int  ; Divide m32int um/durch ST(0) und speichere Ergebnis in ST(0)#\
FIDIVR m16int  ; Divide m16int um/durch ST(0) und speichere Ergebnis in ST(0)#\
FFREE ST(i)  ; Sets tag für/auf ST(i) nach empty#\
FICOM m16int  ; Vergleiche ST(0) mit m16int#\
FICOM m32int  ; Vergleiche ST(0) mit m32int#\
FICOMP m16int  ; Vergleiche ST(0) mit m16int undziehe_Wert_vom stack register#\
FICOMP m32int  ; Vergleiche ST(0) mit m32int undziehe_Wert_vom stack register#\
FILD m16int  ; Push m16intauf/drauf d. FPU Register stack.#\
FILD m32int  ; Push m32intauf/drauf d. FPU Register stack.#\
FILD m64int  ; Push m64intauf/drauf d. FPU Register stack.#\
FINCSTP  ; Erhöhe d. TOP field in d. FPU Status register#\
FINIT  ; Initialisiere FPU nach Überprüfung auf wartende un-ausgeschaltete Gleitkomma exceptions.#\
FNINIT*  ; Initialisiere FPU ohne prüfen auf wartende un-ausgeschaltete Gleitkomma exceptions.#\
FIST m16int  ; Speichere ST(0) in m16int#\
FIST m32int  ; Speichere ST(0) in m32int#\
FISTP m16int  ; Speichere ST(0) in m16int undziehe_Wert_vom Register stack#\
FISTP m32int  ; Speichere ST(0) in m32int undziehe_Wert_vom Register stack#\
FISTP m64int  ; Speichere ST(0) in m64int undziehe_Wert_vom Register stack#\
FLD m32fp  ; Push m32fpauf/drauf d. FPU Register stack.#\
FLD m64fp  ; Push m64fpauf/drauf d. FPU Register stack.#\
FLD m80fp  ; Push m80fpauf/drauf d. FPU Register stack.#\
FLD ST(i)  ; Push ST(i)auf/drauf d. FPU Register stack.#\
FLD1  ; Push +1.0auf/drauf d. FPU Register stack.#\
FLDL2T  ; Push log2_10auf/drauf d. FPU Register stack.#\
FLDL2E  ; Push log2_eauf/drauf d. FPU Register stack.#\
FLDPI  ; Push piauf/drauf d. FPU Register stack.#\
FLDLG2  ; Push log10_2auf/drauf d. FPU Register stack.#\
FLDLN2  ; Push loge_2auf/drauf d. FPU Register stack.#\
FLDZ  ; Push +0.0auf/drauf d. FPU Register stack.#\
FLDCW m2byte  ; Lade FPU Steuerwort von m2byte.#\
FLDENV m14/28byte  ; Lade FPU Umgebung von m14byte oder m28byte.#\
FMUL m32fp  ; Multiply ST(0) um/durch m32fp und speichere Ergebnis in ST(0)#\
FMUL m64fp  ; Multiply ST(0) um/durch m64fp und speichere Ergebnis in ST(0)#\
FMUL ST(0),ST(i)  ; Multiply ST(0) um/durch ST(i) und speichere Ergebnis in ST(0)#\
FMUL ST(i),ST(0)  ; Multiply ST(i) um/durch ST(0) und speichere Ergebnis in ST(i)#\
FMULP ST(i),ST(0)  ; Multiply ST(i) um/durch ST(0), speichere Ergebnis in ST(i), undziehe_Wert_vom d. Register stack#\
FMULP  ; Multiply ST(1) um/durch ST(0), speichere Ergebnis in ST(1), undziehe_Wert_vom d. Register stack#\
FIMUL m32int  ; Multiply ST(0) um/durch m32int und speichere Ergebnis in ST(0)#\
FIMUL m16int  ; Multiply ST(0) um/durch m16int und speichere Ergebnis in ST(0)#\
FNOP  ; No operation ist performed.#\
FPATAN  ; Ersetze ST(1) mit arctan(ST(1)/ST(0)) undziehe_Wert_vom d. Register stack#\
FPTAN  ; Ersetze ST(0) mit its Tangens und Auf_Stack_schieben 1auf/drauf d. FPU stack.#\
FRNDINT  ; Round ST(0) nach an integer.#\
FRSTOR m94/108byte  ; Lade FPU Zustand von m94byte oder m108byte.#\
FSAVE m94/108byte  ; Speichere FPU Zustand nach m94byte oder m108byte nach Überprüfung auf wartende un-ausgeschaltete Gleitkomma exceptions. Then reinitialize d. FPU.#\
FNSAVE* m94/108byte  ; Speichere FPU Umgebung nach m94byte oder m108byte ohne prüfen auf wartende un-ausgeschaltete Gleitkomma exceptions. Then wieder-initialisiere d. FPU.#\
FSCALE  ; Scale ST(0) um/durch ST(1).#\
FSIN  ; Ersetze ST(0) mit its sine.#\
FSINCOS  ; Compute d. Sinus und Cosinus von ST(0); replace ST(0) mit d. sine, und Auf_Stack_schieben d. Cosinusauf/drauf d. Register stack.#\
FSQRT  ; Berechnet Quadratwurzel von ST(0) und stores d. Ergebnis in#\
FST m32fp  ; Copy ST(0) nach m32fp#\
FST m64fp  ; Copy ST(0) nach m64fp#\
FST ST(i)  ; Copy ST(0) nach ST(i)#\
FSTP m32fp  ; Copy ST(0) nach m32fp undziehe_Wert_vom Register stack#\
FSTP m64fp  ; Copy ST(0) nach m64fp undziehe_Wert_vom Register stack#\
FSTP m80fp  ; Copy ST(0) nach m80fp undziehe_Wert_vom Register stack#\
FSTP ST(i)  ; Copy ST(0) nach ST(i) undziehe_Wert_vom Register stack#\
FSTCW m2byte  ; Speichere FPU Steuerwort nach m2byte nach Überprüfung auf wartende un-ausgeschaltete Gleitkomma exceptions.#\
FNSTCW* m2byte  ; Speichere FPU Steuerwort nach m2byte ohne prüfen auf wartende un-ausgeschaltete Gleitkomma exceptions.#\
FSTENV m14/28byte  ; Speichere FPU Umgebung nach m14byte oder m28byte nach Überprüfung auf wartende un-ausgeschaltete Gleitkomma exceptions. Then Maske all Gleitkomma exceptions.#\
FNSTENV* m14/28byte  ; Speichere FPU Umgebung nach m14byte oder m28byte ohne prüfen auf wartende un-ausgeschaltete Gleitkomma exceptions. Then Maske all Gleitkomma exceptions.#\
FSTSW m2byte  ; Speichere FPU Status Word bei m2byte nach Überprüfung auf wartende un-ausgeschaltete Gleitkomma exceptions.#\
FSTSW AX  ; Speichere FPU Status Word in AX Register nach Überprüfung auf wartende un-ausgeschaltete Gleitkomma exceptions.#\
FNSTSW* m2byte  ; Speichere FPU Status Word bei m2byte ohne prüfen auf wartende un-ausgeschaltete Gleitkomma exceptions.#\
FNSTSW* AX  ; Speichere FPU Status Word in AX Register ohne prüfen auf wartende un-ausgeschaltete Gleitkomma exceptions.#\
FSUB m32fp  ; Subtrahiere m32fp von ST(0) und speichere Ergebnis in ST(0)#\
FSUB m64fp  ; Subtrahiere m64fp von ST(0) und speichere Ergebnis in ST(0)#\
FSUB ST(0),ST(i)  ; Subtrahiere ST(i) von ST(0) und speichere Ergebnis in ST(0)#\
FSUB ST(i),ST(0)  ; Subtrahiere ST(0) von ST(i) und speichere Ergebnis in ST(i)#\
FSUBP ST(i),ST(0)  ; Subtrahiere ST(0) von ST(i), speichere Ergebnis in ST(i), undziehe_Wert_vom Register stack#\
FSUBP  ; Subtrahiere ST(0) von ST(1), speichere Ergebnis in ST(1), undziehe_Wert_vom Register stack#\
FISUB m32int  ; Subtrahiere m32int von ST(0) und speichere Ergebnis in ST(0)#\
FISUB m16int  ; Subtrahiere m16int von ST(0) und speichere Ergebnis in ST(0)#\
FSUBR m32fp  ; Subtrahiere ST(0) von m32fp und speichere Ergebnis in ST(0)#\
FSUBR m64fp  ; Subtrahiere ST(0) von m64fp und speichere Ergebnis in ST(0)#\
FSUBR ST(0),ST(i)  ; Subtrahiere ST(0) von ST(i) und speichere Ergebnis in ST(0)#\
FSUBR ST(i),ST(0)  ; Subtrahiere ST(i) von ST(0) und speichere Ergebnis in ST(i)#\
FSUBRP ST(i),ST(0)  ; Subtrahiere ST(i) von ST(0), speichere Ergebnis in ST(i), undziehe_Wert_vom Register stack#\
FSUBRP  ; Subtrahiere ST(1) von ST(0), speichere Ergebnis in ST(1), undziehe_Wert_vom Register stack#\
FISUBR m32int  ; Subtrahiere ST(0) von m32int und speichere Ergebnis in ST(0)#\
FISUBR m16int  ; Subtrahiere ST(0) von m16int und speichere Ergebnis in ST(0)#\
FTST  ; Vergleiche ST(0) mit 0.0#\
FUCOM ST(i)  ; Vergleiche ST(0) mit ST(i)#\
FUCOM  ; Vergleiche ST(0) mit ST(1)#\
FUCOMP ST(i)  ; Vergleiche ST(0) mit ST(i) undziehe_Wert_vom Register stack#\
FUCOMP  ; Vergleiche ST(0) mit ST(1) undziehe_Wert_vom Register stack#\
FUCOMPP  ; Vergleiche ST(0) mit ST(1) undziehe_Wert_vom Register-Stapelspeicher zweimal#\
FXAM  ; Classify Wert oder Zahl-in ST(0)#\
FXCH ST(i)  ; Tausche_aus d. contents von ST(0) und ST(i)#\
FXCH  ; Tausche_aus d. contents von ST(0) und ST(1)#\
FXRSTOR m512byte  ; Restore d. x87 FPU, MMX, XMM, und MXCSR Register Zustand von m512byte.#\
FXSAVE m512byte  ; Save d. x87 FPU, MMX, XMM, und MXCSR Register Zustand nach m512byte.#\
FXTRACT  ; Trenne Wert in ST(0) hinein_in exponent und significand, speichere exponent in ST(0), und Auf_Stack_schieben d. significandauf/drauf d. Register stack.#\
FYL2X  ; Ersetze ST(1) mit (ST(1) * log2ST(0)) undziehe_Wert_vom d. Register stack#\
FYL2XP1  ; Ersetze ST(1) mit ST(1) * log2(ST(0) + 1.0) undziehe_Wert_vom d. Register stack#\
FWAIT  ; Check wartende un-ausgeschaltete Gleitkomma exceptions.\
","#")
var n&=sizeOf(a$[])
declare b$[],c$[n&],d$[n&]
n&=n&-2
WhileLoop 0,n&
b$[]=explode(a$[&Loop],"  ;")
c$[&Loop]=b$[0]
d$[&Loop]=b$[1]
clear b$[]
'print c$[&Loop],,
EndWhile
clear a$[],b$[]
Declare i&,a$
Repeat
i&=rnd(n&)
print i&
print d$[i&]
Input a$
print c$[i&]
print
WaitInput
case %csrlin>4:cls rnd(8^8)
EndWhile
WaitInput

[p. specht]

Abt. Gefahren des Internets
==================
"Toll, wir müssen nichts zahlen für den Stall!" - "Ja, und das Essen ist auch gratis!"
Aber: Kunde bist du nur, wenn du zahlst. Sonst bist du die Ware...