You can subscribe to this list here.
2005 
_{Jan}
(159) 
_{Feb}
(96) 
_{Mar}
(145) 
_{Apr}
(192) 
_{May}
(132) 
_{Jun}
(190) 
_{Jul}
(194) 
_{Aug}
(280) 
_{Sep}
(195) 
_{Oct}
(207) 
_{Nov}
(154) 
_{Dec}
(101) 

2011 
_{Jan}
(18) 
_{Feb}
(39) 
_{Mar}
(18) 
_{Apr}
(27) 
_{May}
(45) 
_{Jun}
(135) 
_{Jul}
(31) 
_{Aug}
(82) 
_{Sep}
(14) 
_{Oct}
(60) 
_{Nov}
(112) 
_{Dec}
(117) 
2003 
_{Jan}
(126) 
_{Feb}
(228) 
_{Mar}
(238) 
_{Apr}
(299) 
_{May}
(257) 
_{Jun}
(283) 
_{Jul}
(192) 
_{Aug}
(227) 
_{Sep}
(295) 
_{Oct}
(202) 
_{Nov}
(180) 
_{Dec}
(70) 
2006 
_{Jan}
(156) 
_{Feb}
(110) 
_{Mar}
(261) 
_{Apr}
(183) 
_{May}
(148) 
_{Jun}
(133) 
_{Jul}
(94) 
_{Aug}
(141) 
_{Sep}
(137) 
_{Oct}
(111) 
_{Nov}
(172) 
_{Dec}
(124) 
2009 
_{Jan}
(143) 
_{Feb}
(168) 
_{Mar}
(68) 
_{Apr}
(142) 
_{May}
(224) 
_{Jun}
(202) 
_{Jul}
(83) 
_{Aug}
(86) 
_{Sep}
(68) 
_{Oct}
(37) 
_{Nov}
(93) 
_{Dec}
(80) 
2012 
_{Jan}
(15) 
_{Feb}
(4) 
_{Mar}
(30) 
_{Apr}
(62) 
_{May}
(45) 
_{Jun}
(30) 
_{Jul}
(9) 
_{Aug}
(23) 
_{Sep}
(41) 
_{Oct}
(56) 
_{Nov}
(35) 
_{Dec}
(43) 
2007 
_{Jan}
(111) 
_{Feb}
(72) 
_{Mar}
(155) 
_{Apr}
(286) 
_{May}
(138) 
_{Jun}
(170) 
_{Jul}
(129) 
_{Aug}
(156) 
_{Sep}
(170) 
_{Oct}
(90) 
_{Nov}
(119) 
_{Dec}
(112) 
2002 
_{Jan}

_{Feb}

_{Mar}
(23) 
_{Apr}
(68) 
_{May}
(99) 
_{Jun}
(109) 
_{Jul}
(112) 
_{Aug}
(104) 
_{Sep}
(177) 
_{Oct}
(211) 
_{Nov}
(162) 
_{Dec}
(135) 
2013 
_{Jan}
(19) 
_{Feb}
(41) 
_{Mar}
(31) 
_{Apr}
(28) 
_{May}
(109) 
_{Jun}
(90) 
_{Jul}
(24) 
_{Aug}
(37) 
_{Sep}
(52) 
_{Oct}
(45) 
_{Nov}
(58) 
_{Dec}
(35) 
2004 
_{Jan}
(88) 
_{Feb}
(73) 
_{Mar}
(133) 
_{Apr}
(141) 
_{May}
(205) 
_{Jun}
(130) 
_{Jul}
(148) 
_{Aug}
(247) 
_{Sep}
(228) 
_{Oct}
(175) 
_{Nov}
(158) 
_{Dec}
(222) 
2008 
_{Jan}
(135) 
_{Feb}
(102) 
_{Mar}
(115) 
_{Apr}
(42) 
_{May}
(132) 
_{Jun}
(106) 
_{Jul}
(94) 
_{Aug}
(67) 
_{Sep}
(33) 
_{Oct}
(123) 
_{Nov}
(54) 
_{Dec}
(219) 
2010 
_{Jan}
(39) 
_{Feb}
(76) 
_{Mar}
(144) 
_{Apr}
(141) 
_{May}
(27) 
_{Jun}
(70) 
_{Jul}
(23) 
_{Aug}
(155) 
_{Sep}
(152) 
_{Oct}
(167) 
_{Nov}
(87) 
_{Dec}
(12) 
2014 
_{Jan}
(24) 
_{Feb}
(48) 
_{Mar}
(93) 
_{Apr}
(100) 
_{May}
(204) 
_{Jun}
(107) 
_{Jul}
(85) 
_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 






1

2

3

4
(1) 
5

6
(1) 
7
(5) 
8
(5) 
9
(11) 
10

11

12
(1) 
13

14

15

16

17
(1) 
18
(4) 
19

20

21

22

23

24

25

26

27

28

29
(1) 
30

From: Lutz Euler <leuler@us...>  20120607 21:22:49

The branch "master" has been updated in SBCL: via adc09c3bd72bf86b1435cc5569682af00f3db348 (commit) from 4de15256dd6387e52c8b9f5588c08044b68f6817 (commit)  Log  commit adc09c3bd72bf86b1435cc5569682af00f3db348 Author: Lutz Euler <lutz.euler@...> Date: Thu Jun 7 23:21:47 2012 +0200 Fix test character.pure.lisp / BUG994487 on nonunicode. Replace a literal 1114111 with (1 CHARCODELIMIT) so that the test works on #sbunicode, too.  tests/character.pure.lisp  3 ++ 1 files changed, 2 insertions(+), 1 deletions() diff git a/tests/character.pure.lisp b/tests/character.pure.lisp index cfa1d2b..95c5833 100644  a/tests/character.pure.lisp +++ b/tests/character.pure.lisp @@ 122,6 +122,7 @@ (withtest (:name :bug994487) (let ((f (compile nil `(lambda (char) (codechar (1+ (charcode char)))))))  (assert (equal `(function (t) (values (sbkernel:characterset ((1 . 1114111))) + (assert (equal `(function (t) (values (sbkernel:characterset + ((1 . ,(1 charcodelimit)))) &optional)) (sbimpl::%funtype f)))))  hooks/postreceive  SBCL 
From: Lutz Euler <leuler@us...>  20120607 12:26:04

The branch "master" has been updated in SBCL: via 4de15256dd6387e52c8b9f5588c08044b68f6817 (commit) from d7c9385e5a7b27d38884ebed9df6e9e5c3ac5cbf (commit)  Log  commit 4de15256dd6387e52c8b9f5588c08044b68f6817 Author: Lutz Euler <lutz.euler@...> Date: Thu Jun 7 14:23:11 2012 +0200 Add a test for range reduction of trigonometric functions on nonx86. Trigonometric functions of large float arguments yield differing results depending on how range reduction is done. There is already a test for the results expected on x86, float.pure.lisp/(:rangereduction :x87). Add a test for the results expected from GNU libm and enable it for all platforms except x86. The new test is impure and therefore added to "float.impure.lisp". Move the x86 test there, too, to reduce the potential for future confusion.  tests/float.impure.lisp  101 +++++++++++++++++++++++++++++++++++++++++++++++ tests/float.pure.lisp  32  2 files changed, 101 insertions(+), 32 deletions() diff git a/tests/float.impure.lisp b/tests/float.impure.lisp index 1cb8c22..daef1f2 100644  a/tests/float.impure.lisp +++ b/tests/float.impure.lisp @@ 234,3 +234,104 @@ (2 0) (2 1) (2 2) (2 3) (3 0) (3 1) (3 2) (3 3)) value single double)))))))) + +;; The x86 port used not to reduce the arguments of transcendentals +;; correctly. +;; This test is valid only for x86: The x86 port uses the builtin x87 +;; FPU instructions to implement the trigonometric functions; other +;; ports rely on the system's math library. These two differ in the +;; precision of pi used for the range reduction and so yield results +;; that can differ by arbitrarily large amounts for large inputs. +;; The test expects the x87 results. +(withtest (:name (:rangereduction :x87) + :skippedon '(not :x86)) + (flet ((almost= (x y) + (< (abs ( x y)) 1d5))) + (macrolet ((foo (op value) + `(assert (almost= (,op (mod ,value (* 2 pi))) + (,op ,value))))) + (let ((big (* pi (expt 2d0 70))) + (mid (coerce mostpositivefixnum 'doublefloat)) + (odd (* pi mostpositivefixnum))) + (foo sin big) + (foo sin mid) + (foo sin odd) + (foo sin (/ odd 2d0)) + + (foo cos big) + (foo cos mid) + (foo cos odd) + (foo cos (/ odd 2d0)) + + (foo tan big) + (foo tan mid) + (foo tan odd))))) + +;; To test the range reduction of trigonometric functions we need a much +;; more accurate approximation of pi than CL:PI is. Calculating this is +;; more fun than copypasting a constant and GaussLegendre converges +;; extremely fast. +(defun pigausslegendre (nbits) + "Return a rational approximation to pi using the GaussLegendre +algorithm. The calculations are done with integers, representing +multiples of (expt 2 ( NBITS)), and the result is an integral multiple +of this number. The result is accurate to a few less than NBITS many +fractional bits." + (let ((a (ash 1 nbits)) ; scaled 1 + (b (isqrt (expt 2 (1 (* nbits 2))))) ; scaled (sqrt 1/2) + (c (ash 1 ( nbits 2))) ; scaled 1/4 + (d 0)) + (loop + (when (<= ( a b) 1) + (return)) + (let ((a1 (ash (+ a b) 1))) + (psetf a a1 + b (isqrt (* a b)) + c ( c (ash (expt ( a a1) 2) ( d nbits))) + d (1+ d)))) + (/ (round (expt (+ a b) 2) (* 4 c)) + (ash 1 nbits)))) + +;; Test that the range reduction of trigonometric functions is done +;; with a sufficiently accurate value of pi that the reduced argument +;; is correct to nearly doublefloat precision even for arguments of +;; very large absolute value. +;; This test is skipped on x86; as to why see the comment at the test +;; (:rangereduction :x87) above. +(withtest (:name (:rangereduction :precisepi) + :skippedon :x86) + (let ((rational2pi (* 2 (pigausslegendre 2200)))) + (labels ((mod2pi (x) + "Return X modulo 2 pi, where pi is precise enough that the + result is exact to doublefloat precision for all possible + doublefloat arguments." + (declare (type doublefloat x)) + (coerce (mod (rational x) rational2pi) + 'doublefloat)) + (test (op x) + (let ((actual (funcall op x)) + (expected (funcall op (mod2pi x)))) + ;; Some of the test values are chosen to reduce modulo + ;; 2 pi to small numbers (between 1d10 and 1d7), + ;; making their sine and tangent this small, too. + ;; For other test values the absolute value of the + ;; tangent may be much larger than 1. Therefore we + ;; measure relative instead of absolute error. + (unless (or (= actual expected 0) + (and (= (signum actual) (signum expected)) + (< (abs (/ ( actual expected) + (+ actual expected))) + (/ 1d12 2)))) + (error "Inaccurate result for ~a: expected ~a, got ~a" + (list op x) expected actual))))) + (dolist (op '(sin cos tan)) + (dolist (val `(,(coerce mostpositivefixnum 'doublefloat) + ,@(loop for v = mostpositivedoublefloat + then (expt v 4/5) + while (> v (expt 2 50)) + collect v) + 6.543554061677196d28 + 1.5334254929660437d43 + 1.837213298702053d93 + 4.913896894631919d229)) + (test op val)))))) diff git a/tests/float.pure.lisp b/tests/float.pure.lisp index 62a54b0..5612a73 100644  a/tests/float.pure.lisp +++ b/tests/float.pure.lisp @@ 269,38 +269,6 @@ (the (eql #c(1.0 2.0)) x)))))))) ;; The x86 port used not to reduce the arguments of transcendentals ;; correctly. ;; This test is valid only for x86: The x86 port uses the builtin x87 ;; FPU instructions to implement the trigonometric functions; other ;; ports rely on the system's math library. These two differ in the ;; precision of pi used for the range reduction and so yield results ;; that can differ by arbitrarily large amounts for large inputs. ;; The test expects the x87 results. (withtest (:name (:rangereduction :x87)  :skippedon '(not :x86))  (flet ((almost= (x y)  (< (abs ( x y)) 1d5)))  (macrolet ((foo (op value)  `(assert (almost= (,op (mod ,value (* 2 pi)))  (,op ,value)))))  (let ((big (* pi (expt 2d0 70)))  (mid (coerce mostpositivefixnum 'doublefloat))  (odd (* pi mostpositivefixnum)))  (foo sin big)  (foo sin mid)  (foo sin odd)  (foo sin (/ odd 2d0))   (foo cos big)  (foo cos mid)  (foo cos odd)  (foo cos (/ odd 2d0))   (foo tan big)  (foo tan mid)  (foo tan odd)))))  ;; Leakage from the host could result in wrong values for truncation. (withtest (:name :truncate) (assert (plusp (sbkernel:%unarytruncate/singlefloat (expt 2f0 33))))  hooks/postreceive  SBCL 
From: Lutz Euler <leuler@us...>  20120607 12:26:02

The branch "master" has been updated in SBCL: via d7c9385e5a7b27d38884ebed9df6e9e5c3ac5cbf (commit) from 05abd44bb4a3699285dd499dbbb4c77b64304835 (commit)  Log  commit d7c9385e5a7b27d38884ebed9df6e9e5c3ac5cbf Author: Lutz Euler <lutz.euler@...> Date: Thu Jun 7 14:23:11 2012 +0200 Skip the float.pure.lisp/RANGEREDUCTION test outside x86. The test was and is meant only to be used on x86 as it tests for results the x87 FPU computes, which can differ from those on other platforms. It was accidentally enabled for all platforms with commit 4c81c652cdc32faefee1bccb84c3c9a7854e3edd. Revert this by skipping the test on everything except x86. Augment the test's name and improve its comment so that it hopefully won't be enabled again everywhere so easily.  tests/float.pure.lisp  16 ++++++++++ 1 files changed, 10 insertions(+), 6 deletions() diff git a/tests/float.pure.lisp b/tests/float.pure.lisp index 4f28680..62a54b0 100644  a/tests/float.pure.lisp +++ b/tests/float.pure.lisp @@ 269,12 +269,16 @@ (the (eql #c(1.0 2.0)) x)))))))) ;; This was previously x86only, with note: ;; The x86 port used not to reduce the arguments of transcendentals ;; correctly. On other platforms, we trust libm to DTRT. ;; but it doesn't cost any real amount to just test them all (withtest (:name :rangereduction  :failson ':x8664) +;; The x86 port used not to reduce the arguments of transcendentals +;; correctly. +;; This test is valid only for x86: The x86 port uses the builtin x87 +;; FPU instructions to implement the trigonometric functions; other +;; ports rely on the system's math library. These two differ in the +;; precision of pi used for the range reduction and so yield results +;; that can differ by arbitrarily large amounts for large inputs. +;; The test expects the x87 results. +(withtest (:name (:rangereduction :x87) + :skippedon '(not :x86)) (flet ((almost= (x y) (< (abs ( x y)) 1d5))) (macrolet ((foo (op value)  hooks/postreceive  SBCL 
From: Lutz Euler <leuler@us...>  20120606 14:31:45

The branch "master" has been updated in SBCL: via 05abd44bb4a3699285dd499dbbb4c77b64304835 (commit) from 25d55fff07e7eb37ad976f980cb440cdd95ff326 (commit)  Log  commit 05abd44bb4a3699285dd499dbbb4c77b64304835 Author: Lutz Euler <lutz.euler@...> Date: Wed Jun 6 16:30:51 2012 +0200 Small enhancements to ISQRT Replace MULTIPLEVALUELIST with MULTIPLEVALUEBIND which conses less and is slightly faster. Correct the docstring. Add a test for correctness.  src/code/numbers.lisp  24 ++++++++++++ tests/arith.pure.lisp  25 +++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 12 deletions() diff git a/src/code/numbers.lisp b/src/code/numbers.lisp index 25c6046..2b86681 100644  a/src/code/numbers.lisp +++ b/src/code/numbers.lisp @@ 1448,26 +1448,26 @@ the first." ((fixnum bignum) (bignumgcd (makesmallbignum u) v)))))) ;;;; from Robert Smith +;;;; from Robert Smith; slightly changed not to cons unnecessarily. (defun isqrt (n) #!+sbdoc  "Return the root of the nearest integer less than n which is a perfect  square." + "Return the greatest integer less than or equal to the square root of N." (declare (type unsignedbyte n)) (cond ((> n 24) (let* ((nfourthsize (ash (1 (integerlength n)) 2)) (nsignificanthalf (ash n ( (ash nfourthsize 1)))) (nsignificanthalfisqrt (isqrt nsignificanthalf))  (zerothiteration (ash nsignificanthalfisqrt nfourthsize))  (qr (multiplevaluelist (floor n zerothiteration)))  (firstiteration (ash (+ zerothiteration (first qr)) 1)))  (cond ((oddp (first qr))  firstiteration)  ((> (expt ( firstiteration zerothiteration) 2) (second qr))  (1 firstiteration))  (t  firstiteration)))) + (zerothiteration (ash nsignificanthalfisqrt nfourthsize))) + (multiplevaluebind (quot rem) + (floor n zerothiteration) + (let ((firstiteration (ash (+ zerothiteration quot) 1))) + (cond ((oddp quot) + firstiteration) + ((> (expt ( firstiteration zerothiteration) 2) rem) + (1 firstiteration)) + (t + firstiteration)))))) ((> n 15) 4) ((> n 8) 3) ((> n 3) 2) diff git a/tests/arith.pure.lisp b/tests/arith.pure.lisp index e6543e7..77291ff 100644  a/tests/arith.pure.lisp +++ b/tests/arith.pure.lisp @@ 555,3 +555,28 @@ (declare (type (integer 3 57216651) a)) (ldb (byte 9 27) a))))) (assert (= 0 ( (funcall one 10) (funcall two 10)))))) + +;; The ISQRT implementation is sufficiently complicated that it should +;; be tested. +(withtest (:name :isqrt) + (labels ((test (x) + (let* ((r (isqrt x)) + (r2 (expt r 2)) + (s2 (expt (1+ r) 2))) + (unless (and (<= r2 x) + (> s2 x)) + (error "isqrt failure for ~a" x)))) + (tests (x) + (test x) + (let ((x2 (expt x 2))) + (test x2) + (test (1+ x2)) + (test (1 x2))))) + (loop for i from 1 to 200 + for pow = (expt 2 (1 i)) + for j = (+ pow (random pow)) + do + (tests i) + (tests j)) + (dotimes (i 10) + (tests (random (expt 2 (+ 1000 (random 10000))))))))  hooks/postreceive  SBCL 
From: stassats <stassats@us...>  20120604 17:25:10

The branch "master" has been updated in SBCL: via 25d55fff07e7eb37ad976f980cb440cdd95ff326 (commit) from a5f57fb517f9ce87e0a602c5d496a132a4527f5e (commit)  Log  commit 25d55fff07e7eb37ad976f980cb440cdd95ff326 Author: Stas Boukarev <stassats@...> Date: Mon Jun 4 21:24:46 2012 +0400 Restore build on sparc/solaris. gcinternal.h: include interr.h before `lose' is used. Fixes lp#1008506.  NEWS  1 + src/runtime/gcinternal.h  1 + 2 files changed, 2 insertions(+), 0 deletions() diff git a/NEWS b/NEWS index 4d10a6d..60a328e 100644  a/NEWS +++ b/NEWS @@ 27,6 +27,7 @@ changes relative to sbcl1.0.57: method combinations. (lp#936513) * bug fix: runprogram no longer unconditionally uses /tmp/ for temporary files. (lp#968837). + * bug fix: restor build on solaris/sparc. (lp#1008506) changes in sbcl1.0.57 relative to sbcl1.0.56: * RANDOM enhancements and bug fixes: diff git a/src/runtime/gcinternal.h b/src/runtime/gcinternal.h index a9a3802..1a72b88 100644  a/src/runtime/gcinternal.h +++ b/src/runtime/gcinternal.h @@ 18,6 +18,7 @@ #include <genesis/simplefun.h> #include "thread.h" +#include "interr.h" #ifdef LISP_FEATURE_GENCGC #include "gencgcinternal.h"  hooks/postreceive  SBCL 