OptiVec: MF_Rows

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

Function

Fast Fourier Transform along the rows

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 function 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 function 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 );

Description

The one-dimensional Fourier transform of all rows of MX is calculated and stored in the corresponding rows of MY. The forward transform is obtained by setting dir = 1, the inverse (or backward) transform by setting dir = -1. By convention, the inverse transform involves scaling the result by the factor 1.0/len (so as to ensure that the result of one forward and one backward transform yields – within round-off error – the original matrix). Since it is sometimes desirable to skip this implicit scaling, MF_Rows_FFT offers the possibility to do so: specify dir = -2 in this case.
A Fast Fourier Transform algorithm is used that requires len to be a power of 2. ht may be set arbitrarily, but the function will be most efficient if ht is a multiple of 4.
Complex version: Both MX and the output MY are complex matrices.
Real-to-complex version: The input matrix MX is real. The output matrix MY is complex. As this function can only perform a forward transform, no argument "dir" is needed.
Purely real version: For the forward transform, MX is a real matrix. The output MY is also defined as fMatrix, although it consists of complex numbers. The reason is that the symmetry properties of FFT allow to store the result in a packed format, fitting into the same memory space as the input matrix. The order of each row of MY is indicated in the following table. U means the uncompressed result, N is len.

MY_i,0	MY_i,1	MY_i,2	MY_i,3	.....	MY_i,N-2	MY_i,N-1
U_i,0.Re	U_i,N/2.Re	U_i,1.Re	U_i,1.Im	.....	U_i,N/2-1.Re	U_i,N/2-1.Im

This storage scheme implies that, for Pascal/Delphi (where matrices are stored in column-major order), the real and imaginary parts of any element are not adjacent in memory .
For inverse real-matrix Rows_FFT, the input matrix has to be of this packed-complex format, and you get a real matrix. If you prefer to get the result of forward FFT in true complex format, use MF_Rows_FFTtoC.

MFb_Rows_FFT, MFb_Rows_FFTtoC and MCFb_Rows_FFT take a buffer vector Buf as an additional argument. They are slightly more efficient than the un-buffered versions. Buf must have (at least) the same size as X and Y (i.e., Buf.size >= ht*len).

Error handling

If len is not a power of 2, the program is aborted with the error message "Size must be an integer power of 2".