﻿ c06fq Method
c06fq computes the discrete Fourier transforms of $m$ Hermitian sequences, each containing $n$ complex data values. This method is designed to be particularly efficient on vector processors.

# Syntax

C#
```public static void c06fq(
int m,
int n,
double[] x,
string init,
double[] trig,
out int ifail
)```
Visual Basic
```Public Shared Sub c06fq ( _
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 c06fq(
int m,
int n,
array<double>^ x,
String^ init,
array<double>^ trig,
[OutAttribute] int% ifail
)```
F#
```static member c06fq :
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 data 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 Hermitian form. If the $n$ data values ${z}_{j}^{p}$ are written as ${x}_{j}^{p}+i{y}_{j}^{p}$, then for $0\le j\le n/2$, ${x}_{j}^{p}$ is contained in ${\mathbf{x}}\left[p-1,j\right]$, and for $1\le j\le \left(n-1\right)/2$, ${y}_{j}^{p}$ is contained in ${\mathbf{x}}\left[p,n-j\right]$. (See also [] in the C06 class Chapter Introduction.)
On exit: the components of 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 as a row of the array, overwriting the corresponding original sequence. If the $n$ components of the discrete Fourier transform are denoted by ${\stackrel{^}{x}}_{\mathit{k}}^{p}$, for $\mathit{k}=0,1,\dots ,n-1$, then the $mn$ elements of the array x contain the values
 $x^01,x^02,…,x^0m,x^11,x^12,…,x^1m,…,x^n-11,x^n-12,…,x^n-1m.$
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$ Hermitian sequences of $n$ complex data values ${z}_{\mathit{j}}^{\mathit{p}}$, for $\mathit{j}=0,1,\dots ,n-1$ and $\mathit{p}=1,2,\dots ,m$, c06fq simultaneously calculates the Fourier transforms of all the sequences defined by
 $x^kp=1n∑j=0n-1zjp×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 discrete Fourier transform is sometimes defined using a positive sign in the exponential term
 $x^kp=1n∑j=0n-1zjp×exp+i2πjkn.$
To compute this form, this method should be preceded 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 c06fq is approximately proportional to $nm\mathrm{log}\left(n\right)$, but also depends on the factors of $n$. c06fq 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.