anchor.diff:               (setf (delta cx) 0)))
       neuron)
     (:method ((layer t-layer) &key max min)
  -    (declare (float max min))
  +    (declare (real max min))
       (loop for neuron across (neuron-array layer)
          do (randomize-weights neuron :max max :min min))
       layer)
     (:method ((net t-net) &key (max 0.25) (min (- max)))
  -    (declare (float max min))
  +    (declare (real max min))
       (loop for layer in (layers net) do
            (randomize-weights layer :max max :min min))
       net))
   
   (defgeneric anneal (object variance)
  -  (:method ((neuron t-neuron) (variance float))
  +  (:method ((neuron t-neuron) (variance real))
       (loop for cx in (cxs neuron)
          do (setf (weight cx)
                   (+ (weight cx)
                      (/ (* (weight cx) (random variance)) 2)))
          finally (return neuron)))
  -  (:method ((layer t-layer) (variance float))
  +  (:method ((layer t-layer) (variance real))
       (loop for neuron across (neuron-array layer)
          do (anneal neuron variance)
          finally (return layer)))
  -  (:method ((net t-net) (variance float))
  +  (:method ((net t-net) (variance real))
       (loop for layer in (layers net)
            do (anneal layer variance)
            finally (return net))))
  
positive.code:                  (or (not last-report-time)
                       (>= (- (get-internal-real-time) last-report-time) rf)))
         do (funcall report-function
                     :elapsed (elapsed start-time) :iteration i :mse mse)
           (setf last-report-time (get-internal-real-time))
         finally (let ((elapsed (elapsed start-time))
                       (status (if (> mse target-mse) "maxi" "target")))
                   (when report-function
                     (funcall report-function
                              :elapsed elapsed :iteration i :mse mse))
                   (when status-function
                     (funcall status-function
                              :net net
                              :status status
                              :elapsed elapsed
  
negative.code: (defun elapsed (start-time)
    (- (get-universal-time) start-time))
  
  (defun default-report-function (&key file elapsed iteration mse)
    (with-open-file (stream file :direction :output
                            :if-exists :append
                            :if-does-not-exist :create)
    (format stream "~as i~a e~a~%" elapsed iteration mse)))
  
  (defun default-status-function (&key file net status elapsed iteration mse)
    (declare (ignore net))
    (with-open-file (stream file :direction :output
                            :if-exists :append
                            :if-does-not-exist :create)
      (format stream "~a ~as i~a e~a~%" status elapsed iteration mse)))
  
  (defun default-logger-function (file message)
    (with-open-file (stream file :direction :output
                            :if-exists :append
                            :if-does-not-exist :create)
      (format stream "~a~%" message)))
  
  (defgeneric train (t-net t-set &key)
    (:method ((net t-net)
  