Numerical recipes

528 Chapter 12. Fast Fourier Transform
overwriting the input array of data. The three enclosing for loops (indices i2, i3,
and i1, from inside to outside) could in fact be done in any order — their actions all
commute. We chose the order shown because of the following considerations: (i) i3
should not be the inner loop, because if it is, then the recurrence relations on wr and
wi become burdensome. (ii) On virtual-memory machines, i1 should be the outer
loop, because (with C order of array storage) this results in the array data, which
might be very large, being accessed in block sequential order.
Note that the work done in rlft3 is quite (logarithmically) small, compared to
the associated complex FFT, fourn. Since C does not have a convenient complex
type, the operations are carried out explicitly below in terms of real and imaginary
parts. The routine rlft3 is based on an earlier routine by G.B. Rybicki.
#include
void rlft3(float ***data, float **speq, unsigned long nn1, unsigned long nn2,
unsigned long nn3, int isign)
Given a three-dimensional real array data[1..nn1][1..nn2][1..nn3] (where nn1 =1for
the case of a logically two-dimensional array), this routine returns (for isign=1) thecomplex
fast Fourier transform as two complex arrays: On output, data contains the zero and positive
frequency values of the third frequency component, while speq[1..nn1][1..2*nn2] contains
the Nyquist critical frequency values of the third frequency component. First (and second)
frequency components are stored for zero, positive, and negative frequencies, in standard wraparound
order. See text for description of how complex values are arranged. For isign=-1, the
inverse transform (times nn1*nn2*nn3/2 as a constant multiplicative factor) is performed,
with output data (viewed as a real array) deriving from input data (viewed as complex) and
speq. For inverse transforms on data not generated first by a forward transform, make sure
the complex input data array satisfies property (12.5.2). The dimensions nn1, nn2, nn3 must
always be integer powers of 2.
{
void fourn(float data[], unsigned long nn[], int ndim, int isign);
void nrerror(char error_text[]);
unsigned long i1,i2,i3,j1,j2,j3,nn[4],ii3;
double theta,wi,wpi,wpr,wr,wtemp;
float c1,c2,h1r,h1i,h2r,h2i;
if (1+&data[nn1][nn2][nn3]-&data[1][1][1] != nn1*nn2*nn3)
nrerror("rlft3: problem with dimensions or contiguity of data array\n");
c1=0.5;
c2 = -0.5*isign;
theta=isign*(6.28318530717959/nn3);
wtemp=sin(0.5*theta);
wpr = -2.0*wtemp*wtemp;
wpi=sin(theta);
nn[1]=nn1;
nn[2]=nn2;
nn[3]=nn3 >> 1;
if (isign == 1) { Case of forward transform.
fourn(&data[1][1][1]-1,nn,3,isign); Here is where most all of the com-
for (i1=1;i1