You can subscribe to this list here.
2002 
_{Jan}

_{Feb}

_{Mar}
(23) 
_{Apr}
(68) 
_{May}
(99) 
_{Jun}
(109) 
_{Jul}
(112) 
_{Aug}
(104) 
_{Sep}
(177) 
_{Oct}
(211) 
_{Nov}
(162) 
_{Dec}
(135) 

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) 
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) 
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) 
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) 
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) 
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) 
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) 
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) 
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) 
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) 
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) 
2014 
_{Jan}
(24) 
_{Feb}
(48) 
_{Mar}
(93) 
_{Apr}
(100) 
_{May}
(204) 
_{Jun}
(107) 
_{Jul}
(85) 
_{Aug}
(89) 
_{Sep}
(79) 
_{Oct}
(70) 
_{Nov}
(92) 
_{Dec}
(54) 
2015 
_{Jan}
(100) 
_{Feb}
(103) 
_{Mar}
(94) 
_{Apr}
(77) 
_{May}
(96) 
_{Jun}
(63) 
_{Jul}
(116) 
_{Aug}
(76) 
_{Sep}
(81) 
_{Oct}
(269) 
_{Nov}
(253) 
_{Dec}
(143) 
2016 
_{Jan}
(78) 
_{Feb}
(150) 
_{Mar}
(151) 
_{Apr}
(107) 
_{May}
(52) 
_{Jun}
(49) 
_{Jul}
(71) 
_{Aug}
(68) 
_{Sep}
(127) 
_{Oct}
(95) 
_{Nov}
(73) 
_{Dec}
(28) 
S  M  T  W  T  F  S 




1
(31) 
2
(5) 
3
(7) 
4

5
(3) 
6
(3) 
7
(2) 
8
(13) 
9
(7) 
10
(4) 
11
(3) 
12
(16) 
13
(6) 
14

15
(6) 
16
(18) 
17
(5) 
18

19
(25) 
20
(15) 
21

22

23
(2) 
24

25

26

27
(1) 
28
(10) 
29
(3) 
30
(5) 


From: Nathan Froyd <nfroyd@us...>  20050602 14:39:09

Update of /cvsroot/sbcl/sbcl/src/compiler In directory sc8prcvs1.sourceforge.net:/tmp/cvsserv1858/src/compiler Modified Files: srctran.lisp Log Message: 0.9.1.22: *sigh* Correct SPECIF*I*ERTYPE typo. Index: srctran.lisp =================================================================== RCS file: /cvsroot/sbcl/sbcl/src/compiler/srctran.lisp,v retrieving revision 1.123 retrieving revision 1.124 diff u d r1.123 r1.124  srctran.lisp 2 Jun 2005 04:02:08 0000 1.123 +++ srctran.lisp 2 Jun 2005 14:38:56 0000 1.124 @@ 2341,7 +2341,7 @@ (let ((low (logxorderiveunsignedlowbound x y)) (high (logxorderiveunsignedhighbound x y))) (specifiertype `(integer ,low ,high)))  (specifertype '(unsignedbyte* *)))) + (specifiertype '(unsignedbyte* *)))) ((and (not xpos) (not ypos)) ;; Both are negative. The result will be positive, and as long ;; as the longer. 
From: Nathan Froyd <nfroyd@us...>  20050602 14:39:08

Update of /cvsroot/sbcl/sbcl In directory sc8prcvs1.sourceforge.net:/tmp/cvsserv1858 Modified Files: version.lispexpr Log Message: 0.9.1.22: *sigh* Correct SPECIF*I*ERTYPE typo. Index: version.lispexpr =================================================================== RCS file: /cvsroot/sbcl/sbcl/version.lispexpr,v retrieving revision 1.2166 retrieving revision 1.2167 diff u d r1.2166 r1.2167  version.lispexpr 2 Jun 2005 04:02:07 0000 1.2166 +++ version.lispexpr 2 Jun 2005 14:38:54 0000 1.2167 @@ 17,4 +17,4 @@ ;;; checkins which aren't released. (And occasionally for internal ;;; versions, especially for internal versions off the main CVS ;;; branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".) "0.9.1.21" +"0.9.1.22" 
From: Nathan Froyd <nfroyd@us...>  20050602 04:02:18

Update of /cvsroot/sbcl/sbcl/src/compiler In directory sc8prcvs1.sourceforge.net:/tmp/cvsserv12117/src/compiler Modified Files: srctran.lisp Log Message: 0.9.1.21: * Add unsigned bounds derivers for LOGXOR, based on the ones present in CMUCL; * Convert existing unsigned bounds derivers to a more idiomatic CL style, eliminating unnecessary work along the way; * Belatedly add tests for bounds derivation. Index: srctran.lisp =================================================================== RCS file: /cvsroot/sbcl/sbcl/src/compiler/srctran.lisp,v retrieving revision 1.122 retrieving revision 1.123 diff u d r1.122 r1.123  srctran.lisp 1 Jun 2005 22:31:35 0000 1.122 +++ srctran.lisp 2 Jun 2005 04:02:08 0000 1.123 @@ 2132,53 +2132,43 @@ (values nil t t))) ;;; See _Hacker's Delight_, Henry S. Warren, Jr. pp 5863 for an ;;; explanation of {LOGAND,LOGIOR}DERIVEUNSIGNED{LOW,HIGH}BOUND. +;;; explanation of LOG{AND,IOR,XOR}DERIVEUNSIGNED{LOW,HIGH}BOUND. +;;; Credit also goes to Raymond Toy for writing (and debugging!) similar +;;; versions in CMUCL, from which these functions copy liberally. (defun logandderiveunsignedlowbound (x y length)  (let ((mask (1 (ash 1 length)))  (a (numerictypelow x)) +(defun logandderiveunsignedlowbound (x y) + (let ((a (numerictypelow x)) (b (numerictypehigh x)) (c (numerictypelow y)) (d (numerictypehigh y)))  (loop for m = (ash 1 (1 length)) then (ash m 1) + (loop for m = (ash 1 (integerlength (lognor a c))) then (ash m 1) until (zerop m) do  (unless (zerop (logand (logand (lognot a) mask)  (logand (lognot c) mask)  m))  (let ((temp (logand (logior a m)  (logand ( m) mask)))) + (unless (zerop (logand m (lognot a) (lognot c))) + (let ((temp (logandc2 (logior a m) (1 m)))) (when (<= temp b) (setf a temp) (loopfinish))  (setf temp (logand (logior c m)  (logand ( m) mask))) + (setf temp (logandc2 (logior c m) (1 m))) (when (<= temp d) (setf c temp) (loopfinish)))) finally (return (logand a c))))) (defun logandderiveunsignedhighbound (x y length)  (let ((mask (1 (ash 1 length)))  (a (numerictypelow x)) +(defun logandderiveunsignedhighbound (x y) + (let ((a (numerictypelow x)) (b (numerictypehigh x)) (c (numerictypelow y)) (d (numerictypehigh y)))  (loop for m = (ash 1 (1 length)) then (ash m 1) + (loop for m = (ash 1 (integerlength (logxor b d))) then (ash m 1) until (zerop m) do (cond  ((not (zerop (logand b  (logand (lognot d) mask)  m)))  (let ((temp (logior (logand b (lognot m) mask)  ( m 1)))) + ((not (zerop (logand b (lognot d) m))) + (let ((temp (logior (logandc2 b m) (1 m)))) (when (>= temp a) (setf b temp) (loopfinish))))  ((not (zerop (logand (logand (lognot b) mask)  d  m)))  (let ((temp (logior (logand d (lognot m) mask)  ( m 1)))) + ((not (zerop (logand (lognot b) d m))) + (let ((temp (logior (logandc2 d m) (1 m)))) (when (>= temp c) (setf d temp) (loopfinish))))) @@ 2202,9 +2192,8 @@ ((null ylen) (specifiertype `(unsignedbyte* ,xlen))) (t  (let* ((length (max xlen ylen))  (low (logandderiveunsignedlowbound x y length))  (high (logandderiveunsignedhighbound x y length))) + (let ((low (logandderiveunsignedlowbound x y)) + (high (logandderiveunsignedhighbound x y))) (specifiertype `(integer ,low ,high))))) ;; X is positive, but Y might be negative. (cond ((null xlen) @@ 2224,47 +2213,39 @@ ;; We can't tell squat about the result. (specifiertype 'integer))))))) (defun logiorderiveunsignedlowbound (x y length)  (let ((mask (1 (ash 1 length)))  (a (numerictypelow x)) +(defun logiorderiveunsignedlowbound (x y) + (let ((a (numerictypelow x)) (b (numerictypehigh x)) (c (numerictypelow y)) (d (numerictypehigh y)))  (loop for m = (ash 1 (1 length)) then (ash m 1) + (loop for m = (ash 1 (integerlength (logxor a c))) then (ash m 1) until (zerop m) do (cond  ((not (zerop (logand (logand (lognot a) mask)  c  m)))  (let ((temp (logand (logior a m) (logand ( m) mask)))) + ((not (zerop (logandc2 (logand c m) a))) + (let ((temp (logand (logior a m) (1+ (lognot m))))) (when (<= temp b) (setf a temp) (loopfinish))))  ((not (zerop (logand a  (logand (lognot c) mask)  m)))  (let ((temp (logand (logior c m) (logand ( m) mask)))) + ((not (zerop (logandc2 (logand a m) c))) + (let ((temp (logand (logior c m) (1+ (lognot m))))) (when (<= temp d) (setf c temp) (loopfinish))))) finally (return (logior a c))))) (defun logiorderiveunsignedhighbound (x y length)  (let ((mask (1 (ash 1 length)))  (a (numerictypelow x)) +(defun logiorderiveunsignedhighbound (x y) + (let ((a (numerictypelow x)) (b (numerictypehigh x)) (c (numerictypelow y)) (d (numerictypehigh y)))  (loop for m = (ash 1 (1 length)) then (ash m 1) + (loop for m = (ash 1 (integerlength (logand b d))) then (ash m 1) until (zerop m) do (unless (zerop (logand b d m))  (let ((temp (logior (logand ( b m) mask)  (logand (1 m) mask)))) + (let ((temp (logior ( b m) (1 m)))) (when (>= temp a) (setf b temp) (loopfinish))  (setf temp (logior (logand ( d m) mask)  (logand (1 m) mask))) + (setf temp (logior ( d m) (1 m))) (when (>= temp c) (setf d temp) (loopfinish)))) @@ 2279,9 +2260,8 @@ ((and (not xneg) (not yneg)) ;; Both are positive. (if (and xlen ylen)  (let* ((length (max xlen ylen))  (low (logiorderiveunsignedlowbound x y length))  (high (logiorderiveunsignedhighbound x y length))) + (let ((low (logiorderiveunsignedlowbound x y)) + (high (logiorderiveunsignedhighbound x y))) (specifiertype `(integer ,low ,high))) (specifiertype `(unsignedbyte* *)))) ((not xpos) @@ 2313,33 +2293,75 @@ ;; Unbounded. (specifiertype 'integer)))))))) +(defun logxorderiveunsignedlowbound (x y) + (let ((a (numerictypelow x)) + (b (numerictypehigh x)) + (c (numerictypelow y)) + (d (numerictypehigh y))) + (loop for m = (ash 1 (integerlength (logxor a c))) then (ash m 1) + until (zerop m) do + (cond + ((not (zerop (logandc2 (logand c m) a))) + (let ((temp (logand (logior a m) + (1+ (lognot m))))) + (when (<= temp b) + (setf a temp)))) + ((not (zerop (logandc2 (logand a m) c))) + (let ((temp (logand (logior c m) + (1+ (lognot m))))) + (when (<= temp d) + (setf c temp))))) + finally (return (logxor a c))))) + +(defun logxorderiveunsignedhighbound (x y) + (let ((a (numerictypelow x)) + (b (numerictypehigh x)) + (c (numerictypelow y)) + (d (numerictypehigh y))) + (loop for m = (ash 1 (integerlength (logand b d))) then (ash m 1) + until (zerop m) do + (unless (zerop (logand b d m)) + (let ((temp (logior ( b m) (1 m)))) + (cond + ((>= temp a) (setf b temp)) + (t (let ((temp (logior ( d m) (1 m)))) + (when (>= temp c) + (setf d temp))))))) + finally (return (logxor b d))))) + (defun logxorderivetypeaux (x y &optional sameleaf) (when sameleaf (returnfrom logxorderivetypeaux (specifiertype '(eql 0)))) (multiplevaluebind (xlen xpos xneg) (integertypelength x) (multiplevaluebind (ylen ypos yneg) (integertypelength y) (cond  ((or (and (not xneg) (not yneg))  (and (not xpos) (not ypos)))  ;; Either both are negative or both are positive. The result  ;; will be positive, and as long as the longer.  (specifiertype `(unsignedbyte* ,(if (and xlen ylen)  (max xlen ylen)  '*))))  ((or (and (not xpos) (not yneg))  (and (not ypos) (not xneg)))  ;; Either X is negative and Y is positive or viceversa. The  ;; result will be negative.  (specifiertype `(integer ,(if (and xlen ylen)  (ash 1 (max xlen ylen))  '*)  1)))  ;; We can't tell what the sign of the result is going to be.  ;; All we know is that we don't create new bits.  ((and xlen ylen)  (specifiertype `(signedbyte ,(1+ (max xlen ylen)))))  (t  (specifiertype 'integer)))))) + ((and (not xneg) (not yneg)) + ;; Both are positive + (if (and xlen ylen) + (let ((low (logxorderiveunsignedlowbound x y)) + (high (logxorderiveunsignedhighbound x y))) + (specifiertype `(integer ,low ,high))) + (specifertype '(unsignedbyte* *)))) + ((and (not xpos) (not ypos)) + ;; Both are negative. The result will be positive, and as long + ;; as the longer. + (specifiertype `(unsignedbyte* ,(if (and xlen ylen) + (max xlen ylen) + '*)))) + ((or (and (not xpos) (not yneg)) + (and (not ypos) (not xneg))) + ;; Either X is negative and Y is positive or viceversa. The + ;; result will be negative. + (specifiertype `(integer ,(if (and xlen ylen) + (ash 1 (max xlen ylen)) + '*) + 1))) + ;; We can't tell what the sign of the result is going to be. + ;; All we know is that we don't create new bits. + ((and xlen ylen) + (specifiertype `(signedbyte ,(1+ (max xlen ylen))))) + (t + (specifiertype 'integer)))))) (macrolet ((deffrob (logfun) (let ((funaux (symbolicate logfun "DERIVETYPEAUX"))) 
From: Nathan Froyd <nfroyd@us...>  20050602 04:02:17

Update of /cvsroot/sbcl/sbcl In directory sc8prcvs1.sourceforge.net:/tmp/cvsserv12117 Modified Files: version.lispexpr Log Message: 0.9.1.21: * Add unsigned bounds derivers for LOGXOR, based on the ones present in CMUCL; * Convert existing unsigned bounds derivers to a more idiomatic CL style, eliminating unnecessary work along the way; * Belatedly add tests for bounds derivation. Index: version.lispexpr =================================================================== RCS file: /cvsroot/sbcl/sbcl/version.lispexpr,v retrieving revision 1.2165 retrieving revision 1.2166 diff u d r1.2165 r1.2166  version.lispexpr 1 Jun 2005 22:31:34 0000 1.2165 +++ version.lispexpr 2 Jun 2005 04:02:07 0000 1.2166 @@ 17,4 +17,4 @@ ;;; checkins which aren't released. (And occasionally for internal ;;; versions, especially for internal versions off the main CVS ;;; branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".) "0.9.1.20" +"0.9.1.21" 
From: Nathan Froyd <nfroyd@us...>  20050602 04:02:17

Update of /cvsroot/sbcl/sbcl/tests In directory sc8prcvs1.sourceforge.net:/tmp/cvsserv12117/tests Modified Files: type.pure.lisp Log Message: 0.9.1.21: * Add unsigned bounds derivers for LOGXOR, based on the ones present in CMUCL; * Convert existing unsigned bounds derivers to a more idiomatic CL style, eliminating unnecessary work along the way; * Belatedly add tests for bounds derivation. Index: type.pure.lisp =================================================================== RCS file: /cvsroot/sbcl/sbcl/tests/type.pure.lisp,v retrieving revision 1.22 retrieving revision 1.23 diff u d r1.22 r1.23  type.pure.lisp 21 Feb 2005 19:18:09 0000 1.22 +++ type.pure.lisp 2 Jun 2005 04:02:09 0000 1.23 @@ 233,3 +233,36 @@ (type (typeof x))) (assert (subtypep type '(complex rational))) (assert (typep x type))) + +;;; Test derivation of LOG{AND,IOR,XOR} bounds for unsigned arguments. +;;; +;;; Fear the Loop of Doom! +(let* ((bits 5) + (size (ash 1 bits))) + (flet ((bruteforce (a b c d op minimize) + (loop with extreme = (if minimize (ash 1 bits) 0) + with collector = (if minimize #'min #'max) + for i from a upto b do + (loop for j from c upto d do + (setf extreme (funcall collector + extreme + (funcall op i j)))) + finally (return extreme)))) + (dolist (op '(logand logior logxor)) + (dolist (minimize '(t nil)) + (let ((deriver (intern (format nil "~ADERIVEUNSIGNED~:[HIGH~;LOW~]BOUND" + op minimize) + (findpackage :sbc)))) + (loop for a from 0 below size do + (loop for b from a below size do + (loop for c from 0 below size do + (loop for d from c below size do + (let* ((brute (bruteforce a b c d op minimize)) + (xtype (sbc::specifiertype `(integer ,a ,b))) + (ytype (sbc::specifiertype `(integer ,c ,d))) + (derived (funcall deriver xtype ytype))) + (unless (= brute derived) + (format t "FAIL: ~A [~D,~D] [~D,~D] ~A~% +ACTUAL ~D DERIVED ~D~%" + op a b c d minimize brute derived) + (assert (= brute derived))))))))))))) 