anchor.diff:    (yscl 0.0)
     (type :mus-interp-none))
   
  -(defun new-delay (size initial-contents initial-element max-size type)
  +(defun make-delay (size initial-contents initial-element max-size type)
     (let ((lsize (round (or max-size size))))
  -    (make-instance 'delay
  -     :loc 0
  -     :size (floor size)
  -     :zsize lsize
  -     :zdly max-size
  -     :zloc (and max-size (- max-size size))
  -     :line (if initial-contents 
  -	       (make-double-array lsize :initial-contents initial-contents)
  -	       (if initial-element
  -		   (make-double-array lsize :initial-element (double initial-element))
  -		   (make-double-array lsize)))
  -     :type (or type
  -	       (if max-size
  -		   :mus-interp-linear
  -		   :mus-interp-none)))))
  +    (%make-delay
  +     (floor size) ;size
  +     (if initial-contents ;line
  +	 (make-double-array lsize :initial-contents initial-contents)
  +	 (if initial-element
  +	     (make-double-array lsize :initial-element (double initial-element))
  +	     (make-double-array lsize)))
  +     0 ;loc
  +     (and max-size (- max-size size)) ;zloc
  +     lsize ;zsize
  +     max-size ;zdly
  +     (or type ;type
  +	 (if max-size
  +	     :mus-interp-linear
  +	     :mus-interp-none)))))
   
   (defun tap (d &optional (offset 0.0))
     (if (delay-zdly d)
  -      (if (= offset 0.0) 
  +      (if (= offset 0.0)
   	  (aref (delay-line d) (delay-zloc d))
   	(array-interp (delay-line d) (- (delay-zloc d) offset) (delay-zsize d)))
  -    (if (= offset 0.0) 
  +    (if (= offset 0.0)
   	(aref (delay-line d) (delay-loc d))
         (aref (delay-line d) (floor (mod (- (delay-loc d) offset) (delay-size d)))))))
  -	  
  +
   (defun delay-tick (d input)
     (setf (aref (delay-line d) (delay-loc d)) (double input))
     (incf (delay-loc d))
  
positive.code:       (setf (oscil-phase gen) (mod (oscil-phase gen) +two-pi+)))))
  
  ;;;;triangle-wave
  (defstruct triangle-wave current-value freq phase base)
  	
  (defun fix-up-phase (s)
    (if (plusp (triangle-wave-phase s))
        (loop while (>= (triangle-wave-phase s) +two-pi+) do (decf (triangle-wave-phase s) +two-pi+))
      (loop while (minusp (triangle-wave-phase s)) do (incf (triangle-wave-phase s) +two-pi+))))
  
  (defun tri-val (amplitude phase)
    (* amplitude (if (< phase (/ pi 2.0)) phase 
  		 (if (< phase (/ (* 3.0 pi) 2.0))
  		     (- pi phase)
  		   (- phase +two-pi+)))))
  
  (defun new-triangle-wave (&key (frequency *default-frequency*) (amplitude 1.0) (initial-phase 0.0))
    (make-instance 'triangle-wave
  		 :current-value (/ (tri-val amplitude initial-phase) (/ pi 2.0))
  		 :base (/ (* 2 amplitude) pi)
  		 :phase initial-phase
  		 :freq (hz->radians frequency)))
  
  (defun triangle-wave (s &optional (fm 0.0))
    (prog1
  
negative.code: 
  
  ;;;;pulse-train
  (defstruct (pulse-train (:include triangle-wave)
  			(:constructor %make-pulse-train (current-value freq phase base))))
  
  (defun make-pulse-train (&optional (frequency *default-frequency*) (amplitude 1.0) (initial-phase +two-pi+))
    (%make-pulse-train
     0.0
     (hz->radians frequency)
     initial-phase	; this will give us an immediate pulse
     amplitude))		; another version alternates sign
  
  (defun pulse-train (s &optional (fm 0.0))
    (prog1
  