# NAG CL Interfacec06fpc (withdraw_​fft_​real_​1d_​multi_​rfmt)

Note: this function is deprecated and will be withdrawn at Mark 30.2. Replaced by c06pqc.
c06pqc provides a simpler interface for both forward and backward transforms.

#### Old Code

`nag_sum_withdraw_fft_real_1d_multi_rfmt(m, n, x, trig, &fail);`

#### New Code

`nag_sum_fft_realherm_1d_multi_col(Nag_ForwardTransform, n, m, x, &fail);`
where the dimension of the array x has been extended from the original ${\mathbf{n}}×{\mathbf{m}}$ to $\left({\mathbf{n}}+2\right)×{\mathbf{m}}$.
The input values are stored slightly differently to allow for two extra storage spaces at the end of each sequence.
The mapping of input elements is as follows:
• for $\mathit{j}=0,1,\dots ,{\mathbf{m}}-1$
• $J=j×\left({\mathbf{n}}+2\right)$;
• ${\mathbf{x}}\left[J+\mathit{i}\right]←{\mathbf{x}}\left[j×{\mathbf{n}}+\mathit{i}\right]$, for $\mathit{i}=0,1,\dots ,{\mathbf{n}}-1$;
• ${\mathbf{x}}\left[J+{\mathbf{n}}\right]$ and ${\mathbf{x}}\left[J+{\mathbf{n}}+1\right]$ need not be set.
The output values x are stored in a different order with real and imaginary parts of each Hermitian sequence stored contiguously.
The mapping of output elements is as follows:
• for $\mathit{j}=0,1,\dots ,{\mathbf{m}}-1$
• $J=j×\left({\mathbf{n}}+2\right)$;
• ${\mathbf{x}}\left[J+2×\mathit{i}\right]←{\mathbf{x}}\left[j×{\mathbf{n}}+\mathit{i}\right]$, for $\mathit{i}=0,1,\dots ,{\mathbf{n}}/2$ (real parts);
• ${\mathbf{x}}\left[J+2×\mathit{i}+1\right]←{\mathbf{x}}\left[j×{\mathbf{n}}+{\mathbf{n}}-\mathit{i}\right]$, for $\mathit{i}=1,2,\dots ,\left({\mathbf{n}}-1\right)/2$ (imaginary parts);
• ${\mathbf{x}}\left[J+1\right]=0$;
• ${\mathbf{x}}\left[J+{\mathbf{n}}+1\right]=0$ when n is even.

Settings help

CL Name Style:

## 1Purpose

c06fpc computes the discrete Fourier transforms of $m$ sequences, each containing $n$ real data values.

## 2Specification

 #include
 void c06fpc (Integer m, Integer n, double x[], const double trig[], NagError *fail)
The function may be called by the names: c06fpc, nag_sum_withdraw_fft_real_1d_multi_rfmt or nag_fft_multiple_real.

## 3Description

Given $m$ sequences of $n$ real data values ${x}_{\mathit{j}}^{\mathit{p}}$, for $\mathit{j}=0,1,\dots ,n-1$ and $\mathit{p}=1,2,\dots ,m$, this function simultaneously calculates the Fourier transforms of all the sequences defined by
 $z ^ k p = 1 n ∑ j=0 n-1 x j p exp(−2πijk/n) , for ​ k = 0 , 1 , … , n - 1 ; p = 1 , 2 , … , m .$
(Note the scale factor $1/\sqrt{n}$ in this definition.)
The transformed values ${\stackrel{^}{z}}_{k}^{p}$ are complex, but for each value of $p$ the ${\stackrel{^}{z}}_{k}^{p}$ form a Hermitian sequence (i.e., ${\stackrel{^}{z}}_{n-k}^{p}$ is the complex conjugate of ${\stackrel{^}{z}}_{k}^{p}$), so they are completely determined by $mn$ real numbers. The first call of c06fpc must be preceded by a call to c06gzc to initialize the array trig with trigonometric coefficients according to the value of n.
The discrete Fourier transform is sometimes defined using a positive sign in the exponential term
 $z ^ k p = 1 n ∑ j=0 n-1 x j p exp(+2πijk/n) .$
To compute this form, this function should be followed by a call to c06gqc to form the complex conjugates of the ${\stackrel{^}{z}}_{k}^{p}$.
The function uses a variant of the fast Fourier transform algorithm (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.

## 4References

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

## 5Arguments

1: $\mathbf{m}$Integer Input
On entry: the number of sequences to be transformed, $m$.
Constraint: ${\mathbf{m}}\ge 1$.
2: $\mathbf{n}$Integer Input
On entry: the number of real values in each sequence, $n$.
Constraint: ${\mathbf{n}}\ge 1$.
3: $\mathbf{x}\left[{\mathbf{m}}×{\mathbf{n}}\right]$double Input/Output
On entry: the $m$ data sequences must be stored in x consecutively. If the data values of the $p$th sequence to be transformed are denoted by ${x}_{\mathit{j}}^{p}$, for $\mathit{j}=0,1,\dots ,n-1$, then the $mn$ elements of the array x must contain the values
 $x 0 1 , x 1 1 , … , x n-1 1 , x 0 2 , x 1 2 , … , x n-1 2 , … , x 0 m , x 1 m , … , x n-1 m .$
On exit: the $m$ discrete Fourier transforms in Hermitian form, stored consecutively, overwriting the corresponding original sequences. If the $n$ components of the discrete Fourier transform ${\stackrel{^}{z}}_{k}^{p}$ are written as ${a}_{k}^{p}+{ib}_{k}^{p}$, then for $0\le k\le n/2$, ${a}_{k}^{p}$ is in array element ${\mathbf{x}}\left[\left(p-1\right)×n+k\right]$ and for $1\le k\le \left(n-1\right)/2$, ${b}_{k}^{p}$ is in array element ${\mathbf{x}}\left[\left(p-1\right)×n+n-k\right]$.
4: $\mathbf{trig}\left[2×{\mathbf{n}}\right]$const double Input
On entry: trigonometric coefficients as returned by a call of c06gzc. c06fpc makes a simple check to ensure that trig has been initialized and that the initialization is compatible with the value of n
5: $\mathbf{fail}$NagError * Input/Output
The NAG error argument (see Section 7 in the Introduction to the NAG Library CL Interface).

## 6Error Indicators and Warnings

NE_ALLOC_FAIL
Dynamic memory allocation failed.
NE_C06_NOT_TRIG
Value of n and trig array are incompatible or trig array not initialized.
NE_INT_ARG_LT
On entry, ${\mathbf{m}}=⟨\mathit{\text{value}}⟩$.
Constraint: ${\mathbf{m}}\ge 1$.
On entry, ${\mathbf{n}}=⟨\mathit{\text{value}}⟩$.
Constraint: ${\mathbf{n}}\ge 1$.

## 7Accuracy

Some indication of accuracy can be obtained by performing a subsequent inverse transform and comparing the results with the original sequence (in exact arithmetic they would be identical).

## 8Parallelism and Performance

c06fpc is not threaded in any implementation.

The time taken is approximately proportional to $nm\mathrm{log}\left(n\right)$, but also depends on the factors of $n$. The function is fastest if the only prime factors of $n$ are $2$, 3 and $5$, and is particularly slow if $n$ is a large prime, or has large prime factors.

## 10Example

This program reads in sequences of real data values and prints their discrete Fourier transforms (as computed by c06fpc). The Fourier transforms are expanded into full complex form using c06gsc and printed. Inverse transforms are then calculated by calling c06gqc followed by c06fqc showing that the original sequences are restored.

### 10.1Program Text

Program Text (c06fpce.c)

### 10.2Program Data

Program Data (c06fpce.d)

### 10.3Program Results

Program Results (c06fpce.r)