anchor.diff:  		       (k6 (.* step (funcall func (+ ti (* 1/2 step)) (reduce #'.+ (list yi (.* -8/27 k1) (.* 2 k2) (.* -3544/2565 k3) (.* 1859/4104 k4) (.* -11/40 k5))))))
   		       (rk4 (the (simple-array double-float *) (reduce #'.+ (list yi (.* 25/216 k1) (.* 1408/2565 k3) (.* 2197/4104 k4) (.* -1/5 k5)))))
   		       (rk5 (the (simple-array double-float *) (reduce #'.+ (list yi (.* 16/135 k1) (.* 6656/12825 k3) (.* 28561/56430 k4) (.* -9/50 k5) (.* 2/55 k6)))))
  -		       (err (/ (the double-float (norm (.- rk5 rk4)))
  +		       (err (/ (max (the double-float (norm (.- rk5 rk4))) double-float-epsilon)
   			       tolerance)))
  +		  (declare (type double-float err))
   		  ;; If err is less > one, the step is not precise enough
   		  ;; if it's smaller than .1, it's too precise!
   		  ;; also, don't adjust the size more than once...
   	(if (and (not looped)
  -		 (not (< (abs (the double-float err)) double-float-epsilon))
  -		 (or (> (abs (the double-float err)) 1d0)
  -		     (< (abs (the double-float err)) 1d-1)))
  -	    (progn (cond
  -		     ((> (abs (the double-float err)) 1d0)
  -		      (setf step (* step (expt (* 2d0 err) -1/4))))
  -		     ((< (abs (the double-float err)) 1d-1)
  -		      (setf step (* step (expt (* 2d0 err) -1/5)))))
  -		   (setf looped t))
  -
  +		 (or (> (abs err) 1d0)
  +		     ;; I'm pretty ok with things being a bit too precise for now
  +		     (< (abs err) 1d-3)))
  +	    (setf step (* step 8d-1 (expt (* 2d0 err) -1/6))
  +		  looped t)
  +	    
   	    ;; Error is low enough, keep the value
   	    (progn
   	      ;; If there's not enough space, make the arrays longer
   
   	      (when (= (1- (array-dimension ys 0)) i)
  -		(setf ys (adjust-array ys (list (* 2 (array-dimension ys 0)) array-width)))
  -		(setf ts (adjust-array ts (* 2 (length ts))))
  -)
  +		(adjust-array ys (list (* 2 (array-dimension ys 0)) array-width))
  +		(adjust-array ts (* 2 (length ts))))
  +
   	      (setf (aref ts i) (+ (the double-float ti) step))
   	      (loop for j from 0 upto (1- array-width)
   		 do (setf (aref ys i j) (elt rk5 j)))
  
positive.code: 
         ;; Stop at the end of the given interval
         until (>= ti (the double-float (range-stop range)))
  
         do (setf array-length i)
         do (loop
  	     with looped = nil
  
negative.code: t-range: a map:range object that contains the start and stop values and a suggested step as the interval.  Since the algorithm picks its own optimal step, it will use that value as guidance only.
  
  tolerance: tolerance"
    (declare (optimize (speed 3) (debug 0) (safety 0)))
    (let* ((array-width (length (the vector y0)))
  	 (array-length 100)
  	 (ys (make-array (list array-length array-width) :element-type 'double-float :adjustable t))
  	 (ts (make-array array-length :element-type 'double-float :adjustable t))
  	 (step (/ (- (range-stop range) (range-start range)) 1d2)))
      (declare (type function func)
  	     (type double-float tolerance)
  	     (type (simple-vector *) y0))
  