anchor.diff:    (:documentation "This function uses the standard backprogation of
     error method to train the neural network on the given sample set
     within the given constraints. Training is achieved when the target
  -  error reaches a level that is equal to or below the given
  -  target-mse value, within the given number of iterations. The
  -  function returns t if training is achieved and nil otherwise. If
  -  training is not achieved, the caller can call again to train for
  -  additional iterations. If randomize-weights is set to true, then the
  -  function starts training from scratch. This function accepts
  -  callback parameters that allow the function to periodically report
  -  on the progress of training.")
  +  error reaches a level that is equal to or below the given target-mse
  +  value, within the given number of iterations. The function returns t
  +  if training is achieved and nil otherwise. If training is not
  +  achieved, the caller can call again to train for additional
  +  iterations. If randomize-weights is set to true, then the function
  +  starts training from scratch. This function accepts callback
  +  parameters that allow the function to periodically report on the
  +  progress of training. t-net is a list of alternating input and
  +  output lists, where each input/output list pair represents a single
  +  training vector.  Here's an example for the exclusive-or problem:
  +  '((0 0) (1) (0 1) (0) (1 0) (0) (1 1) (1))")
     (:method ((net t-net)
               (t-set list)
               &key 
  -            (target-mse 0.08)
  -            (max-iterations 10000)
  -            (report-frequency 1000)
  -            (report-function #'default-report-function)
  -            (status-function #'default-status-function)
  -            (logger-function nil)
  -            (randomize-weights nil))
  +              (target-mse 0.08)
  +              (max-iterations 10000)
  +              (report-frequency 1000)
  +              (report-function #'default-report-function)
  +              (status-function #'default-status-function)
  +              (logger-function nil)
  +              (randomize-weights nil)
  +              (annealing nil))
       (declare (float target-mse)
                (integer max-iterations report-frequency)
                (function report-function status-function))
  
positive.code:    (learning-rate :reader learning-rate :initarg :learning-rate :initform 0.1)
     (momentum :reader momentum :initarg :momentum :initform 0.3)
     (wi :accessor wi :initform 0)
     (transfer-function :reader transfer-function
                        :initarg :transfer-function
                        :initform #'transfer-function-1)
     (transfer-derivative :reader transfer-derivative
                          :initarg :transfer-derivative
                          :initform #'transfer-derivative-1)
     (layers :accessor layers)
     (next-id :accessor next-id :initform 0)))
  
  
negative.code:                    (randomize-weights net))
                 (when logger-function
                   (funcall logger-function "randomized weights")))
               (when (and annealing (> (- i last-anneal-iteration) annealing))
                 (anneal net 1.0)
                 (setf last-anneal-iteration i)
                 (when logger-function
  