----  Very Brief Documentation for the "FastFFT" Library  ----

	Copyright (c) 1997 Scott M. Ransom

	    *** LEGAL NOTICE: ***
   (borrowed and modified from Joerg Arndt's fxt package)

1.) The code herein is freeware.  You may use it at no cost
    and give it away to other people.

2.) You should always attach a copy of the original package
    to your derived work that you give away (at least a pointer to it).

3.) You are NOT allowed to make money with this code in any way.

4.) I make no guarantee about the code.  It could, and probably does,
    contain some nasty bug somewhere.

5.) Be nice and let me know if you use this package for something
    interesting/noticable/scientific.

          *** End of Legal Notice ***


What is it?

This package contains heavily modified code from Mikko Tommila's
Apfloat package.  The original code performed a six-step number-theoretic
transform on a data set to be used in his extended-precision numeric
software package.  The six-step algorithm is described in the following
paper by David Bailey:  

http://science.nas.nasa.gov/Pubs/TechReports/RNRreports/dbailey/RNR-89-004/RNR-89-004.ps

The six-step algorithm treats the 1-D array as a 2-D array while doing the
FFT, allowing much greater memory locality (and therefore cache usage).
I am also implementing an out-of-core memory FFT routine based
on the two-pass algorithm described in the same paper.  This still has
a few bugs in it, but you are more than welcome to play with it.  (And
if you find the bugs, let me know!)

All of these routines do their math in double precision but the input and
output arrays are single precision.  The fastffts.h file shows the definitions
for all the routines, but the two most useful routines are:

void tablesixstepfft(float *indata, long nn, int isign);
 
where *indata is a float array containing "nn" complex data points.  For
example, 1 comple data point of 1.3+i2.5 would be two floats with the first
being 1.3 and the second being 2.5.  The output is the FFT in the same complex
number format.  "isign" give the sign of the exponential used in the FFT, -1
is for a normal forward FFT while 1 is for an inverse FFT.  (Note:  these
routines do not normalize the data by dividing by nn after an inverse FFT)

and

void realfft(float data[], unsigned long n, int isign);

where data[] is a float array containing "n" real data points.  The output
is exactly the same as the Numerical Recipes 2Ed real data FFT routine.
"isign" is the same as above.

The makefiles are very simple and can be easily modified to fit any
machine.  The default makefile is for Linux on a Pentium.  I have
also included a makefile for UltraSparc.  Just type make.

If you have any problems email me at:

ransom@cfa.harvard.edu

Hope you find this useful,

Scott M. Ransom
