anchor.diff:    (sign (f input (averaged-weight-of learner) (averaged-bias-of learner))))
   
   ;;; Linear SVM
  -(defclass svm (learner)
  -  ((learning-rate :accessor learning-rate-of :initarg :learning-rate)
  -   (regularization-parameter :accessor regularization-parameter-of :initarg :regularization-parameter)
  -   (tmp-vec :accessor tmp-vec-of :initarg :tmp-vec)))
  +(defclass$ svm (learner) learning-rate regularization-parameter tmp-vec)
   
   (defun make-svm (input-dimension learning-rate regularization-parameter)
     (check-type input-dimension integer)
  
positive.code:   learner)
  
  ;;; Averaged Perceptron
  (defclass averaged-perceptron (perceptron)
    ((data-size :accessor data-size-of :initarg :data-size)
     (averaged-weight :accessor averaged-weight-of :initarg :averaged-weight)
     (averaged-bias :accessor averaged-bias-of :initarg :averaged-bias)
     (counter :accessor counter-of :initarg :counter)
     (tmp-vec :accessor tmp-vec-of :initarg :tmp-vec)))
  
  (defun make-averaged-perceptron (input-dimension data-size)
    (check-type input-dimension integer)
  
negative.code:   learner)
  
  ;;; AROW
  (defclass$ arow (learner) gamma sigma sigma0 tmp-vec1 tmp-vec2)
  
  (defun make-arow (input-dimension gamma)
    (check-type input-dimension integer)
    (check-type gamma double-float)
    (make-instance 'arow
       :input-dimension input-dimension
       :weight (make-dvec input-dimension 0d0) ; mu
       :bias 0d0                               ; mu0
       :gamma gamma
       :sigma (make-dvec input-dimension 1d0)
       :sigma0 1d0
       :tmp-vec1 (make-dvec input-dimension 0d0)
       :tmp-vec2 (make-dvec input-dimension 0d0)))
  
  (defmethod update ((learner arow) input training-label)
    (let* ((loss (- 1d0 (* training-label (f input (weight-of learner) (bias-of learner))))))
      (if (> loss 0d0)
        (let* ((beta (/ 1d0 (+ (sigma0-of learner)
  			     (inner-product (diagonal-matrix-multiplication (sigma-of learner)
  									    input
  									    (tmp-vec1-of learner))
  					    input)
  