anchor.diff:      (setf g
             (+ 1.0l0 (exp (- z))))
       (if (= g 1.0)
  -        (return-from logistic-regression (- 1 1.0e-10))
  +        (return-from logistic-regression (- 1 1.0e-5))
           (return-from logistic-regression (/ 1.0L0 g)))))
   
   (declaim (inline logistic-regression))
  
positive.code:            (coerce result 'double-float)))
      ))
  
  (defun find-function-min (func arglist &key (which nil) (alpha 0.005) (iterTime 7000))
    "find the min value in special function"
    (let ((result 0)
          (reArgs))
      (declare (inline partial-derivative-ge))
      (dotimes (tt iterTime)
        (let ((pd (partial-derivative-ge func arglist :which which))
              ;(costValue (apply func (loop for i in arglist collect (eval i))))
              (args (eval (elt arglist (1- which)))))
                                          ;(print pd)
                                          ;(print args)
          (setf (elt arglist (1- which))
                (make-array (length args) :initial-contents
                            (loop for i from 0 to (1- (length args)) collect
                                 (cond ((< (elt pd i) 0) (+ (elt args i) alpha))
                                       ((>= (elt pd i) 0) (- (elt args i) alpha))
                                       ))))
          #|(if (< (apply func (loop for i in arglist collect (eval i))) costValue)
              (setf reArgs (elt arglist (1- which))
                    result (apply func (loop for i in arglist collect (eval i))))
              )|#
          ))
      (print "find the min value for function")
      (apply func (loop for i in arglist collect (eval i)))
      ))
  
  ;;; exercise below
  (defvar *X*)
  
negative.code: (load "./package.lisp")
  (load "./gradient-descent.lisp")
  (in-package #:logistic-regression)
  
  (setf *random-state* (make-random-state t))
  
  (defun logistic-regression (z)
    "calculate the g(z), when g(z) larger than 0.5, return 1, else return 0"
  