You can subscribe to this list here.
2009 
_{Jan}
(2) 
_{Feb}
(5) 
_{Mar}

_{Apr}

_{May}
(2) 
_{Jun}
(8) 
_{Jul}
(4) 
_{Aug}

_{Sep}

_{Oct}
(2) 
_{Nov}
(6) 
_{Dec}


2010 
_{Jan}
(1) 
_{Feb}
(1) 
_{Mar}
(3) 
_{Apr}
(2) 
_{May}
(2) 
_{Jun}
(2) 
_{Jul}
(18) 
_{Aug}
(13) 
_{Sep}
(7) 
_{Oct}

_{Nov}

_{Dec}
(2) 
2011 
_{Jan}

_{Feb}
(11) 
_{Mar}

_{Apr}
(4) 
_{May}

_{Jun}
(1) 
_{Jul}
(18) 
_{Aug}
(16) 
_{Sep}
(12) 
_{Oct}
(12) 
_{Nov}
(19) 
_{Dec}
(42) 
2012 
_{Jan}
(16) 
_{Feb}
(3) 
_{Mar}
(8) 
_{Apr}
(14) 
_{May}
(30) 
_{Jun}
(5) 
_{Jul}
(7) 
_{Aug}
(3) 
_{Sep}
(10) 
_{Oct}
(4) 
_{Nov}
(10) 
_{Dec}
(1) 
2013 
_{Jan}
(14) 
_{Feb}
(8) 
_{Mar}
(5) 
_{Apr}
(3) 
_{May}
(9) 
_{Jun}
(19) 
_{Jul}

_{Aug}
(27) 
_{Sep}
(5) 
_{Oct}
(18) 
_{Nov}
(12) 
_{Dec}
(8) 
2014 
_{Jan}
(5) 
_{Feb}
(8) 
_{Mar}
(20) 
_{Apr}
(22) 
_{May}
(28) 
_{Jun}
(9) 
_{Jul}
(6) 
_{Aug}
(46) 
_{Sep}
(40) 
_{Oct}
(15) 
_{Nov}
(8) 
_{Dec}
(34) 
2015 
_{Jan}
(20) 
_{Feb}
(15) 
_{Mar}
(18) 
_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19
(1) 
20

21
(4) 
22
(1) 
23

24
(1) 
25
(3) 
26
(3) 
27

28

29

30

31





From: Arthur Norman <acn1@ca...>  20100822 09:17:36

CSL now has some more functions to help with floating point. To get access to these you will need to rebuild your Reduce image I expect. These are in the lastest subversion. Reduce (Free CSL version), 21Aug10 ... 1: lisp; nil 2* decode!float (1024.0); (1.0 11 0.5) This is basically FREXP and gives you sign, exponant and mantissa. There ought not be to any rounding etc in the process. 3* integer!decode!float (1024.0); (4503599627370496 42 1) Much the same except that the mantissa is returned as an integer of 52 bits. Except of course when the input is 0.0. This gives access to the bitwise representationof the float. 4* scale!float(1.0, 10); 1024.0 This one is as in ldexp and scales by a factor of 2 by addint in exponent bits. 5* rational 3.125; (25 . 8) If the float concerned denotes a neat rational numbet the dotted pair you get back will be that. 6* rational exp 1.0; (6121026514868073 . 2251799813685248) Note that the quotient of those two integers is close to "e", and the second of them is a power of 2. So this is rather like doing integerdecodefloat but then using the exponent to get an integer power of 2. 7* rational 1.0e22; 10000000000000000000000 This may return an integer not a dotted pair if a fraction is not needed. 8* rational 1.0e77; 99999999999999998278261272554585856747747644714015897553975120217811154108416 The exact integer value denoted by the floating point representation. Which is a 52bit number multiplied by 2^21, as integerdecodefloat would tell you. If there were documentation anywhere I might merge this email into it! Arthur 