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

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}
(20) 
_{Dec}
(17) 

2002 
_{Jan}
(39) 
_{Feb}
(21) 
_{Mar}
(33) 
_{Apr}
(135) 
_{May}
(53) 
_{Jun}
(88) 
_{Jul}
(47) 
_{Aug}
(59) 
_{Sep}
(207) 
_{Oct}
(40) 
_{Nov}
(7) 
_{Dec}
(26) 
2003 
_{Jan}
(49) 
_{Feb}
(39) 
_{Mar}
(117) 
_{Apr}
(50) 
_{May}
(62) 
_{Jun}
(6) 
_{Jul}
(19) 
_{Aug}
(24) 
_{Sep}
(11) 
_{Oct}
(11) 
_{Nov}
(49) 
_{Dec}
(9) 
2004 
_{Jan}
(29) 
_{Feb}
(123) 
_{Mar}
(32) 
_{Apr}
(53) 
_{May}
(52) 
_{Jun}
(19) 
_{Jul}
(33) 
_{Aug}
(10) 
_{Sep}
(76) 
_{Oct}
(86) 
_{Nov}
(171) 
_{Dec}
(163) 
2005 
_{Jan}
(147) 
_{Feb}
(121) 
_{Mar}
(120) 
_{Apr}
(126) 
_{May}
(120) 
_{Jun}
(213) 
_{Jul}
(76) 
_{Aug}
(79) 
_{Sep}
(140) 
_{Oct}
(83) 
_{Nov}
(156) 
_{Dec}
(202) 
2006 
_{Jan}
(181) 
_{Feb}
(171) 
_{Mar}
(157) 
_{Apr}
(98) 
_{May}
(96) 
_{Jun}
(97) 
_{Jul}
(193) 
_{Aug}
(76) 
_{Sep}
(130) 
_{Oct}
(63) 
_{Nov}
(196) 
_{Dec}
(253) 
2007 
_{Jan}
(256) 
_{Feb}
(293) 
_{Mar}
(276) 
_{Apr}
(258) 
_{May}
(181) 
_{Jun}
(91) 
_{Jul}
(108) 
_{Aug}
(69) 
_{Sep}
(107) 
_{Oct}
(179) 
_{Nov}
(137) 
_{Dec}
(121) 
2008 
_{Jan}
(124) 
_{Feb}
(129) 
_{Mar}
(192) 
_{Apr}
(201) 
_{May}
(90) 
_{Jun}
(86) 
_{Jul}
(115) 
_{Aug}
(142) 
_{Sep}
(49) 
_{Oct}
(91) 
_{Nov}
(95) 
_{Dec}
(218) 
2009 
_{Jan}
(230) 
_{Feb}
(149) 
_{Mar}
(118) 
_{Apr}
(72) 
_{May}
(77) 
_{Jun}
(68) 
_{Jul}
(102) 
_{Aug}
(72) 
_{Sep}
(89) 
_{Oct}
(76) 
_{Nov}
(125) 
_{Dec}
(86) 
2010 
_{Jan}
(75) 
_{Feb}
(90) 
_{Mar}
(89) 
_{Apr}
(121) 
_{May}
(111) 
_{Jun}
(66) 
_{Jul}
(75) 
_{Aug}
(66) 
_{Sep}
(66) 
_{Oct}
(166) 
_{Nov}
(121) 
_{Dec}
(73) 
2011 
_{Jan}
(74) 
_{Feb}

_{Mar}

_{Apr}
(14) 
_{May}
(22) 
_{Jun}
(31) 
_{Jul}
(53) 
_{Aug}
(37) 
_{Sep}
(23) 
_{Oct}
(25) 
_{Nov}
(31) 
_{Dec}
(28) 
2012 
_{Jan}
(18) 
_{Feb}
(11) 
_{Mar}
(32) 
_{Apr}
(17) 
_{May}
(48) 
_{Jun}
(37) 
_{Jul}
(23) 
_{Aug}
(54) 
_{Sep}
(15) 
_{Oct}
(11) 
_{Nov}
(19) 
_{Dec}
(22) 
2013 
_{Jan}
(11) 
_{Feb}
(32) 
_{Mar}
(24) 
_{Apr}
(37) 
_{May}
(31) 
_{Jun}
(14) 
_{Jul}
(26) 
_{Aug}
(33) 
_{Sep}
(40) 
_{Oct}
(21) 
_{Nov}
(36) 
_{Dec}
(84) 
2014 
_{Jan}
(23) 
_{Feb}
(20) 
_{Mar}
(27) 
_{Apr}
(24) 
_{May}
(31) 
_{Jun}
(27) 
_{Jul}
(34) 
_{Aug}
(26) 
_{Sep}
(21) 
_{Oct}
(45) 
_{Nov}
(23) 
_{Dec}
(73) 
2015 
_{Jan}
(33) 
_{Feb}
(8) 
_{Mar}
(24) 
_{Apr}
(45) 
_{May}
(27) 
_{Jun}
(19) 
_{Jul}
(21) 
_{Aug}
(51) 
_{Sep}
(43) 
_{Oct}
(29) 
_{Nov}
(61) 
_{Dec}
(86) 
2016 
_{Jan}
(99) 
_{Feb}
(52) 
_{Mar}
(80) 
_{Apr}
(61) 
_{May}
(24) 
_{Jun}
(23) 
_{Jul}
(36) 
_{Aug}
(30) 
_{Sep}
(41) 
_{Oct}
(43) 
_{Nov}
(27) 
_{Dec}
(46) 
2017 
_{Jan}
(57) 
_{Feb}
(34) 
_{Mar}
(40) 
_{Apr}
(31) 
_{May}
(78) 
_{Jun}
(49) 
_{Jul}
(72) 
_{Aug}
(33) 
_{Sep}
(16) 
_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 





1

2
(3) 
3

4

5

6

7

8

9

10
(1) 
11

12

13

14
(2) 
15
(3) 
16
(1) 
17

18

19

20

21
(1) 
22
(1) 
23

24
(1) 
25
(4) 
26
(1) 
27
(4) 
28
(1) 
29
(2) 
30
(6) 
31
(1) 
From: Raymond Toy <rtoy@us...>  20120331 01:54:04

This is an automated email from the git hooks/postreceive script. It was generated because a ref change was pushed to the repository containing the project "Maxima, A Computer Algebra System". The branch, master has been updated via dab8e66cc18b04812af83557f663e1c0347cab23 (commit) from 380f0a4c4aef03349684af8e1b9c20405f9569e2 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below.  Log  commit dab8e66cc18b04812af83557f663e1c0347cab23 Author: Raymond Toy <rtoy@...> Date: Fri Mar 30 18:53:41 2012 0700 Try to minimize the chance of overflow for the regularized incomplete gamma function for floats. src/gamma.lisp: o Restructure code, making the original gammaincomplete compute either thee series or continued fraction, without the scale factor. o Make the new gammaincomplete routine carefully compute the scale factor so as not to overflow too soon. tests/rtest_gamma.mac: o Add test for regularized incomplete gamma that used to overflow. Accuracy is reduced because of the large numbers, though. diff git a/src/gamma.lisp b/src/gamma.lisp index 9a1c5c4..9035da0 100644  a/src/gamma.lisp +++ b/src/gamma.lisp @@ 749,11 +749,62 @@ ;;; Maxima returns the numercial result for gamma_incomplete_regularized (defun gammaincomplete (a x &optional (regularized nil)) + (let ((factor + ;; Compute the factor needed to scale the series or continued + ;; fraction. This is x^a*exp(x) or x^a*exp(x)/gamma(a) + ;; depending on whether we want a nonregularized or + ;; regularized form. We want to compute the factor carefully + ;; to avoid unnecessary overflow if possible. + (cond (regularized + (or (tryfloatcomputation + #'(lambda () + ;; gammafloat is more accurate for real + ;; values of a. + (cond ((complexp a) + (/ (* (expt x a) (exp ( x))) + (gammalanczos a))) + (t + (/ (* (expt x a) (exp ( x))) + (gammafloat a)))))) + ;; Easy way failed. Use logs to compute the + ;; result. This loses some precision, especially + ;; for large values of a and/or x because we use + ;; many bits to hold the exponent part. + (exp ( (* a (log x)) + x + (loggammalanczos (if (complexp a) + a + (complex a))))))) + (t + (or (tryfloatcomputation + #'(lambda () + (* (expt x a) (exp ( x))))) + ;; Easy way failed, so use the log form. + (exp ( (* a (log x)) + x))))))) + (multiplevaluebind (result method) + (%gammaincomplete a x) + (cond (method + ;; Series used (which returns the integral from 0 to x). + (cond (regularized + ( 1 (* result factor))) + ((complexp a) + ( (gammalanczos a) (* result factor))) + (t + ( (gammafloat a) (* result factor))))) + (t + ;; Continued fraction used. Just multiply by the factor + ;; to get the final result. + (* factor result)))))) + +;; Compute the key part of the gamma incomplete function using either +;; a series expression or a continued fraction expression. +(defun %gammaincomplete (a x) (let ((gmmaxit *gammaincompletemaxit*) (gmeps *gammaincompleteeps*) (gmmin *gammaincompletemin*)) (when *debuggamma*  (format t "~&GAMMAINCOMPLETE with ~A and ~A~%" a x)) + (format t "~&GAMMAINCOMPLETE with ~A and ~A~%" a x)) (cond ;; The series expansion is done for x within a circle with a radius ;; *gammaradius*+abs(realpart(a)), for all x which are on the negative @@ 783,50 +834,23 @@ (setq del (* d c)) (setq h (* h del)) (when (< (abs ( del 1.0)) gmeps)  (return  (let ((result (* h (expt x a) (exp ( x)))))  (cond  (regularized  ;; Return gamma_incomplete_regularized  (cond  ((complexp a)  (/ result (gammalanczos a)))  (t  ;; Call the more precise function gammafloat  (/ result (gammafloat a)))))  (t  result)))))))   (t  ;; Expansion in a series  (when *debuggamma*  (format t "~&GAMMAINCOMPLETE in series~%"))  (do* ((i 1 (+ i 1))  (ap a (+ ap 1.0))  (del (/ 1.0 a) (* del (/ x ap)))  (sum del (+ sum del)))  ((> i gmmaxit)  (merror (intl:gettext "gamma_incomplete: series expansion failed for gamma_incomplete(~:M, ~:M).") a x))  (when (< (abs del) (* (abs sum) gmeps))  (when *debuggamma* (format t "~&Series converged.~%"))  (return  (let ((result (* sum (expt x a) (exp ( x)))))  (cond  ((complexp a)  (cond  (regularized  ;; Return gamma_incomplete_regularized  ( 1.0 (/ result (gammalanczos a))))  (t  ( (gammalanczos a) result ))))   (t  (cond  (regularized  ;; Return gamma_incomplete_regularized  ( 1.0 (/ result (gammafloat a))))  (t  ( (gammafloat a) result))))))))))))) + ;; Return nil to indicate we used the continued fraction. + (return (values h nil))))) + (t + ;; Expansion in a series + (when *debuggamma* + (format t "~&GAMMAINCOMPLETE in series~%")) + (do* ((i 1 (+ i 1)) + (ap a (+ ap 1.0)) + (del (/ 1.0 a) (* del (/ x ap))) + (sum del (+ sum del))) + ((> i gmmaxit) + (merror (intl:gettext "gamma_incomplete: series expansion failed for gamma_incomplete(~:M, ~:M).") a x)) + (when (< (abs del) (* (abs sum) gmeps)) + (when *debuggamma* (format t "~&Series converged.~%")) + ;; Return T to indicate we used the series and the series + ;; is for the integral from 0 to x, not x to inf. + (return (values sum t)))))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; diff git a/tests/rtest_gamma.mac b/tests/rtest_gamma.mac index 408aadd..5a083cb 100644  a/tests/rtest_gamma.mac +++ b/tests/rtest_gamma.mac @@ 3470,5 +3470,12 @@ closeto( 3.4b67); true; +/* Make sure we don't overflow unnecessarily in gamma_incomplete_regularized */ +closeto( + gamma_incomplete_regularized(45001d0, 45000d0), + 0.5012537510700691773177801688515861486945632498553288, + 6.4e12); +true; + (fpprec:oldfpprec,done); done;  Summary of changes: src/gamma.lisp  114 +++++++++++++++++++++++++++++ tests/rtest_gamma.mac  7 +++ 2 files changed, 76 insertions(+), 45 deletions() hooks/postreceive  Maxima, A Computer Algebra System 