hide long namesshow long names
hide short namesshow short names
Integer type:  int32  int64  nag_int  show int32  show int32  show int64  show int64  show nag_int  show nag_int

PDF version (NAG web site, 64-bit version, 64-bit version)
Chapter Contents
Chapter Introduction
NAG Toolbox

NAG Toolbox: nag_sum_fft_hermitian_1d_rfmt (c06fb)

 Contents

    1  Purpose
    2  Syntax
    7  Accuracy
    9  Example

Purpose

nag_sum_fft_hermitian_1d_rfmt (c06fb) calculates the discrete Fourier transform of a Hermitian sequence of n complex data values (using a work array for extra speed).

Syntax

[x, ifail] = c06fb(x, 'n', n)
[x, ifail] = nag_sum_fft_hermitian_1d_rfmt(x, 'n', n)

Description

Given a Hermitian sequence of n complex data values zj  (i.e., a sequence such that z0  is real and z n-j  is the complex conjugate of zj , for j=1,2,,n-1), nag_sum_fft_hermitian_1d_rfmt (c06fb) calculates their discrete Fourier transform defined by
x^k = 1n j=0 n-1 zj × exp -i 2πjk n ,   k= 0, 1, , n-1 .  
(Note the scale factor of 1n  in this definition.) The transformed values x^k  are purely real (see also the C06 Chapter Introduction).
To compute the inverse discrete Fourier transform defined by
y^k = 1n j=0 n-1 zj × exp +i 2πjk n ,  
this function should be preceded by forming the complex conjugates of the z^k ; that is, xk=-xk, for k=n/2+2,,n.
nag_sum_fft_hermitian_1d_rfmt (c06fb) uses the fast Fourier transform (FFT) algorithm (see Brigham (1974)). There are some restrictions on the value of n (see Arguments).

References

Brigham E O (1974) The Fast Fourier Transform Prentice–Hall

Parameters

Compulsory Input Parameters

1:     xn – double array
The sequence to be transformed stored in Hermitian form. If the data values zj are written as xj + i yj, and if x is declared with bounds 0:n-1 in the function from which nag_sum_fft_hermitian_1d_rfmt (c06fb) is called, then for 0 j n/2, xj is contained in xj, and for 1 j n-1 / 2 , yj is contained in xn-j. (See also Real transforms in the C06 Chapter Introduction and Example.)

Optional Input Parameters

1:     n int64int32nag_int scalar
Default: the dimension of the array x.
n, the number of data values. The largest prime factor of n must not exceed 19, and the total number of prime factors of n, counting repetitions, must not exceed 20.
Constraint: n>1.

Output Parameters

1:     xn – double array
The components of the discrete Fourier transform x^k. If x is declared with bounds 0:n-1 in the function from which nag_sum_fft_hermitian_1d_rfmt (c06fb) is called, then x^k is stored in xk, for k=0,1,,n-1.
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
At least one of the prime factors of n is greater than 19.
   ifail=2
n has more than 20 prime factors.
   ifail=3
On entry,n1.
   ifail=4
An unexpected error has occurred in an internal call. Check all function calls and array dimensions. Seek expert help.
   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 subsequent inverse transform and comparing the results with the original sequence (in exact arithmetic they would be identical).

Further Comments

The time taken is approximately proportional to n × logn, but also depends on the factorization of n. nag_sum_fft_hermitian_1d_rfmt (c06fb) is faster if the only prime factors of n are 2, 3 or 5; and fastest of all if n is a power of 2.

Example

This example reads in a sequence of real data values which is assumed to be a Hermitian sequence of complex data values stored in Hermitian form. The input sequence is expanded into a full complex sequence and printed alongside the original sequence. The discrete Fourier transform (as computed by nag_sum_fft_hermitian_1d_rfmt (c06fb)) is printed out. It then performs an inverse transform using nag_sum_fft_real_1d_rfmt (c06fa) and conjugation, and prints the sequence so obtained alongside the original data values.
function c06fb_example


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

% Hermitian sequence x, stored in Hermitian form.
n = 7;
x = [0.34907;  0.5489;   0.74776;   0.94459;
     1.1385;   1.3285;   1.5137];

% DFT of x
[xtrans, ifail] = c06fa(x);

% Display in full complex form
z = nag_herm2complex(xtrans);
disp('Discrete Fourier Transform of x:');
disp(transpose(z));

% Inverse DFT of xtrans
[xres] = nag_hermconj(xtrans);
[xres, ifail] = c06fb(xres);

 
fprintf('Original sequence as restored by inverse transform\n\n');
fprintf('       Original   Restored\n');
for j = 1:n
  fprintf('%3d   %7.4f    %7.4f\n',j, x(j),xres(j));
end
 


function [z] = nag_herm2complex(x);
  n = int64(size(x,1));
  z(1) = complex(x(1));
  for j = 2:floor((n-1)/2) + 1
    z(j) = x(j) + i*x(n-j+2);
    z(n-j+2) = x(j) - i*x(n-j+2);
  end
  if (mod(n,2)==0)
    z(n/2+1) = complex(x(n/2+1));
  end

function [xconj] = nag_hermconj(x);
  n = size(x,1);
  n2 = floor((n+4)/2);
  xconj = x;
  for j = n2:n
    xconj(j) = -x(j);
  end
c06fb example results

Discrete Fourier Transform of x:
   2.4836 + 0.0000i
  -0.2660 + 0.5309i
  -0.2577 + 0.2030i
  -0.2564 + 0.0581i
  -0.2564 - 0.0581i
  -0.2577 - 0.2030i
  -0.2660 - 0.5309i

Original sequence as restored by inverse transform

       Original   Restored
  1    0.3491     0.3491
  2    0.5489     0.5489
  3    0.7478     0.7478
  4    0.9446     0.9446
  5    1.1385     1.1385
  6    1.3285     1.3285
  7    1.5137     1.5137

PDF version (NAG web site, 64-bit version, 64-bit version)
Chapter Contents
Chapter Introduction
NAG Toolbox

© The Numerical Algorithms Group Ltd, Oxford, UK. 2009–2015