(define vct-multiply! float-vector-multiply!)
(define vct-scale! float-vector-scale!)
(define vct-abs! float-vector-abs!)
(define vct-add! float-vector-add!)
(define vct-subtract! float-vector-subtract!)
(define vct-offset! float-vector-offset!)
(define vct-peak float-vector-peak)
(define vct-peak-and-location float-vector-peak-and-location)
(define vct-move! float-vector-move!)
(define vct-subseq float-vector-subseq)
(define vct->string float-vector->string)
(define vct* float-vector*)
(define vct+ float-vector+)
(define vct-max float-vector-max)
(define vct-min float-vector-min)
(define vct-ref float-vector-ref)
(define vct-set! float-vector-set!)
(define region->vct region->float-vector)
(define mix-vct mix-float-vector)
(define transform->vct transform->float-vector)
(define vct->channel float-vector->channel)
(define channel->vct channel->float-vector)
(define smooth-vct smooth-float-vector)
(define vct-polynomial float-vector-polynomial)
(define mix->vct mix->float-vector)
(define pan-mix-vct pan-mix-float-vector)
(define vct-size float-vector-size)
(define vct-copy copy)
(define vct-fill! fill!)
(define vct float-vector)
(define vct-length length)
(define vct-reverse! reverse!)  ; slight difference: no optional length arg (use subvector)
(define vct->list vector->list)
(define (list->vct x) (apply float-vector x))
(define make-vct make-float-vector)
(define (vector->vct v) (copy v (make-float-vector (length v))))
(define (vct->vector v) (copy v (make-vector (length v))))
(define vct? float-vector?)


(define data-format sample-type)
(define mus-sound-data-format mus-sound-sample-type)
(define mus-data-format-name mus-sample-type-name)
(define mus-data-format->string mus-sample-type->string)
(define default-output-data-format (dilambda 
				    (lambda () *default-output-sample-type*)
				    (lambda (val) (set! *default-output-sample-type* val))))


(define* (if-cursor-follows-play-it-stays-where-play-stopped (enable #t))
  (set! *with-tracking-cursor* (and enable :track-and-stay)))

(define* (find-channel func (beg 0) snd chn edpos) 
  (scan-channel func beg #f snd chn edpos))

(define scan-chan scan-channel)

(define* (map-chan proc beg end origin snd chn edpos) 
  (map-channel proc beg (- (+ end 1) beg) snd chn edpos origin))

(define multiply-arrays float-vector-multiply!)
(define mus-sound-frames mus-sound-framples)
(define region-frames region-framples)
(define selection-frames selection-framples)
(define transform-frames transform-framples)

