anchor.diff:  	   *number--infinity*)
   	  ((zerop n)
   	   *number-0*)
  +	  ((eql n :-0)
  +	   *number--0*)
   	  ((eql n :infinity)
   	   *number-infinity)
   	  (t
   	   (!number (log (1+ x)))))))
   
  -(defun %log10 (x)
  +(defun -math.log10 (x)
     (declare (type number-type x))
     (let ((n (slot-value x '-number-data)))
       (cond ((or (eql n :nan) (eql n :-infinity) (< n 0))
   	   *number-nan*)
  -	  ((zerop n)
  +	  ((or (zerop n) (eql n :-0))
   	   *number--infinity*)
   	  ((= n 1)
   	   *number-0*)
  
positive.code:       (t
         x))))
  
  (defun %math.acos (x)
    (declare (type number-type x))
    (let ((n (slot-value x '-number-data)))
      (cond ((eql n :nan)
  
negative.code:        *number-nan*)
        (0
         *number-0*)
        (:-0
         *number--0*)
        (:infinity
         *number-infinity*)
        (:-infinity
         (!number -1))
        (t
         (!number (- (exp x) 1))))))
  
  (defun -math.floor (x)
    (declare (type number-type x))
    (let ((n (slot-value x '-number-data)))
      (case n
        (:nan
         *number-nan*)
        (0
         *number-0*)
        (:-0
         *number--0*)
        (:infinity
         *number-infinity*)
        (:-infinity
         *number--infinity*)
        (t
         (!number (floor n))))))
  
  (defun -math.fround (x)
    (declare (type number-type x))
    (let ((n (slot-value x '-number-data)))
      (case n
        (:nan
         *number-nan*)
        ((0 :-0 :infinity :-infinity)
         x)
        (t
         (!number (fround n))))))
  