schnelle fourier transformation

[armada]

hi,
also ich hab jetzt nach stundenlangem suchen endlich en code gefunden im dem fft verwendet wird. allerdings in c und davon hab ich nur sehr begrenzt ahnung.

ich bräuchte nur die multiplikation mittels fft...aber in purebasic.

der link zum source: http://www.garlic.com/%7Ewedgingt/mers.tar.gz

die seite von wo aus des verlinkt worden ist: http://www.mersenne.org/freeware.htm

ich würd mich wirklich riesig freuen wenn einer von euch die multiplikation in purebasic umschreiben könnte (muss nich schnell sein oder besonders sauber geschrieben sein, es muss nur funktionieren...optimieren kann ich des selber)

also schonmal danke an alle die sich des mal angucken. und wenn ihr mir helfen könntet wäre echt super

mfg
armada

[armada]

...hmm schade dass ihr mir nicht helfen könnt...
dann is der traum vom eigenen großen datentyp gestorben^^

naja vielleicht poste ich hier bald zumindest mal das was ich schon hab...vielleicht kanns einer ja gebrauchen

mfg
armada

[armada]

Procedure get_length(var, size)
MOV ebx, [esp]
ADD ebx, [esp+4]
SUB ebx, 2
MOV ecx, [esp]
XOR eax, eax
!schleife3start:
CMP ebx, ecx
JL schleife3ende
CMP word[ebx], 0
JE abfrage1ende
MOV eax, ebx
SUB eax, [esp]
ADD eax, 2
SAR eax, 1
JMP schleife3ende
!abfrage1ende:
SUB ebx, 2
JMP schleife3start
!schleife3ende:
ProcedureReturn
EndProcedure

Procedure addition(var1, var2, var3, size, length)
CMP length, 0
JNE abfrage2ende
get_length(var2, size)
MOV edx, eax
JMP abfrage3ende
!abfrage2ende:
MOV edx, length
!abfrage3ende:

MOV eax, var1
MOV ebx, var2
MOV ecx, var3
ADD edx, eax
PUSH dword 0
!schleife1start:
CMP edx, eax
JE schleife1ende
MOV edi, [eax]
And edi, 65535
MOV esi, [ebx]
And esi, 65535
ADD edi, esi
POP esi
SAR esi, 16
ADD edi, esi
PUSH edi
And edi, 65535
MOV [ecx], edi
INC eax
INC eax
INC ebx
INC ebx
INC ecx
INC ecx
JMP schleife1start
!schleife1ende:
MOV ebx, ecx
POP ecx
!schleife2start:
SAR ecx, 16
CMP ecx, 0
JE schleife2ende
MOV edx, [eax]
And edx, 65535
ADD ecx, edx
MOV edi, ecx
And edi, 65535
MOV [ebx], edi
INC eax
INC eax
INC ebx
INC ebx
JMP schleife2start
!schleife2ende:
MOV edi, [esp]
ADD size, edi
SUB size, eax
MOV var1, eax
MOV var3, ebx
CopyMemory(var1, var3, size)
EndProcedure

Procedure add_integer(var, value)
MOV eax, var
MOV ebx, value
MOV ecx, ebx
And ebx, 65535
SAR ecx, 16
MOV edx, [eax]
And edx, 65535
ADD edx, ebx
MOV edi, edx
And edx, 65535
MOV esi, [eax]
And esi, $FFFF0000
ADD edx, esi
MOV [eax], edx
INC eax
INC eax

SAR edi, 16
ADD edi, ecx
MOV ecx, [eax]
And ecx, $FFFF
ADD edi, ecx
MOV edx, edi
And edi, $FFFF
MOV esi, [eax]
And esi, $FFFF0000
ADD edi, esi
MOV [eax], edi
INC eax
INC eax
MOV ebx, edx
!schleife4start:
SAR ebx, 16
CMP ebx, 0
JE schleife4ende
MOV ecx, [eax]
And ecx, $FFFF
ADD ecx, ebx
MOV edi, ecx
MOV ebx, ecx
And edi, $FFFF
MOV esi, [eax]
And esi, $FFFF0000
ADD edi, esi
MOV [eax], edi
INC eax
INC eax
JMP schleife4start
!schleife4ende:
EndProcedure

so also hier ne kurze erklärung der prozeduren:
get_length(var, size) ... brauch euch eigentlich nicht zu interessieren^^

addition(var1, var2, var3, size, length) ... var1 ist der pointer zum ersten summand, var2 der pointer zum zweiten summand, var3 der pointer zum ziel, size is die variablengröße (erklärung kommt später) und length is falls ihr wisst wie groß der zweite summand is (also wieviele WORDS die zahl groß ist) könnt ihr des hier angeben...dann wird der wert nich ermittelt...ansonsten gebt ihr 0 ein

dann noch Procedure add_integer(var, value) ... var ist der pointer zur quelle und zum ziel (also wird einfach dazuaddiert) und value ist der wert der dazuaddiert werden soll

also size meint die größe des dateityps in byte...wichtig ist dass bei der addition var1, var2, var3 dieselbe größe haben. die größe ist ne angabe in byte.

variablen definiert ihr so: bla = AllocateMemory(size)

naja gut ich hoffe das hat jetzt irgendjemand kapiert^^

subtraktion will ich noch was grundlegendes ändern...wird en bissl schneller als momentan...daher folgt die erst in ein paar tagen

wer was zu meckern oder zu verbessern hat der möge das hier tun

wenn ihr wisst wie man an dem code noch was optimieren kann...ich würd mich über jeden hinweis freuen

mfg
armada

[Helle]

Vorsicht mit SAR! Wenn das höchstwertige Bit (MSB) gesetzt war bleibt das erhalten!
Nach SAR blaba,x kannst du dir cmp blaba,0 schenken. Wenn das MSB nicht gesetzt ist kannst du gleich mit jz (je) bei Null verzweigen. Ansonsten drehst du (äh, das Programm ) sowieso Ehrenrunden bis zum Abschiessen.

Gruss
Helle

[armada]

nene das sar is schon richtig so. die register sind 32-bit groß...16 bit nach rechts heißt das hiword einfach...is um den übertrag zu berechnen

sonst noch irgendwas zu meckern?
oder en verbesserungsvorschlag?