(define (linear-select v p)
  (assert (and (>= p 0) (<= p 1)
               (vector? v)))
  (define (fn p0 p1 t)
    (+ (* (- p1 p0) t) p0))
  (define m (- (vector-length v) 1))
  (define f (* m p))
  (define idx (inexact->exact (floor  f)))
  (fn (vector-ref v idx)
      (vector-ref v (if (> (+ idx 1) m) m (+ idx 1)))
      (- f idx)))

(define (bezier-select v p)
  (assert (and (>= p 0) (<= p 1)
               (vector? v)))
  (define (fn n i)
    (/ (factorial n) (* (factorial i) (factorial (- n i)))))
  (define n (- (vector-length v) 1))
  (define (loop i b)
    (if (> i n)
        b
        (loop (+ i 1)
              (+ b (* (expt (- 1 p) (- n i))
                      (expt p i)
                      (vector-ref v i)
                      (fn n i))))))
  (loop 0 0))

(define (catmullrom-select v p)
  (assert (and (>= p 0) (<= p 1)
               (vector? v)))
  (define (fn p0 p1 p2 p3 t)
    (define v0 (* 0.5 (- p2 p0)))
    (define v1 (* 0.5 (- p3 p1)))
    (define t2 (expt t 2))
    (define t3 (expt t 3))
    (+ p1
       (* v0 t)
       (* (- v1 (* 2 v0) (* -3 p2) (* 3 p1)) t2)
       (* (+ (* 2 p1) (* -2 p2) v0 v1) t3)))
  (define m  (- (vector-length v) 1))
  (define f (* m p))
  (define i (floor f))
  (if
   (and (= (vector-ref v 0) (vector-ref v m))
        (< p 0))
   (let* ((f (* m (+ 1 p)))
          (i (floor f)))
     (fn (vector-ref v (modulo (+ i -1 m) m))
         (vector-ref v i)
         (vector-ref v (modulo (+ i 1) m))
         (vector-ref v (modulo (+ i 2) m))
         (- f i)))
   (cond
    ((< p 0) (- (vector-ref v 0)
                (fn (vector-ref v 0)
                    (vector-ref v 0)
                    (vector-ref v 1)
                    (vector-ref v 1)
                    (- f))
                (vector-ref v 0)))
    ((> p 1) (- (vector-ref v m)
                (fn (vector-ref v m)
                    (vector-ref v m)
                    (vector-ref v (- m 1))
                    (vector-ref v (- m 1))
                    (- f m))
                (vector-ref v m)))
    (else (fn (vector-ref v (inexact->exact (if (< 0 i) (- i 1) 0)))
              (vector-ref v (inexact->exact i))
              (vector-ref v (inexact->exact (if (< m (+ i 1)) m (+ i 1))))
              (vector-ref v (inexact->exact (if (< m (+ i 2)) m (+ i 2))))
              (- f i))))))