comparison wavelet.cpp @ 5:5f3c32dc6e17

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

 #include <math.h>
 #include <string.h>
 #include "wavelet.h"
 #include "matrix.h"
 
+/** \file wavelet.h */
+
 //---------------------------------------------------------------------------
-/*
+/**
   function csqrt: real implementation of complex square root z=sqrt(x)
 
   In: xr and xi: real and imaginary parts of x
   Out:  zr and zi: real and imaginary parts of z=sqrt(x)
 

     zr=xi/2/ri;
     zi=ri;
   }
 }//csqrt
 
-/*
+/**
   function Daubechies: calculates the Daubechies filter of a given order p
 
   In: filter order p
   Out:  h[2p]: the 2p FIR coefficients
 

     as another N-point sequance. Level 1 details are found at N/2 points 1, 3, 5, ...,
     N-1; level 2 details are found at N/4 points 2, 6, ..., N-2; level 3 details are
     found at N/8 points 4, 12, ..., N-4; etc.
 */
 
-/*
+/**
   function dwtpqmf: in this implementation h and g are the same as reconstruction qmf filters. In fact
   the actual filters used are their mirrors and filter origin are aligned to the ends of the real
   filters, which turn out to be the starts of h and g.
 
   The inverse transform is idwtp(), the same as inversing dwtp().

   }
   delete[] tmp;
   return n;
 }//dwtpqmf
 
-/*
+/**
   function dwtp: in this implementation h and g can be different from mirrored reconstruction filters,
   i.e. the biorthogonal transform. h[0] and g[0] are aligned at the ends of the filters, i.e. h[-M+1:0],
   g[-M+1:0].
 
   In: in[Count]:  waveform data

   }
   delete[] tmp;
   return n;
 }//dwtp
 
-/*
+/**
   function dwtp: in this implementation h and g can be different size. h[0] and g[0] are aligned at the
   ends of the filters, i.e. h[-Mh+1:0], g[-Mg+1:0].
 
   In: in[Count]:  waveform data
       h[-Mh+1:0], g[-Mg+1:0]: quadratic mirror filter pair

   }
   delete[] tmp;
   return n;
 }//dwtp
 
-/*
+/**
   function dwtp: in this implementation h and g can be arbitrarily located: h from $sh to $eh, g from
   $sg to $eg.
 
   In: in[Count]:  waveform data
       h[sh:eh-1], g[sg:eg-1]: quadratic mirror filter pair

   }
   delete[] tmp;
   return n;
 }//dwtp
 
-/*
+/**
   function idwtp: periodic wavelet reconstruction by qmf
 
   In: in[Count]: wavelet transform in interleaved format
       h[M], g[M]: quadratic mirror filter pair
       N:  maximal time resolution

     L--;
   }
   delete[] tmp;
 }//idwtp
 
-/*
+/**
   function idwtp: in which h and g can have different length.
 
   In: in[Count]: wavelet transform in interleaved format
       h[Mh], g[Mg]: quadratic mirror filter pair
       N:  maximal time resolution

     L--;
   }
   delete[] tmp;
 }//idwtp
 
-/*
+/**
   function idwtp: in which h and g can be arbitrarily located: h from $sh to $eh, g from $sg to $eg
 
   In: in[Count]: wavelet transform in interleaved format
       h[sh:eh-1], g[sg:eg-1]: quadratic mirror filter pair
       N: maximal time resolution

   int c=1;
   for (int i=1; i<=k; i++) c=c*(n+1-i)/i;
   return c;
 }
 
-/*
+/**
   function splinewl: computes spline biorthogonal wavelet filters. This version of splinewl calcualtes
   the positive-time half of h and hm coefficients only.
 
   p1 and p2 must have the same parity. If p1 is even, p1 coefficients will be returned in h1; if p1 is
   odd, p1-1 coefficients will be returned in h1.

   delete[] _hh1;
   delete[] _hh2;
 }//splinewl
 
 
-/*
+/**
   function splinewl: calculates the analysis and reconstruction filter pairs of spline biorthogonal
   wavelet (h, g) and (hm, gm). h has the size p1+1, hm has the size p1+2p2-1.
 
   If p1+1 is odd, then all four filters are symmetric; if not, then h and hm are symmetric, while g and
   gm are anti-symmetric.

   }
   return -p1-p2+1;
 }//splinewl
 
 //---------------------------------------------------------------------------
-/*
+/**
   function wavpacqmf: calculate pseudo local cosine transforms using wavelet packet
 
   In: data[Count], Count=fr*WID, waveform data
       WID: largest scale, equals 2^ORDER
       wid: smallest scale, euqals 2^order

   }
 
   delete[] _data1;
 }//wavpacqmf
 
-/*
+/**
   function iwavpacqmf: inverse transform of wavpacqmf
 
   In: spec[Fr][Wid], Fr>M*2
       h[M], g[M], quadratic mirror filter pair
   Out: data[Fr*Wid]

     K=(K>>1);
   }
   delete[] _data1;
 }//iwavpacqmf
 
-/*
+/**
   function wavpac: calculate pseudo local cosine transforms using wavelet packet,
 
   In: data[Count], Count=fr*WID, waveform data
       WID: largest scale, equals 2^ORDER
       wid: smallest scale, euqals 2^order

   }
 
   delete[] _data1;
 }//wavpac
 
-/*
+/**
   function iwavpac: inverse transform of wavpac
 
   In: spec[Fr][Wid]
       h[hs:he-1], g[gs:ge-1], reconstruction filter pair
   Out: data[Fr*Wid]