·  Home
+   man pages
 -> Linux -> FreeBSD -> OpenBSD -> NetBSD -> Tru64 Unix -> HP-UX 11i -> IRIX
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

man pages->IRIX man pages -> complib/csfft1du (3)
 Title
 Content
 Arch
 Section All Sections 1 - General Commands 2 - System Calls 3 - Subroutines 4 - Special Files 5 - File Formats 6 - Games 7 - Macros and Conventions 8 - Maintenance Commands 9 - Kernel Interface n - New Commands

### Contents

```
csfft1du,zdfft1du(3F)					 csfft1du,zdfft1du(3F)

```

### NAME[Toc][Back]

```     csfft1du, zdfft1du	- 1D, Complex to Real, Inverse Fast Fourier
Transforms.
```

### SYNOPSYS[Toc][Back]

```     Fortran :
subroutine	csfft1du( sign,	n, array, inc, coeff )
integer sign,	n, inc
real array(0:(2*((N+2)/2)-1)*inc), coeff(n+15)

subroutine	zdfft1du( sign,	n, array, inc, coeff )
integer sign,	n, inc
real*8 array(0:(2*((N+2)/2)-1)*inc), coeff(n+15)

C :
#include <fft.h>
int csfft1du ( int	sign, int n, float *array,
int inc,	float *coeff);
int zdfft1du ( int	sign, int n, double *array,
int inc,	double *coeff);

```

### DESCRIPTION[Toc][Back]

```     csfft1du and zdfft1du compute the real sequence of	N samples, from	its
Fourier transform.	The i-th index f(i) of a sequence with Fourier
transform F(k) is equal to:
f(i) = Sum ( W^(i*k) * F(k) ), for k =0, ...,	(N-1)
W = exp(	(Sign*2*sqrt(-1)*PI) / N )

The Inverse Fourier transform is performed	in-place, so the input Fourier
transform is overwritten by the final sequence output. As the output
sequence has real values, only the	first half of the transform is needed.
The (N-k)-th sample of the	transform would	be the conjugate of the	k-th
sample.

However, some extra space is necessary. For an N sample output sequence,
the input complex transform takes ((N+2)/2) complex values.  This
represents	either N+1(odd case) or	N+2(even case) real values, that's one
or	two more real values than the output real sequence.

```

### PARAMETERS[Toc][Back]

```     SIGN Integer specifying which sign	to be used for the expression of W
(see above) - must	be either +1 or	-1.
Unchanged on exit.

N Integer,	the number of samples in each sequence.
Unchanged on exit.

Page 1

csfft1du,zdfft1du(3F)					 csfft1du,zdfft1du(3F)

ARRAY Array containing the	Fourier	Transform.
On	output,	the element "i"	of the real sequence is	stored as A(i*inc) in
Fortran , and A[i*inc] in C.
On	exit, the array	is overwritten by its transform.

INC Integer, increment between two	consecutive elements of	a sequence.
Unchanged on exit.

COEFF Array of at least ( N + 15 )	elements.  On entry it contains	the
Sines/Cosines and factorization of	N. COEFF needs to be initialized with
a call to scfft1dui or dzfft1dui.
Unchanged on exit.

Example	of Calling Sequence
Working on	a sequences of 1024 real values.  We successively apply	a
Direct Fourier Transform, an Inverse Fourier Transform and	finally	scale
back the result by	a factor 1/N (1/1024.)-
This sequence DirectFFT-InverseFFT-Scaling	is equivalent to the identity
operator and the final sequence should be equal (with round-off
precision)	to the initial sequence.
Elements of each sequence are stored with increment (stride) 1, and the
offset between the	first element of two succesive sequence	(leading
dimension)	is 1026	(1026 >= 1024+2).
Fortran
real array(0:1026-1),	coeff(1024+15)
call scfft1dui( 1024,	coeff)
call csfft1du( -1, 1024, array, 1, coeff)
call scfft1du(  1, 1024, array, 1, coeff)
call sscal1d(	1024, (1./real(1024)), array, 1)

C
#include <fft.h>
float	array[1026], *coeff;
coeff	= scfft1dui( 1024, NULL);
csfft1du( -1,	1024, array, 1,	coeff);
scfft1du(  1,	1024, array, 1,	coeff);
sscal1d( 1024, 1./(float)1024, array,	1);

NOTE_1 : The Direct and Inverse transforms	should use opposite signs -
Which one is used (+1 or -1) for Direct transform is just a matter	of
convention
NOTE_2 : The Fourier Transforms are not normalized	so the succession
Direct-Inverse transform scales the input data by a factor	equal to the
size of the transform.
```

```     fft, scfft1dui, dzfft1dui,	scfft1du, dzfft1du, sscal1d, dscal1d