tweaking from v12 while going over dissertation...


V.print_reals renamed to print_floats

IV.print_float renamed to print_floats
IV.write_float renamed to write_floats
added IV.print_ints

fixed bug in IV.vdelay_rec: set nu to buf_start, not 0

there is a problem with fan-out when e.g.
reader A asks for upto 1, then upto 2;
reader B just asks for upto 2.
B should get an error, but doesn't, 
because its !foo#compute call specifies only upto, not length.
this problem arises in allpass1 with len==1, for example.

===== reverb

the delay_rec framework really doesn't handle arbitrary multitap
read/write operations on delay lines.

if you compose the three sections of Gardner's large-room reverb, how
do you then tap from between them?

in terms of delay_rec, what is the delay and what is the feedback f?
the delay is that little 4ms at the end of the first section?
the f is everything else?

========

xbuf_start      time    
xbuf_upto       time    
xbuf_read_upto      time
xbuf_read_upto_ofs  offset  
buf_write_upto_ofs

while xbuf_read_upto <= new_upto
   if new_upto <= xbuf_upto
      copy from xbuf into buf: i = (xbuf_read_upto - xbuf_start) to new_upto-1
         xbuf_read_upto_ofs = xbuf_read_upto - xbuf_start
         buf_write_upto_ofs = buf_write_upto - buf_start
         blit xbuf xbuf_read_upto_ofs buf buf_ofs (new_upto - xbuf_read_upto)
      xbuf_read_upto <- new_upto
      buf_write_upto <- new_upto
   else
      copy entire xbuf into buf
      xbuf_start <- xbuf_upto
      xbuf_read_upto <- xbuf_start
      buf_write_upto += blocklen
      xbuf_upto += blocklen
      !x#compute xbuf_upto

=== fused blits

while xbuf_read_upto <= new_upto
   copy_upto = min(new_upto, xbuf_upto)
   copy from xbuf into buf
      xbuf_read_upto_ofs = xbuf_read_upto - xbuf_start
      buf_write_upto_ofs = buf_write_upto - buf_start
      blit xbuf xbuf_read_upto_ofs buf buf_ofs (copy_upto - xbuf_read_upto)
   xbuf_read_upto <- copy_upto
   buf_write_upto <- copy_upto

   if (copy_upto < new_upto)
      xbuf_start <- xbuf_upto
      xbuf_read_upto <- xbuf_start
      xbuf_upto += blocklen
      !x#compute xbuf_upto

=== w/ offsets

xbuf_start              time
xbuf_len                ofs
xbuf_read_upto          ofs
buf_write_upto          ofs

while (xbuf_start + xbuf_read_upto <= new_upto)
   if (new_upto <= xbuf_start + xbuf_len)
      copy from xbuf into buf
         len = new_upto - (xbuf_start + xbuf_read_upto)
         blit xbuf xbuf_read_upto buf buf_write_upto len
      xbuf_read_upto <- new_upto - xbuf_start
      buf_write_upto <- new_upto - buf_start
   else
