{ SYLMS.ASM      performs the LMS algorithm implemented with a symmetric
    transversal filter structure (even order)

            *****************************************************************
	    * 1) y(n)= SUM[wi(n)*[u(n-i)+u(n-M+i+1)]] for 0 =<i<= N-1       *
	    * where y(n)= FIR filter output, wi= filter weights             *
	    *   u= input samples in delay line, N= number of weights (taps),*
	    *   n= time index, and M= 2N= length of delay line              *
	    * 2) e(n)= d(n)-y(n), e(n)= error signal & d(n)= desired output *
	    * 3) wi(n+1)= wi(n)+STEPSIZE*e(n)*[u(n-i)+u(n-M+i+1)], 0=<i<=N-1*
	    *****************************************************************

     Written by: Wassim G. Najm , Analog Devices, DSP division, April 2 1991

     Calling parameters (inputs):
     f0= u(n)= input sample
     f1= d(n)= desired output

     Altered registers:
     f0, f1, f3, f4, f6, f7, f8, f9, f12, f13

     Computation cycles:
     sylms_alg: 2M+10 per iteration, sylms_init: 17+M

     Results (outputs):
     f13= y(n)= filter output
     f6= e(n)= filter error signal
     i8 -> Program Memory Data buffer of the filter weights

     Memory usage:
     pm code= 39 words, pm data= N words, dm data= 2N 
 }

#define	TAPS	        4
#define	STEPSIZE	0.005

.GLOBAL	sylms_init, sylms_alg;

.SEGMENT/DM     dm_data;
.VAR	deline_data[2*TAPS];
.ENDSEG;

.SEGMENT/PM     pm_data;
.VAR	weights[TAPS];
.ENDSEG;

.SEGMENT/PM     pm_code;
sylms_init:	b0=deline_data;
		b3=deline_data;
		m0=-1;
		m1=1;
		m2=TAPS+2;
		l0=2*TAPS; {circular delay line buffer of length M= 2N}
		l3=2*TAPS;
		b8=weights;
		b9=weights;
		m8=1;
		m9=-1;
		m10=-2; 
		l8=TAPS; {circular weight buffer}
		l9=TAPS;
		f7=STEPSIZE;
		f0=0.0;
		lcntr=2*TAPS, do clear_bufs until lce;
clear_bufs:	  dm(i0,m0)=f0, pm(i8,m8)=f0; {clear delay line & weights}
		rts;


sylms_alg:	dm(i0,m0)=f0, f4=pm(i8,m8); {store u(n) in delay line, f4=w0(n)}
		f8=f0*f4, f0=dm(i0,m0), f4=pm(i8,m8); {f8= u(n)*w0(n)}
					    	      {f0= u(n-1), f4= w1(n)}
        	f12=f0*f4, f0=dm(i0,m0), f4=pm(i8,m8);
			{f12= u(n-1)*w1(n), f0= u(n-2), f4= w2(n)}
		lcntr=TAPS-3, do macs until lce;
macs:		  f12=f0*f4, f8=f8+f12, f0=dm(i0,m0), f4=pm(i8,m8);
		{f12= u(n-i)*wi(n), f8= sum of prod, f0= u(n-i-1), f4=wi+1(n)}
		f12=f0*f4, f8=f8+f12, f0=dm(i0,m0), f9=pm(i8,m10);
			{f12= u(n-N+1)*wN-1(n), i8 -> wN-2(n)}
		lcntr=TAPS-1, do macs1 until lce;
macs1:		  f12=f0*f4, f8=f8+f12, f0=dm(i0,m0), f4=pm(i8,m9); {f4=wi-1(n)}
		f12=f0*f4, f8=f8+f12, i3=i0;
		f13=f8+f12, f9=dm(i0,m0), f12=pm(i8,m8);
			 { f13= y(n), i0 -> u(n-1), i8 -> w0(n) }
		f6=f1-f13, f4=dm(i3,m1); {f6= e(n), f4= u(n), i3 -> u(n-M+1)}
		f1=f6*f7, f3=dm(i3,m1); {f1= STEPSIZE*e(n), f3= u(n-M+1)}
		f4=f3+f4, f3=dm(i3,m1), f12=pm(i8,m8); 
				{f4= u(n)+u(n-M+1), f3= u(n-M+2), f12=w0(n)}
		f9=f1*f4, f0=dm(i0,m0); {f9= STEPSIZE*e(n)*[u(n)+u(n-M+1)]}
					{f0= u(n-1)}
		f4=f0+f3, f3=dm(i3,m1); {f4= u(n-1)+u(n-M+2), f3= u(n-M+3)}
		lcntr=TAPS-1, do update_weights until lce;
		  f9=f1*f4, f8=f9+f12, f0=dm(i0,m0), f12=pm(i8,m8);
		{f9= STEPSIZE*e(n)*[u(n-i-1)+u(n-M+2+i)], f8= wi(n+1)}
			{f4= u(n-2-i), f12= wi+1(n)}
update_weights:   f4=f0+f3, f3=dm(i3,m1), pm(i9,m8)=f8;
		{f4= u(n-2-i)+u(n-M+3+i), f3= u(n-M+4+i), store wi(n+1)}
		rts(db);
		f8=f9+f12, f0=dm(i0,m2);{i0 ->u(n+1) location in delay line}
		pm(i9,m8)=f8;

.ENDSEG;