c06 Chapter Contents
c06 Chapter Introduction
NAG C Library Manual

# NAG Library Function Documentnag_fft_multiple_hermitian (c06fqc)

## 1  Purpose

nag_fft_multiple_hermitian (c06fqc) computes the discrete Fourier transforms of $m$ Hermitian sequences, each containing $n$ complex data values.

## 2  Specification

 #include #include
 void nag_fft_multiple_hermitian (Integer m, Integer n, double x[], const double trig[], NagError *fail)

## 3  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$, this function simultaneously calculates the Fourier transforms of all the sequences defined by
 $x ^ k p = 1 n ∑ j=0 n-1 z 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 are purely real.
The first call of nag_fft_multiple_hermitian (c06fqc) must be preceded by a call to nag_fft_init_trig (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
 $x ^ k p = 1 n ∑ j=0 n-1 z j p exp +2 π ijk / n .$
For that form, this function should be preceded by a call to nag_multiple_conjugate_hermitian (c06gqc) to form the complex conjugates of the ${\stackrel{^}{z}}_{j}^{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 code is included for the factors 2, 3, 4, 5 and 6.

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

## 5  Arguments

1:     mIntegerInput
On entry: the number of sequences to be transformed, $m$.
Constraint: ${\mathbf{m}}\ge 1$.
2:     nIntegerInput
On entry: the number of data values in each sequence, $n$.
Constraint: ${\mathbf{n}}\ge 1$.
3:     x[${\mathbf{m}}×{\mathbf{n}}$]doubleInput/Output
On entry: the $m$ Hermitian sequences must be stored consecutively in x in Hermitian form. Sequence 1 should occupy the first $n$ elements of x, sequence 2 the elements $n$ to $2n-1$, so that in general sequence $p$ occupies the array elements $\left(p-1\right)n$ to $pn-1$. If the $n$ data values ${z}_{j}^{p}$ are written as ${x}_{j}^{p}+{iy}_{j}^{p}$, then for $0\le j\le n/2$, ${x}_{j}^{p}$ should be in array element ${\mathbf{x}}\left[\left(p-1\right)×n+j\right]$ and for $1\le j\le \left(n-1\right)/2$, ${y}_{j}^{p}$ should be in array element ${\mathbf{x}}\left[\left(p-1\right)×n+n-j\right]$.
On exit: the components of the $m$ discrete Fourier transforms, stored consecutively. Transform $p$ occupies the elements $\left(p-1\right)n$ to $pn-1$ of x overwriting the corresponding original sequence; thus 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 ^ 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 .$
4:     trig[$2×{\mathbf{n}}$]const doubleInput
On entry: trigonometric coefficients as returned by a call of nag_fft_init_trig (c06gzc). nag_fft_multiple_hermitian (c06fqc) makes a simple check to ensure that trig has been initialized and that the initialization is compatible with the value of n
5:     failNagError *Input/Output
The NAG error argument (see Section 3.6 in the Essential Introduction).

## 6  Error 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$.

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

The time taken is approximately proportional to $nm\mathrm{log}n$, 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.

## 9  Example

This program reads in sequences of real data values which are assumed to be Hermitian sequences of complex data stored in Hermitian form. The sequences are expanded into full complex form using nag_multiple_hermitian_to_complex (c06gsc) and printed. The discrete Fourier transforms are then computed (using nag_fft_multiple_hermitian (c06fqc)) and printed out. Inverse transforms are then calculated by calling nag_fft_multiple_real (c06fpc) followed by nag_multiple_conjugate_hermitian (c06gqc) showing that the original sequences are restored.

### 9.1  Program Text

Program Text (c06fqce.c)

### 9.2  Program Data

Program Data (c06fqce.d)

### 9.3  Program Results

Program Results (c06fqce.r)