comparison sinsyn.cpp @ 5:5f3c32dc6e17

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

 //---------------------------------------------------------------------------
-
 
 #include "align8.h"
 #include "sinsyn.h"
 #include "splines.h"
 
+/** \file sinsyn.h */
+
 //---------------------------------------------------------------------------
-/*
+/**
   function Sinuoid:	original McAuley-Quatieri synthesizer interpolation between two measurement points.
 
   In: T: length from measurement point 1 to measurement point 2
       a1, f1, p2: amplitude, frequency and phase angle at measurement point 1
       a2, f2, p2: amplitude, frequency and phase angle at measurement point 2

       f[t]=lf;
       la=la+da;
     }
 }//Sinusoid
 
-/*
+/**
   function Sinuoid:	original McAuley-Quatieri synthesizer interpolation between two measurement points,
   without returning interpolated sinusoid parameters.
 
   In: T: length from measurement point 1 to measurement point 2
       a1, f1, p2: amplitude, frequency and phase angle at measurement point 1

       la=la+da;
     }
 }//Sinusoid
 
 //---------------------------------------------------------------------------
-/*
+/**
   function Sinusoid_direct: synthesizes sinusoid over [CountSt, CountEn) from tronomial coefficients of
   amplitude and frequency, direct implementation.
 
   In: CountSt, CountEn
       aa, ab, ac, ad: trinomial coefficients of amplitude

     else data[i]=a*cos(ph);
   }
   p1=p1+2*M_PI*i*(fd+i*((fc/2)+i*((fb/3)+i*fa/4)));
 }//Sinusoid
 
-/*
+/**
   function Sinusoid: synthesizes sinusoid over [CountSt, CountEn) from tronomial coefficients of
   amplitude and frequency, recursive implementation.
 
   In: CountSt, CountEn
       a3, a2, a1, a0: trinomial coefficients of amplitude

     }
   }
   ph=p0+CountEn*(p1+CountEn*(p2+CountEn*(p3+CountEn*p4)));
 }
 
-/*
+/**
   function SinusoidExp: synthesizes complex sinusoid whose derivative log amplitude and frequency are
   trinomials
 
   In: CountSt, CountEn
       a3, a2, a1, a0: trinomial coefficients for the derivative of log amplitude

 	}
 	ea=e0+CountEn*(e1+CountEn*(e2+CountEn*(e3+CountEn*e4)));
 	ph=p0+CountEn*(p1+CountEn*(p2+CountEn*(p3+CountEn*p4)));
 }//SinusoidExp
 
-/*
+/**
   function SinusoidExp: synthesizes complex sinusoid piece whose derivative logarithm is h[M]'lamda[M].
   This version also synthesizes its derivative.
 
   In: h[M][T], dih[M][T]: basis functions and their difference-integrals
       lamda[M]: coefficients of h[M]

 		tmpexp+=dexp;
 		ds[t]=s[t]*dR;
 	}
 }//SinusoidExp
 
-/*
+/**
   function SinusoidExp: synthesizes complex sinusoid piece whose derivative logarithm is h[M]'lamda[M].
   This version does not synthesize its derivative.
 
   In: dih[M][T]: difference of integrals of basis functions h[M]
       lamda[M]: coefficients of h[M]

 		for (int m=0; m<M; m++)	dexp+=lamda[m]*dih[m][t];
 		tmpexp+=dexp;
 	}
 }//SinusoidExp
 
-/*
+/**
   function SinusoidExpA: synthesizes complex sinusoid whose log amplitude and frequency are trinomials
 
   In: CountSt, CountEn
       a3, a2, a1, a0: trinomial coefficients for log amplitude
       omg3, omg2, omg1, omg0: trinomial coefficients for angular frequency

 		data[i]=exp(cdouble(lea, lph));
 	}
 	ph=p0+CountEn*(p1+CountEn*(p2+CountEn*(p3+CountEn*p4)));
 }//SinusoidExpA
 
-/*
+/**
   function SinusoidExpA: synthesizes complex sinusoid whose log amplitude and frequency are trinomials
   with phase angle specified at both ends.
 
   In: CountSt, CountEn
       a3, a2, a1, a0: trinomial coefficients for log amplitude

 		double lph=p0+i*(p1+i*(p2+i*(p3+i*p4)));
 		data[i]=exp(cdouble(lea, lph+(i*i*(_q+i*_p))));
 	}
 }//SinusoidExpA
 
-/*
+/**
   function SinusoidExpA: synthesizes complex sinusoid piece whose log amplitude is h[M]'p[M] and
   frequency is h[M]'q[M]. This version also synthesizes its derivative.
 
   In: h[M][T], dh[M][T], dih[M][T]: basis functions and their derivatives and difference-integrals
       p[M], q[M]: real and imaginary parts of coefficients of h[M]

 		ds[t]=s[t]*cdouble(drr, dri);
 		tmpph+=dph;
 	}
 }//SinusoidExpA
 
-/*
+/**
   function SinusoidExpA: synthesizes complex sinusoid piece whose log amplitude is h[M]'p[M] and
   frequency is h[M]'q[M]. This version does not synthesize its derivative.
 
   In: h[M][T], dih[M][T]: basis functions and their difference-integrals
       p[M], q[M]: real and imaginary parts of coefficients of h[M]

 		s[t]=exp(cdouble(e, tmpph));
 		tmpph+=dph;
 	}
 }//SinusoidExpA
 
-/*
+/**
   function SinusoidExpA: synthesizes complex sinusoid piece whose log amplitude is h[M]'p[M] and
   frequency is h[M]'q[M] with phase angle specified at both ends. This version does not synthesize its
   derivative.
 
   In: h[M][T], dih[M][T]: basis functions and their difference-integrals

 	}
 	ea=e0+CountEn*(e1+CountEn*(e2+CountEn*(e3+CountEn*e4)));
 	ph=p0+CountEn*(p1+CountEn*(p2+CountEn*(p3+CountEn*p4)));
 }   //*/
 
-/*
+/**
   function Sinusoid: recursive cos-sin generator with trinomial frequency
 
   In: CountSt, CountEn
       f3, f2, f1, f0: trinomial coefficients of frequency
       ph: initial phase angle at 0 (NOT at CountSt)

     tmp=cdddph*cddddph-sdddph*sddddph; sdddph=sdddph*cddddph+cdddph*sddddph; cdddph=tmp;
   }
   ph=p0+CountEn*(p1+CountEn*(p2+CountEn*(p3+CountEn*p4)));
 }//Sinusoid*/
 
-/*
+/**
   function Sinusoids: recursive harmonic multi-sinusoid generator
 
   In: st, en
       M: number of partials
       a3[M], a2[M], a1[M], a0[M]: trinomial coefficients for partial amplitudes

   {
   }
   free8(a);
 }//Sinusoids*/
 
-/*
+/**
   function Sinusoid: synthesizes sinusoid piece from trinomial frequency and amplitude coefficients.
 
   In: CountSt, CountEn
       aa, ab, ac, ad: trinomial coefficients of amplitude.
       fa, fb, fc, fd: trinomial coefficients of frequency.

     if (add) data[i]+=a*cos(ph);
     else data[i]=a*cos(ph);
   }
 }//Sinusoid
 
-/*
+/**
   function Sinusoid: synthesizes sinusoid piece from trinomial frequency and amplitude coefficients,
   returning sinusoid coefficients instead of waveform.
 
   In: CountSt, CountEn
       aa, ab, ac, ad: trinomial coefficients of amplitude (or log amplitude if LogA=true)

 		f[i]=fd+i*(fc+i*(fb+i*fa))+i*(2*q+3*i*p)/(2*M_PI);
     ph[i]=ph0+2*M_PI*i*(fd+i*((fc/2)+i*((fb/3)+i*fa/4)))+i*i*(q+i*p);
 	}
 }//Sinusoid
 
-/*
+/**
   function Sinusoid: generates trinomial frequency and phase with phase correction.
 
   In: CountSt, CountEn
       fa, fb, fc, fd: trinomial coefficients of frequency.
       ph0, ph2: phase angles at 0 and CountEn.

 		f[i]=fd+i*(fc+i*(fb+i*fa))+i*(2*q+3*i*p)/(2*M_PI);
     ph[i]=ph0+2*M_PI*i*(fd+i*((fc/2)+i*((fb/3)+i*fa/4)))+i*i*(q+i*p);
 	}
 }//Sinusoid
 
-/*
+/**
   function SynthesizeSinusoid: synthesizes a time-varying sinusoid from a sequence of frequencies and amplitudes
 
   In: xs[Fr]: measurement points, should be integers although *xs has double type.
       fs[Fr], as[Fr]: sequence of frequencies and amplitudes at xs[Fr]
       phs[0]: initial phase angle at (int)xs[0].

          Sinusoid(&xrec[(int)xs[0]-dst], dst-xs[0], 0, a3[0], a2[0], a1[0], a0[0], f3[0], f2[0], f1[0], f0[0], phs[0], add);)
   delete[] f3;
   return xrec;
 }//SynthesizeSinusoid
 
-/*
+/**
   function ShiftTrinomial: shifts the origin of a trinomial from 0 to T
 
   In: a3, a2, a1, a0.
   Out: b3, b2, b1, b0, so that a3*x^3+a2*x^2+a1*x+a0=b3(x-T)^3+b2(x-T)^2+b1(x-T)+b0
 

   b2=a2+T*3*b3;
   b1=a1+T*(2*b2-T*3*b3);
   b0=a0+T*(b1-T*(b2-T*b3));
 }//ShiftTrinomial
 
-/*
+/**
   function SynthesizeSinusoidP: synthesizes a time-varying sinusoid from a sequence of frequencies,
   amplitudes and phase angles
 
   In: xs[Fr]: measurement points, should be integers although *xs has double type.
       fs[Fr], as[Fr], phs[Fr]: sequence of frequencies, amplitudes and phase angles at xs[Fr]