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

_{Feb}
(1) 
_{Mar}
(11) 
_{Apr}

_{May}
(16) 
_{Jun}
(5) 
_{Jul}
(5) 
_{Aug}
(27) 
_{Sep}
(25) 
_{Oct}
(10) 
_{Nov}
(40) 
_{Dec}
(40) 

2001 
_{Jan}
(78) 
_{Feb}
(80) 
_{Mar}
(35) 
_{Apr}
(73) 
_{May}
(97) 
_{Jun}
(44) 
_{Jul}
(38) 
_{Aug}
(43) 
_{Sep}
(94) 
_{Oct}
(124) 
_{Nov}
(13) 
_{Dec}
(79) 
2002 
_{Jan}
(144) 
_{Feb}
(68) 
_{Mar}
(128) 
_{Apr}
(117) 
_{May}
(90) 
_{Jun}
(63) 
_{Jul}
(42) 
_{Aug}
(66) 
_{Sep}
(97) 
_{Oct}
(89) 
_{Nov}
(92) 
_{Dec}
(88) 
2003 
_{Jan}
(101) 
_{Feb}
(127) 
_{Mar}
(103) 
_{Apr}
(145) 
_{May}
(211) 
_{Jun}
(143) 
_{Jul}
(67) 
_{Aug}
(184) 
_{Sep}
(212) 
_{Oct}
(117) 
_{Nov}
(181) 
_{Dec}
(86) 
2004 
_{Jan}
(92) 
_{Feb}
(95) 
_{Mar}
(163) 
_{Apr}
(242) 
_{May}
(202) 
_{Jun}
(114) 
_{Jul}
(94) 
_{Aug}
(148) 
_{Sep}
(163) 
_{Oct}
(111) 
_{Nov}
(95) 
_{Dec}
(133) 
2005 
_{Jan}
(148) 
_{Feb}
(102) 
_{Mar}
(213) 
_{Apr}
(178) 
_{May}
(202) 
_{Jun}
(199) 
_{Jul}
(189) 
_{Aug}
(309) 
_{Sep}
(126) 
_{Oct}
(128) 
_{Nov}
(148) 
_{Dec}
(156) 
2006 
_{Jan}
(222) 
_{Feb}
(184) 
_{Mar}
(152) 
_{Apr}
(176) 
_{May}
(189) 
_{Jun}
(186) 
_{Jul}
(75) 
_{Aug}
(182) 
_{Sep}
(103) 
_{Oct}
(144) 
_{Nov}
(265) 
_{Dec}
(197) 
2007 
_{Jan}
(175) 
_{Feb}
(202) 
_{Mar}
(212) 
_{Apr}
(309) 
_{May}
(203) 
_{Jun}
(162) 
_{Jul}
(207) 
_{Aug}
(156) 
_{Sep}
(136) 
_{Oct}
(99) 
_{Nov}
(199) 
_{Dec}
(201) 
2008 
_{Jan}
(190) 
_{Feb}
(201) 
_{Mar}
(180) 
_{Apr}
(132) 
_{May}
(204) 
_{Jun}
(149) 
_{Jul}
(125) 
_{Aug}
(102) 
_{Sep}
(86) 
_{Oct}
(269) 
_{Nov}
(167) 
_{Dec}
(291) 
2009 
_{Jan}
(155) 
_{Feb}
(119) 
_{Mar}
(174) 
_{Apr}
(186) 
_{May}
(168) 
_{Jun}
(217) 
_{Jul}
(107) 
_{Aug}
(134) 
_{Sep}
(111) 
_{Oct}
(184) 
_{Nov}
(81) 
_{Dec}
(140) 
2010 
_{Jan}
(91) 
_{Feb}
(93) 
_{Mar}
(132) 
_{Apr}
(137) 
_{May}
(86) 
_{Jun}
(112) 
_{Jul}
(38) 
_{Aug}
(112) 
_{Sep}
(111) 
_{Oct}
(124) 
_{Nov}
(52) 
_{Dec}
(49) 
2011 
_{Jan}
(72) 
_{Feb}
(115) 
_{Mar}
(91) 
_{Apr}
(38) 
_{May}
(119) 
_{Jun}
(129) 
_{Jul}
(34) 
_{Aug}
(140) 
_{Sep}
(37) 
_{Oct}
(58) 
_{Nov}
(130) 
_{Dec}
(59) 
2012 
_{Jan}
(20) 
_{Feb}
(9) 
_{Mar}
(41) 
_{Apr}
(89) 
_{May}
(69) 
_{Jun}
(21) 
_{Jul}
(14) 
_{Aug}
(24) 
_{Sep}
(52) 
_{Oct}
(49) 
_{Nov}
(45) 
_{Dec}
(21) 
2013 
_{Jan}
(36) 
_{Feb}
(53) 
_{Mar}
(50) 
_{Apr}
(142) 
_{May}
(125) 
_{Jun}
(120) 
_{Jul}
(89) 
_{Aug}
(82) 
_{Sep}
(45) 
_{Oct}
(104) 
_{Nov}
(69) 
_{Dec}
(40) 
2014 
_{Jan}
(28) 
_{Feb}
(85) 
_{Mar}
(99) 
_{Apr}
(108) 
_{May}
(92) 
_{Jun}
(73) 
_{Jul}
(7) 
_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 



1
(8) 
2
(9) 
3
(2) 
4
(2) 
5

6

7

8
(3) 
9

10
(2) 
11

12

13
(1) 
14
(2) 
15

16
(9) 
17
(2) 
18

19

20

21
(5) 
22
(3) 
23
(2) 
24
(1) 
25
(2) 
26

27
(4) 
28
(2) 
29
(6) 
30
(2) 
31
(2) 


From: Nikodemus Siivola <nikodemus@ra...>  20120528 19:52:54

On 28 May 2012 18:36, Lutz Euler <lutz.euler@...> wrote: >  Document that x86 is imprecise. To the degree that we can't fix it (or haven't yet fixed tis), we should do this. >  Completely revert the fix for lp#327192 on the account that delivering > 0 or some random value are both equally bad (the bug that "tan" > crashes can be fixed independently; there is only an "fldz" missing). Adding the missing fldz sounds right TRT. >  Change the test to test for correct results and mark x86 as failing. Sounds right. >  Drop the test as nobody would be using arguments this large to > trigonometric functions anyway. Someone ran across it... so I think there's some experimental proof to the contrary. >  Implement a better range reduction on x86 (in Lisp, presumably) and > use it for arguments above (expt 2 20) or so. >  Convert x86 to use libm for these functions. I think I would prefer to use libm, but I foresee that even if we use libm elsewhere, we may need to do something else on Windows  but let's not hope so... Cheers,  Nikodemus 
From: <lutz.euler@fr...>  20120528 15:39:28

Hi, the mentioned test is tagged as "Expected failure", currently only on x8664 (but also fails on PPC, see lp#964348  I agree with Nikodemus that that is expected). I am getting earnestly annoyed by this, so I investigated. It turns out things are completely different. The test is about range reduction for trigonometric functions on large float arguments, like (sin (expt 2d0 70)). It was introduced with commit ad9090dc91fc922a with a fix for lp#327192 where Gabor had noticed that on x86 the above expression returns 0d0 and Paul committed a change introducing range reduction into the relevant VOPs on x86. In short: The test is bogus. Even on x86 it only doesn't fail due to an (un)lucky choice of test values. Trigonometric functions on large float arguments on x86 still deliver completely wrong results. The x8664 port gets everything right but the test punishes that. Basically, x86 gets things wrong because it does range reduction (even for arguments below (expt 2 63), it seems) modulo some limitedprecision approximation of 2 pi while libm uses an algorithm that delivers results as if the infinitely precise pi was used to reduce mod 2 pi. So what do we want:  Document that x86 is imprecise.  Completely revert the fix for lp#327192 on the account that delivering 0 or some random value are both equally bad (the bug that "tan" crashes can be fixed independently; there is only an "fldz" missing).  Change the test to test for correct results and mark x86 as failing.  Drop the test as nobody would be using arguments this large to trigonometric functions anyway.  Implement a better range reduction on x86 (in Lisp, presumably) and use it for arguments above (expt 2 20) or so.  Convert x86 to use libm for these functions. Any comments appreciated! Some details: Here are some results of (sin (expt 2d0 n)) on SBCL x86, respectively (coerce (sin (expt 2l0 n)) 'doublefloat) on Clisp with the longfloat precision set to 3000 bits (the results of the first expression on SBCL x8664 are equal to Clisp's results and I assume that both are mathematically correct within one ULP or so): n = 20: SBCL x86: 0.33049314002173596d0 Clisp: 0.3304931400217347d0 n = 40: SBCL x86: 0.4057050128266265d0 Clisp: 0.40570501153282873d0 n = 70: SBCL x86: 0.936042960761405d0 Clisp: 0.9981794021933068d0 So, with n = 70, x86 does not even get the sign of the result right. Here is why the test only accidentally works on x86: For several values it compares for example (sin value) with (sin (mod value (* 2 pi))). It turns out that for the only value large enough to have a chance to make "almost=" in the test fail (in light of the size of the errors seen above), namely (* pi (expt 2d0 70)), the modular reductions by mod (Lisp) and by fprem/fsin (x87) yield the same, namely 0d0: (All following expressions are evaluated on x86) * (sin (* pi (expt 2d0 70))) 0.0d0 * (mod (* pi (expt 2d0 70)) (* 2 pi)) 0.0d0 * (sin (mod (* pi (expt 2d0 70)) (* 2 pi))) 0.0d0 But for some other values these are not equal (or "almost=") anymore (and still both completely wrong, I need not mention): * (let* ((value (* 1.625d0 pi (expt 2d0 70))) (mod (mod value (* 2 pi)))) (values (sin value) mod (sin mod))) 0.1676180272408028d0 0.0d0 0.0d0 * (let* ((value (* 1.6d0 (expt 2d0 70))) (mod (mod value (* 2 pi)))) (values (sin value) mod (sin mod))) 0.5720626950150568d0 262144.0d0 0.08410702780950105d0 Greetings, Lutz 