anchor.diff:  (defconstant *num-points* 100)
   
   (defclass equation ()
  -  ((a        :reader equation-a    :initarg :a)
  -   (b        :reader equation-b    :initarg :b)
  -   (c        :reader equation-c    :initarg :c)
  -   (init-val :reader equation-init :initarg :init-val)
  -   (min      :reader equation-min  :initarg :min)
  -   (max      :reader equation-max  :initarg :max)))
  +  ((a        :reader equation-a    :initarg :a        :initform 0)
  +   (b        :reader equation-b    :initarg :b        :initform 0)
  +   (c        :reader equation-c    :initarg :c        :initform 0)
  +   (init-val :reader equation-init :initarg :init-val :initform 0)
  +   (min      :reader equation-min  :initarg :min      :initform 0)
  +   (max      :reader equation-max  :initarg :max      :initform 1)))
  +
  +(defmethod display ((e equation)
  +                    &optional (dest t))
  +  (format dest
  +          "~Dy'' + ~Dy' + ~Dy = 0; y(0) = ~D; ~D <= x <= ~D~%"
  +          (equation-a    e) (equation-b   e) (equation-c e)
  +          (equation-init e)
  +          (equation-min  e) (equation-max e)))
   
   (defclass solution ()
     ((c1 :reader solution-c1 :initarg :c1)
  
positive.code:    (r1 :reader solution-r1 :initarg :r1)
     (r2 :reader solution-r2 :initarg :r2)))
  
  (defclass real-distinct-solution (solution))
  
  (defclass real-repeated-solution (solution))
  
  (defclass       complex-solution (solution))
  
  (defmethod solution-y ((s real-distinct-solution))
    "y(x) = c_1 \\exp(r_1 x) + c_2 \\exp(r_2 x)"
  
negative.code:         (A  (solution-r1 s))
          (B  (solution-r2 s)))
      (lambda (x)
        (let ((Ax (* A x))
              (Bx (* B x)))
          (* (exp Ax)
             (+ (* A
                   (+ (* c1 (cos Bx))
                      (* c2 (sin Bx))))
                (* B
                   (- (* c2 (cos Bx))
                      (* c1 (sin Bx))))))))))
  
  (defmethod solution-y-prime-prime ((s complex-solution))
    "y(x) = \\exp(\\alpha x) \\left(
                \\alpha \\left( c_1 \\cos(\\beta x) + c_2 \\sin(\\beta x) \\right)
              + \\beta  \\left( c_2 \\cos(\\beta x) - c_1 \\sin(\\beta x) \\right)
            \\right)"
    (let ((c1 (solution-c1 s))
          (c2 (solution-c2 s))
          (A  (solution-r1 s))
          (B  (solution-r2 s)))
      (lambda (x)
        (let ((Ax (* A x))
              (Bx (* B x)))
          (* (exp Ax)
             (- (* A A
                   (+ (* c1 (cos Bx))
                      (* c2 (sin Bx))))
                (* 2 A B
                   (- (* c1 (sin Bx))
                      (* c2 (cos Bx))))
                (* B B
                   (+ (* c1 (cos Bx))
                      (* c2 (sin Bx))))))))))
  