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}
(60) 
_{Dec}

S  M  T  W  T  F  S 



1
(2) 
2

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

10

11

12

13
(1) 
14

15
(3) 
16

17

18

19

20

21

22

23

24
(1) 
25

26

27
(1) 
28

29
(3) 
30

31



From: Rupert Swarbrick <rswarbrick@us...>  20131024 18:59:05

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 CAS". The branch, master has been updated via 9f2bf3dc73250c88152d346918053b5b16aab866 (commit) from f5e6d072e3a41bf217e58abfb2eb2dea8cffa3c4 (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 9f2bf3dc73250c88152d346918053b5b16aab866 Author: Rupert Swarbrick <rswarbrick@...> Date: Thu Oct 24 19:47:49 2013 +0100 Revert cleanup changes to rat package Starting with the one that nuked errjfflag, since it caused a massive slowdown on CMUCL. diff git a/share/affine/sheafa.lisp b/share/affine/sheafa.lisp index 466918d..705ae3d 100644  a/share/affine/sheafa.lisp +++ b/share/affine/sheafa.lisp @@ 2003,7 +2003,8 @@ ;;where zi=qi(x1,x2, xn)/gp and xi=pi(z1,..,zn)/gq (defmfun mytestdivide (x y)  (ignoreraterr (pquotient x y))) + (let ((errrjfflag t)) + (catch 'raterr (pquotient x y)))) (defun newtestdivide (f g &aux quot) (setq quot (ratreduce f g)) diff git a/src/maxima.system b/src/maxima.system index 0e554ce..a3e46ef 100644  a/src/maxima.system +++ b/src/maxima.system @@ 514,8 +514,7 @@ (:file "rat3c") (:file "rat3e") (:file "nrat4")  (:file "ratout"))  :dependson (ratmacros othermacros)) + (:file "ratout"))) (:module maximalanguagecompiler :sourcepathname "" :components ((:file "transl") (:file "transs") diff git a/src/nrat4.lisp b/src/nrat4.lisp index f35546d..3f5c40c 100644  a/src/nrat4.lisp +++ b/src/nrat4.lisp @@ 15,6 +15,8 @@ (declaretop (special $ratsimpexpons *exp *exp2 *radsubst *loglist $radsubstflag $radexpand $logsimp *v *var frfactor radcanp ratsubvl)) +(loadmacsymamacros rzmac ratmac) + (defmvar $radsubstflag nil "`radsubstflag' `t' makes `ratsubs' call `radcan' when it appears useful") diff git a/src/rat3a.lisp b/src/rat3a.lisp index a8cb706..ef84c4f 100644  a/src/rat3a.lisp +++ b/src/rat3a.lisp @@ 25,169 +25,94 @@ ;;slow it down on lispm. We also eliminated the special ;;from ptimes2wfs +(loadmacsymamacros ratmac) + ;; Global variables referenced throughout the rational function package. (defmvar modulus nil "Global switch for doing modular arithmetic") ;; CQUOTIENT ;; ;; Calculate the quotient of two coefficients, which should be numbers. If ;; MODULUS is nonnil, we try to take the reciprocal of A with respect to the ;; modulus (using CRECIP) and then multiply by B. Note that this fails if B ;; divides A as an integer, but B is not a unit in the ring of integers modulo ;; MODULUS. For example, ;; ;; (let ((modulus 20)) (cquotient 10 5)) => ERROR ;; ;; If MODULUS is nil, then we work over the ring of integers when A and B are ;; integers, and raise a RATERROR if A is not divisible by B. If either A or B ;; is a float then the division is done in floating point. Floats can get as far ;; as the rational function code if $KEEPFLOAT is true. +(defmacro bctimes (&rest l) + `(rem (* ,@l) modulus)) + +;; coefficient quotient a / b +;; a and b may be integers (possibly with modulus) or floats if keepfloat=true (defun cquotient (a b) (cond ((equal a 0) 0) ((null modulus)  (if (or (floatp a) (floatp b)  (zerop (rem a b)))  (/ a b)  (raterror "quotient is not exact"))) + (cond ((equal 0 (cremainder a b)) (/ a b)) + (t (raterror "quotient is not exact")))) (t (ctimes a (crecip b))))) ;; ALG ;; ;; Get any value stored on the tellrat property of (car l). Returns NIL if L ;; turns out not to be a list or if $ALGEBRAIC is false. (defun alg (l)  (unless (atom l) (algv (car l)))) + (and $algebraic (not (atom l)) (get (car l) 'tellrat))) ;; PACOEFP ;; ;; Return T if either X is a bare coefficient or X is a polynomial whose main ;; variable has a declared value as an algebraic integer. Otherwise return NIL. (defun pacoefp (x)  (and (or (pcoefp x) (alg x))  T)) + (or (pcoefp x) (alg x))) ;; LEADTERM ;; ;; Return the leading term of POLY as a polynomial itself. (defun leadterm (poly)  (if (pcoefp poly)  poly  (makepoly (pvar poly) (ple poly) (plc poly))))  ;; CBEXPT ;; ;; Raise an number to a positive integral power. P should be a number (and ;; really only makes sense if it is an integer). N should be a nonnegative ;; integer. + (cond ((pcoefp poly) poly) + (t (makepoly (pvar poly) (ple poly) (plc poly))))) + +(defun cremainder (a b) + (cond ((or modulus (floatp a) (floatp b)) 0) + ((rem a b)))) + (defun cbexpt (p n) (do ((n (ash n 1) (ash n 1)) (s (if (oddp n) p 1))) ((zerop n) s)  (setq p (rem (* p p) modulus))  (when (oddp n) (setq s (rem (* s p) modulus))))) + (setq p (bctimes p p)) + (and (oddp n) (setq s (bctimes s p))))) + ;; Coefficient Arithmetic  coefficients are assumed to be something ;; that is NUMBERP in lisp. If MODULUS is nonNIL, then all coefficients ;; are assumed to be less than its value. Some functions use LOGAND ;; when MODULUS = 2. This will not work with bignum coefficients. ;; CRECIP ;; ;; Takes the inverse of an integer N mod MODULUS. If there is a modulus then the ;; result is constrained to lie in (modulus/2, modulus/2] ;; ;; This just uses the extended Euclidean algorithm: once you have found a,b such ;; that a*n + b*modulus = 1 then a must be the reciprocal you're after. ;; ;; When MODULUS is greater than 2^15, we use exactly the same algorithm in ;; CRECIPGENERAL, but it can't use fixnum arithmetic. Note: There's no ;; particular reason to target 32 bits except that trying to work out the right ;; types on the fly looks complicated and this lisp compiler, at least, uses 32 ;; bit words. Since we have to take a product, we constrain the types to 16 bit ;; numbers. (defun crecip (n)  ;; Punt on anything complicated  (unless (and modulus (typep modulus '(unsignedbyte 15)))  (returnfrom crecip (crecipgeneral n)))   ;; And make sure that MODULUS < N < MODULUS  (unless (<= ( modulus) n modulus)  (merror "N is out of range [MODULUS, MODULUS] in crecip."))   ;; N in [0, MODULUS]  (when (minusp n) (setf n (+ n modulus)))   ;; The modcopy parameter stores a copy of MODULUS on the stack, which is  ;; useful because the lisp implementation doesn't know that the special  ;; variable MODULUS is still an (unsignedbyte 15) when we get to the end  ;; (since it can't tell that our function calls don't change it behind our  ;; backs, I guess)  (let ((mod modulus) (remainder n) (a 1) (b 0)  (modcopy modulus))  ;; On SBCL in 2013 at least, the compiler doesn't spot that MOD and  ;; REMAINDER are unsigned and bounded above by MODULUS, a 16bit integer. So  ;; we have to tell it. Also, the lisp implementation can't really be  ;; expected to know that Bezout coefficients are bounded by the modulus and  ;; remainder, so we have to tell it that too.  (declare (type (unsignedbyte 15) mod modcopy remainder)  (type (signedbyte 16) a b))   (loop  until (= remainder 1)   when (zerop remainder) do  (merror (intl:gettext "CRECIP: attempted inverse of zero (mod ~M)")  mod)  doing  (multiplevaluebind (quot rem)  (truncate mod remainder)  (setf mod remainder  remainder rem)  (psetf a ( b (* a quot))  b a))   finally  ;; Since this isn't some general purpose Euclidean algorithm, but  ;; instead is trying to find a modulo inverse, we need to ensure that  ;; the Bezout coefficient we found (called A) is actually in [0,  ;; MODULUS).  ;;  ;; The general code calls CMOD here, but that doesn't know about the  ;; types of A and MODULUS, so we do it by hand, specialcasing the easy  ;; case of modulus=2.  (return  (if (= modcopy 2)  (logand a 1)  (let ((nn (mod a modcopy)))  ;; nn here is in [0, modulus)  (if (<= (* 2 nn) modcopy)  nn  ( nn modcopy))))))))  ;; CRECIPGENERAL ;; ;; The general algorithm for CRECIP, valid when the modulus is any integer. See ;; CRECIP for more details. (defun crecipgeneral (n)  ;; We assume that n < modulus, so n+modulus is always positive  (let ((mod modulus)  (remainder (if (minusp n) (+ n modulus) n))  (a 1) (b 0))  (loop  until (= remainder 1)   when (zerop remainder) do  (merror (intl:gettext "CRECIP: attempted inverse of zero (mod ~M)")  mod)  doing  (let ((quotient (truncate mod remainder)))  (psetf mod remainder  remainder ( mod (* quotient remainder)))  (psetf a ( b (* a quotient))  b a))   finally (return (cmod a))))) +;; Takes the inverse of an integer N mod P. Solve N*X + P*Y = 1 +;; I suspect that N is guaranteed to be less than P, since in the case +;; where P is a fixnum, N is also assumed to be one. + +(defmfun crecip (n) + (cond ((bignump modulus) ;; Have to use bignum arithmetic if modulus is a bignum + (prog (a1 a2 y1 y2 q (bign n)) + (if (minusp bign) (setq bign (+ bign modulus))) + (setq a1 modulus a2 bign) + (setq y1 0 y2 1) + (go step3) + step2 (setq q (truncate a1 a2)) + (psetq a1 a2 a2 ( a1 (* a2 q))) + (psetq y1 y2 y2 ( y1 (* y2 q))) + step3 (cond ((zerop a2) (merror (intl:gettext "CRECIP: attempted inverse of zero (mod ~M)") modulus)) + ((not (equal a2 1)) (go step2))) + (return (cmod y2)))) + ;; Here we can use fixnum arithmetic + (t (prog ((a1 0) (a2 0) (y1 0) (y2 0) (q 0) (nn 0) (pp 0)) + (declare (fixnum a1 a2 y1 y2 q nn pp)) + (setq nn n pp modulus) + (cond ((minusp nn) (setq nn (+ nn pp)))) + (setq a1 pp a2 nn) + (setq y1 0 y2 1) + (go step3) + step2 (setq q (truncate a1 a2)) + (psetq a1 a2 a2 (rem a1 a2)) + (psetq y1 y2 y2 ( y1 (* y2 q))) + step3 (cond ((= a2 0) (merror (intl:gettext "CRECIP: attempted inverse of zero (mod ~M)") modulus)) + ((not (= a2 1)) (go step2))) + ;; Is there any reason why this can't be (RETURN (CMOD Y2)) ? cwh + (return (cmod y2) + ;; (COND ((= PP 2) (LOGAND 1 Y2)) + ;; (T (LET ((NN (rem Y2 PP))) + ;; (DECLARE (FIXNUM NN)) + ;; (COND ((MINUSP NN) + ;; (AND (< NN ( (ASH PP 1))) + ;; (SETQ NN (+ NN PP)))) + ;; ((> NN (ASH PP 1)) + ;; (SETQ NN ( NN PP)))) + ;; NN))) + ) + )))) (defun cexpt (n e) (cond ((null modulus) (expt n e)) diff git a/src/rat3b.lisp b/src/rat3b.lisp index ca7c5e0..178542d 100644  a/src/rat3b.lisp +++ b/src/rat3b.lisp @@ 17,6 +17,8 @@ (declaretop (special $algebraic $ratfac $keepfloat $float)) +(loadmacsymamacros ratmac) + (defmvar $ratwtlvl nil) (defmvar $ratalgdenom t) ;If T then denominator is rationalized. diff git a/src/rat3c.lisp b/src/rat3c.lisp index 2d48c44..a92e2d5 100644  a/src/rat3c.lisp +++ b/src/rat3c.lisp @@ 15,6 +15,8 @@ ;; THIS IS THE NEW RATIONAL FUNCTION PACKAGE PART 3. ;; IT INCLUDES THE GCD ROUTINES AND THEIR SUPPORTING FUNCTIONS +(loadmacsymamacros ratmac) + (declaretop (special $float $keepfloat $algebraic $ratfac genvar)) ;; List of GCD algorithms. Default one is first. @@ 283,12 +285,7 @@ (go a))) (defun prem (p q)  (cond ((pcoefp p)  (if (pcoefp q)  (if (or modulus (floatp p) (floatp q))  0  (rem p q))  p)) + (cond ((pcoefp p) (if (pcoefp q) (cremainder p q) p)) ((pcoefp q) (pzero)) (t (psimp (pvar p) (pgcd1 (pterms p) (pterms q)))))) diff git a/src/rat3d.lisp b/src/rat3d.lisp index d19151f..58cf5c2 100644  a/src/rat3d.lisp +++ b/src/rat3d.lisp @@ 12,6 +12,9 @@ (macsymamodule rat3d) +(loadmacsymamacros ratmac) + + ;; THIS IS THE NEW RATIONAL FUNCTION PACKAGE PART 4. ;; IT INCLUDES THE POLYNOMIAL FACTORING ROUTINES. diff git a/src/rat3e.lisp b/src/rat3e.lisp index 39c5439..a226c85 100644  a/src/rat3e.lisp +++ b/src/rat3e.lisp @@ 20,6 +20,8 @@ vlist scanmapp radlist expsumsplit *ratsimp* mplc* $ratsimpexpons $expop $expon $negdistrib $gcd)) +(loadmacsymamacros rzmac ratmac) + (defmvar genvar nil "List of gensyms used to point to kernels from within polynomials. The values cell and property lists of these symbols are used to diff git a/src/ratout.lisp b/src/ratout.lisp index 1d87f62..84c9ab9 100644  a/src/ratout.lisp +++ b/src/ratout.lisp @@ 18,6 +18,8 @@ genvar *a* *alpha *var* *x* *p *max *var *res *chk *l $intfaclim $ratfac u* $ratwtlvl *ratweights $ratweights $keepfloat)) +(loadmacsymamacros ratmac) + (declaretop (special $gcd xv bigf1 bigf2 nonlindeg $linhack $intfaclim bigf1tilde bigf2tilde gcd $factorflag *gcdl* lastgoodprime))  Summary of changes: share/affine/sheafa.lisp  3 + src/maxima.system  3 + src/nrat4.lisp  2 + src/rat3a.lisp  203 +++++++++++++++ src/rat3b.lisp  2 + src/rat3c.lisp  9 + src/rat3d.lisp  3 + src/rat3e.lisp  2 + src/ratout.lisp  2 + 9 files changed, 81 insertions(+), 148 deletions() hooks/postreceive  Maxima CAS 