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}}\times {\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$${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{.}$$ *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 ${\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 ${\mathbf{x}}[p-1,k-1]$, and for $1\le k\le \left(n-1\right)/2$, ${b}_{k}^{p}$ is contained in ${\mathbf{x}}[p-1,n-k-1]$. (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 c06fp, c06fq 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\times {\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

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

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

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**class).The discrete Fourier transform is sometimes defined using a positive sign in the exponential term:

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

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

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–HallTemperton 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.

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