naginterfaces.library.sum.fft_​complex_​multid_​sep

naginterfaces.library.sum.fft_complex_multid_sep(nd, x, y)

fft_complex_multid_sep computes the multidimensional discrete Fourier transform of a multivariate sequence of complex data values.

For full information please refer to the NAG Library document for c06fj

https://support.nag.com/numeric/nl/nagdoc_30.3/flhtml/c06/c06fjf.html

Parameters

ndint, array-like, shape $\left(\text{ndim}\right)$

$nd[\text{i}-1]$ must contain $n_{\text{i}}$ (the dimension of the $\text{i}$th variable), for $\text{i}=1,2,\dots ,m$.

xfloat, array-like, shape $\left(n\right)$

$x[1+j_1+n_1{j}_2+n_1{n}_2{j}_3+\cdots -1]$ must contain the real part of the complex data value $z_{j_1{j}_2\dots j_m}$, for $0\le j_1\le n_1-1,0\le j_2\le n_2-1,\dots$; i.e., the values are stored in consecutive elements of the array according to the Fortran convention for storing multidimensional arrays.

yfloat, array-like, shape $\left(n\right)$

The imaginary parts of the complex data values, stored in the same way as the real parts in the array $x$.

Returns

xfloat, ndarray, shape $\left(n\right)$

The real parts of the corresponding elements of the computed transform.

yfloat, ndarray, shape $\left(n\right)$

The imaginary parts of the corresponding elements of the computed transform.

Raises

NagValueError

(errno $1$)

On entry, $\text{ndim}=⟨value⟩$.

Constraint: $\text{ndim}\ge 1$.

(errno $2$)

On entry, $n=⟨value⟩$.

Constraint: $n=nd\left[0\right]\times nd\left[1\right]\times \cdots \times nd[\text{ndim}-1]$.

(errno $imod10=3$)

On entry, $l=⟨value⟩$.

Constraint: $nd[l-1]\ge 1$.

Notes

No equivalent traditional C interface for this routine exists in the NAG Library.

fft_complex_multid_sep computes the multidimensional discrete Fourier transform of a multidimensional sequence of complex data values $z_{j_1{j}_2\dots j_m}$, where $j_1=0,1,\dots ,n_1-1\text{,}{j}_2=0,1,\dots ,n_2-1$, and so on. Thus the individual dimensions are $n_1,n_2,\dots ,n_m$, and the total number of data values is $n=n_1\times n_2\times \cdots \times n_m$.

The discrete Fourier transform is here defined (e.g., for $m=2$) by:

$${\hat{z}}_{k_1,k_2}=\frac{1}{\sqrt{n}}\sum _{j_1=0}^{n_1-1}\sum _{j_2=0}^{n_2-1}{z}_{j_1{j}_2}\times exp\left(-2\pi i(\frac{j_1{k}_1}{n_1}+\frac{j_2{k}_2}{n_2})\right)\text{,}$$

where $k_1=0,1,\dots ,n_1-1$, $k_2=0,1,\dots ,n_2-1$.

The extension to higher dimensions is obvious. (Note the scale factor of $\frac{1}{\sqrt{n}}$ in this definition.)

To compute the inverse discrete Fourier transform, defined with $exp(+2\pi i(\dots ))$ in the above formula instead of $exp(-2\pi i(\dots ))$, this function should be preceded and followed by the complex conjugation of the data values and the transform (by negating the imaginary parts stored in $y$).

The data values must be supplied in a pair of one-dimensional arrays (real and imaginary parts separately), in accordance with the Fortran convention for storing multidimensional data (i.e., with the first subscript $j_1$ varying most rapidly).

This function calls fft_complex_1d_sep() to perform one-dimensional discrete Fourier transforms by the fast Fourier transform (FFT) algorithm in Brigham (1974).

References

Brigham, E O, 1974, The Fast Fourier Transform, Prentice–Hall