- cmucl-cvs - mailman3.common-lisp.net

[git] CMU Common Lisp branch rtoy-lisp-trig updated. snapshot-2013-12-a-10-g1266d1f
by rtoy＠common-lisp.net 08 Apr '15

08 Apr '15

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, rtoy-lisp-trig has been updated via 1266d1ff1eb938136e8ae684eb9e3be8009ec350 (commit) from 6ec982de562b883722c7efc85d44f9fada24b9ef (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 1266d1ff1eb938136e8ae684eb9e3be8009ec350 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Tue Dec 17 13:10:30 2013 -0800 Convert to using lisp-unit. diff --git a/src/tests/trig.lisp b/src/tests/trig.lisp index 57a5355..41e444a 100644 --- a/src/tests/trig.lisp +++ b/src/tests/trig.lisp @@ -1,238 +1,193 @@ -(rt:deftest sin.1 - (sin 0d0) - 0d0) - -(rt:deftest sin.2 - (sin -0d0) - -0d0) - -(rt:deftest sin.3 - ;; Tests the case for |x| < 2^-27, but not 0. - (sin (scale-float 1d0 -28)) - #.(scale-float 1d0 -28)) - -(rt:deftest sin.4 - ;; Just a random test, without argument reduction - (sin .5d0) - 0.479425538604203d0) - -(rt:deftest sin.5 - ;; Test for arg near pi/2 - (sin (/ pi 2)) - 1d0) - -(rt:deftest sin.red.0 - ;; Test for argument reduction with n mod 4 = 0 - (sin (* 7/4 pi)) - -7.07106781186547675943154203316156531867416581156d-1) - -(rt:deftest sin.red.1 +(defpackage :trig-tests + (:use :cl :lisp-unit)) + +(in-package "TRIG-TESTS") + +(define-test sin.signed-zeroes + "Test sin for 0d0 and -0d0" + (:tag :sin :signed-zeroes) + (assert-eql 0d0 (sin 0d0)) + (assert-eql -0d0 (sin -0d0))) + + +(define-test sin.very-small + "Tests sin for the case of |x| < 2^-27, but not 0." + (:tag :sin) + (assert-eql (scale-float 1d0 -28) + (sin (scale-float 1d0 -28)))) + +(define-test sin.no-reduction + "Test sin for small args without reduction" + (:tag :sin) + (assert-eql 0.479425538604203d0 + (sin .5d0)) + (assert-eql -0.479425538604203d0 + (sin -0.5d0))) + +(define-test sin.pi/2 + "Test for arg near pi/2" + (:tag :sin) + (assert-eql 1d0 (sin (/ pi 2)))) + +(define-test sin.arg-reduction + "Test for sin with arg reduction" + (:tag :sin) + ;; Test for argument reduction with n mod 4 = 0 + (assert-eql -7.07106781186547675943154203316156531867416581156d-1 + (sin (* 7/4 pi))) ;; Test for argument reduction with n mod 4 = 1 - (sin (* 9/4 pi)) - 7.07106781186547329560731709118834541043171055432d-1) - -(rt:deftest sin.red.2 - ;; Test for argument reduction with n mod 4 = 2 - (sin (* 11/4 pi)) - 7.07106781186548390575743300374993861263439430213d-1) - -(rt:deftest sin.red.3 - ;; Test for argument reduction with n mod 4 = 3 - (sin (* 13/4 pi)) - -7.07106781186547871002109559079472349116005337743d-1) - -(rt:deftest sin.misc.1 - ;; Test for argument reduction - (sin (scale-float 1d0 120)) - 0.377820109360752d0) - -(rt:deftest cos.1 - (cos 0d0) - 1d0) - -(rt:deftest cos.2 - (cos -0d0) - 1d0) - -(rt:deftest cos.3 - ;; Test for |x| < 2^-27 - (cos (scale-float 1d0 -28)) - 1d0) - -(rt:deftest cos.4 - ;; Test for branch |x| < .3 - (cos 0.25d0) - 0.9689124217106447d0) - -(rt:deftest cos.5 - ;; Test for branch |x| > .3 and \x| < .78125 - (cos 0.5d0) - 8.7758256189037271611628158260382965199164519711d-1) - -(rt:deftest cos.6 - ;; Test for branch |x| > .3 and |x| > .78125 - (cos 0.785d0) - 0.7073882691671998d0) - -(rt:deftest cos.7 - ;; Random test near pi/2 - (cos (/ pi 2)) - 6.123233995736766d-17) - -(rt:deftest cos.misc.1 - ;; Test for argument reduction - (cos (scale-float 1d0 120)) - -0.9258790228548379d0) - -(rt:deftest cos.red.0 + (assert-eql 7.07106781186547329560731709118834541043171055432d-1 + (sin (* 9/4 pi))) + ;; Test for argument reduction with n mod 4 = 2 + (assert-eql 7.07106781186548390575743300374993861263439430213d-1 + (sin (* 11/4 pi))) + ;; Test for argument reduction with n mod 4 = 3 + (assert-eql -7.07106781186547871002109559079472349116005337743d-1 + (sin (* 13/4 pi))) + ;; Test for argument reduction, big value + (assert-eql 0.377820109360752d0 + (sin (scale-float 1d0 120)))) + +(define-test sin.exceptions + "Test sin for exceptional values" + (:tag :sin :exceptions) + (kernel::with-float-traps-masked () + (assert-error 'floating-point-invalid-operation (sin ext:double-float-positive-infinity)) + (assert-error 'floating-point-invalid-operation (sin ext:double-float-negative-infinity)))) + +(define-test cos.signed-zeroes + "Test cos for 0d0 and -0d0" + (:tag :cos :signed-zeroes) + (assert-eql 1d0 (cos 0d0)) + (assert-eql 1d0 (cos -0d0))) + +(define-test cos.very-small + "Test cos for |x| < 2^-27" + (:tag :cos) + (assert-eql 1d0 (cos (scale-float 1d0 -28)))) + +(define-test cos.code-paths + "Tests various code paths in cos evaluation" + (:tag :cos) + ;; Test for branch |x| < .3 + (assert-eql 0.9689124217106447d0 + (cos 0.25d0)) + ;; Test for branch |x| > .3 and \x| < .78125 + (assert-eql 8.7758256189037271611628158260382965199164519711d-1 + (cos 0.5d0)) + ;; Test for branch |x| > .3 and |x| > .78125 + (assert-eql 0.7073882691671998d0 + (cos 0.785d0))) + +(define-test cos.pi/2 + "Test cos(pi/2)" + (:tag :cos) + (assert-eql 6.123233995736766d-17 + (cos (/ pi 2)))) + +(define-test cos.arg-reduction + "Test for cos with arg reduction" + (:tag :cos) ;; Test for argument reduction with n mod 4 = 0 - (cos (* 7/4 pi)) - 7.07106781186547372858534520893509069186435867941d-1) + (assert-eql 7.07106781186547372858534520893509069186435867941d-1 + (cos (* 7/4 pi))) + ;; Test for argument reduction with n mod 4 = 1 + (assert-eql 7.0710678118654771924095701509080985020443197242d-1 + (cos (* 9/4 pi))) + ;; Test for argument reduction with n mod 4 = 2 + (assert-eql -7.07106781186546658225945423833643190916000739026d-1 + (cos (* 11/4 pi))) + ;; Test for argument reduction with n mod 4 = 3 + (assert-eql -7.07106781186547177799579165130055836531929091466d-1 + (cos (* 13/4 pi))) + ;; Test for argument reduction + (assert-eql -0.9258790228548379d0 + (cos (scale-float 1d0 120)))) + +(define-test tan.signed-zeroes + "Test tan for 0d0 and -0d0" + (:tag :tan :signed-zeroes) + (assert-eql 0d0 (tan 0d0)) + (assert-eql -0d0 (tan -0d0))) + +(define-test tan.very-small + "Test for tan, |x| < 2^-28" + (:tag :tan) + (assert-eql (scale-float 1d0 -29) + (tan (scale-float 1d0 -29))) + (assert-eql (scale-float -1d0 -29) + (tan (scale-float -1d0 -29)))) + +(define-test tan.pi/2 + "Test for tan(pi/2)" + (:tag :tan) + (assert-eql 1.63312393531953697559677370415289165308640681049d16 + (tan (/ pi 2)))) + +(define-test tan.code-paths + "Tests for various code paths in tan" + (:tag :tan) + ;; |x| < .6744 + (assert-eql 5.4630248984379051325517946578028538329755172018d-1 + (tan 0.5d0)) + ;; |x = 11/16 = 0.6875 > .6744 + (assert-eql 8.21141801589894121911423965374711700875371645309d-1 + (tan (float 11/16 1d0))) + ;; This was found by maxima's testsuite. A bug in kernel-tan when + ;; returning cot(x). + (assert-eql 2.0000000000000028604455051971538975562294147582d0 + (tan 1.107148717794091d0))) + +(define-test tan.arg-reduction + "Test for tan with arg reduction" + (:tag :tan) + ;; Test for argument reduction with n even + (assert-eql -1.00000000000000042862637970157370388940976433505d0 + (tan (* 7/4 pi))) + ;; Test for argument reduction with n odd + (assert-eql 9.99999999999999448908940383691222098948324989275d-1 + (tan (* 9/4 pi))) + (assert-eql -4.08066388841804238545143494525595117765084022768d-1 + (tan (scale-float 1d0 120)))) + + +(define-test sincos.signed-zeroes + "Test sincos at 0d0, -0d0" + (:tag :sincos :signed-zeroes) + (assert-equal '(0d0 1d0) + (multiple-value-list (kernel::%sincos 0d0))) + (assert-equal '(-0d0 1d0) + (multiple-value-list (kernel::%sincos -0d0)))) + +(defun sincos-test (limit n) + (let (results) + (dotimes (k n) + (let* ((x (random limit)) + (s-exp (sin x)) + (c-exp (cos x))) + (multiple-value-bind (s c) + (kernel::%sincos x) + (unless (and (eql s s-exp) + (eql c c-exp)) + (push (list x + (list s s-exp) + (list c c-exp)) + results))))) + results)) + +(define-test sincos.consistent + "Test sincos is consistent with sin and cos" + (:tag :sincos) + ;; Small values + (assert-eql nil + (sincos-test (/ pi 4) 1000)) + ;; Medium + (assert-eql nil + (sincos-test 16d0 1000)) + ;; Large + (assert-eql nil + (sincos-test (scale-float 1d0 120) 1000)) + ;; Very large + (assert-eql nil + (sincos-test (scale-float 1d0 1023) 1000))) -(rt:deftest cos.red.1 - ;; Test for argument reduction with n mod 4 = 1 - (cos (* 9/4 pi)) - 7.0710678118654771924095701509080985020443197242d-1) - -(rt:deftest cos.red.2 - ;; Test for argument reduction with n mod 4 = 2 - (cos (* 11/4 pi)) - -7.07106781186546658225945423833643190916000739026d-1) - -(rt:deftest cos.red.3 - ;; Test for argument reduction with n mod 4 = 3 - (cos (* 13/4 pi)) - -7.07106781186547177799579165130055836531929091466d-1) - -(rt:deftest tan.1 - (tan 0d0) - 0d0) - -(rt:deftest tan.2 - (tan -0d0) - -0d0) - -(rt:deftest tan.3 - ;; |x| < 2^-28 - (tan (scale-float 1d0 -29)) - #.(scale-float 1d0 -29)) - -(rt:deftest tan.4 - ;; |x| < .6744 - (tan 0.5d0) - 5.4630248984379051325517946578028538329755172018d-1) - -(rt:deftest tan.5 - ;; |x = 11/16 = 0.6875 > .6744 - (tan (float 11/16 1d0)) - 8.21141801589894121911423965374711700875371645309d-1) - -(rt:deftest tan.6 - ;; This was found by maxima's testsuite. A bug in kernel-tan when - ;; returning cot(x). - (tan 1.107148717794091d0) - 2.0000000000000028604455051971538975562294147582d0) - -(rt:deftest tan.red.0 - ;; Test for argument reduction with n even - (tan (* 7/4 pi)) - -1.00000000000000042862637970157370388940976433505d0) - -(rt:deftest tan.red.1 - ;; Test for argument reduction with n odd - (tan (* 9/4 pi)) - 9.99999999999999448908940383691222098948324989275d-1) - -(rt:deftest tan.misc.1 - (tan (scale-float 1d0 120)) - -4.08066388841804238545143494525595117765084022768d-1) - - -(rt:deftest sincos.0 - (multiple-value-list (kernel::%sincos -0d0)) - (-0d0 1d0)) - -(rt:deftest sincos.1 - (let (results) - (dotimes (k 1000) - (let* ((x (random (/ pi 4))) - (s-exp (sin x)) - (c-exp (cos x))) - (multiple-value-bind (s c) - (kernel::%sincos x) - (unless (and (= s s-exp) - (= c c-exp)) - (push (list x - (list s s-exp) - (list c c-exp)) - results))))) - results) - nil) - -(rt:deftest sincos.2 - (let (results) - (dotimes (k 1000) - (let* ((x (random 16d0)) - (s-exp (sin x)) - (c-exp (cos x))) - (multiple-value-bind (s c) - (kernel::%sincos x) - (unless (and (= s s-exp) - (= c c-exp)) - (push (list x - (list s s-exp) - (list c c-exp)) - results))))) - results) - nil) - -(rt:deftest sincos.3 - (let (results) - (dotimes (k 1000) - (let* ((x (random (scale-float 1d0 120))) - (s-exp (sin x)) - (c-exp (cos x))) - (multiple-value-bind (s c) - (kernel::%sincos x) - (unless (and (= s s-exp) - (= c c-exp)) - (push (list x - (list s s-exp) - (list c c-exp)) - results))))) - results) - nil) - -(rt:deftest sincos.3a - (let (results) - (dotimes (k 1000) - (let* ((x (- (random (scale-float 1d0 120)))) - (s-exp (sin x)) - (c-exp (cos x))) - (multiple-value-bind (s c) - (kernel::%sincos x) - (unless (and (= s s-exp) - (= c c-exp)) - (push (list x - (list s s-exp) - (list c c-exp)) - results))))) - results) - nil) - -(rt:deftest sincos.4 - (let (results) - (dotimes (k 1000) - (let* ((x (random (scale-float 1d0 1023))) - (s-exp (sin x)) - (c-exp (cos x))) - (multiple-value-bind (s c) - (kernel::%sincos x) - (unless (and (= s s-exp) - (= c c-exp)) - (push (list x - (list s s-exp) - (list c c-exp)) - results))))) - results) - nil) ----------------------------------------------------------------------- Summary of changes: src/tests/trig.lisp | 425 +++++++++++++++++++++++---------------------------- 1 file changed, 190 insertions(+), 235 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[git] CMU Common Lisp branch master updated. snapshot-2014-09-12-g2451162
by rtoy＠common-lisp.net 08 Apr '15

08 Apr '15

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via 24511623e8c3ba1752339d2613bbd18ef27859b0 (commit) from 32ad743155af81b7c3e2ee31726272a85e8f3247 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 24511623e8c3ba1752339d2613bbd18ef27859b0 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Sat Sep 20 13:50:47 2014 -0700 Add fdlibm's log10. * src/code/irrat.lisp: * Define %log10 to use fdlibm's log10 * src/lisp/GNUmakefile * Compile e_log10 * tests/trig.lisp * Add tests for %log10. diff --git a/src/code/irrat.lisp b/src/code/irrat.lisp index 2591907..61d4314 100644 --- a/src/code/irrat.lisp +++ b/src/code/irrat.lisp @@ -81,7 +81,7 @@ ;;; Exponential and Logarithmic. (def-math-rtn ("__ieee754_exp" %exp) 1) (def-math-rtn ("__ieee754_log" %log) 1) -(def-math-rtn "log10" 1) +(def-math-rtn ("__ieee754_log10" %log10) 1) (def-math-rtn ("__ieee754_pow" %pow) 2) #-(or x86 sparc-v7 sparc-v8 sparc-v9) diff --git a/src/lisp/GNUmakefile b/src/lisp/GNUmakefile index c557d3b..d0d6104 100644 --- a/src/lisp/GNUmakefile +++ b/src/lisp/GNUmakefile @@ -12,6 +12,7 @@ FDLIBM = k_sin.c k_cos.c k_tan.c s_sin.c s_cos.c s_tan.c sincos.c \ e_acosh.c s_asinh.c e_atanh.c \ e_atan2.c \ e_rem_pio2.c k_rem_pio2.c \ + e_log10.c \ setexception.c SRCS = lisp.c coreparse.c alloc.c monitor.c print.c interr.c \ diff --git a/tests/trig.lisp b/tests/trig.lisp index 861a298..cdebe39 100644 --- a/tests/trig.lisp +++ b/tests/trig.lisp @@ -1006,3 +1006,24 @@ (assert-true (ext:float-nan-p (kernel:%atan *qnan*))) (kernel::with-float-traps-masked (:invalid) (assert-true (ext:float-nan-p (kernel:%atan *snan*))))) + +(define-test %log10.exceptions + (:tag :fdlibm) + ;; %log10(2^k) = k + (dotimes (k 23) + (assert-equalp k + (kernel:%log10 (float (expt 10 k) 1d0)))) + (assert-error 'division-by-zero + (kernel:%log10 0d0)) + (assert-error 'floating-point-invalid-operation + (kernel:%log10 -1d0)) + (assert-true (ext:float-nan-p (kernel:%log10 *qnan*))) + (assert-equal ext:double-float-positive-infinity + (kernel:%log10 ext:double-float-positive-infinity)) + (kernel::with-float-traps-masked (:divide-by-zero) + (assert-equal ext:double-float-negative-infinity + (kernel:%log10 0d0)) + (assert-equal ext:double-float-negative-infinity + (kernel:%log10 -0d0))) + (kernel::with-float-traps-masked (:invalid) + (assert-true (ext:float-nan-p (kernel:%log10 -1d0))))) ----------------------------------------------------------------------- Summary of changes: src/code/irrat.lisp | 2 +- src/lisp/GNUmakefile | 1 + tests/trig.lisp | 21 +++++++++++++++++++++ 3 files changed, 23 insertions(+), 1 deletion(-) hooks/post-receive -- CMU Common Lisp

1 0

[git] CMU Common Lisp branch master updated. snapshot-2014-08-31-g9b6ad20
by rtoy＠common-lisp.net 08 Apr '15

08 Apr '15

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via 9b6ad20132565202c72dec2dd2d8c6ee287c1601 (commit) from 0abe7883718b87b3dee2d8e3fb698183cbbca932 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 9b6ad20132565202c72dec2dd2d8c6ee287c1601 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Mon Aug 25 19:31:03 2014 -0700 Deprecate FLOAT-TRAPPING-NAN-P in favor of FLOAT-SIGNALING-NAN-P. These numbers are called signaling, not trapping NaN in almost all usages. * code/exports.lisp: * Export FLOAT-SIGNALING-NAN-P. * code/float.lisp: * Implement FLOAT-SIGNALING-NAN-P. * Make FLOAT-TRAPPING-NAN-P an inline call to the FLOAT-SIGNALING-NAN-P and add a docstring to say it is deprecated. * code/print.lisp: * Print "Signaling" instead of "Trapping". * i18n/locale/cmucl.pot: * Regenerated due to the changes in docstrings. diff --git a/src/code/exports.lisp b/src/code/exports.lisp index 0f224f6..d3c8fa7 100644 --- a/src/code/exports.lisp +++ b/src/code/exports.lisp @@ -1416,7 +1416,8 @@ "DOUBLE-FLOAT-NEGATIVE-INFINITY" "LONG-FLOAT-NEGATIVE-INFINITY" "GET-FLOATING-POINT-MODES" "SET-FLOATING-POINT-MODES" "FLOAT-DENORMALIZED-P" "FLOAT-INFINITY-P" - "FLOAT-NAN-P" "FLOAT-TRAPPING-NAN-P" + "FLOAT-NAN-P" "FLOAT-TRAPPING-NAN-P" + "FLOAT-SIGNALING-NAN-P" "WITH-FLOAT-TRAPS-MASKED") ;; More float extensions #+double-double diff --git a/src/code/float.lisp b/src/code/float.lisp index 9a7080d..cace1a4 100644 --- a/src/code/float.lisp +++ b/src/code/float.lisp @@ -57,7 +57,8 @@ single-float-negative-infinity short-float-negative-infinity double-float-negative-infinity long-float-negative-infinity set-floating-point-modes float-denormalized-p float-nan-p - float-trapping-nan-p float-infinity-p)) + float-trapping-nan-p float-infinity-p + float-signaling-nan-p)) #+double-double (export '(least-positive-normalized-double-double-float @@ -285,7 +286,7 @@ ;;;; Float predicates and environment query: (declaim (maybe-inline float-denormalized-p float-infinity-p float-nan-p - float-trapping-nan-p)) + float-signaling-nan-p)) ;;; FLOAT-DENORMALIZED-P -- Public ;;; @@ -344,7 +345,7 @@ #+double-double (float-infinity-p (double-double-hi x))) - (frob float-nan-p "Return true if the float X is a NaN (Not a Number)." + (frob float-nan-p "Return true if the float X is a quiet or signaling NaN (Not a Number)." (not (zerop (ldb vm:single-float-significand-byte bits))) (or (not (zerop (ldb vm:double-float-significand-byte hi))) (not (zerop lo))) @@ -354,8 +355,8 @@ #+double-double (float-nan-p (double-double-hi x))) - (frob float-trapping-nan-p - "Return true if the float X is a trapping NaN (Not a Number)." + (frob float-signaling-nan-p + "Return true if the float X is a signaling NaN (Not a Number)." (zerop (logand (ldb vm:single-float-significand-byte bits) vm:single-float-trapping-nan-bit)) (zerop (logand (ldb vm:double-float-significand-byte hi) @@ -364,8 +365,12 @@ (zerop (logand (ldb vm:long-float-significand-byte hi) vm:long-float-trapping-nan-bit)) #+double-double - (float-trapping-nan-p (double-double-hi x)))) + (float-signaling-nan-p (double-double-hi x)))) +(declaim (inline float-trapping-nan-p)) +(defun float-trapping-nan-p (x) + "Deprecated. Use FLOAT-SIGNALING-NAN-P instead." + (float-signaling-nan-p x)) ;;; FLOAT-PRECISION -- Public ;;; @@ -928,7 +933,7 @@ ;; Infinity is infinity, no matter how small... x) ((float-nan-p x) - (when (and (float-trapping-nan-p x) + (when (and (float-signaling-nan-p x) (vm:current-float-trap :invalid)) (error 'floating-point-invalid-operation :operation 'scale-float :operands (list x exp))) diff --git a/src/code/print.lisp b/src/code/print.lisp index f2a1205..778d827 100644 --- a/src/code/print.lisp +++ b/src/code/print.lisp @@ -1732,7 +1732,7 @@ radix-R. If you have a power-list then pass it in as PL." (defun output-float-nan (x stream) (print-unreadable-object (x stream) (write-string (float-format-name x) stream) - (write-string (if (float-trapping-nan-p x) " Trapping" " Quiet") stream) + (write-string (if (float-signaling-nan-p x) " Signaling" " Quiet") stream) (write-string " NaN" stream))) diff --git a/src/general-info/release-20f.txt b/src/general-info/release-20f.txt index 7179f1f..14c64b8 100644 --- a/src/general-info/release-20f.txt +++ b/src/general-info/release-20f.txt @@ -64,6 +64,10 @@ New in this release: CMUCL will not run on chips without SSE2 anymore. * (cosh 1000d0) signals an overflow error as it should. Previously, it just incorrectly returned infinity. + * Deprecating FLOAT-TRAPPING-NAN-P in favor of + FLOAT-SIGNALING-NAN-P. + * Changed the printer to print "Signaling" instead of "Trapping" + when printing a signaling NaN. * ANSI compliance fixes: * The values on the branch cuts for the inverse trig and diff --git a/src/i18n/locale/cmucl.pot b/src/i18n/locale/cmucl.pot index 15366ac..a885634 100644 --- a/src/i18n/locale/cmucl.pot +++ b/src/i18n/locale/cmucl.pot @@ -4783,11 +4783,15 @@ msgid "Return true if the float X is an infinity (+ or -)." msgstr "" #: src/code/float.lisp -msgid "Return true if the float X is a NaN (Not a Number)." +msgid "Return true if the float X is a quiet or signaling NaN (Not a Number)." msgstr "" #: src/code/float.lisp -msgid "Return true if the float X is a trapping NaN (Not a Number)." +msgid "Return true if the float X is a signaling NaN (Not a Number)." +msgstr "" + +#: src/code/float.lisp +msgid "Deprecated. Use FLOAT-SIGNALING-NAN-P instead." msgstr "" #: src/code/float.lisp ----------------------------------------------------------------------- Summary of changes: src/code/exports.lisp | 3 ++- src/code/float.lisp | 19 ++++++++++++------- src/code/print.lisp | 2 +- src/general-info/release-20f.txt | 4 ++++ src/i18n/locale/cmucl.pot | 8 ++++++-- 5 files changed, 25 insertions(+), 11 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[git] CMU Common Lisp branch master updated. snapshot-2014-06-96-g4b8c616
by rtoy＠common-lisp.net 08 Apr '15

08 Apr '15

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via 4b8c616db3f31214542a2793fa7365e464990f74 (commit) from c355485f5a73b92f3bf9a5fdc726bec9ffc15857 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 4b8c616db3f31214542a2793fa7365e464990f74 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Mon Aug 4 20:39:05 2014 -0700 Document that the argument/result timespec starts at 0, not 1. diff --git a/src/compiler/meta-vmdef.lisp b/src/compiler/meta-vmdef.lisp index 0b202de..bc679f0 100644 --- a/src/compiler/meta-vmdef.lisp +++ b/src/compiler/meta-vmdef.lisp @@ -1669,9 +1669,9 @@ :To Time-Spec Specify the beginning or end of the operand's lifetime. :From can only be used with results, and :To only with arguments. The default - for the N'th argument/result is (:ARGUMENT N)/(:RESULT N). These - options are necessary primarily when operands are read or written out - of order. + for the N'th argument/result is (:ARGUMENT N)/(:RESULT N). (The + first argument/result is number 0.) These options are necessary + primarily when operands are read or written out of order. :Conditional This is used in place of :RESULTS with conditional branch VOPs. There ----------------------------------------------------------------------- Summary of changes: src/compiler/meta-vmdef.lisp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[git] CMU Common Lisp branch master updated. snapshot-2014-03-4-g8e693e5
by rtoy＠common-lisp.net 08 Apr '15

08 Apr '15

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via 8e693e5bbc23fbfad188d2d6fd8b76be7fcef031 (commit) from 179e05df049f705f95eea224d1248ba5e979ce18 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 8e693e5bbc23fbfad188d2d6fd8b76be7fcef031 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Mon Mar 10 20:21:09 2014 -0700 Add unicode tests, based on the tests in src/i18n/tests. diff --git a/tests/unicode.lisp b/tests/unicode.lisp new file mode 100644 index 0000000..f863e31 --- /dev/null +++ b/tests/unicode.lisp @@ -0,0 +1,194 @@ +(defpackage :unicode-tests + (:use :cl :lisp-unit)) + +(in-package "UNICODE-TESTS") + +(defvar *normalization-test* "target:i18n/tests/NormalizationTest.txt") + +(defun parse-norm-line (line) + (declare (string line)) + (cond ((or (char= (aref line 0) #\@) + (char= (aref line 0) #\#)) + ;; Delete lines starting with # or @ + nil) + (t + ;; Split the line into columns. There are 5 columns. Column 6 is a comment. + (let* ((p1 (position #\; line)) + (p2 (position #\; line :start (1+ p1))) + (p3 (position #\; line :start (1+ p2))) + (p4 (position #\; line :start (1+ p3))) + (p5 (position #\; line :start (1+ p4)))) + (labels + ((convert (codes) + (let ((result nil)) + (map nil #'(lambda (x) + (multiple-value-bind (hi lo) + (lisp::surrogates x) + (push hi result) + (when lo (push lo result)))) + codes) + (coerce (nreverse result) 'simple-string))) + (read-values (string start end) + (with-input-from-string (s string :start start :end end) + (let ((*read-base* 16)) + (convert + (loop for x = (read s nil nil) while x collect x)))))) + (values (read-values line 0 p1) + (read-values line (1+ p1) p2) + (read-values line (1+ p2) p3) + (read-values line (1+ p3) p4) + (read-values line (1+ p4) p5))))))) + +(define-test unicode.nfd + "Test Unicode NFD normalization" + (:tag :unicode) + (with-open-file (testfile *normalization-test* :direction :input :external-format :iso8859-1) + (loop for line = (read-line testfile nil nil) while line do + (multiple-value-bind (c1 c2 c3 c4 c5) + (parse-norm-line line) + (when c1 + (let ((test1 (lisp::string-to-nfd c1)) + (test2 (lisp::string-to-nfd c2)) + (test3 (lisp::string-to-nfd c3)) + (test4 (lisp::string-to-nfd c4)) + (test5 (lisp::string-to-nfd c5))) + (assert-equalp (list c3 c3 c3 c5 c5) + (list test1 test2 test3 test4 test5)) + )))))) + +(define-test unicode.nfkd + "Test Unicode NFKD normalization" + (:tag :unicode) + (with-open-file (testfile *normalization-test* :direction :input :external-format :utf-8) + (loop for line = (read-line testfile nil nil) while line do + ;;(format t "line = ~S~%" line) + (multiple-value-bind (c1 c2 c3 c4 c5) + (parse-norm-line line) + (when c1 + (let ((test1 (lisp::string-to-nfkd c1)) + (test2 (lisp::string-to-nfkd c2)) + (test3 (lisp::string-to-nfkd c3)) + (test4 (lisp::string-to-nfkd c4)) + (test5 (lisp::string-to-nfkd c5))) + (assert-equalp (list c5 c5 c5 c5 c5) + (list test1 test2 test3 test4 test5)))))))) + +(define-test unicode.nfc + "Test Unicode NFC normalization" + (:tag :unicode) + (with-open-file (testfile *normalization-test* :direction :input :external-format :utf-8) + (loop for line = (read-line testfile nil nil) while line do + (multiple-value-bind (c1 c2 c3 c4 c5) + (parse-norm-line line) + (when c1 + (let ((test1 (lisp::string-to-nfc c1)) + (test2 (lisp::string-to-nfc c2)) + (test3 (lisp::string-to-nfc c3)) + (test4 (lisp::string-to-nfc c4)) + (test5 (lisp::string-to-nfc c5))) + (assert-equalp (list c2 c2 c2 c4 c4) + (list test1 test2 test3 test4 test5)))))))) + +(define-test unicode-nfkc + "Test Unicode NFKC normalization" + (:tag :unicode) + (with-open-file (testfile *normalization-test* :direction :input :external-format :utf-8) + (loop for line = (read-line testfile nil nil) while line do + (multiple-value-bind (c1 c2 c3 c4 c5) + (parse-norm-line line) + (when c1 + (let ((test1 (lisp::string-to-nfkc c1)) + (test2 (lisp::string-to-nfkc c2)) + (test3 (lisp::string-to-nfkc c3)) + (test4 (lisp::string-to-nfkc c4)) + (test5 (lisp::string-to-nfkc c5))) + (assert-equalp (list c4 c4 c4 c4 c4) + (list test1 test2 test3 test4 test5)))))))) + +(defvar *word-break-test* "target:i18n/tests/WordBreakTest.txt") + +(defun parse-word-break-line (line) + (let* ((eos (or (position #\# line) + (length line)))) + ;; See WordBreakTest.txt for the format of the file. Basically + ;; each test is on one line and consists of a marker and a + ;; codepoint. The marker indicates whether a break is allowed (a + ;; division sign for a break, a multiplication sign for no break). + ;; The test ends with a marker to indicate if a division is + ;; allowed at the end of the test. After this marker is a comment + ;; for the test. + (when (plusp eos) + ;; For each non-empty line, read the codepints into a string and + ;; the markers into a second array. The second array contains + ;; indices into the string where a break is allowed. + (let ((*read-base* 16) + (count 0) + (breaks (make-array 10 :fill-pointer 0)) + (string (make-array 10 :fill-pointer 0 :element-type 'character))) + (with-input-from-string (s line :end eos) + (flet ((handle-break (c) + (when (eql #\division_sign (char (string c) 0)) + (vector-push-extend count breaks)))) + (handle-break (read s)) + (incf count) + (loop + (let ((c (read s nil nil))) + (unless c + (return)) + ;; Handle codepoints outside the BMP carefully. + (if (> c #xffff) + (let ((s (lisp::codepoints-string (list c)))) + ;; Need to increment the count because of our + ;; UTF-16 encoding of strings. + (incf count) + (vector-push-extend (aref s 0) string) + (vector-push-extend (aref s 1) string)) + (vector-push-extend (code-char c) string)) + (let ((c (read s))) + (handle-break c)) + (incf count))))) + (values string breaks))))) + +(defun do-test (string breaks) + (let ((posn -1) + (count 0) + (string (coerce string 'simple-string))) + (loop + (let ((end (unicode:string-next-word-break string posn))) + (when (= end posn) + (return)) + (unless (= end (aref breaks count)) + (format t "Test failed!~%") + (format t " String = ~S~%" (map 'list #'char-name string)) + (format t " Breaks = ~S~%" breaks) + (format t " Expected ~S but got ~S for break #~D~%" (aref breaks count) end count) + (finish-output) + (return-from do-test nil)) + (setf posn end) + (incf count))) + t)) + +(define-test unicode.word-break + "Test Unicode word break algorithm" + (:tag :unicode) + (with-open-file (s *word-break-test* :direction :input :external-format :utf) + (loop for line = (read-line s nil nil) + while line + do + (progn + (multiple-value-bind (s b) + (parse-word-break-line line) + (when s + (flet ((do-test (string) + (let ((posn -1) + (string (coerce string 'simple-string)) + (computed-breaks (make-array 10 :fill-pointer 0))) + (loop + (let ((end (unicode:string-next-word-break string posn))) + (when (= end posn) + (return)) + (vector-push-extend end computed-breaks) + (setf posn end))) + computed-breaks))) + (assert-equalp b + (do-test s))))))))) \ No newline at end of file ----------------------------------------------------------------------- Summary of changes: tests/unicode.lisp | 194 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 194 insertions(+) create mode 100644 tests/unicode.lisp hooks/post-receive -- CMU Common Lisp

1 0

[git] CMU Common Lisp branch master updated. snapshot-2014-08-34-g1345f3b
by rtoy＠common-lisp.net 08 Apr '15

08 Apr '15

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via 1345f3b146c9840447fa7a943daf85f111011a7f (commit) from df548f6e69bc4fa0aec3825d10074135c9e4ac03 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 1345f3b146c9840447fa7a943daf85f111011a7f Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Tue Aug 26 20:29:56 2014 -0700 Use the two-prod algorithm from crlibm documentation. This handles overflows better and (c::two-prod 1.7976931214684583d308 (1+ (scale-float 1d0 -28))) doesn't signal an overflow like the old algorithm. diff --git a/src/compiler/float-tran.lisp b/src/compiler/float-tran.lisp index 7da6b95..ccb6e06 100644 --- a/src/compiler/float-tran.lisp +++ b/src/compiler/float-tran.lisp @@ -2289,22 +2289,9 @@ (kernel:%make-double-double-float hi lo)))) (declaim (maybe-inline split)) -;; This algorithm is the version given by Yozo Hida. It has problems -;; with overflow because we multiply by 1+2^27. -;; -;; But be very careful about replacing this with a new algorithm. The -;; values computed here are very important to get the rounding right. -;; If you change this, the rounding may be different, which will -;; affect other parts of the algorithm. -;; -;; I (rtoy) tried a different algorithm that split the number in two -;; as described, but without overflow. However, that caused -;; -9.4294948327242751340284975915175w0/1w14 to return a value that -;; wasn't really close to -9.4294948327242751340284975915175w-14. -;; -;; This also means we can't print numbers like 1w308 with the current -;; printing algorithm, or even divide 1w308 by 10. -#+nil +;; See Listing 2.6: Mul12 in "CR-LIBM: A library of correctly rounded +;; elementary functions in double-precision". Also known as Dekker's +;; algorithm. (defun split (a) "Split the double-float number a into a-hi and a-lo such that a = a-hi + a-lo and a-hi contains the upper 26 significant bits of a and @@ -2315,68 +2302,61 @@ (a-lo (- a a-hi))) (values a-hi a-lo))) -;; +split-limit+ is the largest number for which Yozo's algorithm -;; still works. Basically we want a*(1+2^27) <= -;; most-positive-double-float < 2^1024. Therefore, a < 2^1024/(1+2^27) -;; If we calculate that, we get a = 1.3393857490036326d300. A quick -;; test shows that this would cause overflow, but previous float would -;; not. This is the value we want. -(defconstant +split-limit+ - (scale-float (/ (float (1+ (expt 2 27)) 1d0)) 1024)) +;; Values used for scaling in two-prod. These are used to determine +;; if SPLIT might overflow so the value (and result) can be scaled to +;; prevent overflow. +(defconstant +two970+ + (scale-float 1d0 970)) -(defun split (a) - "Split the double-float number a into a-hi and a-lo such that a = - a-hi + a-lo and a-hi contains the upper 26 significant bits of a and - a-lo contains the lower 26 bits." - (declare (double-float a) - (optimize (speed 3) - (inhibit-warnings 3))) - ;; This splits the number a into 2 parts of 27 and 26 bits each, but - ;; the parts are, I think, supposed to be properly rounded in an - ;; IEEE fashion. - ;; - ;; For numbers that are very large, we use a different algorithm. - ;; For smaller numbers, we can use the original algorithm of Yozo - ;; Hida. - (if (>= (abs a) +split-limit+) - ;; I've tested this algorithm against Yozo's method for 1 - ;; billion randomly generated double-floats between 2^(-995) and - ;; 2^996, and identical results are obtained. For numbers that - ;; are very small, this algorithm produces different numbers - ;; because of underflow. For very large numbers, we, of course - ;; produce different results because Yozo's method causes - ;; overflow. - (let* ((tmp (* a (+ 1 (scale-float 1d0 -27)))) - (as (* a (scale-float 1d0 -27))) - (a-hi (* (- tmp (- tmp as)) (expt 2 27))) - (a-lo (- a a-hi))) - (values a-hi a-lo)) - ;; Yozo's algorithm. - (let* ((tmp (* a (+ 1 (expt 2 27)))) - (a-hi (- tmp (- tmp a))) - (a-lo (- a a-hi))) - (values a-hi a-lo)))) +(defconstant +two53+ + (scale-float 1d0 53)) +(defconstant +two-53+ + (scale-float 1d0 -53)) (declaim (inline two-prod)) + +;; This is essentially the algorithm given by Listing 2.7 Mul12Cond +;; given in "CR-LIBM: A library of correctly rounded elementary +;; functions in double-precision". #-ppc (defun two-prod (a b) _N"Compute fl(a*b) and err(a*b)" - (declare (double-float a b)) - (let ((p (* a b))) - (multiple-value-bind (a-hi a-lo) - (split a) - ;;(format t "a-hi, a-lo = ~S ~S~%" a-hi a-lo) - (multiple-value-bind (b-hi b-lo) - (split b) - ;;(format t "b-hi, b-lo = ~S ~S~%" b-hi b-lo) - (let ((e (+ (+ (- (* a-hi b-hi) p) - (* a-hi b-lo) - (* a-lo b-hi)) - (* a-lo b-lo)))) - (locally - (declare (optimize (inhibit-warnings 3))) - (values p e))))))) + (declare (double-float a b) + (optimize (speed 3))) + ;; If the numbers are too big, scale them done so SPLIT doesn't overflow. + (multiple-value-bind (aa bb) + (values (if (> a +two970+) + (* a +two-53+) + a) + (if (> b +two970+) + (* b +two-53+) + b)) + (let ((p (* aa bb))) + (declare (double-float p) + (inline split)) + (multiple-value-bind (aa-hi aa-lo) + (split aa) + ;;(format t "aa-hi, aa-lo = ~S ~S~%" aa-hi aa-lo) + (multiple-value-bind (bb-hi bb-lo) + (split bb) + ;;(format t "bb-hi, bb-lo = ~S ~S~%" bb-hi bb-lo) + (let ((e (+ (+ (- (* aa-hi bb-hi) p) + (* aa-hi bb-lo) + (* aa-lo bb-hi)) + (* aa-lo bb-lo)))) + (declare (double-float e)) + (locally + (declare (optimize (inhibit-warnings 3))) + ;; If the numbers was scaled down, we need to scale the + ;; result back up. + (when (> a +two970+) + (setf p (* p +two53+) + e (* e +two53+))) + (when (> b +two970+) + (setf p (* p +two53+) + e (* e +two53+))) + (values p e)))))))) #+ppc (defun two-prod (a b) @@ -2402,6 +2382,27 @@ (values q (+ (+ (- (* a-hi a-hi) q) (* 2 a-hi a-lo)) (* a-lo a-lo))))))) +(defun two-sqr (a) + _N"Compute fl(a*a) and err(a*b). This is a more efficient + implementation of two-prod" + (declare (double-float a)) + (let ((aa (if (> a +two970+) + (* a +two-53+) + a))) + (let ((q (* aa aa))) + (declare (double-float q) + (inline split)) + (multiple-value-bind (a-hi a-lo) + (split aa) + (locally + (declare (optimize (inhibit-warnings 3))) + (let ((e (+ (+ (- (* a-hi a-hi) q) + (* 2 a-hi a-lo)) + (* a-lo a-lo)))) + (if (> a +two970+) + (values (* q +two53+) + (* e +two53+)) + (values q e)))))))) #+ppc (defun two-sqr (a) ----------------------------------------------------------------------- Summary of changes: src/compiler/float-tran.lisp | 143 +++++++++++++++++++++--------------------- 1 file changed, 72 insertions(+), 71 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[git] CMU Common Lisp branch master updated. snapshot-2014-06-93-gb424b78
by rtoy＠common-lisp.net 08 Apr '15

08 Apr '15

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via b424b78d3e33bf8438a364920c5a2987aa0cacb8 (commit) from 75d14d2ed7dc9085858d9119013b67fbdfe77390 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit b424b78d3e33bf8438a364920c5a2987aa0cacb8 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Mon Aug 4 18:59:06 2014 -0700 Remove -mtune=generic from Config.x86_common. Netbsd apparently doesn't like this, so we're moving that option to the linux and darwin config files. Reported by Robert Swindells. diff --git a/src/lisp/Config.x86_common b/src/lisp/Config.x86_common index ad2b1a0..1873f7d 100644 --- a/src/lisp/Config.x86_common +++ b/src/lisp/Config.x86_common @@ -54,7 +54,7 @@ CPP_INCLUDE_OPTIONS := -I. -I$(PATH1) -I- endif CPPFLAGS := $(CPP_DEFINE_OPTIONS) $(CPP_INCLUDE_OPTIONS) -CFLAGS += -Wstrict-prototypes -Wall -O2 -g -mtune=generic +CFLAGS += -Wstrict-prototypes -Wall -O2 -g ASFLAGS = -g ASSEM_SRC = x86-assem.S diff --git a/src/lisp/Config.x86_darwin b/src/lisp/Config.x86_darwin index 39c09bd..7de9ef2 100644 --- a/src/lisp/Config.x86_darwin +++ b/src/lisp/Config.x86_darwin @@ -6,7 +6,7 @@ include Config.x86_common MIN_VER = -mmacosx-version-min=10.5 CPPFLAGS += -DDARWIN $(MIN_VER) -m32 -CFLAGS += -g3 +CFLAGS += -g3 -mtune=generic ASFLAGS += -g3 $(MIN_VER) diff --git a/src/lisp/Config.x86_linux b/src/lisp/Config.x86_linux index cba5ec6..f43ac53 100644 --- a/src/lisp/Config.x86_linux +++ b/src/lisp/Config.x86_linux @@ -1,7 +1,8 @@ # -*- Mode: makefile -*- include Config.x86_common -CPPFLAGS += -m32 -rdynamic -D__NO_CTYPE -D_GNU_SOURCE -march=pentium4 -mfpmath=sse +CPPFLAGS += -D__NO_CTYPE -D_GNU_SOURCE +CFLAGS += -m32 -rdynamic -march=pentium4 -mfpmath=sse -mtune=generic UNDEFSYMPATTERN = -Xlinker -u -Xlinker & ASSEM_SRC += linux-stubs.S ----------------------------------------------------------------------- Summary of changes: src/lisp/Config.x86_common | 2 +- src/lisp/Config.x86_darwin | 2 +- src/lisp/Config.x86_linux | 3 ++- 3 files changed, 4 insertions(+), 3 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[git] CMU Common Lisp branch master updated. snapshot-2014-01-9-gc9a3b19
by rtoy＠common-lisp.net 08 Apr '15

08 Apr '15

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via c9a3b19c19a5f2a5a09500c621694cc061cb6d5a (commit) from 189dc5b6a717ad0a93354e55d87bc0ab41e6745d (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit c9a3b19c19a5f2a5a09500c621694cc061cb6d5a Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Sat Jan 11 17:34:21 2014 -0800 Remove the zero checking of the heap. It's been several months without any issue after adding the lazy zeroing of heap pages, so it's probably safe to remove the zero checking of the heap pages. It can still be enabled by setting the appropriate variables. diff --git a/src/lisp/gencgc.c b/src/lisp/gencgc.c index a9c3e96..cdc95e0 100644 --- a/src/lisp/gencgc.c +++ b/src/lisp/gencgc.c @@ -367,7 +367,7 @@ boolean gencgc_zero_check_during_free_heap = FALSE; * enough. */ -#define DO_GENCGC_ZERO_CHECK (gencgc_zero_check || (gencgc_unmap_zero == MODE_LAZY) || (gencgc_unmap_zero == MODE_MADVISE)) +#define DO_GENCGC_ZERO_CHECK (gencgc_zero_check) /* * Only to the zero check during free_heap if both @@ -375,7 +375,7 @@ boolean gencgc_zero_check_during_free_heap = FALSE; * MODE_MAP or MODE_MEMSET because in all other modes, unallocated * pages are known not to contain zeroes. */ -#define DO_GENCGC_ZERO_CHECK_DURING_FREE_HEAP (gencgc_zero_check_during_free_heap && ((gencgc_unmap_zero == MODE_MAP) || (gencgc_unmap_zero == MODE_MEMSET))) +#define DO_GENCGC_ZERO_CHECK_DURING_FREE_HEAP (gencgc_zero_check_during_free_heap) /* * The minimum size for a large object. ----------------------------------------------------------------------- Summary of changes: src/lisp/gencgc.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[git] CMU Common Lisp annotated tag movable-linkage-space-alloc-fixed created. movable-linkage-space-alloc-fixed
by rtoy＠common-lisp.net 08 Apr '15

08 Apr '15

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The annotated tag, movable-linkage-space-alloc-fixed has been created at 161af01f18804789172ed93e0f50a5f03575dc74 (tag) tagging fc13642018cdc018403d8f9e891b8c6d8b1b5012 (commit) replaces snapshot-2012-09 tagged by Raymond Toy on Wed Sep 12 23:10:08 2012 -0700 - Log ----------------------------------------------------------------- Changes to allocation complete so that we can do an indirect call. Raymond Toy (11): Finish splitting out x86-validate into separate OS versions. Fix ticket:62: Needed an IN-PACKAGE. Output lisp strings in utf8 format in ldb print. New MOVE-FROM-UNSIGNED, more like sparc and MOVE-FROM-SIGNED. Change the optional args for ALLOCATION and WITH-FIXED-ALLOCATION to ALLOCATION and WITH-ALLOCATION take a new temp arg for a register to Allow the temp arg to ALLOCATION to be NIL; replace all uses of the macros.lisp: Move common allocation stuff into SLOW-ALLOCATION-PATH. Always do indirect call. Remove the temp arg from ALLOCATION and WITH-FIXED-ALLOCATION. Remove ----------------------------------------------------------------------- hooks/post-receive -- CMU Common Lisp

1 0

[git] CMU Common Lisp branch master updated. snapshot-2014-02-3-g1554c68
by rtoy＠common-lisp.net 08 Apr '15

08 Apr '15

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via 1554c686c73c29228bf5b77425837fe27f3aa201 (commit) from 9be8ccbffdd602b08e0ba12aa59bc0d137dc569d (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 1554c686c73c29228bf5b77425837fe27f3aa201 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Fri Feb 7 08:15:27 2014 -0800 Add news about lisp-unit. diff --git a/src/general-info/release-20f.txt b/src/general-info/release-20f.txt index 8df0287..628236b 100644 --- a/src/general-info/release-20f.txt +++ b/src/general-info/release-20f.txt @@ -45,6 +45,8 @@ New in this release: * Run-time checks for zero pages on newly allocated pages has been disabled now that the lazy zeroing of the heap pages has been the default for several months now. + * Add lisp-unit as a contrib. Use (require :lisp-unit) to load + it. Precompiled fasls are not included. * ANSI compliance fixes: * The values on the branch cuts for the inverse trig and ----------------------------------------------------------------------- Summary of changes: src/general-info/release-20f.txt | 2 ++ 1 file changed, 2 insertions(+) hooks/post-receive -- CMU Common Lisp

1 0