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

naginterfaces.library.sum.fft_complex_multid_1d_sep(l, nd, x, y)

fft_complex_multid_1d_sep computes the discrete Fourier transform of one variable in a multivariate sequence of complex data values.

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

https://support.nag.com/numeric/nl/nagdoc_30.2/flhtml/c06/c06fff.html

Parameters

lint

$l$, the index of the variable (or dimension) on which the discrete Fourier transform is to be performed.

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 $3$)

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

Constraint: $1\le l\le \text{ndim}$.

(errno $10\times l+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_1d_sep computes the discrete Fourier transform of one variable (the $l$th say) in a multivariate sequence of complex data values $z_{j_1{j}_2\dots j_m}$, for ${\text{j}}_2=0,1,\dots ,n_2-1$, for ${\text{j}}_1=0,1,\dots ,n_1-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 function computes $n/n_l$ one-dimensional transforms defined by

$${\hat{z}}_{j_1\dots k_l\dots j_m}=\frac{1}{\sqrt{n_l}}\sum _{j_l=0}^{n_l-1}{z}_{j_1\dots j_l\dots j_m}\times exp(-\frac{2\pi i{j}_l{k}_l}{n_l})\text{,}$$

where $k_l=0,1,\dots ,n_l-1$.

(Note the scale factor of $\frac{1}{\sqrt{n_l}}$ in this definition.)

To compute the inverse discrete Fourier transforms, defined with $exp(+\frac{2\pi i{j}_l{k}_l}{n_l})$ in the above formula instead of $exp(-\frac{2\pi i{j}_l{k}_l}{n_l})$, 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