anchor.diff:                       (:map :function ,#'logistic
                              :derivative ,#'logistic-derivative)
   
  +                     :sigmoid
  +                     (:map :function ,#'logistic
  +                           :derivative ,#'logistic-derivative)
  +
  +                     :tanh
  +                     (:map :function ,#'tanh
  +                           :derivative ,#'tanh-derivative)
  +
  +                     :identity
  +                     (:map :function ,#'identity
  +                           :derivative ,#'identity-derivative)
  +
                        :relu
                        (:map :function ,#'relu
                              :derivative ,#'relu-derivative)
   
                        :rectified-linear
                        (:map :function ,#'relu
  -                           :derivative ,#'relu-derivative)))
  +                           :derivative ,#'relu-derivative)
  +
  +                     :none
  +                     (:map :function ,#'no-activation
  +                           :derivative ,#'no-activation-derivative)))
             name function-or-derivative))
   
   (defclass t-net ()
  
positive.code: (defmethod get-neuron ((net t-net) (layer-index integer) (neuron-index integer))
    (elt (neuron-array (elt (layers net) layer-index)) neuron-index))
  
  (defmethod transfer ((neuron t-neuron))
    (setf (output neuron)
          (funcall (transfer-function neuron) (input neuron)))
  
negative.code:   (* output (- 1 output)))
  
  (defun relu (x)
    (max 0.0 x))
  
  (defun relu-derivative (x)
    (if (>= x 0.0) 1.0 0.0))
  
  (defun tanh-derivative (x) (- 1 (* x x)))
  
  (defun identity-derivative (x)
    (declare (ignore x))
    1)
  
  (defun no-activation (x) x)
  
  (defun no-activation-derivative (x) x)
  
  (defun transfer-functions (name function-or-derivative)
    (ds-get (ds `(:map :bound-logistic
  