| MF_FFT |
MD_FFT |
ME_FFT |
| MFb_FFT |
MDb_FFT |
MEb_FFT |
| MF_FFTtoC
| MD_FFTtoC |
ME_FFTtoC |
| MFb_FFTtoC
| MDb_FFTtoC |
MEb_FFTtoC |
| MCF_FFT |
MCD_FFT |
MCE_FFT |
| MCFb_FFT |
MCDb_FFT |
MCEb_FFT |
|
| Funktion | Zwei-dimensionale Schnelle Fourier-Transformation (Fast Fourier Transformation, FFT) |
|
| Syntax C/C++ | #include <MFstd.h>
void MF_FFT( fMatrix Y, fMatrix X, ui ht, ui len, int dir );
void MCF_FFT( cfMatrix Y, cfMatrix X, ui ht, ui len, int dir );
void MF_FFTtoC( cfMatrix Y, fMatrix X, ui ht, ui len );
void MFb_FFT( fMatrix Y, fMatrix X, ui ht, ui len, int dir, fVector Buf );
void MCFb_FFT( cfMatrix Y, cfMatrix X, ui ht, ui len, int dir, cfVector Buf );
void MFb_FFTtoC( cfMatrix Y, fMatrix X, ui ht, ui len, cfVector Buf ); |
| C++ MatObj | #include <OptiVec.h>
void matrix<T>::FFT( const matrix<T>& MX, int dir );
void matrix<complex<T> >::FFT( const matrix<complex<T> >& MX, int dir );
void matrix<complex<T> >::FFTtoC( const matrix<T>& MX );
void matrix<T>::b_FFT( const matrix<T>& MX, int dir, vector<T>& Buf );
void matrix<complex<T> >::b_FFT( const matrix<complex<T> > MX, int dir, vector<complex<T> >&Buf );
void matrix<complex<T> >::b_FFTtoC( const matrix<T> MX, vector<complex<T>>& Buf ); |
| Pascal/Delphi | uses MFstd;
procedure MF_FFT( MY, MX:fMatrix; ht, len:UIntSize; dir:Integer );
procedure MCF_FFT( MY, MX:cfMatrix; ht, len:UIntSize; dir:Integer );
procedure MF_FFTtoC( MY:cfMatrix; MX:fMatrix; ht, len:UIntSize );
procedure MFb_FFT( MY, MX:fMatrix; ht, len:UIntSize; dir:Integer; Buf:fVector );
procedure MCFb_FFT( MY, MX:cfMatrix; ht, len:UIntSize; dir:Integer; Buf:cfVector );
procedure MFb_FFTtoC( MY:cfMatrix; MX:fMatrix; ht, len:UIntSize; Buf:cfVector ); |
|
| CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_FFT( fMatrix d_MY, fMatrix d_MX, ui ht, ui len, int dir );
int cudaMCF_FFT( cfMatrix d_MY, cfMatrix d_MX, ui ht, ui len, int dir );
int cudaMF_FFTtoC( cfMatrix d_MY, fMatrix d_MX, ui ht, ui len );
void MFcu_FFT( fMatrix h_MY, fMatrix h_MX, ui ht, ui len, int dir );
void MCFcu_FFT( cfMatrix h_MY, cfMatrix h_MX, ui ht, ui len, int dir );
void MFcu_FFTtoC( cfMatrix h_MY, fMatrix h_MX, ui ht, ui len );
|
| CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_FFT( d_MY, d_MX:fMatrix; ht, len:UIntSize; dir:Integer );
function cudaMCF_FFT( d_MY, d_MX:cfMatrix; ht, len:UIntSize; dir:Integer );
function cudaMF_FFTtoC( d_MY:cfMatrix; d_MX:fMatrix; ht, len:UIntSize );
procedure MFcu_FFT( h_MY, h_MX:fMatrix; ht, len:UIntSize; dir:Integer );
procedure MCFcu_FFT( h_MY, h_MX:cfMatrix; ht, len:UIntSize; dir:Integer );
procedure MFcu_FFTtoC( h_MY:cfMatrix; h_MX:fMatrix; ht, len:UIntSize );
|
|
| Beschreibung | Die Fourier-Transformierte von MX wird in MY zurückgegeben. Die Vorwärts-Transformation erhält man für dir = 1, die inverse (oder Rückwärts-) Transformation für dir = -1. Gemäß Konvention enthält die Rückwärts-Transformation eine Skalierung des Ergebnisses mit dem Faktor 1.0/(ht*len) (wodurch das Ergebnis von einmal Vorwärts- und einmal Rückwärts-Transformation wieder - von Rundungsfehlern abgesehen - die Ausgangs-Matrix ergibt). Für Situationen, in denen man diese implizite Skalierung umgehen möchte, spezifiziere man dir = -2.
Der verwendete FFT-Algorithmus erfordert es, dass sowohl ht als auch len ganzzahlige Potenzen von 2 sind.
Komplexe Version: Sowohl die Eingabe-Matrix X also auch die Ausgabe-Matrix Y sind komplex.
Reell-zu-Komplex-Version: Die Eingabe-Matrix X ist reell. Die Ausgabe-Matrix Y ist komplex. Da diese Funktion nur in Vorwärts-Richtung ausgeführt werden kann, ist kein Argument "dir" erforderlich.
Rein reelle Version: Für die Vorwärts-Transformation ist MX eine reelle Matrix. Die Ausgabe-Matrix Y ist ebenfalls als reelle Matrix definiert, obwohl sie aus komplexen Zahlen besteht. Diese sind auf spezielle Weise so gepackt, dass sie in den für eine gleich große reelle Matrix zur Verfügung stehenden Speicherplatz passen. Die Reihenfolge der Elemente in MY ist von derjenigen im ein-dimensionalen Fall abgeleitet, wobei die Komprimierung zuerst auf alle Zeilen und danach auf die Spalten angewandt wird. Die folgende Tabelle faßt die sich so ergebende Anordnung zusammen. U ist die unkomprimierte Fourier-Transformierte von MX.
| U0,0.Re | U0,len/2.Re | U0,1.Re | U0,1.Im | ··· | U0,len/2-1.Re | U0,len/2-1.Im |
| Uht/2,0.Re | Uht/2,len/2.Re | U1,1.Re | U1,1.Im | ··· | U1,len/2-1.Re | U1,len/2-1.Im |
| U1,0.Re | U1,len/2.Re | U2,1.Re | U2,1.Im | ··· | U2,len/2-1.Re | U2,len/2-1.Im |
| U1,0.Im | U1,len/2.Im | U3,1.Re | U3,1.Im | ··· | U3,len/2-1.Re | U3,len/2-1.Im |
| ··· | ··· | ··· | ··· | ··· | ··· | ··· |
| Uht/2-1,0.Re | Uht/2-1,len/2.Re | ··· | ··· | ··· | ··· | ··· |
| Uht/2-1,0.Im | Uht/2-1,len/2.Im | Uht-1,1.Re | Uht-1,1.Im | ··· | Uht-1,len/2-1.Re | Uht-1,len/2-1.Im |
Für die inverse FFT reeller Matrizen muss die Eingabe-Matrix in diesem gepackt-komplexen Format vorliegen. und als Ergebnis erhält man eine "echte" reelle Matrix. Falls Sie es vorziehen, das Ergebnis der Vorwärts-Transformation einer rellen Matrix ungepackt, also als komplexe Matrix zu erhalten, benutzen Sie bitte MF_FFTtoC.
MFb_FFT, MFb_FFTtoC und MCFb_FFT verwenden den als Argument Buf übergebenen Puffer-Speicher, anstatt ihn selbst zu reservieren. Dadurch sind sie etwas effizienter als die ungepufferten Versionen. Buf muss (mindestens) so groß sein wie X und Y.Außerdem muss Buf 128-bit (P8) bzw. 256-bit( P9) ausgerichtet sein. Um dies zu garantieren, sollte man nur Vektoren als Buf verwenden, die mit der VF_vector-Familie alloziert wurden. |
|
| Fehlerbehandlung | Falls entweder len oder ht nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf MF_FFT basiert) mit der Fehlermeldung "Size must be an integer power of 2" und bricht das Programm ab. |
|
|