naginterfaces.library.sum.withdraw_​fft_​real_​1d_​multi_​rfmt

naginterfaces.library.sum.withdraw_fft_real_1d_multi_rfmt(m, n, x, init, trig)

withdraw_fft_real_1d_multi_rfmt computes the discrete Fourier transforms of $m$ sequences, each containing $n$ real data values. This function is designed to be particularly efficient on vector processors.

Deprecated since version 27.2.0.0: withdraw_fft_real_1d_multi_rfmt will be removed in naginterfaces 30.2.0.0. Please use fft_realherm_1d_multi_row() or fft_realherm_1d_multi_col() instead. See also the Replacement Calls document.

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

https://www.nag.com/numeric/nl/nagdoc_29.3/flhtml/c06/c06fpf.html

Parameters

mint

$m$, the number of sequences to be transformed.

nint

$n$, the number of real values in each sequence.

xfloat, array-like, shape $(m\times n)$

The data must be stored in $x$ as if in a two-dimensional array of dimension $(1:m,0:n-1)$; each of the $m$ sequences is stored in a row of the array. In other words, if the data values of the $p$th sequence to be transformed are denoted by $x_j^p$, for $\text{j}=0,1,\dots ,n-1$, the $mn$ elements of the array $x$ must contain the values

$$x_0^1,x_0^2,\dots ,x_0^m,x_1^1,x_1^2,\dots ,x_1^m,\dots ,x_{n-1}^1,x_{n-1}^2,\dots ,x_{n-1}^m\text{.}$$

initstr, length 1

Indicates whether trigonometric coefficients are to be calculated.

$init=\text{'I'}$

Calculate the required trigonometric coefficients for the given value of $n$, and store in the array $trig$.

$init=\text{'S'}$ or $\text{'R'}$

The required trigonometric coefficients are assumed to have been calculated and stored in the array $trig$ in a prior call to one of withdraw_fft_real_1d_multi_rfmt or withdraw_fft_hermitian_1d_multi_rfmt(). The function performs a simple check that the current value of $n$ is consistent with the values stored in $trig$.

trigfloat, array-like, shape $(2\times n)$

If $init=\text{'S'}$ or $\text{'R'}$, $trig$ must contain the required trigonometric coefficients that have been previously calculated. Otherwise $trig$ need not be set.

Returns

xfloat, ndarray, shape $(m\times n)$

The $m$ discrete Fourier transforms stored as if in a two-dimensional array of dimension $(1:m,0:n-1)$. Each of the $m$ transforms is stored in a row of the array in Hermitian form, overwriting the corresponding original sequence. If the $n$ components of the discrete Fourier transform ${\hat{z}}_k^p$ are written as $a_k^p+i{b}_k^p$, then for $0\le k\le n/2$, $a_k^p$ is contained in $x[p-1,k-1]$, and for $1\le k\le (n-1)/2$, $b_k^p$ is contained in $x[p-1,n-k-1]$. (See also the C06 Introduction.)

trigfloat, ndarray, shape $(2\times n)$

Contains the required coefficients (computed by the function if $init=\text{'I'}$).

Raises

NagValueError

(errno $1$)

On entry, $m=⟨value⟩$.

Constraint: $m\ge 1$.

(errno $2$)

On entry, $n=⟨value⟩$.

Constraint: $n\ge 1$.

(errno $3$)

On entry, $init=⟨value⟩$.

Constraint: $init=\text{'I'}$, $\text{'S'}$ or $\text{'R'}$.

(errno $5$)

On entry, $init=⟨value⟩$ but $n$ and $trig$ array incompatible.

Notes

In the NAG Library the traditional C interface for this routine uses a different algorithmic base. Please contact NAG if you have any questions about compatibility.

Given $m$ sequences of $n$ real data values $x_{\text{j}}^{\text{p}}$, for $\text{p}=1,2,\dots ,m$, for $\text{j}=0,1,\dots ,n-1$, withdraw_fft_real_1d_multi_rfmt simultaneously calculates the Fourier transforms of all the sequences defined by

$${\hat{z}}_k^p=\frac{1}{\sqrt{n}}\sum _{j=0}^{n-1}{x}_j^p\times exp\left(-i\frac{2\pi jk}{n}\right)\text{,}k=0,1,\dots ,n-1\text{and}p=1,2,\dots ,m\text{.}$$

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

The transformed values ${\hat{z}}_k^p$ are complex, but for each value of $p$ the ${\hat{z}}_k^p$ form a Hermitian sequence (i.e., ${\hat{z}}_{n-k}^p$ is the complex conjugate of ${\hat{z}}_k^p$), so they are completely determined by $mn$ real numbers (see also the C06 Introduction).

The discrete Fourier transform is sometimes defined using a positive sign in the exponential term:

$${\hat{z}}_k^p=\frac{1}{\sqrt{n}}\sum _{j=0}^{n-1}{x}_j^p\times exp\left(+i\frac{2\pi jk}{n}\right)\text{.}$$

To compute this form, this function should be followed by forming the complex conjugates of the ${\hat{z}}_k^p$; that is $x\left(\text{k}\right)=-x\left(\text{k}\right)$, for $\text{k}=(n/2+1)\times m+1,\dots ,m\times n$.

The function uses a variant of the fast Fourier transform (FFT) algorithm (see Brigham (1974)) known as the Stockham self-sorting algorithm, which is described in Temperton (1983). Special coding is provided for the factors $2$, $3$, $4$, $5$ and $6$. This function is designed to be particularly efficient on vector processors, and it becomes especially fast as $m$, the number of transforms to be computed in parallel, increases.

References

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

Temperton, C, 1983, Fast mixed-radix real Fourier transforms, J. Comput. Phys. (52), 340–350