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}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 







1
(1) 
2

3
(2) 
4

5

6

7

8

9

10

11

12
(3) 
13
(2) 
14

15

16

17

18

19

20

21

22

23

24

25

26

27
(6) 
28
(3) 
29

30

31






From: Knut Arild Erstad <knute@ii...>  20000728 14:20:52

On Fri, Jul 28, 2000 at 03:30:45PM +0200, Bruno Haible wrote: > Knut Arild Erstad writes: > > > I understand the argument, but it still seemed unintuitive somehow, and > > different from all other languages and Lisp versions I remember seeing > > But it is closer to what a real computer algebra system does. Because > it is closer to the true mathematical result. That I can agree with. But it was certainly an unexpected result for me, and I still think it is a violation of the standard... > > <URL:http://www.xanalys.com/software_tools/reference/HyperSpec/Body/ > > sec_12144.html> > > This section applies only to floatfloat combinations. Look at section > 12.1.4.1 and at section 12.1.3.3: > > "When the arguments to an irrational mathematical function are all > rational and the true mathematical result is also (mathematically) > rational, then unless otherwise noted an implementation is free to > return either an accurate rational result or a single float > approximation." "When the arguments to an irrational mathematic functions are *all* rational" ... this does not apply to (* 0 1.1). From what I can see it applies only to the functions listed in that section, and only if all arguments are rational, so that (expt 0 1.1) must return 0.0, and (log 1 2.0) must return 0.0, for instance. clisp returns 0 in the second case, BTW. Section 12.1.4.1 says "When rationals and floats are combined by a numerical function, *the rational is first converted to a float* of the same format. For functions such as + that take more than two arguments, it is permitted that *part* of the operation be carried out exactly using rationals and the rest be done using floatingpoint arithmetic." It seems pretty clear to me: a numerical function with one or more float arguments always returns a float (or in some cases a complex number with float parts). Am I missing something?  Knut Arild Erstad Vacuums are nothings. We only mention them to let them know we know they're there. 
From: Bruno Haible <haible@il...>  20000728 13:32:10

Knut Arild Erstad writes: > I understand the argument, but it still seemed unintuitive somehow, and > different from all other languages and Lisp versions I remember seeing But it is closer to what a real computer algebra system does. Because it is closer to the true mathematical result. > <URL:http://www.xanalys.com/software_tools/reference/HyperSpec/Body/ > sec_12144.html> This section applies only to floatfloat combinations. Look at section 12.1.4.1 and at section 12.1.3.3: "When the arguments to an irrational mathematical function are all rational and the true mathematical result is also (mathematically) rational, then unless otherwise noted an implementation is free to return either an accurate rational result or a single float approximation." Bruno 
From: Knut Arild Erstad <knute@ii...>  20000728 00:07:31

On Thu, Jul 27, 2000 at 08:22:52PM +0200, Bruno Haible wrote: > Knut Arild Erstad writes: > > > Another somewhat unrelated problem I ran into: (* 0 1.1) returns 0, not > > 0.0. Is this a bug? It seems like strange behaviour to me... > > The difference between 0 and 0.0 in Lisp sense is that 0.0 is an > approximate zero, possibly originated from the subtraction of two > different but very close numbers, whereas 0 is a precise zero  it is > always zero no matter how close you look. [...] I understand the argument, but it still seemed unintuitive somehow, and different from all other languages and Lisp versions I remember seeing, so I looked it up both in Graham's ANSI Common Lisp book and the HyperSpec, and there it is: <URL:http://www.xanalys.com/software_tools/reference/HyperSpec/Body/ sec_12144.html> "The result of a numerical function is a float of the largest format among all the floatingpoint arguments to the function."  Knut Arild Erstad Vacuums are nothings. We only mention them to let them know we know they're there. 