You can subscribe to this list here.
2000 
_{Jan}
(16) 
_{Feb}
(21) 
_{Mar}
(49) 
_{Apr}
(35) 
_{May}
(25) 
_{Jun}
(15) 
_{Jul}
(17) 
_{Aug}
(15) 
_{Sep}
(12) 
_{Oct}
(18) 
_{Nov}
(42) 
_{Dec}
(31) 

2001 
_{Jan}
(35) 
_{Feb}
(24) 
_{Mar}
(53) 
_{Apr}
(59) 
_{May}
(124) 
_{Jun}
(134) 
_{Jul}
(92) 
_{Aug}
(74) 
_{Sep}
(75) 
_{Oct}
(95) 
_{Nov}
(47) 
_{Dec}
(32) 
2002 
_{Jan}
(191) 
_{Feb}
(143) 
_{Mar}
(279) 
_{Apr}
(287) 
_{May}
(106) 
_{Jun}
(96) 
_{Jul}
(95) 
_{Aug}
(126) 
_{Sep}
(184) 
_{Oct}
(152) 
_{Nov}
(84) 
_{Dec}
(136) 
2003 
_{Jan}
(170) 
_{Feb}
(64) 
_{Mar}
(202) 
_{Apr}
(142) 
_{May}
(103) 
_{Jun}
(145) 
_{Jul}
(56) 
_{Aug}
(204) 
_{Sep}
(130) 
_{Oct}
(91) 
_{Nov}
(32) 
_{Dec}
(130) 
2004 
_{Jan}
(89) 
_{Feb}
(208) 
_{Mar}
(190) 
_{Apr}
(61) 
_{May}
(111) 
_{Jun}
(126) 
_{Jul}
(121) 
_{Aug}
(90) 
_{Sep}
(65) 
_{Oct}
(80) 
_{Nov}
(90) 
_{Dec}
(95) 
2005 
_{Jan}
(63) 
_{Feb}
(106) 
_{Mar}
(105) 
_{Apr}
(90) 
_{May}
(99) 
_{Jun}
(96) 
_{Jul}
(197) 
_{Aug}
(144) 
_{Sep}
(128) 
_{Oct}
(123) 
_{Nov}
(232) 
_{Dec}
(153) 
2006 
_{Jan}
(210) 
_{Feb}
(69) 
_{Mar}
(37) 
_{Apr}
(74) 
_{May}
(123) 
_{Jun}
(51) 
_{Jul}
(91) 
_{Aug}
(25) 
_{Sep}
(98) 
_{Oct}
(98) 
_{Nov}
(87) 
_{Dec}
(33) 
2007 
_{Jan}
(43) 
_{Feb}
(41) 
_{Mar}
(27) 
_{Apr}
(18) 
_{May}
(20) 
_{Jun}
(18) 
_{Jul}
(35) 
_{Aug}
(35) 
_{Sep}
(21) 
_{Oct}
(75) 
_{Nov}
(41) 
_{Dec}
(28) 
2008 
_{Jan}
(34) 
_{Feb}
(28) 
_{Mar}
(33) 
_{Apr}
(26) 
_{May}
(45) 
_{Jun}
(35) 
_{Jul}
(36) 
_{Aug}
(32) 
_{Sep}
(87) 
_{Oct}
(70) 
_{Nov}
(98) 
_{Dec}
(96) 
2009 
_{Jan}
(94) 
_{Feb}
(79) 
_{Mar}
(9) 
_{Apr}
(10) 
_{May}
(5) 
_{Jun}
(54) 
_{Jul}
(49) 
_{Aug}
(65) 
_{Sep}
(61) 
_{Oct}
(16) 
_{Nov}
(61) 
_{Dec}
(70) 
2010 
_{Jan}
(2) 
_{Feb}
(67) 
_{Mar}
(8) 
_{Apr}
(30) 
_{May}
(19) 
_{Jun}
(2) 
_{Jul}
(17) 
_{Aug}
(30) 
_{Sep}
(23) 
_{Oct}
(20) 
_{Nov}
(47) 
_{Dec}
(12) 
2011 
_{Jan}
(44) 
_{Feb}
(46) 
_{Mar}
(20) 
_{Apr}
(74) 
_{May}
(35) 
_{Jun}
(37) 
_{Jul}
(5) 
_{Aug}
(14) 
_{Sep}

_{Oct}
(8) 
_{Nov}
(6) 
_{Dec}
(1) 
2012 
_{Jan}
(18) 
_{Feb}
(12) 
_{Mar}
(22) 
_{Apr}
(6) 
_{May}
(16) 
_{Jun}
(17) 
_{Jul}
(10) 
_{Aug}
(13) 
_{Sep}
(2) 
_{Oct}
(8) 
_{Nov}
(10) 
_{Dec}
(1) 
2013 
_{Jan}
(19) 
_{Feb}
(14) 
_{Mar}
(12) 
_{Apr}
(3) 
_{May}
(33) 
_{Jun}
(12) 
_{Jul}
(20) 
_{Aug}
(5) 
_{Sep}
(5) 
_{Oct}
(17) 
_{Nov}
(15) 
_{Dec}
(4) 
2014 
_{Jan}
(8) 
_{Feb}
(4) 
_{Mar}
(17) 
_{Apr}

_{May}
(16) 
_{Jun}
(10) 
_{Jul}
(7) 
_{Aug}

_{Sep}
(1) 
_{Oct}
(25) 
_{Nov}
(6) 
_{Dec}
(1) 
2015 
_{Jan}
(1) 
_{Feb}
(3) 
_{Mar}
(9) 
_{Apr}
(1) 
_{May}
(8) 
_{Jun}

_{Jul}
(16) 
_{Aug}
(13) 
_{Sep}

_{Oct}
(44) 
_{Nov}
(1) 
_{Dec}
(4) 
2016 
_{Jan}
(1) 
_{Feb}
(1) 
_{Mar}

_{Apr}
(3) 
_{May}

_{Jun}
(8) 
_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 





1

2
(2) 
3
(1) 
4
(2) 
5
(12) 
6
(8) 
7
(3) 
8
(15) 
9
(2) 
10
(2) 
11

12
(4) 
13

14
(1) 
15
(4) 
16
(2) 
17
(9) 
18

19
(4) 
20

21

22
(2) 
23
(3) 
24

25

26
(5) 
27
(3) 
28
(10) 
29

30

31

From: Raymond Toy <toy.raymond@gm...>  20090117 15:01:04

Kaz Kylheku wrote: > Here is a crazy function I hacked up > I didn't inspect your function too closely, but what I did with cmucl was to compute log2(x) and log2(y) carefully. Then (log x y) = (log2(x)log2(y))/log(2). This is relatively easy since x = 2^n*f, where f is some rational such that 1/2<f<=1. Computing the log of f is easy since we can convert it to a float. For best precision, it's best to keep log2(x) in two parts: the exponent n and the fraction log2(f). (Think what happens if x is very, very large and we add n+log2(f)). This would, of course, need adjustment with clisp if you want to be able to return rationals too. Ray 
From: Kaz Kylheku <kkylheku@gm...>  20090117 11:09:28

Here is a crazy function I hacked up (defun bignumlog (x &optional (b 10)) "logarithm function for CLISP that tries to handle large numbers when the answer is real, and the LOG function blows up. This uses the transformation log x = log x / y + log y. A suitable y is found which is a power of the base that is close to magnitude to x. CLISP can deal with logs of small rations between large bignums better than logs of bignum integers." ;; cases we don't handle (when (or (minusp x) (minusp b) (not (integerp x)) (not (integerp b))) (log x b)) ;; Try LOG function first, but don't bother ;; if X is ``obviously'' too large by inspection. (let* ((obviouslytoolarge (loadtimevalue (expt 10 50))) (trylog (if (not (> x obviouslytoolarge)) (ignoreerrors (log x b))))) (if trylog trylog (loop with y = (expt b 100) with lowestacceptable = (/ x (expt b 4)) with lowprobe = 0 with highprobe = nil do (flet ((bisect() (let* ((delta (/ highprobe lowprobe)) (digits (log delta b))) (* lowprobe (expt b (truncate digits 2)))))) (cond ((< y lowestacceptable) (when (> y lowprobe) (setf lowprobe y)) (if highprobe (setf y (bisect)) (setf y (* y y)))) ((> y x) (when (or (null highprobe) (< y highprobe)) (setf highprobe y)) (setf y (bisect))) (t (return (+ (log (/ x y) b) (log y b)))))))))) 
From: Kaz Kylheku <kkylheku@gm...>  20090117 10:02:23

On Sat, Jan 17, 2009 at 1:21 AM, Gabriel Dos Reis <gdr@...> wrote: > On Sat, Jan 17, 2009 at 2:30 AM, Kaz Kylheku <kkylheku@...> wrote: >> Uh, you're using exponentiation to create a large number, which you >> then reduce with a logarithm. Algebra calling! > > Obviously the testcase was reduced from more complicated > realworld situations, and I hope the real issue is not > summarily dismissed on the ground of 'Algebra calling!'. > The testcase was distilled from the Computer Algebra System > OpenAxiom, see > > http://www.openaxiom.org/ And what does it have to say about this? ;) > The value of (expt 234 108) was created as a result of long > and complicated computations. We have not exhausted the properties of logarithms yet. There is also this: log (x/y) = log x  log y log x = log (x/y) + log y We can transform a logarithm of large bignum x into a logarithm of a fraction of two bignums (which it itself not a large number just a number with a large precision). CLISP's log can handle such an animal better. Let's cheat a little in choosing a y; we already know that the answer is 255 plus a fractional part. So let's choose y so that log y is 255. In other words, let y be (EXPT 10 255). What do we have to add to 255 to get the answer? (log (/ (expt 234 108) (expt 10 255)) 10) > 0.87531257 ;; See, CLISP does it. The 255 we can get by taking (exp 234 108) as a string, and using the length. But typographic hacks are ugly; it is more elegant to search numerically for a suitable y. Basically it can be a value that is near x. Say, one that is smaller than x, but not smaller than 1/10 x. But other values in nearby orders of magnitude, maybe even quite distant ones, should work. Our criteria are that y must be a power of 10, so the log will be an integer, and will work for this large number. And (log (/ x y) 10) must work, of course. An efficient search (in the logarithm space) should be possible to find a power of 10 y that is close in magnitude to the input quantity x. Suppose that the initial guess is 1000. If that's too small, you can double the number of digits by squaring it to 1000000. Then square again if that's too small. It will quickly grow. If it grows past x, then apply a binary search (translated to work arithmetically over powers of 10). Hope this is useful in some way. 
From: Gabriel Dos Reis <gdr@in...>  20090117 09:21:22

On Sat, Jan 17, 2009 at 2:30 AM, Kaz Kylheku <kkylheku@...> wrote: > On Fri, Jan 16, 2009 at 7:05 PM, Don Cohen > <donsourceforgexxz@...> wrote: >> Gabriel Dos Reis writes: >> > The call to the function log in the form >> > (log (expt 234 108) 10) >> > signals a floating point overflow. >> > I'm not sure the hyperspec specifies an exceptional >> > situation in this case. Both SBCL and GCL evaluates >> > the form without fuss. >> Just as a guess, the integer (expt ...) is probably being converted to >> float, and this integer is too big to be converted. > > Uh, you're using exponentiation to create a large number, which you > then reduce with a logarithm. Algebra calling! Obviously the testcase was reduced from more complicated realworld situations, and I hope the real issue is not summarily dismissed on the ground of 'Algebra calling!'. The testcase was distilled from the Computer Algebra System OpenAxiom, see http://www.openaxiom.org/ The value of (expt 234 108) was created as a result of long and complicated computations. The log part happens only long after the computation when attempting to display the result of the computation.  Gaby 
From: Kaz Kylheku <kkylheku@gm...>  20090117 08:35:40

On Fri, Jan 16, 2009 at 7:05 PM, Don Cohen <donsourceforgexxz@...> wrote: > Gabriel Dos Reis writes: > > The call to the function log in the form > > (log (expt 234 108) 10) > > signals a floating point overflow. > > I'm not sure the hyperspec specifies an exceptional > > situation in this case. Both SBCL and GCL evaluates > > the form without fuss. > Just as a guess, the integer (expt ...) is probably being converted to > float, and this integer is too big to be converted. Uh, you're using exponentiation to create a large number, which you then reduce with a logarithm. Algebra calling! Purely mathematically speaking (not numerically): (log (expt base1 exponent) base2) ==> (* exponent (log base1 base2)) So: (* 108 (log 234 10)) > 255.87532 > Perhaps the code should check the size and use a larger float format > if necessary. I was wondering what type of result should be expected > here. Given that the mathematical value is an irrational number close to 255.87532, I'd say that all bets are off for an integer or rational. :) By the way, you can check that the result 255 is in the right ball park by calculating the string length of the decimarl representation of the big number (since the base for your reducing log is 10). (length (princtostring (expt 234 108))) > 256 > The hyperspec says log can return either an integer or float in > cases where the result is actually an integer. CLISP's log is quite nicely behaved like that. It returns rationals too: (log 10 100) > 1/2. 
From: Kaz Kylheku <kkylheku@gm...>  20090117 08:30:13

On Fri, Jan 16, 2009 at 7:05 PM, Don Cohen <donsourceforgexxz@...> wrote: > Gabriel Dos Reis writes: > > The call to the function log in the form > > (log (expt 234 108) 10) > > signals a floating point overflow. > > I'm not sure the hyperspec specifies an exceptional > > situation in this case. Both SBCL and GCL evaluates > > the form without fuss. > Just as a guess, the integer (expt ...) is probably being converted to > float, and this integer is too big to be converted. Uh, you're using exponentiation to create a large number, which you then reduce with a logarithm. Algebra calling! Purely mathematically speaking (not numerically): (log (expt base1 exponent) base2) ==> (* exponent (log base1 base2)) So: (* 108 (log 234 10)) > 255.87532 > Perhaps the code should check the size and use a larger float format > if necessary. I was wondering what type of result should be expected > here. Given that the mathematical value is an irrational number close to 255.87532, I'd say that all bets are off for an integer or rational. :) By the way, you can check that the result 255 is in the right ball park by calculating the string length of the decimarl representation of the big number (since the base for your reducing log is 10). (length (princtostring (expt 234 108))) > 256 > The hyperspec says log can return either an integer or float in > cases where the result is actually an integer. CLISP's log is quite nicely behaved like that. It returns rationals too: (log 10 100) > 1/2. 
From: <donsourceforgexxz@is...>  20090117 03:59:05

Gabriel Dos Reis writes: > > Just as a guess, the integer (expt ...) is probably being converted to > > float, and this integer is too big to be converted. > I think a result as floating point number is OK  that is what the > other two Lisps do. But, a floating overflow signal is just not good... Break 1 [3]> (coerce (expt 234 108) 'DOUBLEFLOAT) 7.5043416907592645d255 Break 1 [3]> (log * 10) 255.87531260029542d0 Break 1 [3]> (coerce (expt 234 108) 'FLOAT) ***  COERCE: floating point overflow 
From: Gabriel Dos Reis <gdr@in...>  20090117 03:15:34

On Fri, Jan 16, 2009 at 9:05 PM, Don Cohen <donsourceforgexxz@...> wrote: > Gabriel Dos Reis writes: > > The call to the function log in the form > > (log (expt 234 108) 10) > > signals a floating point overflow. > > I'm not sure the hyperspec specifies an exceptional > > situation in this case. Both SBCL and GCL evaluates > > the form without fuss. > Just as a guess, the integer (expt ...) is probably being converted to > float, and this integer is too big to be converted. > Perhaps the code should check the size and use a larger float format > if necessary. I was wondering what type of result should be expected > here. I think a result as floating point number is OK  that is what the other two Lisps do. But, a floating overflow signal is just not good... > The hyperspec says log can return either an integer or float in > cases where the result is actually an integer, but it doesn't say > anything about which type of float should be returned in any given > case. I guess for an integer it would make sense to try to return a > number of significant digits similar to the number of digits in the > integer, or as many as possible for really big integers. > Maybe the sum of the numbers of digits for the integers in rationals? > In this case the (expt ...) fits in a double float, but I still think > it should be converted to a long float, and then the log will also end > up being a long float. > hmm.  Gaby 
From: <donsourceforgexxz@is...>  20090117 03:05:38

Gabriel Dos Reis writes: > The call to the function log in the form > (log (expt 234 108) 10) > signals a floating point overflow. > I'm not sure the hyperspec specifies an exceptional > situation in this case. Both SBCL and GCL evaluates > the form without fuss. Just as a guess, the integer (expt ...) is probably being converted to float, and this integer is too big to be converted. Perhaps the code should check the size and use a larger float format if necessary. I was wondering what type of result should be expected here. The hyperspec says log can return either an integer or float in cases where the result is actually an integer, but it doesn't say anything about which type of float should be returned in any given case. I guess for an integer it would make sense to try to return a number of significant digits similar to the number of digits in the integer, or as many as possible for really big integers. Maybe the sum of the numbers of digits for the integers in rationals? In this case the (expt ...) fits in a double float, but I still think it should be converted to a long float, and then the log will also end up being a long float. 