| MF_Rows_FFT |
MD_Rows_FFT |
ME_Rows_FFT |
| MFb_Rows_FFT |
MDb_Rows_FFT |
MEb_Rows_FFT |
| MF_Rows_FFTtoC
| MD_Rows_FFTtoC |
ME_Rows_FFTtoC |
| MFb_Rows_FFTtoC
| MDb_Rows_FFTtoC |
MEb_Rows_FFTtoC |
| MCF_Rows_FFT |
MCD_Rows_FFT |
MCE_Rows_FFT |
| MCFb_Rows_FFT |
MCDb_Rows_FFT |
MCEb_Rows_FFT |
|
| Funktion | Schnelle Fourier-Transformation (Fast Fourier Transformation) entlang der Zeilen einer Matrix |
|
| Syntax C/C++ | #include <MFstd.h>
void MF_Rows_FFT( fMatrix Y, fMatrix X, ui ht, ui len, int dir );
void MCF_Rows_FFT( cfMatrix Y, cfMatrix X, ui ht, ui len, int dir );
void MF_Rows_FFTtoC( cfMatrix Y, fMatrix X, ui ht, ui len );
void MFb_Rows_FFT( fMatrix Y, fMatrix X, ui ht, ui len, int dir, fVector Buf );
void MCFb_Rows_FFT( cfMatrix Y, cfMatrix X, ui ht, ui len, int dir, cfVector Buf );
void MFb_Rows_FFTtoC( cfMatrix Y, fMatrix X, ui ht, ui len, cfVector Buf ); |
| C++ MatObj | #include <OptiVec.h>
void matrix<T>::Rows_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_Rows_FFT( const matrix<T>& MX, int dir, vector<T>& Buf );
void matrix<complex<T> >::b_Rows_FFT( const matrix<complex<T> > MX, int dir, vector<complex<T> >&Buf );
void matrix<complex<T> >::b_Rows_FFTtoC( const matrix<T> MX, vector<complex<T>>& Buf ); |
| Pascal/Delphi | uses MFstd;
procedure MF_Rows_FFT( MY, MX:fMatrix; ht, len:UIntSize; dir:Integer );
procedure MCF_Rows_FFT( MY, MX:cfMatrix; ht, len:UIntSize; dir:Integer );
procedure MF_Rows_FFTtoC( MY:cfMatrix; MX:fMatrix; ht, len:UIntSize );
procedure MFb_Rows_FFT( MY, MX:fMatrix; ht, len:UIntSize; dir:Integer; Buf:fVector );
procedure MCFb_Rows_FFT( MY, MX:cfMatrix; ht, len:UIntSize; dir:Integer; Buf:cfVector );
procedure MFb_Rows_FFTtoC( MY:cfMatrix; MX:fMatrix; ht, len:UIntSize; Buf:cfVector ); |
|
| CUDA-Funktion C/C++ | #include <cudaMFstd.h>
#include <cudaMCFstd.h>
int cudaMF_Rows_FFT( fMatrix d_Y, fMatrix d_X, ui ht, ui len, int dir );
int cuda MCF_Rows_FFT( cfMatrix d_Y, cfMatrix d_X, ui ht, ui len, int dir );
int cudaMF_Rows_FFTtoC( cfMatrix d_Y, fMatrix d_X, ui ht, ui len );
void MFcu_Rows_FFT( fMatrix h_Y, fMatrix h_X, ui ht, ui len, int dir );
void MCFcu_Rows_FFT( cfMatrix h_Y, cfMatrix h_X, ui ht, ui len, int dir );
void MFcu_Rows_FFTtoC( cfMatrix h_Y, fMatrix h_X, ui ht, ui len ); |
| CUDA-Funktion Pascal/Delphi | uses MFstd, MCFstd;
function cudaMF_Rows_FFT( d_MY, d_MX:fMatrix; ht, len:UIntSize; dir:Integer ): IntBool;
function cudaMCF_Rows_FFT( d_MY, d_MX:cfMatrix; ht, len:UIntSize; dir:Integer ): IntBool;
function cudaMF_Rows_FFTtoC( d_MY:cfMatrix; d_MX:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_FFT( h_MY, h_MX:fMatrix; ht, len:UIntSize; dir:Integer );
procedure MCFcu_Rows_FFT( h_MY, h_MX:cfMatrix; ht, len:UIntSize; dir:Integer );
procedure MFcu_Rows_FFTtoC( h_MY:cfMatrix; h_MX:fMatrix; ht, len:UIntSize );
|
|
| Beschreibung | Die Fourier-Transformierten der Zeilen von MX werden in den Zeilen von 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/len (wodurch das Ergebnis von einmal Vorwärts- und einmal Rückwärts-Transformation wieder – von Rundungsfehlern abgesehen – die Ursprungs-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 len eine ganzzahlige Potenz von 2 ist. ht hingegen kann zwar beliebige Werte annehmen; die Funktion ist aber am effizientesten, wenn ht ein Vielfaches von 4 ist.
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 der Zeilen von MY ist in folgenden Tabelle angegeben. U ist die unkomprimierte Fourier-Transformierte, N ist ht.
| MYi,0 | MYi,1 | MYi,2
| MYi,3 | .....
| MYi,N-2 | MYi,N-1 |
| Ui,0.Re | Ui,N/2.Re | Ui,1.Re
| Ui,1.Im | .....
| Ui,N/2-1.Re | Ui,N/2-1.Im |
Dieses Speicher-Schema bedeutet, dass in Pascal/Delphi (wo Matrizen spaltenweise gespeichert werden), Real- und Imaginärteil eines jeden Elements nicht an benachbarten Speicherplätzen abgelegt sind.
Für die inverse Rows_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 ungepackt, also als "echte" komplexe Zahlen zu erhalten, benutzen Sie bitte MF_Rows_FFTtoC.
MFb_Rows_FFT, MFb_Rows_FFTtoC und MCFb_Rows_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 (d.h. Buf.size >= ht*len).
|
|
| Fehlerbehandlung | Falls len nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf MF_Rows_FFT basiert) mit der Fehlermeldung "Size must be an integer power of 2" und bricht das Programm ab. |
|
|