anchor.diff:                 (x0 (cadar closest)))
             (if (< t1 t0)
               (error "Can't go back in time."))
  -          (cond
  -            ((num-equal t0 t1)
  -             x0)
  -            (t
  -              (let ((graph (runge-kutta-graph the-ode x0 t0 t1 stepsize)))
  -                (insert-at closest graph)
  -                (cadar (last graph)))))))
  +          (if (num-equal t0 t1)
  +            x0
  +            (let1 (graph (runge-kutta-graph the-ode x0 t0 t1 stepsize))
  +              (insert-at closest graph)
  +              (cadar (last graph))))))
         (lambda () known-graph))))
  
positive.code:   (let* ((dim (length x0))
           (rk-steps  (length *c*))
           (len (* dim rk-steps)))
      (labels ((weight-diff (kij fj) (- kij (* fj stepsize)))
               (eqs-for-ki (ki ode-system) (mapcar #'weight-diff ki ode-system))
               (ode-system-for-step (k) (flet ((ode-eval (ai ci)
                                                         (funcall ode
                                                                  (+ t0 (* ci stepsize))
                                                                  (eval-point x0 k ai))))
                                          (mapcar #'ode-eval *A* *c*)))
               (implicit-system (k-flat) (let ((k (split k-flat dim)))
                                           (mapcan #'eqs-for-ki k (ode-system-for-step k)))))
        (split (newton-solver #'implicit-system len) dim))))
  
  (defun runge-kutta-single-step (f x0 t0 stepsize)
    (let* ((solver (if *is-implicit* #'solve-implicit-rks #'solve-explicit-rks))
           (k (funcall solver f x0 t0 stepsize))
           (bk (mapcar (lambda (bi ki) (mapcar (lambda (kij) (* bi kij)) ki)) *b* k)))
      (apply #'mapcar (cons #'+ (cons x0 bk)))))
  
  (defun ensure-last-step (ode last-x last-t t1)
  
negative.code: (in-package :ode)
  
  (defstruct (butcher-tableau
               (:constructor make-butcher
                             (&optional (matrix '((0)))
                                        (weights '(1))
                                        (time-coeffs '(0))
                                        (is-implicit (not (lower-triangular-p matrix))))))
    (matrix :read-only)
    (weights :read-only)
    (time-coeffs :read-only)
  