comparison fft.cpp @ 5:5f3c32dc6e17

* Adjust comment syntax to permit Doxygen to generate HTML documentation; add Doxyfile

 
 #include <string.h>
 #include <stdlib.h>
 #include "fft.h"
 
-//---------------------------------------------------------------------------
-/*
+/** \file fft.h */
+
+//---------------------------------------------------------------------------
+/**
   function Atan2: (0, 0)-safe atan2
 
   Returns 0 is x=y=0, atan2(x,y) otherwise.
 */
 double Atan2(double y, double x)
 {
   if (x==0 && y==0) return 0;
   else return atan2(y, x);
 }//Atan2
 
-/*
+/**
   function BitInv: inverse bit order of Value within an $Order-bit expression.
 
   In: integer Value smaller than 2^Order
 
   Returns an integer whose lowest Order bits are the lowest Order bits of Value in reverse order.

     Value=Value>>1;
   }
   return Result;
 }//BitInv
 
-/*
+/**
   function SetTwiddleFactors: fill w[N/2] with twiddle factors used in N-point complex FFT.
 
   In: N
   Out: array w[N/2] containing twiddle factors
 

     w[i].x=cos(tmp), w[i].y=sin(tmp);
   }
 }//SetTwiddleFactors
 
 //---------------------------------------------------------------------------
-/*
+/**
   function CFFTCbii: basic complex DIF-FFT module, applied after bit-inversed ordering of inputs
 
   In: Order: integer, equals log2(Wid)
       W[Wid/2]: twiddle factors
       X[Wid]: complex waveform

       X0+=ElemsPerGroup*2;
     }
   }
 }//CFFTCbii
 
-/*
+/**
   function CFFTC: in-place complex FFT
 
   In: Order: integer, equals log2(Wid)
       W[Wid/2]: twiddle factors
       X[Wid]: complex waveform

   }
   if (!bitinv1) free(bitinv);
   CFFTCbii(Order, W, X);
 }//CFFTC
 
-/*
+/**
   function CFFTC: complex FFT
 
   In: Input[Wid]: complex waveform
       Order: integer, equals log2(Wid)
       W[Wid/2]: twiddle factors

   if (Amp) for (i=0; i<N; i++) Amp[i]=sqrt(X[i].x*X[i].x+X[i].y*X[i].y);
   if (Arg) for (i=0; i<N; i++) Arg[i]=Atan2(X[i].y, X[i].x);
 }//CFFTC
 
 //---------------------------------------------------------------------------
-/*
+/**
   function CIFFTCbii: basic complex IFFT module, applied after bit-inversed ordering of inputs
 
   In: Order: integer, equals log2(Wid)
       W[Wid/2]: twiddle factors
       X[Wid]: complex spectrum

     X[i].x/=N;
     X[i].y/=N;
   }
 }//CIFFTCbii
 
-/*
+/**
   function CIFFTC: in-place complex IFFT
 
   In: Order: integer, equals log2(Wid)
       W[Wid/2]: twiddle factors
       X[Wid]: complex spectrum

   }
   if (!bitinv1) free(bitinv);
   CIFFTCbii(Order, W, X);
 }//CIFFTC
 
-/*
+/**
   function CIFFTC: complex IFFT
 
   In: Input[Wid]: complex spectrum
       Order: integer, equals log2(Wid)
       W[Wid/2]: twiddle factors

   if (bitinv) CIFFTC(Order, W, X, bitinv);
   else CIFFTC(Order, W, X);
 }//CIFFTC
 
 //---------------------------------------------------------------------------
-/*
+/**
   function CIFFTR: complex-to-real IFFT
 
   In: Input[Wid/2+1]: complex spectrum, imaginary parts of Input[0] and Input[Wid/2] are ignored
       Order: integer, equals log2(Wid)
       W[Wid/2]: twiddle factors

   for (int i=0; i<N; i++) X[i]*=norm;
   if (!hbitinv1) free(hbitinv);
 }//CIFFTR
 
 //---------------------------------------------------------------------------
-/*
+/**
   function CreateBitInvTable: creates a table of bit-inversed integers
 
   In: Order: interger, equals log2(size of table)
 
   Returns a pointer to a newly allocated array containing the table. The returned pointer must be freed

   return result;
 }//CreateBitInvTable
 
 
 //---------------------------------------------------------------------------
-/*
+/**
   function RFFTC_ual: unaligned real-to-complex FFT
 
   In: Input[Wid]: real waveform
       Order; integer, equals log2(Wid)
       W[Wid/2]: twiddle factors

   if (Amp) for (i=0; i<N; i++) Amp[i]=sqrt(X[i].x*X[i].x+X[i].y*X[i].y);
   if (Arg) for (i=0; i<N; i++) Arg[i]=Atan2(X[i].x, X[i].y);
 }//RFFTC_ual
 
 //---------------------------------------------------------------------------
-/*
+/**
   function RFFTCW: real-to-complex FFT with window
 
   In: Input[Wid]: real waveform
       Window[Wid]:  window function
       Order; integer, equals log2(Wid)

 
   RFFTC_ual(0, Amp, Arg, Order, W, X, hbitinv);
   if (!hbitinv1) free(hbitinv);
 }//RFFTCW
 
-/*
+/**
   function RFFTCW: real-to-complex FFT with window
 
   In: Input[Wid]: real waveform as _int16 array
       Window[Wid]:  window function
       Order; integer, equals log2(Wid)

   RFFTC_ual(0, Amp, Arg, Order, W, X, hbitinv);
   if (!hbitinv1) free(hbitinv);
 }//RFFTCW
 
 //---------------------------------------------------------------------------
-/*
+/**
   function CFFTCW: complex FFT with window
 
   In: Window[Wid]: window function
       Order: integer, equals log2(Wid)
       W[Wid/2]: twiddle factors

   int N=1<<Order;
   for (int i=0; i<N; i++) X[i].x*=Window[i], X[i].y*=Window[i];
   CFFTC(Order, W, X, bitinv);
 }//CFFTCW
 
-/*
+/**
   function CFFTCW: complex FFT with window
 
   In: Input[Wid]: complex waveform
       Window[Wid]: window function
       Order: integer, equals log2(Wid)

   for (int i=0; i<N; i++) X[i].x=Input[i].x*Window[i], X[i].y=Input[i].y*Window[i];
   CFFTC(X, Amp, Arg, Order, W, X, bitinv);
 }//CFFTCW
 
 //---------------------------------------------------------------------------
-/*
+/**
   function RDCT1: fast DCT1 implemented using FFT. DCT-I has the time scale 0.5-sample shifted from the DFT.
 
   In: Input[Wid]: real waveform
       Order: integer, equals log2(Wid)
       qW[Wid/8]: quarter table of twiddle factors

   if (createbitinv) free(qbitinv);
   free8(even);
 }//RDCT1
 
 //---------------------------------------------------------------------------
-/*
+/**
   function RDCT4: fast DCT4 implemented using FFT. DCT-IV has both the time and frequency scales
   0.5-sample or 0.5-bin shifted from DFT.
 
   In: Input[Wid]: real waveform
       Order: integer, equals log2(Wid)

     Output[N-1-2*i]=-gr*si-gi*co;
   }
 }//RDCT4
 
 //---------------------------------------------------------------------------
-/*
+/**
   function RIDCT1: fast IDCT1 implemented using FFT.
 
   In: Input[Wid]: DCT-I of some real waveform.
       Order: integer, equals log2(Wid)
       qW[Wid/8]: quarter table of twiddle factors

   if (createbitinv) free(qbitinv);
   free8(even);
 }//RIDCT1
 
 //---------------------------------------------------------------------------
-/*
+/**
   function RIDCT4: fast IDCT4 implemented using FFT.
 
   In: Input[Wid]: DCT-IV of some real waveform
       Order: integer, equals log2(Wid)
       hW[Wid/4]: half table of twiddle factors

     Output[N-1-2*i]=(-gr*si-gi*co)*i2N;
   }
 }//RIDCT4
 
 //---------------------------------------------------------------------------
-/*
+/**
   function RLCT: real local cosine transform of equal frame widths Wid=2^Order
 
   In: data[Count]: real waveform
       Order: integer, equals log2(Wid), Wid being the cosine atom size
       g[wid]: lap window, designed so that g[k] increases from 0 to 1 and g[k]^2+g[wid-1-k]^2=1

   free(hbitinv);
   free8(hx);
 }//RLCT
 
 //---------------------------------------------------------------------------
-/*
+/**
   function RILCT: inverse local cosine transform of equal frame widths Wid=2^Order
 
   In: spec[Fr][Wid]: the local cosine transform
       Order: integer, equals log2(Wid), Wid being the cosine atom size
       g[wid]: lap window, designed so that g[k] increases from 0 to 1 and g[k]^2+g[wid-1-k]^2=1.

 ////The following line can be removed if the corresponding line in RLCT(...) is removed
   for (int i=0; i<Count; i++) data[i]*=norm;
 }//RILCT
 
 //---------------------------------------------------------------------------
-/*
+/**
   function CMFTC: radix-2 complex multiresolution Fourier transform
 
   In: x[Wid]: complex waveform
       Order: integer, equals log2(Wid)
       W[Wid/2]: twiddle factors