; wolves and rabbits

(define (zip . xss) (apply map list xss))

(define (wolves-rabbits init-rabbit rabbit-growth rabbit-death
                        init-wolf wolf-growth wolf-death limit)
  (let loop ((ts (list 0)) (rs (list init-rabbit)) (ws (list init-wolf)))
    (if (= (car ts) limit)
        (apply zip (map reverse (list ts rs ws)))
        (let* ((rabbit-deriv
                 (- (* rabbit-growth (car rs))
                    (* rabbit-death (car rs) (car ws))))
               (wolf-deriv
                 (- (* wolf-growth (car ws) (car rs))
                    (* wolf-death (car ws))))
               (rabbit-half
                 (+ (car rs) (/ rabbit-deriv 2)))
               (wolf-half
                 (+ (car ws) (/ wolf-deriv 2)))
               (rabbit-half-deriv
                 (- (* rabbit-growth rabbit-half)
                    (* rabbit-death rabbit-half wolf-half)))
               (wolf-half-deriv
                 (- (* wolf-growth wolf-half rabbit-half)
                    (* wolf-death wolf-half))))
          (loop (cons (+ (car ts) 1) ts)
                (cons (+ (car rs) rabbit-half-deriv) rs)
                (cons (+ (car ws) wolf-half-deriv) ws))))))

(for-each
  (lambda (x) (display x) (newline))
  (wolves-rabbits 40 0.1 0.01 15 0.005 0.1 200))