nag_sum_fft_hermitian_2d (c06pw) computes the two-dimensional inverse discrete Fourier transform of a bivariate Hermitian sequence of complex data values.

Syntax

[x, ifail] = c06pw(m, n, y)

[x, ifail] = nag_sum_fft_hermitian_2d(m, n, y)

Description

nag_sum_fft_hermitian_2d (c06pw) computes the two-dimensional inverse discrete Fourier transform of a bivariate Hermitian sequence of complex data values

z_{j1 j2}

, for

j1 = 0, 1, \dots, m - 1

and

j2 = 0, 1, \dots, n - 1

The discrete Fourier transform is here defined by

{\hat{x}}_{k_{1} k_{2}} = \frac{1}{\sqrt{m n}} \sum_{j_{1} = 0}^{m - 1} \sum_{j_{2} = 0}^{n - 1} z_{j_{1} j_{2}} \times \exp (2 π i (\frac{j_{1} k_{1}}{m} + \frac{j_{2} k_{2}}{n})),

where

k_{1} = 0, 1, \dots, m - 1

and

k_{2} = 0, 1, \dots, n - 1

. (Note the scale factor of

\frac{1}{\sqrt{m n}}

in this definition.)

Because the input data satisfies conjugate symmetry (i.e.,

z_{k_{1} k_{2}}

is the complex conjugate of

z_{(m - k_{1}) k_{2}}

, the transformed values

{\hat{x}}_{k_{1} k_{2}}

are real.

A call of nag_sum_fft_real_2d (c06pv) followed by a call of nag_sum_fft_hermitian_2d (c06pw) will restore the original data.

This function calls nag_sum_fft_realherm_1d_multi_col (c06pq) and nag_sum_fft_complex_1d_multi_row (c06pr) to perform multiple one-dimensional discrete Fourier transforms by the fast Fourier transform (FFT) algorithm in Brigham (1974) and Temperton (1983).

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

Parameters

Compulsory Input Parameters

1: $m$ – int64int32nag_int scalar: $m$ , the first dimension of the transform.

Constraint: $m \geq 1$ .
2: $n$ – int64int32nag_int scalar: $n$ , the second dimension of the transform.

Constraint: $n \geq 1$ .
3: $y ((m / 2 + 1) \times n)$ – complex array: The Hermitian sequence of complex input dataset $z$ , where $z_{j1 j2}$ is stored in $y (j2 \times (m / 2 + 1) + j_{1})$ , for $j1 = 0, 1, \dots, m / 2$ and $j2 = 0, 1, \dots, n - 1$ . That is, if y is regarded as a two-dimensional array of dimension $(0 : m / 2, 0 : n - 1)$ , then $y (j_{1}, j_{2})$ must contain $z_{j_{1} j_{2}}$ .

Optional Input Parameters

None.

Output Parameters

1: $x (m \times n)$ – double array: The real output dataset $\hat{x}$ , where ${\hat{x}}_{k1 k2}$ is stored in $x (k2 \times m + k1)$ , for $k1 = 0, 1, \dots, m - 1$ and $k2 = 0, 1, \dots, n - 1$ . That is, if x is regarded as a two-dimensional array of dimension $(0 : m - 1, 0 : n - 1)$ , then $x (k_{1}, k_{2})$ contains ${\hat{x}}_{k_{1} k_{2}}$ .
2: $ifail$ – int64int32nag_int scalar: $ifail = 0$ unless the function detects an error (see Error Indicators and Warnings).

Error Indicators and Warnings

Errors or warnings detected by the function:

$ifail = 1$: Constraint: $m \geq 1$ .

$ifail = 2$: Constraint: $n \geq 1$ .

$ifail = 3$: An internal error has occurred in this function. Check the function call and any array sizes. If the call is correct then please contact NAG for assistance.

$ifail = - 99$: An unexpected error has been triggered by this routine. Please contact NAG.

$ifail = - 399$: Your licence key may have expired or may not have been installed correctly.

$ifail = - 999$: Dynamic memory allocation failed.

Accuracy

Some indication of accuracy can be obtained by performing a forward transform using nag_sum_fft_real_2d (c06pv) and a backward transform using nag_sum_fft_hermitian_2d (c06pw), and comparing the results with the original sequence (in exact arithmetic they would be identical).

Further Comments

The time taken by nag_sum_fft_hermitian_2d (c06pw) is approximately proportional to

m n \log (m n)

, but also depends on the factors of

m

and

n

. nag_sum_fft_hermitian_2d (c06pw) is fastest if the only prime factors of

m

and

n

are

2

3

and

5

, and is particularly slow if

m

n

is a large prime, or has large prime factors.

Workspace is internally allocated by nag_sum_fft_hermitian_2d (c06pw). The total size of these arrays is approximately proportional to

m n

Example

See Example in nag_sum_fft_real_2d (c06pv).

Open in the MATLAB editor: c06pw_example

function c06pw_example


fprintf('c06pw example results\n\n');

m = int64(5);
n = int64(2);
x = [0.010  0.346; 
     1.284  1.960; 
     1.754  0.855; 
     0.089  0.161; 
     1.004  1.844];

% Compute Transform
[y, ifail] = c06pv(m, n, x);
fprintf('\nComponents of discrete Fourier transform\n');
% Display as 2-d array
disp(reshape(y, m/2, n));

% Compute Inverse Transform
[x, ifail] = c06pw(m, n, y);
fprintf('Original sequence as restored by inverse transform\n');
% Display as 2-d array
disp(reshape(x, m, n));

c06pw example results


Components of discrete Fourier transform
   2.9431 + 0.0000i  -0.3241 + 0.0000i
  -0.0235 - 0.5576i  -0.4660 - 0.2298i
  -1.1666 + 0.6359i   0.3624 + 0.2615i

Original sequence as restored by inverse transform
    0.0100    0.3460
    1.2840    1.9600
    1.7540    0.8550
    0.0890    0.1610
    1.0040    1.8440

PDF version (NAG web site, 64-bit version, 64-bit version)

Chapter Contents

Chapter Introduction

NAG Toolbox