anchor.diff:    (:documentation "Math object, used as a reference type."))
   
   ;;; Some wrapper functions.
  -(declaim (inline %math.abs %math.acos %math.acosh %math.asin %math.asinh
  -		 %math.atan %math.atanh %math.atan2 %math.cbrt %math.ceil
  -		 %math.clz32 %math.cos %math.cosh %math.exp %math.expm1
  -		 %math.floor %math.fround %math.hypot %math.imul %math.log
  -		 %math.log1p %math.log10 %math.log2 %math.max %math.min
  -		 %math.pow %math.random %math.round %math.sign %math.sin
  -		 %math.sinh %math.sqrt %math.tan %math.tanh %math.trunc))
  +(declaim (inline -math.abs -math.acos -math.acosh -math.asin -math.asinh
  +		 -math.atan -math.atanh -math.atan2 -math.cbrt -math.ceil
  +		 -math.clz32 -math.cos -math.cosh -math.exp -math.expm1
  +		 -math.floor -math.fround -math.hypot -math.imul -math.log
  +		 -math.log1p -math.log10 -math.log2 -math.max -math.min
  +		 -math.pow -math.random -math.round -math.sign -math.sin
  +		 -math.sinh -math.sqrt -math.tan -math.tanh -math.trunc))
   
   ;;; All declarations shall be replaced by a implicit type conversion,
   ;;; which converts and handles the type error.
  -(defun %math.abs (x)
  +(defun -math.abs (x)
     (declare (type number-type x))
     (let ((n (slot-value x '-number-data)))
       (case n
  
positive.code: 	   (!number (atanh n))))))
  
  ;;; Add -0 as a case.
  (defun %math.atan2 (y x)
    (declare (type number-type y x))
    (let ((n (slot-value y '-number-data))
  	(m (slot-value x '-number-data)))
      (cond ((or (eql n :nan) (eql m :nan))
  	   *number-nan*)
  	  ((and (> n 0) (zerop m))
  	   (!number (/ +number-pi+ 2)))
  	  ((and (> m 0) (zerop n))
  	   *number-0*)
  	  ((and (zerop n) (zerop m))
  	   *number-0*)
  	  ((and (< m 0) (zerop n))
  	   (!number +number-pi+))
  	  ((and (< n 0) (zerop m))
  	   (!number (/ +number-pi+ 2)))
  	  ((and (> n 0) (eql m :infinity))
  	   *number-0*)
  	  ((and (> n 0) (eql m :-infinity))
  	   (!number +number-pi+))
  	  ((and (< n 0) (eql m :infinity))
  	   *number-0*)
  	  ((and (< n 0) (eql m :-infinity))
  	   (!number (- +number-pi+)))
  	  ((and (eql n :infinity) (eql m :infinity))
  
negative.code: 	  (t
  	   (!number (asinh n))))))
  
  (defun -math.atan (x)
    (declare (type number-type x))
    (let ((n (slot-value x '-number-data)))
      (cond ((eql n :nan)
  