Algorithmen Teil IV (Software-Spielereien) -Seite 2 - Paules-PC-Forum.de

**Frabbing** · 16.01.2012, 22:01

Schon gemein.

p. specht · 17.01.2012, 13:48

Abt. Grau ist alle Theorie
================
Mit Floating-Point-Ganzzahlen könnte man im Bereich +/- 9007199254740992
fehlerfrei bits indexieren, - nimmt man das Vorzeichenbit auch noch mit, dann geht der Bereich von 0 - 18,014,398,509,481,984. Theoretisch könnte man damit ein Erathostenes-Filter für ca. die ersten 720 Bio. Primzahlen aufbauen (Geschätzte Primzahldichte etwas unter 4%) - allerdings: Wo speichern wir die 2048 Terabyte der Bitleiste? (Von der Rechenzeit gar nicht zu reden...). Selbst wenn wir Runlenght-Encoden ist das noch immer gewaltig...
Gruss

P.S.: Hier hat jemand MIRPZAHLEN gefunden - finde ich Essalk!!

p. specht · 17.01.2012, 16:07

Abt. Assemblertrainer - Kapitel 4: Manipulation der mm-Register (Zugegeben nur was für geeks)
=========================================

Code:

WindowTitle "Assemblertrainer --- Kapitel 4. Befehle der 64-bit-MMx MultiMedia-Einheit"
'(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! 'mm1', 'mm2' bedeuten: Unterschiedliche Register aus mm0 bis mm7 (andere Betriebsart der FPU-Register, FPU nicht verwenden!)."
Declare a$[]:a$[]=explode("\
MASKMOVQ mm1,mm2  ; Schreibe ausgewählte Bytes von mm1 in eine Speicherstelle unter Verwendung der Byte-Maske in mm2.#\
MOVD mm,r/m32  ; Bewege Doppelwort von r/m32 nach mm .#\
MOVD r/m32,mm  ; Bewege Doppelwort von mm nach r/m32.#\
MOVNTQ m64,mm  ; Bewege Quadword von mm nach m64 und verhindere Cachebelegung ('temporal hint').#\
MOVQ mm,mm/m64  ; Bewege Quadword von mm/m64 nach mm.#\
MOVQ mm/m64,mm  ; Bewege quadword von mm nach mm/m64.#\
PACKSSWB mm1,mm2/m64  ; Wandele 4 gepackte vorzeichenbehaftete/s Word-Ganzzahlen von mm1 und mm2/m64 in 8 gepackte vorzeichenbehaftete/s Byte Ganzzahlen in mm1 unter_Verwendung_von vorzeichenbehaftete/s Endbegrenzung der Werte.#\
PACKSSDW mm1,mm2/m64  ; Wandele 2 gepackte vorzeichenbehaftete/s Doppelwort-Ganzzahlen von mm1 und mm2/m64 in 4 gepackte vorzeichenbehaftete/s Word Ganzzahlen in mm1 unter_Verwendung_von vorzeichenbehaftete/s Endbegrenzung der Werte.#\
PACKUSWB mm,mm/m64  ; Wandelt_um 4 vorzeichenbehaftete/s Word Ganzzahlen von mm und 4 vorzeichenbehaftete/s Word Ganzzahlen von mm/m64 hinein_in 8 vorzeichenlose Byte Ganzzahlen in mm unter_Verwendung_von vorzeichenlose Endbegrenzung der Werte.#\
PADDB mm,mm/m64  ; Addiere gepackte Byte Ganzzahlen von mm/m64 und mm.#\
PADDW mm,mm/m64  ; Addiere gepackte Word Ganzzahlen von mm/m64 und mm.#\
PADDD mm,mm/m64  ; Addiere gepackte Doppelwort Ganzzahlen von mm/m64 und mm.#\
PADDQ mm1,mm2/m64  ; Addiere Quadword integer mm2/m64 nach mm1#\
PADDSB mm,mm/m64  ; Addiere gepackte vorzeichenbehaftete/s Byte Ganzzahlen von mm/m64 und mm und endbegrenze die Ergebnisse.#\
PADDSW mm,mm/m64  ; Addiere gepackte vorzeichenbehaftete/s Word Ganzzahlen von mm/m64 und mm und endbegrenze die Ergebnisse.#\
PADDUSB mm,mm/m64  ; Addiere gepackte vorzeichenlose Byte Ganzzahlen von mm/m64 und mm und endbegrenze die Ergebnisse.#\
PADDUSW mm,mm/m64  ; Addiere gepackte vorzeichenlose Word Ganzzahlen von mm/m64 und mm und endbegrenze die Ergebnisse.#\
PAND mm,mm/m64  ; Bit-weises AND mm/m64 und mm.#\
PANDN mm,mm/m64  ; Bit-weises AND NOT von mm/m64 und mm.#\
PAVGB mm1,mm2/m64  ; Durschnittswert gepackte vorzeichenlose Byte Ganzzahlen von mm2/m64 und mm1 mit Rundung .#\
PAVGW mm1,mm2/m64  ; Durschnittswert gepackte vorzeichenlose Word Ganzzahlen von mm2/m64 und mm1 mit Rundung .#\
PCMPEQB mm,mm/m64  ; Vergleiche gepackte Bytes in mm/m64 und mm für/auf equality.#\
PCMPEQW mm,mm/m64  ; Vergleiche gepackte words in mm/m64 und mm für/auf equality.#\
PCMPEQD mm,mm/m64  ; Vergleiche gepackte doublewords in mm/m64 und mm für/auf equality.#\
PCMPGTB mm,mm/m64  ; Vergleiche gepackte vorzeichenbehaftete/s Byte Ganzzahlen in mm und mm/m64 für/auf größer als .#\
PCMPGTW mm,mm/m64  ; Vergleiche gepackte vorzeichenbehaftete/s Word Ganzzahlen in mm und mm/m64 für/auf größer als .#\
PCMPGTD mm,mm/m64  ; Vergleiche gepackte vorzeichenbehaftete/s Doppelwort Ganzzahlen in mm und mm/m64 für/auf größer als .#\
PMADDWD mm,mm/m64  ; Multiply d. gepackte words in mm um/durch d. gepackte words in mm/m64,add adjacent Doppelwort results,and speichere in mm.#\
PMAXSW mm1,mm2/m64  ; Vergleiche vorzeichenbehaftete/s Word Ganzzahlen in mm2/m64 und mm1 und Rückgabe maximum values.#\
PMAXUB mm1,mm2/m64  ; Vergleiche vorzeichenlose Byte Ganzzahlen in mm2/m64 und mm1 und returns maximum values.#\
PMINSW mm1,mm2/m64  ; Vergleiche vorzeichenbehaftete/s Word Ganzzahlen in mm2/m64 und mm1 und Rückgabe minimum values.#\
PMINUB mm1,mm2/m64  ; Vergleiche vorzeichenlose Byte Ganzzahlen in mm2/m64 und mm1 und returns minimum values.#\
PMOVMSKB r32,mm  ; Bewege eine Byte-Maske von mm nach r32.#\
PMULHUW mm1,mm2/m64  ; Multiply d. gepackte vorzeichenlose Word Ganzzahlen in mm1 Register und mm2/m64, und speichere d. high 16 bits von d. results in mm1.#\
PMULHW mm,mm/m64  ; Multiply d. gepackte vorzeichenbehaftete/s Word Ganzzahlen in mm1 Register und mm2/m64, und speichere d. high 16 bits von d. results in mm1.#\
PMULLW mm,mm/m64  ; Multiply d. gepackte vorzeichenbehaftete/s Word Ganzzahlen in mm1 Register und mm2/m64, und speichere d. niedere/s 16 bits von d. results in mm1.#\
PMULUDQ mm1,mm2/m64  ; Multiply vorzeichenlose Doppelwort integer in mm1 um/durch vorzeichenlose Doppelwort integer in mm2/m64, und speichere d. quadword Ergebnis in mm1.#\
POR mm,mm/m64  ; Bit-weises OR von mm/m64 und mm.#\
PSADBW mm1,mm2/m64  ; Berechnet d. absolut differences von d. gepackte vorzeichenlose Byte Ganzzahlen von mm2 /m64 und mm1; differences are then summed nach produce an vorzeichenlose Word integer result.#\
PSLLW mm,mm/m64  ; Schiebe words in mm links mm/m64 während Nullen nachgeschoben werden.#\
PSLLD mm,mm/m64  ; Schiebe doublewords in mm links um/durch mm/m64 während Nullen nachgeschoben werden.#\
PSLLQ mm,mm/m64  ; Schiebe quadword in mm links um/durch mm/m64 während Nullen nachgeschoben werden.#\
PSRAW mm,mm/m64  ; Schiebe words in mm rechts um/durch mm/m64 while verschiebe in Vorzeichen bits.#\
PSRAD mm,mm/m64  ; Schiebe doublewords in mm rechts um/durch mm/m64 while verschiebe in Vorzeichen bits.#\
PSRLW mm,mm/m64  ; Schiebe words in mm rechts um/durch amount angegeben in mm/m64 während Nullen nachgeschoben werden.#\
PSRLD mm,mm/m64  ; Schiebe doublewords in mm rechts um/durch amount angegeben in mm/m64 während Nullen nachgeschoben werden.#\
PSRLQ mm,mm/m64  ; Schiebe mm rechts um/durch amount angegeben in mm/m64 während Nullen nachgeschoben werden.#\
PSUBB mm,mm/m64  ; Subtrahiere gepackte Byte Ganzzahlen in mm/m64 von gepackte Byte Ganzzahlen in mm.#\
PSUBW mm,mm/m64  ; Subtrahiere gepackte Word Ganzzahlen in mm/m64 von gepackte Word Ganzzahlen in mm.#\
PSUBD mm,mm/m64  ; Subtrahiere gepackte Doppelwort Ganzzahlen in mm/m64 von gepackte Doppelwort Ganzzahlen in mm.#\
PSUBQ mm1,mm2/m64  ; Subtrahiere quadword integer in mm1 von mm2 /m64.#\
PSUBSB mm,mm/m64  ; Subtrahiere vorzeichenbehaftete/s gepackte Bytes in mm/m64 von vorzeichenbehaftete/s gepackte Bytes in mm und endbegrenze Resultate.#\
PSUBSW mm,mm/m64  ; Subtrahiere vorzeichenbehaftete/s gepackte words in mm/m64 von vorzeichenbehaftete/s gepackte words in mm und endbegrenze Resultate.#\
PSUBUSB mm,mm/m64  ; Subtrahiere vorzeichenlose gepackte Bytes in mm/m64 von vorzeichenlose gepackte Bytes in mm und endbegrenze Resultat.#\
PSUBUSW mm,mm/m64  ; Subtrahiere vorzeichenlose gepackte words in mm/m64 von vorzeichenlose gepackte words in mm und endbegrenze Resultat.#\
PUNPCKHBW mm,mm/m64  ; Entpacke und verschneide obere Bytes von mm und mm/m64 hinein_in mm.#\
PUNPCKHWD mm,mm/m64  ; Entpacke und verschneide obere words von mm und mm/m64 hinein_in mm.#\
PUNPCKHDQ mm,mm/m64  ; Entpacke und verschneide obere doublewords von mm und mm/m64 hinein_in mm.#\
PUNPCKLBW mm,mm/m32  ; Verzahne niederwertiges Bytes von mm und mm/m32 hinein_in mm.#\
PUNPCKLWD mm,mm/m32  ; Verzahne niederwertiges words von mm und mm/m32 hinein_in mm.#\
PUNPCKLDQ mm,mm/m32  ; Verkämme niederwertiges doublewords von mm und mm/m32 hinein_in mm.#\
PXOR mm,mm/m64  ; Bit-weises XOR von mm/m64 und mm.#\
SHRD r/m32,r32,mm8  ; Schiebe r/m32 nach rechts um imm8 Plätze während die bits von r32 von links hereingeschoben werden\
","#")
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$[]
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 · 17.01.2012, 20:14

Abt. Heizkostensenkung durch CPU-Abwärme
============================
CPU-Temperaturen sind bei modernen Prozessoren voll im Griff, schlimmstenfalls taktet die CPU runter. Bei Mehrkernsystemen ist das ganze noch feiner ausgeklügelt. Wer allerdings einen XP-Rechner sein kosiges Eigen nennen darf, den könnte vielleicht doch interessieren wie heiß die Spinnweben da drinnen werden: Hier gibts Software-Temperatur- und Lüftermonitoren dazu.

P.S.: Auch für Mehrkerner grade was gefunden...

p. specht · 17.01.2012, 20:38

Abt. Assemblertrainer, Kapitel 5: Befehle der 128-bit-XMM-Extended MultiMedia Unit
=====================================================
Eine Fortsetzung ist derzeit nicht geplant, ihr könnt also aufatmen

!

Code:

WindowTitle "Assemblertrainer --- Kapitel 5. Befehle der 128-bit-XMM-Extended MultiMedia 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,"Befehlsmnemonic eingeben. 'xmm1', 'xmm2' bedeuten nur: Unterschiedliche Register aus xmm0 bis xmm7"
Declare a$[]:a$[]=explode("\
ADDPD xmm1,xmm2/m128  ; Addiere gepackte doppeltgenaue Gleitkommazahl von xmm2/m128 nach xmm1.#\
ADDPS xmm1,xmm2/m128  ; Addiere gepackte einfach-genaue Gleitkommazahl von xmm2/m128 nach xmm1.#\
ADDSD xmm1,xmm2/m64  ; Addiere d. niedere/s doppeltgenaue Gleitkommazahl Wert von xmm2/m64 nach xmm1.#\
ADDSS xmm1,xmm2/m32  ; Addiere d. niedere/s einfach-genaue Gleitkommazahl Wert von xmm2/m32 nach xmm1.#\
ANDPD xmm1,xmm2/m128  ; Bit-weises logisches AND von xmm2/m128 und xmm1.#\
ANDPS xmm1,xmm2/m128  ; Bit-weises logisches AND von xmm2/m128 und xmm1.#\
ANDNPD xmm1,xmm2/m128  ; Bit-weises logisches AND NOT von xmm2/m128 und xmm1.#\
ANDNPS xmm1,xmm2/m128  ; Bit-weises logisches AND NOT von xmm2/m128 und xmm1.#\
CMPPD xmm1,xmm2/m128,imm8  ; Vergleiche gepackte doppeltgenaue Gleitkommazahl in xmm2/m128 und xmm1 unter_Verwendung_von imm8 als Vergleichsauftragstyp .#\
CMPPS xmm1,xmm2/m128,imm8  ; Vergleiche gepackte einfach-genaue Gleitkommazahl values in xmm2/mem und xmm1 unter_Verwendung_von imm8 als Vergleichsauftragstyp .#\
CMPSD xmm1,xmm2/m64,imm8  ; Vergleiche niedere/s doppeltgenaue Gleitkommazahl in xmm2/m64 und xmm1 unter_Verwendung_von imm8 als Vergleichsauftragstyp .#\
CMPSS xmm1,xmm2/m32,imm8  ; Vergleiche niedere/s einfach-genaue Gleitkommazahl in xmm2/m32 und xmm1 unter_Verwendung_von imm8 als Vergleichsauftragstyp .#\
COMISD xmm1,xmm2/m64  ; Vergleiche niedere/s doppeltgenaue Gleitkommazahl in xmm1 und xmm2/mem64 und setze d. EFLAGS Flags entsprechend .#\
COMISS xmm1,xmm2/m32  ; Vergleiche niedere/s einfach-genaue Gleitkommazahl in xmm1 und xmm2/mem32 und setze d. EFLAGS Flags entsprechend .#\
CVTDQ2PD xmm1,xmm2/m64  ; Wandle_um zwei gepackte vorzeichenbehaftete/s Doppelwort Ganzzahlen von xmm2/m128 nach zwei gepackte doppeltgenaue Gleitkomma in xmm1.#\
CVTDQ2PS xmm1,xmm2/m128  ; Wandle_um vier gepackte vorzeichenbehaftete/s Doppelwort Ganzzahlen von xmm2/m128 nach vier gepackte einfach-genaue Gleitkomma in xmm1.#\
CVTPD2DQ xmm1,xmm2/m128  ; Wandle_um zwei gepackte doppeltgenaue Gleitkommazahl von xmm2/m128 nach zwei gepackte vorzeichenbehaftete/s Doppelwort Ganzzahlen in xmm1.#\
CVTPD2PI mm,xmm/m128  ; Wandle_um zwei gepackte doppeltgenaue Gleitkommazahl von xmm/m128 nach zwei gepackte vorzeichenbehaftete/s Doppelwort Ganzzahlen in mm.#\
CVTPD2PS xmm1,xmm2/m128  ; Wandle_um zwei gepackte doppeltgenaue Gleitkommazahl in xmm2/m128 nach zwei gepackte Einfach-genaue Gleitkomma in xmm1.#\
CVTPI2PD xmm,mm/m64  ; Wandle_um zwei gepackte vorzeichenbehaftete/s Doppelwort Ganzzahlen von mm/mem64 nach zwei gepackte doppeltgenaue Gleitkomma in xmm.#\
CVTPI2PS xmm,mm/m64  ; Wandle_um zwei vorzeichenbehaftete/s Doppelwort Ganzzahlen von mm/m64 nach zwei einfach-genaue Gleitkomma in xmm..#\
CVTPS2DQ xmm1,xmm2/m128  ; Wandle_um vier gepackte einfach-genaue Gleitkommazahl von xmm2/m128 nach vier gepackte vorzeichenbehaftete/s Doppelwort Ganzzahlen in xmm1.#\
CVTPS2PD xmm1,xmm2/m64  ; Wandle_um zwei gepackte einfach-genaue Gleitkommazahl in xmm2/m64 nach zwei gepackte doppeltgenaue Gleitkomma in xmm1.#\
CVTPS2PI mm,xmm/m64  ; Wandle_um zwei gepackte einfach-genaue Gleitkommazahl von xmm/m64 nach zwei gepackte vorzeichenbehaftete/s Doppelwort Ganzzahlen in mm.#\
CVTSD2SI r32,xmm/m64  ; Wandle_um ein doppeltgenaue Gleitkomma Wert von xmm/m64 nach ein vorzeichenbehaftete/s Doppelwort integer r32.#\
CVTSD2SS xmm1,xmm2/m64  ; Wandle_um ein doppeltgenaue Gleitkommazahl in xmm2/m64 nach ein einfach-genaue Gleitkomma Wert in xmm1.#\
CVTSI2SD xmm,r/m32  ; Wandle_um ein vorzeichenbehaftete/s Doppelwort integer von r/m32 nach ein doppeltgenaue Gleitkomma Wert in xmm.#\
CVTSI2SS xmm,r/m32  ; Wandle_um ein vorzeichenbehaftete/s Doppelwort integer von r/m32 nach ein einfach-genaue Gleitkomma Wert in xmm.#\
CVTSS2SD xmm1,xmm2/m32  ; Wandle_um ein einfach-genaue Gleitkommazahl in xmm2/m32 nach ein doppeltgenaue Gleitkomma Wert in xmm1.#\
CVTSS2SI r32,xmm/m32  ; Wandle_um ein einfach-genaue Gleitkommazahl von xmm/m32 nach ein vorzeichenbehaftete/s Doppelwort integer in r32.#\
CVTTPD2PI mm,xmm/m128  ; Wandle_um zwei packer doppeltgenaue Gleitkommazahl von xmm/m128 nach zwei gepackte vorzeichenbehaftete/s Doppelwort Ganzzahlen in mm, mit abschneiden.#\
CVTTPD2DQ xmm1,xmm2/m128  ; Wandle_um zwei gepackte doppeltgenaue Gleitkommazahl von xmm2/m128 nach zwei gepackte vorzeichenbehaftete/s Doppelwort Ganzzahlen in xmm1, mit abschneiden.#\
CVTTPS2DQ xmm1,xmm2/m128  ; Wandle_um vier einfach-genaue Gleitkommazahl von xmm2/m128 nach vier vorzeichenbehaftete/s Doppelwort Ganzzahlen in xmm1, mit abschneiden.#\
CVTTPS2PI mm,xmm/m64  ; Wandle_um zwei einfach-genaue Gleitkommazahl von xmm/m64 nach zwei vorzeichenbehaftete/s Doppelwort vorzeichenbehaftete/s Ganzzahlen in mm, mit abschneiden.#\
CVTTSD2SI r32,xmm/m64  ; Wandle_um ein doppeltgenaue Gleitkommazahl von xmm/m64 nach ein vorzeichenbehaftete/s Doppelwort integer in r32, mit abschneiden.#\
CVTTSS2SI r32,xmm/m32  ; Wandle_um ein einfach-genaue Gleitkommazahl von xmm/m32 nach ein vorzeichenbehaftete/s Doppelwort integer in r32, mit abschneiden.#\
DIVPD xmm1,xmm2/m128  ; Dividiere gepackte doppeltgenaue Gleitkommazahl in xmm1 durch gepackte doppeltgenaue Gleitkomma xmm2/m128.#\
DIVPS xmm1,xmm2/m128  ; Dividiere gepackte einfach-genaue Gleitkommazahl in xmm1durch gepackte einfach-genaue Gleitkomma xmm2/m128.#\
DIVSD xmm1,xmm2/m64  ; Dividiere niedere/s doppeltgenaue Gleitkommazahl n xmm1 durch niedere/s doppeltgenaue Gleitkomma Wert in xmm2/mem64.#\
DIVSS xmm1,xmm2/m32  ; Dividiere niedere/s einfach-genaue Gleitkommazahl in xmm1 durch niedere/s einfach-genaue Gleitkomma Wert in xmm2/m32#\
MASKMOVDQU xmm1,xmm2  ; Wähle_aus_und schreibe Bytes von xmm1 nach Speicherstelle unter_Verwendung_von d. Byte Maske in xmm2.#\
MAXPD xmm1,xmm2/m128  ; Retourniere d. Maximum der doppeltgenauen Gleitkommazahlzahlen in xmm2/m128 und xmm1.#\
MAXPS xmm1,xmm2/m128  ; Retourniere d. Maximum der einfach-genaue Gleitkommazahl in xmm2/m128 und xmm1.#\
MAXSD xmm1,xmm2/m64  ; Retourniere d. Maximumwert d. doppeltgenauen Gleitkommazahlen in xmm2/mem64 und xmm1.#\
MAXSS xmm1,xmm2/m32  ; Retourniere d. Maximumwert einfach-genaue Gleitkommazahl in xmm2/mem32 und xmm1.#\
MINPD xmm1,xmm2/m128  ; Retourniere d. Minimum der doppeltgenauen Gleitkommazahlen in xmm2/m128 und xmm1.#\
MINPS xmm1,xmm2/m128  ; Retourniere d. Minimum einfach-genauen Gleitkommazahlen in xmm2/m128 und xmm1.#\
MINSD xmm1,xmm2/m64  ; Retourniere d. Minimumwert der doppeltgenauen Gleitkommazahleb in xmm2/mem64 und xmm1.#\
MINSS xmm1,xmm2/m32  ; Retourniere d. Minimumwert der einfach-genauen Gleitkommazahlen in xmm2/mem32 und xmm1.#\
MOVAPD xmm1,xmm2/m128  ; Bewege gepackte doppeltgenaue Gleitkommazahl von xmm2/m128 nach xmm1.#\
MOVAPD xmm2/m128,xmm1  ; Bewege gepackte doppeltgenaue Gleitkommazahl von xmm1 nach xmm2/m128.#\
MOVAPS xmm1,xmm2/m128  ; Bewege gepackte einfach-genaue Gleitkommazahl von xmm2/m128 nach xmm1.#\
MOVAPS xmm2/m128,xmm1  ; Bewege gepackte einfach-genaue Gleitkommazahl von xmm1 nach xmm2/m128.#\
MOVD xmm,r/m32  ; Bewege Doppelwort von r/m32 nach xmm.#\
MOVD r/m32,xmm  ; Bewege Doppelwort von xmm Register nach r/m32.#\
MOVDQA xmm1,xmm2/m128  ; Bewege ausgerichtet double Quadword von xmm2/m128 nach xmm1.#\
MOVDQA xmm2/m128,xmm1  ; Bewege ausgerichtet double Quadword von xmm1 nach xmm2/m128.#\
MOVDQU xmm1,xmm2/m128  ; Bewege un-ausgerichtet DoubleQuadword von xmm2/m128 nach xmm1.#\
MOVDQU xmm2/m128,xmm1  ; Bewege un-ausgerichtet DoubleQuadword von xmm1 nach xmm2/m128.#\
MOVDQ2Q mm,xmm  ; Bewege niedere/s Quadword von xmm nach mmx Register .#\
MOVHLPS xmm1,xmm2  ; Bewege zwei gepackte einfach-genaue Gleitkommazahl von high Quadword von xmm2 nach niedere/s Quadword von xmm1.#\
MOVHPD xmm,m64  ; Bewege doppeltgenaue Gleitkommazahl von m64 nach high Quadword von xmm.#\
MOVHPD m64,xmm  ; Bewege doppeltgenaue Gleitkommazahl von high Quadword von xmm nach m64.#\
MOVHPS xmm,m64  ; Bewege zwei gepackte einfach-genaue Gleitkommazahl von m64 nach high Quadword von xmm.#\
MOVHPS m64,xmm  ; Bewege zwei gepackte einfach-genaue Gleitkommazahl von high Quadword von xmm nach m64.#\
MOVLHPS xmm1,xmm2  ; Bewege zwei gepackte einfach-genaue Gleitkommazahl von niedere/s Quadword von xmm2 nach high Quadword von xmm1.#\
MOVLPD xmm,m64  ; Bewege doppeltgenaue Gleitkommazahl von m64 nach niedere/s Quadword von xmm register.#\
MOVLPD m64,xmm  ; Bewege doppeltgenaue Gleitkommazahl von niedere/s Quadword von xmm Register nach m64.#\
MOVLPS xmm,m64  ; Bewege zwei gepackte einfach-genaue Gleitkommazahl von m64 nach niedere/s Quadword von xmm.#\
MOVLPS m64,xmm  ; Bewege zwei gepackte einfach-genaue Gleitkommazahl von niedere/s Quadword von xmm nach m64.#\
MOVMSKPD r32,xmm  ; Extract 2-bit Vorzeichen Maske von von xmm und speichere in r32.#\
MOVMSKPS r32,xmm  ; Extract 4-bit Vorzeichen Maske von von xmm und speichere in r32.#\
MOVNTDQ m128,xmm  ; Bewege double Quadword von xmm nach m128 unter_Verwendung_von nontemporal hint.#\
MOVNTPD m128,xmm  ; Bewege gepackte doppeltgenaue Gleitkommazahl von xmm nach m128 unter_Verwendung_von Nicht-Zwischenspeicherungswürdigkeits-Hinweis .#\
MOVNTPS m128,xmm  ; Bewege gepackte einfach-genaue Gleitkommazahl von xmm nach m128 unter_Verwendung_von Nicht-Zwischenspeicherungswürdigkeits-Hinweis .#\
MOVQ xmm1,xmm2/m64  ; Bewege Quadword von xmm2/mem64 nach xmm1.#\
MOVQ xmm2/m64,xmm1  ; Bewege Quadword von xmm1 nach xmm2/mem64.#\
MOVQ2DQ xmm,mm  ; Bewege Quadword von mmx nach niedere/s Quadword von xmm.#\
MOVSD xmm1,xmm2/m64  ; Bewege Einzelwert doppeltgenaue Gleitkommazahl von xmm2/m64 nach xmm1 register.#\
MOVSD xmm2/m64,xmm  ; Bewege Einzelwert doppeltgenaue Gleitkommazahl von xmm1 Register nach xmm2/m64.#\
MOVSS xmm1,xmm2/m32  ; Bewege Einzelwert einfach-genaue Gleitkommazahl von xmm2/m64 nach xmm1 register.#\
MOVSS xmm2/m32,xmm  ; Bewege Einzelwert einfach-genaue Gleitkommazahl von xmm1 Register nach xmm2/m64.#\
MOVUPD xmm1,xmm2/m128  ; Bewege gepackte doppeltgenaue Gleitkommazahl von xmm2/m128 nach xmm1.#\
MOVUPD xmm2/m128,xmm  ; Bewege gepackte doppeltgenaue Gleitkommazahl von xmm1 nach xmm2/m128.#\
MOVUPS xmm1,xmm2/m128  ; Bewege gepackte einfach-genaue Gleitkommazahl von xmm2/m128 nach xmm1.#\
MOVUPS xmm2/m128,xmm1  ; Bewege gepackte einfach-genaue Gleitkommazahl von xmm1 nach xmm2/m128.#\
MULPD xmm1,xmm2/m128  ; Multipliziere gepackte doppeltgenaue Gleitkommazahl in xmm2/m128 um/durch xmm1.#\
MULPS xmm1,xmm2/m128  ; Multipliziere gepackte einfach-genaue Gleitkommazahl in xmm2/mem um/durch xmm1.#\
MULSD xmm1,xmm2/m64  ; Multipliziere d. niedere/s doppeltgenaue Gleitkommazahl in xmm2/mem64 mit d. niedere/s doppeltgenaue Gleitkommazahl in xmm1.#\
MULSS xmm1,xmm2/m32  ; Multipliziere d. niedere/s einfach-genaue Gleitkommazahl  in xmm2/mem mit d. niedere/s einfach-genaue Gleitkomma in xmm1.#\
ORPD xmm1,xmm2/m128  ; Bit-weises OR von xmm2/m128 und xmm1.#\
ORPS xmm1,xmm2/m128  ; Bit-weises OR von xmm2/m128 und xmm1#\
PACKSSWB xmm1,xmm2/m128  ; Wandelt_um 8 gepackte vorzeichenbehaftete/s Word Ganzzahlen von xmm1 und von xmm2/m128 hinein_in 16 gepackte vorzeichenbehaftete/s Byte Ganzzahlen in xmm1 unter_Verwendung_von vorzeichenbehaftete/s Endbegrenzung der Werte.#\
PACKSSDW xmm1,xmm2/m128  ; Wandelt_um 4 gepackte vorzeichenbehaftete/s Doppelwort Ganzzahlen von xmm1 und von xmm2/m128 hinein_in 8 gepackte vorzeichenbehaftete/s Word Ganzzahlen in xmm1 unter_Verwendung_von vorzeichenbehaftete/s Endbegrenzung der Werte.#\
PACKUSWB xmm1,xmm2/m128  ; Wandelt_um 8 vorzeichenbehaftete/s Word Ganzzahlen von xmm1 und 8 vorzeichenbehaftete/s Word Ganzzahlen von xmm2/m128 hinein_in 16 vorzeichenlose Byte Ganzzahlen in xmm1 unter_Verwendung_von vorzeichenlose Endbegrenzung der Werte.#\
PADDB xmm1,xmm2/m128  ; Addiere gepackte Byte Ganzzahlen von xmm2/m128 und xmm1.#\
PADDW xmm1,xmm2/m128  ; Addiere gepackte Word Ganzzahlen von xmm2/m128 und xmm1.#\
PADDD xmm1,xmm2/m128  ; Addiere gepackte Doppelwort Ganzzahlen von xmm2/m128 und xmm1.#\
PADDQ xmm1,xmm2/m128  ; Addiere gepackte Quadword Ganzzahlen xmm2/m128 nach xmm1#\
PADDSB xmm1,xmm2/m128  ; Addiere gepackte vorzeichenbehaftete/s Byte Ganzzahlen von xmm2/m128 und xmm1, endbegrenze d. Resultate .#\
PADDSW xmm1,xmm2/m128  ; Addiere gepackte vorzeichenbehaftete/s Word Ganzzahlen von xmm2/m128 und xmm1 und endbegrenze die Ergebnisse.#\
PADDUSB xmm1,xmm2/m128  ; Addiere gepackte vorzeichenlose Byte Ganzzahlen von xmm2/m128 und xmm1 endbegrenze die Ergebnisse.#\
PADDUSW xmm1,xmm2/m128  ; Addiere gepackte vorzeichenlose Word Ganzzahlen von xmm2/m128 nach xmm1 und endbegrenze die Ergebnisse.#\
PAND xmm1,xmm2/m128  ; Bit-weises AND von xmm2/m128 und xmm1.#\
PANDN xmm1,xmm2/m128  ; Bit-weises AND NOT von xmm2/m128 und xmm1.#\
PAVGB xmm1,xmm2/m128  ; Bilde Durchschnittswert aus gepackten vorzeichenlosen Byte Ganzzahlen von xmm2/m128 und xmm1 mit Rundung .#\
PAVGW xmm1,xmm2/m128  ; Bilde Durchschnittswert aus gepackten vorzeichenlosen Word Ganzzahlen von xmm2/m128 und xmm1 mit Rundung .#\
PCMPEQB xmm1,xmm2/m128  ; Vergleiche gepackte Bytes in xmm2/m128 und xmm1 für/auf equality.#\
PCMPEQW xmm1,xmm2/m128  ; Vergleiche gepackte words in xmm2/m128 und xmm1 für/auf equality.#\
PCMPEQD xmm1,xmm2/m128  ; Vergleiche gepackte doublewords in xmm2/m128 und xmm1 für/auf equality.#\
PCMPGTB xmm1,xmm2/m128  ; Vergleiche gepackte vorzeichenbehaftete/s Byte Ganzzahlen in xmm1 und xmm2/m128 für/auf größer als .#\
PCMPGTW xmm1,xmm2/m128  ; Vergleiche gepackte vorzeichenbehaftete/s Word Ganzzahlen in xmm1 und xmm2/m128 für/auf größer als .#\
PCMPGTD xmm1,xmm2/m128  ; Vergleiche gepackte vorzeichenbehaftete/s Doppelwort Ganzzahlen in xmm1 und xmm2/m128 für/auf größer als .#\
PEXTRW r32,xmm,imm8  ; Extract d. Word specified um/durch imm8 von xmm und move it nach a r32.#\
PINSRW xmm,r32/m16,imm8  ; Bewege d. niedere/s Word von r32 oder von m16 hinein_in xmm bei d. Word position specified um/durch imm8.#\
PMADDWD xmm1,xmm2/m128  ;  Multiply d. gepackte Word Ganzzahlen in xmm1 um/durch d. gepackte Word Ganzzahlen in xmm2/m128, add adjacent Doppelwort Resultate , und speichere in xmm1.#\
PMAXSW xmm1,xmm2/m128  ; Vergleiche vorzeichenbehaftete/s Word Ganzzahlen in xmm2/m128 und xmm1 und Rückgabe Maximum Werte.#\
PMAXUB xmm1,xmm2/m128  ; Vergleiche vorzeichenlose Byte Ganzzahlen in xmm2/m128 und xmm1 und gib_zurück Maximum-Werte.#\
PMINSW xmm1,xmm2/m128  ; Vergleiche vorzeichenbehaftete/s Word Ganzzahlen in xmm2/m128 und xmm1 und Rückgabe Minimum-Werte.#\
PMINUB xmm1,xmm2/m128  ; Vergleiche vorzeichenlose Byte Ganzzahlen in xmm2/m128 und xmm1 und gib_zurück d. Minimum Werte.#\
PMOVMSKB r32,xmm  ; Bewege a Byte Maske von xmm nach r32.#\
PMULHUW xmm1,xmm2/m128  ; Multiply d. gepackte vorzeichenlose Word Ganzzahlen in xmm1 und xmm2/m128, und speichere d. high 16 bits von d. Resultate  in xmm1.#\
PMULHW xmm1,xmm2/m128  ; Multiply d. gepackte vorzeichenbehaftete/s Word Ganzzahlen in xmm1 und xmm2/m128, und speichere d. high 16 bits von d. Resultate  in xmm1.#\
PMULLW xmm1,xmm2/m128  ; Multiply d. gepackte vorzeichenbehaftete/s Word Ganzzahlen in xmm1 und xmm2/m128, und speichere d. niedere/s 16 bits von d. Resultate  in xmm1.#\
PMULUDQ xmm1,xmm2/m128  ; Multiply gepackte vorzeichenlose Doppelwort Ganzzahlen in xmm1 um/durch gepackte vorzeichenlose Doppelwort Ganzzahlen in xmm2/m128, und speichere d. Quadword Resultate  in xmm1.#\
POR xmm1,xmm2/m128  ; Bit-weises OR von xmm2/m128 und xmm1.#\
PSADBW xmm1,xmm2/m128  ; Berechnet d. absolut differences von d. gepackte vorzeichenlose Byte Ganzzahlen von xmm2 /m128 und xmm1; d. 8 niedere/s differences und 8 high differences are then summed separately nach produce zwei vorzeichenlose Word integer Resultate .#\
PSHUFD xmm1,xmm2/m128,imm8  ; Shuffle d. doublewords in xmm2/m128 based auf/zu/bereffs d. encoding in imm8 und speichere d. Ergebnis in xmm1.#\
PSHUFHW xmm1,xmm2/m128,imm8  ; Shuffle d. high words in xmm2/m128 based auf/zu/bereffs d. encoding in imm8 und speichere d. Ergebnis in xmm1.#\
PSHUFLW xmm1,xmm2/m128,imm8  ; Shuffle d. niedere/s words in xmm2/m128 based auf/zu/bereffs d. encoding in imm8 und speichere d. Ergebnis in xmm1.#\
PSLLDQ xmm1,imm8  ; Schiebe xmm1 nach links um imm8 Bytes während Nullen hereingeschoben werden.#\
PSLLW xmm1,xmm2/m128  ; Schiebe words in xmm1 nach links um xmm2/m128 während Nullen nachgeschoben werden.#\
PSLLW xmm1,imm8  ; Schiebe words in xmm1 links um/durch imm8 während Nullen Nachgeschoben werden.#\
PSLLD xmm1,xmm2/m128  ; Schiebe doublewords in xmm1 links um/durch xmm2/m128 während Nullen Nachgeschoben werden.#\
PSLLD xmm1,imm8  ; Schiebe doublewords in xmm1 links um/durch imm8 während Nullen Nachgeschoben werden.#\
PSLLQ xmm1,xmm2/m128  ; Schiebe Quadwords in xmm1 links um/durch xmm2/m128 während Nullen Nachgeschoben werden.#\
PSLLQ xmm1,imm8  ; Schiebe Quadwords in xmm1 links um/durch imm8 während Nullen nachgeschoben werden#\
PSRAW xmm1,xmm2/m128  ; Schiebe words in xmm1 rechts um/durch xmm2/m128 while verschiebe in Vorzeichen bits.#\
PSRAW xmm1,imm8  ; Schiebe words in xmm1 rechts um/durch imm8 while verschiebe in Vorzeichen bits#\
PSRAD xmm1,xmm2/m128  ; Schiebe Doppelwort in xmm1 rechts um/durch xmm2 /m128 while verschiebe in Vorzeichen bits.#\
PSRAD xmm1,imm8  ; Schiebe doublewords in xmm1 rechts um/durch imm8 while verschiebe in Vorzeichen bits.#\
PSRLDQ xmm1,imm8  ; Schiebe xmm1 rechts um/durch imm8 while verschiebe in 0s.#\
PSRLW xmm1,xmm2/m128  ; Schiebe words in xmm1 rechts um/durch amount angegeben in xmm2/m128 while verschiebe in 0s.#\
PSRLW xmm1,imm8  ; Schiebe words in xmm1 rechts um/durch imm8 while verschiebe in 0s.#\
PSRLD xmm1,xmm2/m128  ; Schiebe doublewords in xmm1 rechts um/durch amount angegeben in xmm2 /m128 while verschiebe in 0s.#\
PSRLD xmm1,imm8  ; Schiebe doublewords in xmm1 rechts um/durch imm8 while verschiebe in 0s.#\
PSRLQ xmm1,xmm2/m128  ; Schiebe Quadwords in xmm1 rechts um/durch amount angegeben in xmm2/m128 while verschiebe in 0s.#\
PSRLQ xmm1,imm8  ; Schiebe Quadwords in xmm1 rechts um/durch imm8 while verschiebe in 0s.#\
PSUBB xmm1,xmm2/m128  ; Subtrahiere gepackte Byte Ganzzahlen in xmm2/m128 von gepackte Byte Ganzzahlen in xmm1.#\
PSUBW xmm1,xmm2/m128  ; Subtrahiere gepackte Word Ganzzahlen in xmm2/m128 von gepackte Word Ganzzahlen in xmm1.#\
PSUBD xmm1,xmm2/m128  ; Subtrahiere gepackte Doppelwort Ganzzahlen in xmm2/mem128 von gepackte Doppelwort Ganzzahlen in xmm1.#\
PSUBQ xmm1,xmm2/m128  ; Subtrahiere gepackte Quadword Ganzzahlen in xmm1 von xmm2 /m128.#\
PSUBSB xmm1,xmm2/m128  ; Subtrahiere gepackte vorzeichenbehaftete/s Byte Ganzzahlen in xmm2/m128 von gepackte vorzeichenbehaftete/s Byte Ganzzahlen in xmm1 und endbegrenze Resultate .#\
PSUBSW xmm1,xmm2/m128  ; Subtrahiere gepackte vorzeichenbehaftete/s Word Ganzzahlen in xmm2/m128 von gepackte vorzeichenbehaftete/s Word Ganzzahlen in xmm1 und endbegrenze Resultate .#\
PSUBUSB xmm1,xmm2/m128  ; Subtrahiere gepackte vorzeichenlose Byte Ganzzahlen in xmm2/m128 von gepackte vorzeichenlose Byte Ganzzahlen in xmm1 und endbegrenze Resultat.#\
PSUBUSW xmm1,xmm2/m128  ; Subtrahiere gepackte vorzeichenlose Word Ganzzahlen in xmm2/m128 von gepackte vorzeichenlose Word Ganzzahlen in xmm1 und endbegrenze Resultat.#\
PUNPCKHBW xmm1,xmm2/m128  ; Entpacke und verschneide oberes Bytes von xmm1 und xmm2/m128 hinein_in xmm1.#\
PUNPCKHWD xmm1,xmm2/m128  ; Entpacke und verschneide oberes words von xmm1 und xmm2/m128 hinein_in xmm1.#\
PUNPCKHDQ xmm1,xmm2/m128  ; Entpacke und verschneide oberes doublewords von xmm1 und xmm2/m128 hinein_in xmm1.#\
PUNPCKHQDQ xmm1,xmm2/m128  ; Entpacke und verschneide oberes Quadwords von xmm1 und xmm2/m128 hinein_in xmm1#\
PUNPCKLBW xmm1,xmm2/m128  ; Verzahne niederwertige Bytes von xmm1 und xmm2/m128 hinein_in xmm1.#\
PUNPCKLWD xmm1,xmm2/m128  ; Verzahne niederwertige Words von xmm1 und xmm2/m128 hinein_in xmm1.#\
PUNPCKLDQ xmm1,xmm2/m128  ; Verzahne  niederwertige Doublewords von xmm1 und xmm2/m128 hinein_in xmm1.#\
PUNPCKLQDQ xmm1,xmm2/m128  ; Verzahne  niederwertige Quadwords von xmm1 und xmm2/m128 hinein_in xmm1 register#\
PXOR xmm1,xmm2/m128  ; Bit-weises XOR von xmm2/m128 und xmm1.#\
RCPPS xmm1,xmm2/m128  ; Berechnet d. ungefähren Kehrwerte von gepackten einfach-genaue Gleitkommawerten in xmm2/m128 und speichere d. Resultate  in xmm1.#\
RCPSS xmm1,xmm2/m32  ; Berechnet d. ungefähres reciprocal von d. Einzelwert einfach-genaue Gleitkommazahl in xmm2/m32 und speichere d. Ergebnis in xmm1.#\
RSQRTPS xmm1,xmm2/m128  ; Berechnet d. ungefähres Kehrwerte von d. square roots von d. gepackte einfach-genaue Gleitkommazahl in xmm2/m128 und speichere d. Resultate  in xmm1. #\
RSQRTSS xmm1,xmm2/m32  ; Berechnet d. ungefähres reciprocal von d. Quadratwurzel von d. niedere/s einfach-genaue Gleitkommazahl in xmm2/m32 und speichere d. Resultate  in xmm1.#\
SHUFPD xmm1,xmm2/m128,imm8  ; Verkämme gepackte doppeltgenaue Gleitkommazahl gemäß Auswahl in imm8 von xmm1 und xmm1/m128 nach xmm1.#\
SHUFPS xmm1,xmm2/m128,imm8  ; Verkämme gepackte einfach-genaue Gleitkommazahl gemäß Auswahl in imm8 von xmm1 und xmm1/m128 nach xmm1.#\
SQRTPD xmm1,xmm2/m128  ; Berechnet square roots von d. gepackte doppeltgenaue Gleitkommazahl in xmm2/m128 und speichere d. Resultate  in xmm1.#\
SQRTPS xmm1,xmm2/m128  ; Berechnet square roots von d. gepackte einfach-genaue Gleitkommazahl in xmm2/m128 und speichere d. Resultate  in xmm1.#\
SQRTSD xmm1,xmm2/m64  ; Berechnet Quadratwurzel von d. niedere/s doppeltgenaue Gleitkommazahl in xmm2/m64 und speichere d. Resultate  in xmm1.#\
SQRTSS xmm1,xmm2/m32  ; Berechnet Quadratwurzel von d. niedere/s einfach-genaue Gleitkommazahl in xmm2/m32 und speichere d. Resultate  in xmm1.#\
SUBPD xmm1,xmm2/m128  ; Subtrahiere gepackte doppeltgenaue Gleitkommazahl in xmm2/m128 von xmm1.#\
SUBPS xmm1 xmm2/m128  ; Subtrahiere gepackte einfach-genaue Gleitkommazahl in xmm2/mem von xmm1.#\
SUBSD xmm1,xmm2/m64  ; Subtrachiere d. niedere doppeltgenaue Gleitkommazahl in xmm2/mem64 von xmm1.#\
SUBSS xmm1,xmm2/m32  ; Subtrahiere d. geringer einfach-genaue Gleitkommazahl in xmm2/m32 von xmm1.#\
UCOMISD xmm1,xmm2/m64  ;  Vergleicht (unordered) d. niedere/s doppeltgenaue Gleitkommazahl in xmm1 und xmm2/m64 und setze d. EFLAGS entsprechend .#\
UCOMISS xmm1,xmm2/m32  ; Vergleiche geringer einfach-genaue Gleitkommazahl in xmm1 Register mit geringer einfach-genaue Gleitkommazahl in xmm2/mem und setze d. StatusFlags entsprechend .#\
UNPCKHPD xmm1,xmm2/m128  ; Entpackt und verschneidet doppeltgenaue Gleitkommazahl von high Quadwords von xmm1 und xmm2/m128.#\
UNPCKHPS xmm1,xmm2/m128  ; Entpackt und verschneidet einfach-genaue Gleitkommazahl von high Quadwords von xmm1 und xmm2/mem hinein_in xmm1.#\
UNPCKLPD xmm1,xmm2/m128  ; Entpackt und verschneidet doppeltgenaue Gleitkommazahl von niedere/s Quadwords von xmm1 und xmm2/m128.#\
UNPCKLPS xmm1,xmm2/m128  ; Entpackt und verschneidet einfach-genaue Gleitkommazahl von niederen Quadwords von xmm1 und xmm2/mem hinein_in xmm1.#\
XORPD xmm1,xmm2/m128  ; Bit-weises XOR von xmm2/m128 und xmm1#\
XORPS xmm1,xmm2/m128  ; Bit-weises XOR von xmm2/m128 und xmm1\
","#")
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$[]
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 · 20.01.2012, 20:39

Quizfrage an den kleinen Gauß:
----------------------------------
Die höchste positive darstellbare Integerzahl mit 4-Byte Long& Variablen ist bekanntlich 2147483647. Was ist die höchste Zahl, deren Summe von 1 bis zu ebendieser höchsten Zahl noch innerhalb dieses positiven Zahlenbereiches bleibt?

Vorsicht: Mit dem nachfolgenden Programm selbst ist diese Grenze nicht ermittelbar, weil XProfan mit Floatingpointwerten rechnet, sobald irgendwo ein * oder / Zeichen auftaucht:

Code:

WindowTitle "Der kleine Gauß"
Font 2: Randomize
Set("Decimals",0)
Declare sum!,n&,Ende%
Repeat
CLS rnd(8^8)
Print "\n Aufsummieren aller Zahlen von 1 bis: ";
Input n&
if n& mod 2
  print " Gescheite Formel für n=ungerade liefert: ";
  print (int(n&/2)+1)*n&
  print " Beweis durch doofe Laufsumme: ";
  WhileLoop n&
  sum!=sum!+&Loop
  EndWhile
else
  print " Gescheite Formel für n=gerade liefert: ";
  print n&/2*(n&+1)
  print " Beweis durch doofe Laufsumme: ";
  WhileLoop n&
  sum!=sum!+&Loop
  EndWhile
Endif
Print Sum!
WaitInput
Sum!=0
Until Ende%

P.S.: Damit geht´s schon eher:

Code:

WindowTitle "Verkehrter kleiner Gauß"
Font 2
Randomize
set("Decimals",0)
Declare sum!,n!,n&,Ende%,Sum1!
Repeat
CLS rnd(8^8)
AppendMenuBar 10,"Mein Gehirn ist mir mein zweitliebstes Organ. (Woody Allen)"
Print "\n Aufsummiert ab 1 bis zu der hier gesuchten Zahl "
print " ergab sich in etwa folgende Summe:              ";
positiv:
locate 3,38: Input Sum!
case Sum!<0: goto "positiv"
' Die allgemeingültige Gaußformel ist umzukehren: ";
' Sum! = n!/2*(n!+1), umgeformt:
' n^2/2 + n/2 = Sum , bzw. in "homogener" Form geschrieben:
' x^2   + x - 2*Sum = 0 ...also eine Quadratische Gleichung
' Anwendung der 'Mitternachtsformel':
' x1= - 1/2 + sqrt((1/2)^2+2*SUM)
' x2= - 1/2 - sqrt((1/2)^2+2*SUM)= Negativ, also irrelevant

n!= -0.5 + sqrt( 0.25+2*Sum!)
set("Decimals",18)
Print " Die Zahl lag bei: "; n!
set("Decimals",0)
Print " Probe:"
n&=int(n!)
sum1!=0
WhileLoop n&
sum1!=sum1!+&Loop
Endwhile
print " Summe von 1 bis "+str$(n&)+" = "+str$(sum1!);
case sum!>sum1!: print ", also "+str$(sum!-sum1!)+" darunter!"
if n!<>n&
sum1!=0
WhileLoop n&+1
sum1!=sum1!+&Loop
Endwhile
print " Summe von 1 bis "+str$(n&+1)+" = "+str$(sum1!);
case sum!<sum1!: print ", also "+str$(sum1!-sum!)+" darüber!"
EndIf
print
WaitInput
Until Ende%

Jonathan · 21.01.2012, 16:01

Du meinst sowas?:

Zahl: 5
1+2+3+4+5

Jonathan · 21.01.2012, 16:17

Ach Mist, sehe gerade, ich habe die selbe Lösung wie Du...

p. specht · 21.01.2012, 17:38

Genau: 65535 als Endwert einer Summe von 1 - 65535 bleibt gerade noch im gewünschten Zahlenbereich. Ab 65536 benötigen wird schon Floatingpoint-Variablen, um Overflow zu vermeiden

p. specht · 26.01.2012, 03:08

Abt. "Die n. Permutation im Lucas-Lehmer-Code darstellen"
=====================================
Dezimalzahlen sind so aufgebaut, daß links neu dazukommende Stellen jeweils um den Faktor 10 mehr wert sind als die vorherige Stelle rechts davon.

Lucas-Lehmer-Zahlen sind so aufgebaut, daß die Basis nicht fix 10 ist, sondern sich mit der Stellenzahl ändert. Der Stellenwert ist also nicht 10^(Stellenzahl-1) ist, sondern "Produkt aller Zahlen von 1 bis (Stellenzahl-1)".

Solche "Zahlen" haben die besondere Eigenschaft, daß sie lexikalische Permutationen von Elementen "ein-eindeutig" kennzeichnen. Man kann also z.B. die 12.354ste Umordnung (Permutation) der Elemente A B C D E F G H I direkt damit erzeugen, und muss nicht von 0 bis dorthin alle Umordnungen der Reihe nach ermitteln, um das herauszubekommen. Auch die umgekehrte Fragestellung ("Die wievielte Permutation ist dieses vorgegebene Muster eigentlich?") lässt sich so leichter klären. Praktische Anwendungen finden die Lucas-Lehmer-Codes z.B. beim Knacken von RSA-Cryptosystemen.

Hier ein kurzes Programm, das die (dezimal) n.te Umordnung in den Lucas-Lehmer-Code wandelt:

Code:

WindowTitle "Permutationen im eindeutigen Lucas-Lehmer Code darstellen"
CLS
AppendMenuBar 10, "Summe aufeinanderfolgenden Fakultäten mal ihrem Index ist Nächste_Fakultät-1"
' "http://de.wikipedia.org/wiki/Fakult%C3%A4tsbasiertes_Zahlensystem"
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*1.5 : var v%= 480*1.5
Window (u%-xr%)*xf!+xr%, (v%-yr%)*yf!+yr%
SetWindowPos %HWnd=(%maxx-u%)/2,((%maxy-v%)/2) - u%,v%
Declare s$,s!,n!,m!,m&,mmax&,prod!,lprod!,w&[200]

set("decimals",0)
Font 2:randomize
nomoi:
CLS rnd(8^8)
Print " Zugrundeliegende Frage: Welches Produkt aller Integerzahlen von n bis 1 "
Print " ergibt ein bestimmtes Ergebnis 'Fakultät von n' = \n ";
Input s$
s!=val(s$)
Print "\n (Rest)-Laufprodukt:"

ausloten:
prod!=1
WhileLoop 2147483647
  n!=&Loop
  lprod!=prod!
  Prod!=Prod!*n!
  case Prod!>S!:break
EndWhile
'print " Drüber:  Produkt 1 .. "; n!;" mit Produkt ";tab(40);Prod!
'print " Drunter: Produkt 1 .. "; n!-1; " mit Produkt ";tab(40);LProd!
m!=n!-1
m&=m!
case mmax&<m&:mmax&=m&
'print m!,
w&[m&]=w&[m&]+1
S!=s!-LProd!
case s!>0: goto "ausloten"


print
print 
'print " = ";mmax&;":";
WhileLoop mmax&,0,-1
  if W&[&Loop]>9:print "'";
      if W&[&Loop]>99:print "'";
        if W&[&Loop]>999:print "'";
        endif
      endif
  endif
  print W&[&Loop];
  'case (&Loop>1):print ",";
  
EndWhile

WaitInput
clear w&[]
mmax&=0
goto "nomoi"

'  Beispiel, um die n. Permuation tatsächlich zu ermitteln:
'  
'  "4041000" = 4*6!+0*5!+1*3!+0*2!+0*1!
'  Stellenwert = (len-pos)! = (7-1)! = 6!
'  Permutation erzeugen aus Fakultätsbasierter Zahl:
'  ps: 0123456
'  -4  0123456	4
'  -0  012356	0
'  -4  12356 	6
'  -1  1235		2		
'  -0  135		1
'  -0  35		3
'  -0  5              5

Die 4.041.000 Anordnung ist also: "4062135"

P.S.: Details hier

p. specht · 29.01.2012, 20:46

Abt. Simuliertes Gehirn auf Ähnlichkeitssuche in Film-, Musik- und Literaturdatenbanken
======================================================

Gnod - The global network of dreams
Hier die Deutsche Version.
Es gibt dafür aber auch viele andere Anwendungsmöglichkeiten, siehe hier.
Eine Einführung findet man hier.

Gruss

P.S.: Wir scheinen also tatsächlich im 21. Jahrhundert angekommen zu sein. Vielleicht sollte man sich viel mehr damit beschäftigen! Interessante Links auch: Hopfield-Netz, Neocognitron, Adaline-Modell

**Frabbing** · 05.02.2012, 12:45

Klappt sogar einigermassen.

p. specht · 05.02.2012, 16:33

Kleine Schatzkiste dazu gefunden: ÖFFNEN

**Frabbing** · 05.02.2012, 21:38

Da hat sich aber jemand richtig Arbeit gemacht.

**AHT** · 11.02.2012, 16:41

Absolut unnötig:

Code:

'#####################################################################################
'#########         Nicht mehr erscheinde Messagebox                          #########
'#########             Code von AHT                                          #########
'#########      Gepostet für Startseite - Paules-PC-Forum.de                   #########
'#####################################################################################

Declare MessageText$, Ret&, Caption$, RegString$, RET$
CLS
RegString$ = "Ich bin Blöd!!!!!!!!!!!!!!!!!!!!!!"
MessageText$ = "Soll ich eine Ton machen?"
Caption$ = "Kurze Frage..."
Set("ErrorLevel", -1)
RET$ = ReadIni$("HKEY_1","Software\Microsoft\Windows\CurrentVersion\Explorer\DontShowMeThisDialogAgain", RegString$)
Print RET$
IF RET$ = "NO"
 Ret& = val(ReadIni$("HKEY_1", "Software\AHT", RegString$))
endif
Set("ErrorLevel", -1)
While Ret& <> 2
 Ret& = External("Shlwapi", "SHMessageBoxCheckA", %HWND, addr(MessageText$), addr(Caption$), $4 | $40, Ret&, addr(RegString$))
 Writeini "HKEY_1", "Software\AHT", RegString$ = str$(Ret&)
 Print Ret&
 If Ret& <> 2
  Sleep 500
  Sleep 500
  Sleep 500
  Sleep 500
  Sleep 500
  Sleep 500
 endif
 If Ret& = 6
  SOUND 440,360
 endif
Wend

16.01.2012, 22:01	#16 (Direktlink)
Frabbing Super-Moderator Registriert seit: 05.02.2009 Ort: Westliches NRW Alter: 44 Beiträge: 5.089	Schon gemein. __________________ Gruß, Frank Webpage http://frabbing.bplaced.net mit Freeware - Tools, Spiele und Grafiken.

17.01.2012, 13:48	#17 (Direktlink)
p. specht Dauergast Registriert seit: 06.02.2009 Ort: Wien, Österreich Beiträge: 1.078	Abt. Grau ist alle Theorie ================ Mit Floating-Point-Ganzzahlen könnte man im Bereich +/- 9007199254740992 fehlerfrei bits indexieren, - nimmt man das Vorzeichenbit auch noch mit, dann geht der Bereich von 0 - 18,014,398,509,481,984. Theoretisch könnte man damit ein Erathostenes-Filter für ca. die ersten 720 Bio. Primzahlen aufbauen (Geschätzte Primzahldichte etwas unter 4%) - allerdings: Wo speichern wir die 2048 Terabyte der Bitleiste? (Von der Rechenzeit gar nicht zu reden...). Selbst wenn wir Runlenght-Encoden ist das noch immer gewaltig... Gruss P.S.: Hier hat jemand MIRPZAHLEN gefunden - finde ich Essalk!! __________________ Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,XPSE,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB2:USB3 Geändert von p. specht (17.01.2012 um 13:58 Uhr)

17.01.2012, 20:14	#19 (Direktlink)
p. specht Dauergast Registriert seit: 06.02.2009 Ort: Wien, Österreich Beiträge: 1.078	Abt. Heizkostensenkung durch CPU-Abwärme ============================ CPU-Temperaturen sind bei modernen Prozessoren voll im Griff, schlimmstenfalls taktet die CPU runter. Bei Mehrkernsystemen ist das ganze noch feiner ausgeklügelt. Wer allerdings einen XP-Rechner sein kosiges Eigen nennen darf, den könnte vielleicht doch interessieren wie heiß die Spinnweben da drinnen werden: Hier gibts Software-Temperatur- und Lüftermonitoren dazu. P.S.: Auch für Mehrkerner grade was gefunden... __________________ Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,XPSE,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB2:USB3 Geändert von p. specht (17.01.2012 um 20:28 Uhr)

21.01.2012, 16:01	#22 (Direktlink)
Jonathan Stammuser Registriert seit: 21.04.2011 Ort: Hessen Alter: 15 Beiträge: 327	Du meinst sowas?: Zahl: 5 1+2+3+4+5 __________________ ASUS K50IJ Notebook --- Pentium T4500 2x 2,4GHz --- 4GB RAM --- 64GB m4 SSD --- Win 7 Home Premium 32-Bit --- XProfan X2.0b Das Schönste am Programmieren ist immernoch die Fehlersuche Dieser Beitrag besteht zu 100% aus Recycling-Bytes.

21.01.2012, 16:17	#23 (Direktlink)
Jonathan Stammuser Registriert seit: 21.04.2011 Ort: Hessen Alter: 15 Beiträge: 327	Ach Mist, sehe gerade, ich habe die selbe Lösung wie Du... __________________ ASUS K50IJ Notebook --- Pentium T4500 2x 2,4GHz --- 4GB RAM --- 64GB m4 SSD --- Win 7 Home Premium 32-Bit --- XProfan X2.0b Das Schönste am Programmieren ist immernoch die Fehlersuche Dieser Beitrag besteht zu 100% aus Recycling-Bytes.

21.01.2012, 17:38	#24 (Direktlink)
p. specht Dauergast Registriert seit: 06.02.2009 Ort: Wien, Österreich Beiträge: 1.078	Genau: 65535 als Endwert einer Summe von 1 - 65535 bleibt gerade noch im gewünschten Zahlenbereich. Ab 65536 benötigen wird schon Floatingpoint-Variablen, um Overflow zu vermeiden __________________ Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,XPSE,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB2:USB3

29.01.2012, 20:46	#26 (Direktlink)
p. specht Dauergast Registriert seit: 06.02.2009 Ort: Wien, Österreich Beiträge: 1.078	Abt. Simuliertes Gehirn auf Ähnlichkeitssuche in Film-, Musik- und Literaturdatenbanken ====================================================== Gnod - The global network of dreams Hier die Deutsche Version. Es gibt dafür aber auch viele andere Anwendungsmöglichkeiten, siehe hier. Eine Einführung findet man hier. Gruss P.S.: Wir scheinen also tatsächlich im 21. Jahrhundert angekommen zu sein. Vielleicht sollte man sich viel mehr damit beschäftigen! Interessante Links auch: Hopfield-Netz, Neocognitron, Adaline-Modell __________________ Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,XPSE,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB2:USB3 Geändert von p. specht (29.01.2012 um 21:17 Uhr)

05.02.2012, 12:45	#27 (Direktlink)
Frabbing Super-Moderator Registriert seit: 05.02.2009 Ort: Westliches NRW Alter: 44 Beiträge: 5.089	Klappt sogar einigermassen. __________________ Gruß, Frank Webpage http://frabbing.bplaced.net mit Freeware - Tools, Spiele und Grafiken.

05.02.2012, 16:33	#28 (Direktlink)
p. specht Dauergast Registriert seit: 06.02.2009 Ort: Wien, Österreich Beiträge: 1.078	Kleine Schatzkiste dazu gefunden: ÖFFNEN __________________ Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,XPSE,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB2:USB3

05.02.2012, 21:38	#29 (Direktlink)
Frabbing Super-Moderator Registriert seit: 05.02.2009 Ort: Westliches NRW Alter: 44 Beiträge: 5.089	Da hat sich aber jemand richtig Arbeit gemacht. __________________ Gruß, Frank Webpage http://frabbing.bplaced.net mit Freeware - Tools, Spiele und Grafiken.

Themen-Optionen
Druckbare Version zeigen Jemanden per E-Mail auf dieses Thema hinweisen
Ansicht
Linear-Darstellung Zur Hybrid-Darstellung wechseln Zur Baum-Darstellung wechseln

Ähnliche Themen
Thema	Autor	Forum	Antworten	Letzter Beitrag
Überflüssige Algorithmen Teil III (Programme, die die Welt nicht braucht)	p. specht	Algorithmen & Lehrreiches	264	12.01.2012 15:47
Überflüssige Algorithmen Teil II (Experimentalprogramme)	p. specht	Algorithmen & Lehrreiches	260	17.09.2011 14:53
Überflüssige Algorithmen (Programmierabfall)	p. specht	Algorithmen & Lehrreiches	247	10.07.2011 23:14
Systemsteuerung Software ist zum Teil Schwarz	Otholt	Viren-Forum	1	18.11.2008 17:50