Update of /project/oct/cvsroot/oct In directory clnet:/tmp/cvs-serv7652

Modified Files: qd-extra.lisp qd-fun.lisp qd-rep.lisp qd.lisp timing2.lisp Log Message: Merge the changes from the THREE-ARG-BRANCH to HEAD.

--- /project/oct/cvsroot/oct/qd-extra.lisp 2007/10/26 15:48:15 1.5 +++ /project/oct/cvsroot/oct/qd-extra.lisp 2007/11/07 21:38:10 1.6 @@ -1099,14 +1099,14 @@ ;; Time Sparc PPC x86 PPC (fma) Sparc2 ;; exp-qd/reduce 2.06 3.18 10.46 2.76 6.12 ;; expm1-qd/series 8.81 12.24 18.87 3.26 29.0 -;; expm1-qd/dup 5.68 4.34 18.47 3.64 18.78 -;; exp-qd/pade 1.53 +;; expm1-qd/dup 5.68 4.34 18.47 3.64 9.77 +;; exp-qd/pade 1.53 4.51 ;; ;; Consing (MB) Sparc ;; exp-qd/reduce 45 45 638 44.4 45 ;; expm1-qd/series 519 519 1201 14.8 519 ;; expm1-qd/dup 32 32 1224 32.0 32 -;; exp-qd/pade 44 +;; exp-qd/pade 44 44 ;; ;; Speeds seem to vary quite a bit between architectures. ;; --- /project/oct/cvsroot/oct/qd-fun.lisp 2007/10/18 14:38:56 1.90 +++ /project/oct/cvsroot/oct/qd-fun.lisp 2007/11/07 21:38:10 1.91 @@ -47,6 +47,7 @@

#+cmu (declaim (ext:maybe-inline sqrt-qd)) +#+nil (defun sqrt-qd (a) "Square root of the (non-negative) quad-float" (declare (type %quad-double a) @@ -79,6 +80,47 @@ (setf r (add-qd r (mul-qd r (sub-d-qd half (mul-qd h (sqr-qd r))))))) (scale-float-qd (mul-qd r new-a) (ash k -1)))))

+(defun sqrt-qd (a) + "Square root of the (non-negative) quad-float" + (declare (type %quad-double a) + (optimize (speed 3) (space 0))) + ;; Perform the following Newton iteration: + ;; + ;; x' = x + (1 - a * x^2) * x / 2 + ;; + ;; which converges to 1/sqrt(a). + ;; + ;; However, there appear to be round-off errors when x is either + ;; very large or very small. So let x = f*2^(2*k). Then sqrt(x) = + ;; 2^k*sqrt(f), and sqrt(f) doesn't have round-off problems. + (when (zerop-qd a) + (return-from sqrt-qd a)) + (when (float-infinity-p (qd-0 a)) + (return-from sqrt-qd a)) + + (let* ((k (logandc2 (logb-finite (qd-0 a)) 1)) + (new-a (scale-float-qd a (- k)))) + (assert (evenp k)) + (let* ((r (make-qd-d (cl:/ (sqrt (the (double-float (0d0)) + (qd-0 new-a)))))) + (temp (%make-qd-d 0d0 0d0 0d0 0d0)) + (half 0.5d0) + (h (mul-qd-d new-a half))) + (declare (type %quad-double r)) + ;; Since we start with double-float precision, three more + ;; iterations should give us full accuracy. + (dotimes (k 3) + #+nil + (setf r (add-qd r (mul-qd r (sub-d-qd half (mul-qd h (sqr-qd r)))))) + (sqr-qd r temp) + (mul-qd h temp temp) + (sub-d-qd half temp temp) + (mul-qd r temp temp) + (add-qd r temp r) + ) + (mul-qd r new-a r) + (scale-float-qd r (ash k -1))))) + (defun hypot-aux-qd (x y) (declare (type %quad-double x y)) (let ((k (- (logb-finite (max (cl:abs (qd-0 x)) --- /project/oct/cvsroot/oct/qd-rep.lisp 2007/10/16 17:09:46 1.10 +++ /project/oct/cvsroot/oct/qd-rep.lisp 2007/11/07 21:38:10 1.11 @@ -81,6 +81,9 @@ (kernel:%make-double-double-float a2 a3))) )

+(defmacro %store-qd-d (target q0 q1 q2 q3) + (declare (ignore target)) + `(%make-qd-d ,q0 ,q1, q2, q3))

(defun qd-parts (qd) "Extract the four doubles comprising a quad-double and return them @@ -169,6 +172,15 @@ (setf (aref ,a 3) ,a3) ,a)))

+(defmacro %store-qd-d (target q0 q1 q2 q3) + (let ((dest (gensym "TARGET-"))) + `(let ((,dest ,target)) + (setf (aref ,dest 0) ,q0) + (setf (aref ,dest 1) ,q1) + (setf (aref ,dest 2) ,q2) + (setf (aref ,dest 3) ,q3) + ,dest))) + (defun qd-parts (qd) "Extract the four doubles comprising a quad-double and return them as multiple values. The most significant double is the first value." @@ -221,3 +233,81 @@ (declare (ignore x)) nil) ) ; end progn + + +(macrolet + ((frob (qd qd-t) + #+cmu + `(define-compiler-macro ,qd (a b &optional c) + (if c + `(setf ,c (,',qd-t ,a ,b nil)) + `(,',qd-t ,a ,b nil))) + #-cmu + `(define-compiler-macro ,qd (a b &optional (c (%make-qd-d 0d0 0d0 0d0 0d0))) + `(,',qd-t ,a ,b ,c)))) + (frob add-qd add-qd-t) + (frob mul-qd mul-qd-t) + (frob div-qd div-qd-t) + (frob add-qd-d add-qd-d-t) + (frob mul-qd-d mul-qd-d-t)) + +#+cmu +(define-compiler-macro sub-qd (a b &optional c) + (if c + `(setf ,c (add-qd-t ,a (neg-qd ,b) nil)) + `(add-qd-t ,a (neg-qd ,b) nil))) + +#-cmu +(define-compiler-macro sub-qd (a b &optional (c #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) + `(add-qd-t ,a (neg-qd ,b) ,c)) + +#+cmu +(define-compiler-macro sqr-qd (a &optional c) + (if c + `(setf ,c (sqr-qd-t ,a nil)) + `(sqr-qd-t ,a nil))) + +#-cmu +(define-compiler-macro sqr-qd (a &optional (c #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) + `(sqr-qd-t ,a ,c)) + +#+cmu +(define-compiler-macro add-d-qd (a b &optional c) + (if c + `(setf ,c (add-qd-d ,b ,a)) + `(add-qd-d ,b ,a))) + +#-cmu +(define-compiler-macro add-d-qd (a b &optional (c #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) + `(add-qd-d ,b ,a ,c)) + +#+cmu +(define-compiler-macro sub-qd-d (a b &optional c) + (if c + `(setf ,c (add-qd-d ,a (cl:- ,b))) + `(add-qd-d ,a (cl:- ,b)))) + +#-cmu +(define-compiler-macro sub-qd-d (a b &optional (c #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) + `(add-qd-d ,a (cl:- ,b) ,c)) + +#+cmu +(define-compiler-macro sub-d-qd (a b &optional c) + (if c + `(setf ,c (add-d-qd ,a (neg-qd ,b))) + `(add-d-qd ,a (neg-qd ,b)))) + +#-cmu +(define-compiler-macro sub-d-qd (a b &optional (c #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) + `(add-d-qd ,a (neg-qd ,b) ,c)) + +#+cmu +(define-compiler-macro neg-qd (a &optional c) + (if c + `(setf ,c (neg-qd-t ,a nil)) + `(neg-qd-t ,a nil))) + +#-cmu +(define-compiler-macro neg-qd (a &optional (c #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) + `(neg-qd-t ,a ,c)) + --- /project/oct/cvsroot/oct/qd.lisp 2007/10/18 14:38:11 1.60 +++ /project/oct/cvsroot/oct/qd.lisp 2007/11/07 21:38:10 1.61 @@ -132,6 +132,7 @@ add-d-qd add-dd-qd neg-qd + neg-qd-t sub-qd sub-qd-dd sub-qd-d @@ -159,13 +160,19 @@ renorm-4 renorm-5 add-qd-d + add-qd-d-t add-qd-dd add-qd + add-qd-t mul-qd-d + mul-qd-d-t mul-qd-dd mul-qd + mul-qd-t sqr-qd + sqr-qd-t div-qd + div-qd-t div-qd-d div-qd-dd))

@@ -179,12 +186,15 @@ make-qd-d add-qd-d add-d-qd add-qd-dd add-dd-qd - add-qd + add-qd add-qd-t neg-qd sub-qd sub-qd-dd sub-qd-d sub-d-qd - mul-qd-d mul-qd-dd mul-qd + mul-qd-d mul-qd-dd + mul-qd + mul-qd-t sqr-qd div-qd div-qd-d div-qd-dd + div-qd-t make-qd-dd ))

@@ -293,13 +303,17 @@ ;;;; Addition

;; Quad-double + double -(defun add-qd-d (a b) +(defun add-qd-d (a b &optional (target #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) + (add-qd-d-t a b target)) + +(defun add-qd-d-t (a b target) "Add a quad-double A and a double-float B" (declare (type %quad-double a) (double-float b) (optimize (speed 3) (space 0)) - (inline float-infinity-p)) + (inline float-infinity-p) + #+cmu (ignore target)) (let* ((c0 0d0) (e c0) (c1 c0) @@ -309,21 +323,22 @@ (two-sum c0 e (qd-0 a) b)

(when (float-infinity-p c0) - (return-from add-qd-d (%make-qd-d c0 0d0 0d0 0d0))) + (return-from add-qd-d-t (%store-qd-d target c0 0d0 0d0 0d0))) (two-sum c1 e (qd-1 a) e) (two-sum c2 e (qd-2 a) e) (two-sum c3 e (qd-3 a) e) (multiple-value-bind (r0 r1 r2 r3) (renorm-5 c0 c1 c2 c3 e) (if (and (zerop (qd-0 a)) (zerop b)) - (%make-qd-d c0 0d0 0d0 0d0) - (%make-qd-d r0 r1 r2 r3))))) + (%store-qd-d target c0 0d0 0d0 0d0) + (%store-qd-d target r0 r1 r2 r3)))))

-(defun add-d-qd (a b) +(defun add-d-qd (a b &optional (target #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) (declare (double-float a) (type %quad-double b) - (optimize (speed 3))) - (add-qd-d b a)) + (optimize (speed 3)) + #+cmu (ignore target)) + (add-qd-d b a #-cmu target))

#+cmu (defun add-qd-dd (a b) @@ -385,10 +400,16 @@ ;; which don't do a very good job with dataflow. CMUCL is one of ;; those compilers.

-(defun add-qd (a b) +(defun add-qd (a b &optional (target #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) + (add-qd-t a b target)) + + +(defun add-qd-t (a b target) (declare (type %quad-double a b) (optimize (speed 3) - (space 0))) + (space 0)) + #+cmu + (ignore target)) ;; This is the version that is NOT IEEE. Should we use the IEEE ;; version? It's quite a bit more complicated. ;; @@ -407,7 +428,7 @@ (inline float-infinity-p))

(when (float-infinity-p s0) - (return-from add-qd (%make-qd-d s0 0d0 0d0 0d0))) + (return-from add-qd-t (%store-qd-d target s0 0d0 0d0 0d0))) (let ((v0 (cl:- s0 a0)) (v1 (cl:- s1 a1)) (v2 (cl:- s2 a2)) @@ -441,19 +462,27 @@ (multiple-value-setq (s0 s1 s2 s3) (renorm-5 s0 s1 s2 s3 t0)) (if (and (zerop a0) (zerop b0)) - (%make-qd-d (+ a0 b0) 0d0 0d0 0d0) - (%make-qd-d s0 s1 s2 s3))))))))))) + (%store-qd-d target (+ a0 b0) 0d0 0d0 0d0) + (%store-qd-d target s0 s1 s2 s3)))))))))))

-(defun neg-qd (a) - (declare (type %quad-double a)) +;; Define some compiler macros to transform add-qd to add-qd-t +;; directly. For CMU, we always replace the parameter C with NIL +;; because we don't use it. For other Lisps, we create the necessary +;; object and call add-qd-t. +(defun neg-qd (a &optional (target #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) + (neg-qd-t a target)) + +(defun neg-qd-t (a target) + (declare (type %quad-double a) + #+cmu (ignore target)) (with-qd-parts (a0 a1 a2 a3) a (declare (double-float a0 a1 a2 a3)) - (%make-qd-d (cl:- a0) (cl:- a1) (cl:- a2) (cl:- a3)))) + (%store-qd-d target (cl:- a0) (cl:- a1) (cl:- a2) (cl:- a3))))

-(defun sub-qd (a b) +(defun sub-qd (a b &optional (target #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) (declare (type %quad-double a b)) - (add-qd a (neg-qd b))) + (add-qd-t a (neg-qd b) target))

#+cmu (defun sub-qd-dd (a b) @@ -461,16 +490,18 @@ (type double-double-float b)) (add-qd-dd a (cl:- b)))

-(defun sub-qd-d (a b) +(defun sub-qd-d (a b &optional (target #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) (declare (type %quad-double a) - (type double-float b)) - (add-qd-d a (cl:- b))) + (type double-float b) + #+cmu (ignore target)) + (add-qd-d a (cl:- b) #-cmu target))

-(defun sub-d-qd (a b) +(defun sub-d-qd (a b &optional (target #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) (declare (type double-float a) - (type %quad-double b)) + (type %quad-double b) + #+cmu (ignore target)) ;; a - b = a + (-b) - (add-d-qd a (neg-qd b))) + (add-d-qd a (neg-qd b) #-cmu target))

;; Works @@ -480,18 +511,22 @@ ;; Clisp says ;; 14.142135623730950488016887242096980785696718753769480731766797379908L0 ;; -(defun mul-qd-d (a b) +(defun mul-qd-d (a b &optional (target #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) + (mul-qd-d-t a b target)) + +(defun mul-qd-d-t (a b target) "Multiply quad-double A with B" (declare (type %quad-double a) (double-float b) (optimize (speed 3) (space 0)) - (inline float-infinity-p)) + (inline float-infinity-p) + #+cmu (ignore target)) (multiple-value-bind (p0 q0) (two-prod (qd-0 a) b)

(when (float-infinity-p p0) - (return-from mul-qd-d (%make-qd-d p0 0d0 0d0 0d0))) + (return-from mul-qd-d-t (%store-qd-d target p0 0d0 0d0 0d0))) (multiple-value-bind (p1 q1) (two-prod (qd-1 a) b) (declare (double-float p1 q1)) @@ -511,8 +546,8 @@ (multiple-value-bind (s0 s1 s2 s3) (renorm-5 s0 s1 s2 s3 s4) (if (zerop s0) - (%make-qd-d (float-sign p0 0d0) 0d0 0d0 0d0) - (%make-qd-d s0 s1 s2 s3))))))))) + (%store-qd-d target (float-sign p0 0d0) 0d0 0d0 0d0) + (%store-qd-d target s0 s1 s2 s3)))))))))

;; a0 * b0 0 ;; a0 * b1 1 @@ -602,11 +637,17 @@ ;; ;; Clisp says ;; 14.142135623730950488016887242096980785696718753769480731766797379908L0 -(defun mul-qd (a b) + +(defun mul-qd (a b &optional (target #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) + (mul-qd-t a b target)) + +(defun mul-qd-t (a b target) (declare (type %quad-double a b) (optimize (speed 3) (space 0)) - (inline float-infinity-p)) + (inline float-infinity-p) + #+cmu + (ignore target)) (with-qd-parts (a0 a1 a2 a3) a (declare (double-float a0 a1 a2 a3)) @@ -617,7 +658,7 @@ (two-prod a0 b0) #+cmu (when (float-infinity-p p0) - (return-from mul-qd (%make-qd-d p0 0d0 0d0 0d0))) + (return-from mul-qd-t (%store-qd-d target p0 0d0 0d0 0d0))) (multiple-value-bind (p1 q1) (two-prod a0 b1) (multiple-value-bind (p2 q2) @@ -662,8 +703,9 @@ (multiple-value-bind (r0 r1 s0 s1) (renorm-5 p0 p1 s0 s1 s2) (if (zerop r0) - (%make-qd-d p0 0d0 0d0 0d0) - (%make-qd-d r0 r1 s0 s1)))))))))))))) + (%store-qd-d target p0 0d0 0d0 0d0) + (%store-qd-d target r0 r1 s0 s1)))))))))))))) +

;; This is the non-sloppy version. I think this works just fine, but ;; since qd defaults to the sloppy multiplication version, we do the @@ -766,11 +808,16 @@ (multiple-value-call #'%make-qd-d (renorm-5 p0 p1 s0 t0 t1))))))))))))))))))))

-(defun sqr-qd (a) +(defun sqr-qd (a &optional (target #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) + (sqr-qd-t a target)) + +(defun sqr-qd-t (a target) "Square A" (declare (type %quad-double a) (optimize (speed 3) - (space 0))) + (space 0)) + #+cmu + (ignore target)) (multiple-value-bind (p0 q0) (two-sqr (qd-0 a)) (multiple-value-bind (p1 q1) @@ -810,14 +857,20 @@

(multiple-value-bind (a0 a1 a2 a3) (renorm-5 p0 p1 p2 p3 p4) - (%make-qd-d a0 a1 a2 a3))))))))) + (%store-qd-d target a0 a1 a2 a3)))))))))

-(defun div-qd (a b) +(defun div-qd (a b &optional (target #-cmu (%make-qd-d 0d0 0d0 0d0 0d0))) + (div-qd-t a b target)) + +#+nil +(defun div-qd-t (a b target) (declare (type %quad-double a b) (optimize (speed 3) (space 0)) - (inline float-infinity-p)) + (inline float-infinity-p) + #+cmu + (ignore target)) (let ((a0 (qd-0 a)) (b0 (qd-0 b))) (let* ((q0 (cl:/ a0 b0)) @@ -825,18 +878,46 @@ (q1 (cl:/ (qd-0 r) b0)))

(when (float-infinity-p q0) - (return-from div-qd (%make-qd-d q0 0d0 0d0 0d0))) + (return-from div-qd-t (%store-qd-d target q0 0d0 0d0 0d0))) (setf r (sub-qd r (mul-qd-d b q1))) (let ((q2 (cl:/ (qd-0 r) b0))) (setf r (sub-qd r (mul-qd-d b q2))) (let ((q3 (cl:/ (qd-0 r) b0))) (multiple-value-bind (q0 q1 q2 q3) (renorm-4 q0 q1 q2 q3) - (%make-qd-d q0 q1 q2 q3))))))) + (%store-qd-d target q0 q1 q2 q3))))))) + +(defun div-qd-t (a b target) + (declare (type %quad-double a b) + (optimize (speed 3) + (space 0)) + (inline float-infinity-p) + #+cmu + (ignore target)) + (let ((a0 (qd-0 a)) + (b0 (qd-0 b))) + (let* ((q0 (cl:/ a0 b0)) + (r (%make-qd-d 0d0 0d0 0d0 0d0))) + (mul-qd-d b q0 r) + (sub-qd a r r) + (let* ((q1 (cl:/ (qd-0 r) b0)) + (temp (mul-qd-d b q1))) + (when (float-infinity-p q0) + (return-from div-qd-t (%store-qd-d target q0 0d0 0d0 0d0))) + + (sub-qd r temp r) + (let ((q2 (cl:/ (qd-0 r) b0))) + (mul-qd-d b q2 temp) + (sub-qd r temp r) + (let ((q3 (cl:/ (qd-0 r) b0))) + (multiple-value-bind (q0 q1 q2 q3) + (renorm-4 q0 q1 q2 q3) + (%store-qd-d target q0 q1 q2 q3))))))))

(declaim (inline invert-qd))

-(defun invert-qd(v) ;; a quartic newton iteration for 1/v +(defun invert-qd (v) + ;; a quartic newton iteration for 1/v ;; to invert v, start with a good guess, x. ;; let h= 1-v*x ;; h is small ;; return x+ x*(h+h^2+h^3) . compute h3 in double-float --- /project/oct/cvsroot/oct/timing2.lisp 2007/10/16 14:21:13 1.4 +++ /project/oct/cvsroot/oct/timing2.lisp 2007/11/07 21:38:10 1.5 @@ -117,140 +117,143 @@ Test Time qd oct ---- ----------- -add 0.023 0.09 -mul 0.075 0.13 -div 0.299 0.29 -sqrt 0.105 0.11 -sin 0.115 0.14 -log 0.194 0.12 - -Times are in sec for the test. The default number of iterations were -used. Most of the timings match my expectations, including the log -test. Oct uses a different algorithm (Halley's method) which is -faster (in Lisp) than the algorithm used in qd (Newtwon iteration). +add 0.23 1.16 +mul 0.749 1.54 +div 3.00 3.11 +sqrt 10.57 12.2 +sin 57.33 64.5 +log 194 119 + +Times are in microsec/operation for the test. The default number of +iterations were used. Most of the timings match my expectations, +including the log test. Oct uses a different algorithm (Halley's +method) which is faster (in Lisp) than the algorithm used in qd +(Newtwon iteration).

+Not also that these times include the 3-arg versions of the routines.

------------------------------------------------------------------------------- The raw data:

The output from qd_timer -qd -v:

+Timing qd_real +-------------- + Timing addition... -n = 100000 t = 0.0231462 -b = 1.428571e+04 -100000 operations in 0.0231462 s. - 0.231462 us +n = 1000000 t = 0.236154 +b = 142857.142857 +1000000 operations in 0.236154 s. + 0.236154 us

Timing multiplication ... -n = 100000 t = 0.0749929 -b = 2.718268e+00 -100000 operations in 0.0749929 s. - 0.749929 us +n = 1000000 t = 0.748933 +b = 2.718280 +1000000 operations in 0.748933 s. + 0.748933 us

Timing division ... -n = 100000 t = 0.298858 -b = 0.367881 -100000 operations in 0.298858 s. - 2.988580 us +n = 1000000 t = 3.004328 +b = 0.367880 +1000000 operations in 3.004328 s. + 3.004328 us

Timing square root ... -n = 10000 t = 0.105049 +n = 100000 t = 1.057170 a = 2.821980 -10000 operations in 0.105049 s. - 10.504860 us +100000 operations in 1.057170 s. + 10.571696 us

Timing sin ... -n = 2000 t = 0.114943 +n = 20000 t = 1.146667 a = 3.141593 -2000 operations in 0.114943 s. - 57.471350 us +20000 operations in 1.146667 s. + 57.333335 us

Timing log ... -n = 1000 t = 0.193698 +n = 10000 t = 1.939869 a = -50.100000 -1000 operations in 0.193698 s. -193.697800 us -The output from CMUCL: +10000 operations in 1.939869 s. +193.986900 us + +-------------------------------------------------- +CMUCL results:

-QD> (time-add) +CL-USER> (oct::time-add 1000000)

; Evaluation took: -; 0.09 seconds of real time -; 0.1 seconds of user run time -; 0.0 seconds of system run time -; 147,285,856 CPU cycles +; 1.16 seconds of real time +; 0.98 seconds of user run time +; 0.18 seconds of system run time +; 1,845,637,904 CPU cycles ; 0 page faults and -; 7,200,016 bytes consed. +; 72,000,248 bytes consed. ; -n = 100000 -b = #q14285.7142857142857142857142857142857142857142857142857142857142855q0 -NIL -QD> (time-mul) +n = 1000000 +b = #q142857.142857142857142857142857142857142857142857142857142857142854q0 + +CL-USER> (oct::time-mul 1000000)

; Evaluation took: -; 0.13 seconds of real time -; 0.1 seconds of user run time -; 0.02 seconds of system run time -; 203,790,588 CPU cycles +; 1.53 seconds of real time +; 1.27 seconds of user run time +; 0.25 seconds of system run time +; 2,430,859,732 CPU cycles ; 0 page faults and -; 7,200,824 bytes consed. +; 72,000,248 bytes consed. ; -n = 100000 -b = #q2.71826823717448966803506482442604644797444693267782286300915989397q0 -NIL -QD> (time-div) +n = 1000000 +b = #q2.71828046931937688381979970845435639275164502668250771294016782123q0 + +CL-USER> (oct::time-div 1000000)

; Evaluation took: -; 0.29 seconds of real time -; 0.28 seconds of user run time -; 0.01 seconds of system run time -; 460,956,912 CPU cycles +; 3.11 seconds of real time +; 2.94 seconds of user run time +; 0.16 seconds of system run time +; 4,957,512,968 CPU cycles ; 0 page faults and -; 7,200,016 bytes consed. +; 72,000,248 bytes consed. ; -n = 100000 -b = #q0.36788128056098406210328658773118942247132502490133718973918140856q0 -NIL -QD> (time-sqrt 10000) +n = 1000000 +b = #q0.367879625111086265804761271038216553876450599098470428879260437304q0 +CL-USER> (oct::time-sqrt 100000)

; Evaluation took: -; 0.11 seconds of real time -; 0.1 seconds of user run time -; 0.0 seconds of system run time -; 173,209,708 CPU cycles +; 1.22 seconds of real time +; 1.1 seconds of user run time +; 0.1 seconds of system run time +; 1,938,798,996 CPU cycles ; 0 page faults and -; 2,402,560 bytes consed. +; 24,000,128 bytes consed. ; -n = 10000 +n = 100000 a = #q2.82198033014704783016853125515542796898998765943212617578596649019q0 -NIL -QD> (time-sin) + +CL-USER> (oct::time-sin 20000)

; Evaluation took: -; 0.14 seconds of real time -; 0.14 seconds of user run time -; 0.0 seconds of system run time -; 213,378,476 CPU cycles +; 1.29 seconds of real time +; 1.24 seconds of user run time +; 0.05 seconds of system run time +; 2,053,157,408 CPU cycles ; 0 page faults and -; 3,105,800 bytes consed. +; 27,751,144 bytes consed. ; -n = 2000 -a = #q3.14159265358979323846264338327950288419716939937510582097494459409q0 -NIL -QD> (time-log) +n = 20000 +a = #q3.14159265358979323846264338327950288419716939937510582097494458294q0 + +CL-USER> (oct::time-log 10000)

; Evaluation took: -; 0.12 seconds of real time -; 0.12 seconds of user run time -; 0.01 seconds of system run time -; 192,187,304 CPU cycles +; 1.19 seconds of real time +; 1.13 seconds of user run time +; 0.04 seconds of system run time +; 1,890,677,952 CPU cycles ; 0 page faults and -; 1,621,792 bytes consed. +; 16,197,536 bytes consed. ; -n = 1000 -a = #q-50.100000000000000000000000000000000000000000000000000000000208796q0 -NIL -QD> +n = 10000 +a = #q-50.100000000000000000000000000000000000000000000000000000552824575q0

---------------------------------------------- ||#