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

# Syntax

C#
```public static void c06fp(
int m,
int n,
double[] x,
string init,
double[] trig,
out int ifail
)```
Visual Basic
```Public Shared Sub c06fp ( _
m As Integer, _
n As Integer, _
x As Double(), _
init As String, _
trig As Double(), _
<OutAttribute> ByRef ifail As Integer _
)```
Visual C++
```public:
static void c06fp(
int m,
int n,
array<double>^ x,
String^ init,
array<double>^ trig,
[OutAttribute] int% ifail
)```
F#
```static member c06fp :
m : int *
n : int *
x : float[] *
init : string *
trig : float[] *
ifail : int byref -> unit
```

#### Parameters

m
Type: System..::..Int32
On entry: $m$, the number of sequences to be transformed.
Constraint: ${\mathbf{m}}\ge 1$.
n
Type: System..::..Int32
On entry: $n$, the number of real values in each sequence.
Constraint: ${\mathbf{n}}\ge 1$.
x
Type: array<System..::..Double>[]()[][]
An array of size [${\mathbf{m}}×{\mathbf{n}}$]
On entry: the data must be stored in x as if in a two-dimensional array of dimension $\left(1:{\mathbf{m}},0:{\mathbf{n}}-1\right)$; 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 $\mathit{j}=0,1,\dots ,n-1$, then the $mn$ elements of the array x must contain the values
 $x01,x02,…,x0m,x11,x12,…,x1m,…,xn-11,xn-12,…,xn-1m.$
On exit: the $m$ discrete Fourier transforms stored as if in a two-dimensional array of dimension $\left(1:{\mathbf{m}},0:{\mathbf{n}}-1\right)$. 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 ${\stackrel{^}{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 ${\mathbf{x}}\left[p-1,k-1\right]$, and for $1\le k\le \left(n-1\right)/2$, ${b}_{k}^{p}$ is contained in ${\mathbf{x}}\left[p-1,n-k-1\right]$. (See also [] in the C06 class Chapter Introduction.)
init
Type: System..::..String
On entry: indicates whether trigonometric coefficients are to be calculated.
${\mathbf{init}}=\text{"I"}$
Calculate the required trigonometric coefficients for the given value of $n$, and store in the array trig.
${\mathbf{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 c06fpc06fq or c06fr. The method performs a simple check that the current value of $n$ is consistent with the values stored in trig.
Constraint: ${\mathbf{init}}=\text{"I"}$, $\text{"S"}$ or $\text{"R"}$.
trig
Type: array<System..::..Double>[]()[][]
An array of size [$2×{\mathbf{n}}$]
On entry: if ${\mathbf{init}}=\text{"S"}$ or $\text{"R"}$, trig must contain the required trigonometric coefficients that have been previously calculated. Otherwise trig need not be set.
On exit: contains the required coefficients (computed by the method if ${\mathbf{init}}=\text{"I"}$).
ifail
Type: System..::..Int32%
On exit: ${\mathbf{ifail}}={0}$ unless the method detects an error or a warning has been flagged (see [Error Indicators and Warnings]).

# Description

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$, c06fp simultaneously calculates the Fourier transforms of all the sequences defined by
 $z^kp=1n∑j=0n-1xjp×exp-i2πjkn, k=0,1,…,n-1​ and ​p=1,2,…,m.$
(Note the scale factor $\frac{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 (see also the C06 class).
The discrete Fourier transform is sometimes defined using a positive sign in the exponential term:
 $z^kp=1n∑j=0n-1xjp×exp+i2πjkn.$
To compute this form, this method should be followed by forming the complex conjugates of the ${\stackrel{^}{z}}_{k}^{p}$; that is $x\left(\mathit{k}\right)=-x\left(\mathit{k}\right)$, for $\mathit{k}=\left(n/2+1\right)×m+1,\dots ,m×n$.
The method 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 method 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

# Error Indicators and Warnings

Errors or warnings detected by the method:
${\mathbf{ifail}}=1$
 On entry, ${\mathbf{m}}<1$.
${\mathbf{ifail}}=2$
 On entry, ${\mathbf{n}}<1$.
${\mathbf{ifail}}=3$
 On entry, ${\mathbf{init}}\ne \text{"I"}$, $\text{"S"}$ or $\text{"R"}$.
${\mathbf{ifail}}=4$
Not used at this Mark.
${\mathbf{ifail}}=5$
 On entry, ${\mathbf{init}}=\text{"S"}$ or $\text{"R"}$, but the array trig and the current value of n are inconsistent.
${\mathbf{ifail}}=6$
An unexpected error has occurred in an internal call. Check all method calls and array dimensions. Seek expert help.
${\mathbf{ifail}}=-9000$
An error occured, see message report.
${\mathbf{ifail}}=-8000$
Negative dimension for array $〈\mathit{\text{value}}〉$
${\mathbf{ifail}}=-6000$
Invalid Parameters $〈\mathit{\text{value}}〉$

# Accuracy

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).

# Parallelism and Performance

None.

The time taken by c06fp is approximately proportional to $nm\mathrm{log}\left(n\right)$, but also depends on the factors of $n$. c06fp 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.