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}
(26) 
_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 



1
(1) 
2
(1) 
3

4

5

6
(1) 
7

8

9

10
(1) 
11
(1) 
12
(1) 
13
(3) 
14

15

16
(1) 
17
(6) 
18

19

20
(2) 
21

22
(2) 
23
(2) 
24

25

26
(1) 
27
(3) 
28
(3) 
29
(4) 
30
(1) 
31



From: Rupert Swarbrick <rswarbrick@us...>  20140728 22:39:50

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 6db8907fce2cff0e9ef01fe660d3a6d647ade567 (commit) from 71578fbaaeaebeb632f7446ece47c79235ebc767 (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 6db8907fce2cff0e9ef01fe660d3a6d647ade567 Author: Rupert Swarbrick <rswarbrick@...> Date: Mon Jul 28 23:37:56 2014 +0100 Avoid infinite recursion in SP1TRIGEX There was an infinite recursion in SP1TRIGEX when evaluating powerseries(sin(x+qq),x,pp); that caused bug #2772. It happened when trying to expand sin(pp+qq) (which is free of X). Arguably, we might try to spot that the expression is free of X before trying to expand it, but it's probably a good idea to make sure that SP1TRIGEX can't ever trigger an infinite recursion. The problem was that there was some special code to deal with the case when all terms involved X, but no code for the opposite case. This patch rewrites SP1TRIGEX in (I think) a more obvious fashion, factoring out the actual expansion rules to avoid having to assign to variables (and changing their meanings, which confused me a bit). The rewrite uses SCHATCHENCOND, a macro that I wrote recently to factor some logic out of INTEGRATEEXPSPECIAL. As such, the patch moves that macro from sin.lisp into schatc.lisp. There is no code change in the macro, but there is a comment added about how to write an "otherwise" clause. The extra code responsible for actually fixing the bug is the ROTATEF near the top of the new SP1TRIGEX. I'm not including a test, because I don't know how to write one that won't kill the testsuite on failure. diff git a/src/maxima.system b/src/maxima.system index 0e554ce..80a4097 100644  a/src/maxima.system +++ b/src/maxima.system @@ 566,7 +566,8 @@ (:module integration :sourcepathname "" :components ((:file "sinint") (:file "sin")  (:file "risch"))) + (:file "risch")) + :dependson (patternmatching)) (:module taylorseries :sourcepathname "" :components ((:file "hayat"))) (:module definiteintegration :sourcepathname "" @@ 575,7 +576,8 @@ (:module trigonometry :sourcepathname "" :components ((:file "trigi") (:file "trigo")  (:file "trgred"))) + (:file "trgred")) + :dependson (patternmatching)) (:module specialfunctions :sourcepathname "" :components ((:file "specfn"))) (:module matrixalgebra :sourcepathname "" diff git a/src/schatc.lisp b/src/schatc.lisp index 984cb46..63d3423 100644  a/src/schatc.lisp +++ b/src/schatc.lisp @@ 627,4 +627,63 @@ (cdr w1)) (exp1)))) +;; Factor out the common logic to write a COND statement that uses the Schatchen +;; pattern matcher. +;; +;; Each clause in CLAUSES should match (TEST VARIABLES &body BODY). This will be +;; transformed into a COND clause that first runs TEST and binds the result to +;; W. TEST is assumed to boil down to a call to M2, which returns an alist of +;; results for the matched variables. VARIABLES should be a list of symbols and +;; the clause only matches if each of these symbols is bound in the alist. +;; +;; As a special rule, if the CAR of TEST is of the form (AND F1 F2 .. FN) then +;; the result of evaluating F1 is bound to W and then the clause only matches if +;; F2 .. FN all evaluate to true as well as the test described above. +;; +;; If the clause matches then the result of the cond is that of evaluating BODY +;; (in an implicit PROGN) with each variable bound to the corresponding element +;; of the alist. +;; +;; To add an unconditional form at the bottom, use a clause of the form +;; +;; (T NIL F1 .. FN). +;; +;; This will always match and doesn't try to bind any extra variables. + +(defmacro schatchencond (w &body clauses) + `(let ((,w)) + (cond + ,@(loop + for clause in clauses + collecting + (let ((test (car clause)) + (variables (cadr clause)) + (body (cddr clause))) + ;; A clause matches in the cond if TEST returns nonnil and + ;; binds all the expected variables in the alist. As a special + ;; syntax, if the car of TEST is 'AND, then we bind W to the + ;; result of the first argument and then check the following + ;; arguments in an environment where W is bound (but the + ;; variables aren't). + (let ((condtest + (if (and (not (atom test)) (eq 'and (car test))) + `(progn + (setf ,w ,(cadr test)) + (and ,w ,@(loop for var in variables + collecting `(cdras ',var ,w)) + ,@(cddr test))) + `(progn + (setf ,w ,test) + (and ,w ,@(loop for var in variables + collecting `(cdras ',var ,w)))))) + ;; If the clause matched, we explicitly bind all of those + ;; variables in a let form and then evaluate the + ;; associated body. + (condbody + `((let ,(loop for var in variables + collecting `(,var (cdras ',var ,w))) + ,@body)))) + `(,condtest + ,@condbody))))))) + (declaretop (unspecial var ans)) diff git a/src/sin.lisp b/src/sin.lisp index 45c3a91..80e92a9 100644  a/src/sin.lisp +++ b/src/sin.lisp @@ 2301,58 +2301,6 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Factor out the common logic to write a COND statement that uses the Schatchen ;; pattern matcher. ;; ;; Each clause in CLAUSES should match (TEST VARIABLES &body BODY). This will be ;; transformed into a COND clause that first runs TEST and binds the result to ;; W. TEST is assumed to boil down to a call to M2, which returns an alist of ;; results for the matched variables. VARIABLES should be a list of symbols and ;; the clause only matches if each of these symbols is bound in the alist. ;; ;; As a special rule, if the CAR of TEST is of the form (AND F1 F2 .. FN) then ;; the result of evaluating F1 is bound to W and then the clause only matches if ;; F2 .. FN all evaluate to true as well as the test described above. ;; ;; If the clause matches then the result of the cond is that of evaluating BODY ;; (in an implicit PROGN) with each variable bound to the corresponding element ;; of the alist. (defmacro schatchencond (w &body clauses)  `(let ((,w))  (cond  ,@(loop  for clause in clauses  collecting  (let ((test (car clause))  (variables (cadr clause))  (body (cddr clause)))  ;; A clause matches in the cond if TEST returns nonnil and  ;; binds all the expected variables in the alist. As a special  ;; syntax, if the car of TEST is 'AND, then we bind W to the  ;; result of the first argument and then check the following  ;; arguments in an environment where W is bound (but the  ;; variables aren't).  (let ((condtest  (if (and (not (atom test)) (eq 'and (car test)))  `(progn  (setf ,w ,(cadr test))  (and ,w ,@(loop for var in variables  collecting `(cdras ',var ,w))  ,@(cddr test)))  `(progn  (setf ,w ,test)  (and ,w ,@(loop for var in variables  collecting `(cdras ',var ,w))))))  ;; If the clause matched, we explicitly bind all of those  ;; variables in a let form and then evaluate the  ;; associated body.  (condbody  `((let ,(loop for var in variables  collecting `(,var (cdras ',var ,w)))  ,@body))))  `(,condtest  ,@condbody)))))))  (defun integrateexpspecial (expr var &aux w const) ;; First factor the expression. diff git a/src/trgred.lisp b/src/trgred.lisp index 47b7257..b847f5e 100644  a/src/trgred.lisp +++ b/src/trgred.lisp @@ 538,39 +538,65 @@ (sp1trigex e)) ( e ))) +;; Return the expansion of ((trigfun) ((mplus) a b)). For example sin(a+b) = +;; sin(a)cos(b) + cos(a)sin(b). +(defun expandtrigofsum (trigfun a b) + (ecase trigfun + (%sin + (m+ (m* (sp1trig (list '(%sin) a)) + (sp1trig (list '(%cos) b))) + (m* (sp1trig (list '(%cos) a)) + (sp1trig (list '(%sin) b))))) + (%cos + (m (m* (sp1trig (list '(%cos) a)) + (sp1trig (list '(%cos) b))) + (m* (sp1trig (list '(%sin) a)) + (sp1trig (list '(%sin) b))))) + (%sinh + (m+ (m* (sp1trig (list '(%sinh) a)) + (sp1trig (list '(%cosh) b))) + (m* (sp1trig (list '(%cosh) a)) + (sp1trig (list '(%sinh) b))))) + (%cosh + (m+ (m* (sp1trig (list '(%cosh) a)) + (sp1trig (list '(%cosh) b))) + (m* (sp1trig (list '(%sinh) a)) + (sp1trig (list '(%sinh) b))))))) + +;; Try to expand f(a+b) where f is sin, cos, sinh or cosh. (defun sp1trigex (e)  (let* ((ans (m2 (cadr e) '((mplus) ((coeffpp) (fr freevar))  ((coeffpp) (exp true)))))  (fr (cdr (assoc 'fr ans :test #'eq)))  (exp (cdr (assoc 'exp ans :test #'eq))))  (cond ((signp e fr)  (setq fr (cadr exp)  exp (if (cdddr exp)  (cons (car exp) (cddr exp))  (caddr exp)))))  (cond ((or (equal fr 0)  (null (member (caar e) '(%sin %cos %sinh %cosh) :test #'eq)))  e)  ((eq (caar e) '%sin)  (m+ (m* (sp1trig (list '(%sin) exp))  (sp1trig (list '(%cos) fr)))  (m* (sp1trig (list '(%cos) exp))  (sp1trig (list '(%sin) fr)))))  ((eq (caar e) '%cos)  (m (m* (sp1trig (list '(%cos) exp))  (sp1trig (list '(%cos) fr)))  (m* (sp1trig (list '(%sin) exp))  (sp1trig (list '(%sin) fr)))))  ((eq (caar e) '%sinh)  (m+ (m* (sp1trig (list '(%sinh) exp))  (sp1trig (list '(%cosh) fr)))  (m* (sp1trig (list '(%cosh) exp))  (sp1trig (list '(%sinh) fr)))))  ((eq (caar e) '%cosh)  (m+ (m* (sp1trig (list '(%cosh) exp))  (sp1trig (list '(%cosh) fr)))  (m* (sp1trig (list '(%sinh) exp))  (sp1trig (list '(%sinh) fr)))))))) + (schatchencond w + ;; Ideally, we'd like to split the argument of the trig function into terms + ;; that involve VAR and those that are free of it. + ((m2 (cadr e) '((mplus) ((coeffpp) (a freevar)) ((coeffpp) (b true)))) + (a b) + + ;; Make sure that if B is zero then so is A (to simplify the cond) + (when (signp e b) (rotatef a b)) + + ;; Assuming we didn't just swap them, A will be free of VAR and B will + ;; contain any other terms. If A is zero (because the argument of trig + ;; function is a sum of terms, all of which involve VAR), then fall back on + ;; a different splitting, by terms of taking the first term of B. + (cond + ((and (signp e a) + (not (atom b)) + (eq (caar b) 'mplus)) + (expandtrigofsum (caar e) + (cadr b) + (if (cdddr b) + (cons (car b) (cddr b)) + (caddr b)))) + + ;; For some weird reason, B isn't a sum. Give up. + ((signp e a) e) + + ;; Do the splitting we intended in the first place. + (t + (expandtrigofsum (caar e) a b)))) + + ;; E doesn't match f(a+b). Return it unmodified. + (t nil e))) (defun sp1atrig (fn exp) (cond ((atom exp)  Summary of changes: src/maxima.system  6 ++ src/schatc.lisp  59 ++++++++++++++++++++++++++++++++++ src/sin.lisp  52  src/trgred.lisp  90 ++++++++++++++++++++++++++++++++++ 4 files changed, 121 insertions(+), 86 deletions() hooks/postreceive  Maxima CAS 
From: Rupert Swarbrick <rswarbrick@us...>  20140728 21:16:45

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 71578fbaaeaebeb632f7446ece47c79235ebc767 (commit) via f9db5cbac9b7db100b6db706ff688272307250a8 (commit) from a11f1a4829c8794bdf9898e51dc23cc68107aa84 (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 71578fbaaeaebeb632f7446ece47c79235ebc767 Author: Rupert Swarbrick <rswarbrick@...> Date: Mon Jul 28 22:13:57 2014 +0100 Avoid splitting out negative terms in SP1LOG This should fix bug #2775 diff git a/src/trgred.lisp b/src/trgred.lisp index 889eb3e..47b7257 100644  a/src/trgred.lisp +++ b/src/trgred.lisp @@ 446,6 +446,25 @@ (m^ '$%e exp)) ((m* (m^ '$%e fr) (m^ '$%e exp)))))) +;; Split TERMS into (VALUES NONNEG OTHER) where NONNEG and OTHER are a +;; partition of the elements of TERMS. Expressions that are known not to be +;; negative are placed in NONNEG and all others end up in OTHER. +;; +;; This function is used to safely split products when expanding logarithms to +;; avoid accidentally ending up with something like +;; +;; log(1  x) => log(1) + log(x1). +;; +;; Note that we don't check a term is strictly positive: if it was actually +;; zero, the logarithm was bogus in the first place. +(defun nonnegativesplit (terms) + (let ((nonneg) (other)) + (dolist (term terms) + (if (memq ($sign term) '($pos $pz $zero)) + (push term nonneg) + (push term other))) + (values nonneg other))) + ;; Try to expand a logarithm for use in a power series in VAR by splitting up ;; products. (defun sp1log (e &optional norecurse) @@ 470,8 +489,18 @@ ;; A product is much more promising. Do the transformation log(ab) => ;; log(a)+log(b) and pass it to SP1 for further simplification. + ;; + ;; We need to be a little careful here because eg. factor(1x) gives + ;; (x1). We don't want to end up with a log(1) term! So check the sign of + ;; terms and only pull out the terms we know to be nonnegative. If the + ;; argument was a negative real in the first place then we'd already got + ;; rubbish, but otherwise we won't pull out anything we don't want. ((eq (caar e) 'mtimes)  (sp1 (m+l (mapcar #'sp1log (cdr e))))) + (multiplevaluebind (nonneg other) (nonnegativesplit (cdr e)) + (cond + ((null nonneg) (sp1log2 e)) + (t + (sp1 (m+l (mapcar #'sp1log (cons other nonneg)))))))) ;; Similarly, transform log(a^b) => b log(a) and pass back to SP1. ((eq (caar e) 'mexpt) diff git a/tests/rtest16.mac b/tests/rtest16.mac index 6f3be7b..224c4ac 100644  a/tests/rtest16.mac +++ b/tests/rtest16.mac @@ 2020,3 +2020,10 @@ powerseries(x^x,x,0); sumcontract(intosum(powerseries(1+ (1x)^(a),x,0)  powerseries((1x)^(a),x,0))); 1$ + +/* + #2775: Don't expand a powerseries with log(ab)=log(a)+log(b) if a + is negative +*/ +(gensumnum : 0, powerseries (log(2x), x, 0)); +sum(2^(i11)*x^(i1+1)/(i1+1), i1, 0, inf)$ commit f9db5cbac9b7db100b6db706ff688272307250a8 Author: Rupert Swarbrick <rswarbrick@...> Date: Mon Jul 28 21:52:32 2014 +0100 Add some comments to SP1LOG explaining what it's doing Also, get rid of the *SP1LOGF* special variable, which is only used to avoid recursion in this function. Replace it with an optional norecurse argument, which is much easier to understand. diff git a/src/trgred.lisp b/src/trgred.lisp index 69708ca..889eb3e 100644  a/src/trgred.lisp +++ b/src/trgred.lisp @@ 45,7 +45,6 @@ (defvar *laws*) (defvar *trigbuckets*) (defvar *hyperbuckets*) (defvar *sp1logf* nil) ;;The Trigreduce file contains a group of routines which can be used to ;;make trigonometric simplifications of expressions. The bulk of the @@ 447,24 +446,40 @@ (m^ '$%e exp)) ((m* (m^ '$%e fr) (m^ '$%e exp)))))) (defun sp1log (e)  (cond ((or *trigred (atom e) (free e var))  (list '(%log) e))  ((eq (caar e) 'mplus)  (let* ((exp (m1 e))  (*a nil)  (*n nil))  (declare (special *n *a))  (cond ((smono exp var)  (list '(%log) e))  (*sp1logf* (sp1log2 e))  ((let* ((*sp1logf* t))  (sp1log ($factor e)))))))  ((eq (caar e) 'mtimes)  (sp1 (m+l (mapcar #'sp1log (cdr e)))))  ((eq (caar e) 'mexpt)  (sp1 (m* (caddr e) (list '(%log) (cadr e)))))  ((sp1log2 e)))) +;; Try to expand a logarithm for use in a power series in VAR by splitting up +;; products. +(defun sp1log (e &optional norecurse) + (cond + ;; If E is free of VAR, is an atom, or we're supposed to be reducing rather + ;; than expanding, then just return E. + ((or *trigred (atom e) (free e var)) + (list '(%log) e)) + + ;; The logarithm of a sum doesn't simplify very nicely, but call $factor to + ;; see if we can pull out one or more terms and then recurse (setting + ;; NORECURSE to make sure we don't end up in a loop) + ((eq (caar e) 'mplus) + (let* ((exp (m1 e)) *a *n) + (declare (special *n *a)) + (cond + ((smono exp var) + (list '(%log) e)) + ((not norecurse) + (sp1log ($factor e) t)) + (t (sp1log2 e))))) + + ;; A product is much more promising. Do the transformation log(ab) => + ;; log(a)+log(b) and pass it to SP1 for further simplification. + ((eq (caar e) 'mtimes) + (sp1 (m+l (mapcar #'sp1log (cdr e))))) + + ;; Similarly, transform log(a^b) => b log(a) and pass back to SP1. + ((eq (caar e) 'mexpt) + (sp1 (m* (caddr e) (list '(%log) (cadr e))))) + + ;; If we can't find any other expansions, pass the result to SP1LOG2, which + ;; tries again after expressing E as integrate(diff(e)/e). + ((sp1log2 e)))) (defun sp1log2 (e) (and $verbose  Summary of changes: src/trgred.lisp  82 ++++++++++++++++++++++++++++++++++++++++ tests/rtest16.mac  7 ++++ 2 files changed, 70 insertions(+), 19 deletions() hooks/postreceive  Maxima CAS 
From: Mario Rodriguez Riotorto <riotorto@us...>  20140728 09:19:38

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 a11f1a4829c8794bdf9898e51dc23cc68107aa84 (commit) from e057f0c7197d75475e4d6ed534ad78e3116f849c (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 a11f1a4829c8794bdf9898e51dc23cc68107aa84 Author: Mario Rodriguez <riotorto@...> Date: Mon Jul 28 11:19:07 2014 +0200 Rotate z label when it is too long. Return error messages when variables are not defined in graphic objects. diff git a/share/draw/gnuplot.lisp b/share/draw/gnuplot.lisp index 1e8305e..67c0ca6 100644  a/share/draw/gnuplot.lisp +++ b/share/draw/gnuplot.lisp @@ 1197,9 +1197,11 @@ (ymax mostnegativedoublefloat) (*plotrealpart* *plotrealpart*) xsamples ysamples yy result pltcmd resultarray)  (setq *plotrealpart* (getoption '$draw_realpart))  (if (< xmax xmin) + (when (< xmax xmin) (merror "draw2d (explicit): illegal range")) + (when (not (subsetp (rest ($listofvars fcn)) (list var))) + (merror "draw2d (explicit): non defined variable")) + (setq *plotrealpart* (getoption '$draw_realpart)) (setf fcn ($float fcn)) (cond ((floatp fcn) ; if function is a constant, we only need the end points @@ 1352,6 +1354,9 @@ (pts '()) pltcmd grouping x y) + (when (not (subsetp (rest ($listofvars ineq)) (list xvar yvar))) + (merror "draw2d (region): non defined variable")) + ; build 2d arrays: x, y and boolean (labels ((fun (xx yy) ; evaluates boolean expression (isboolecheck @@ 1580,12 +1585,13 @@ ,(1+ ($second ipgrid))))) (ssample (makearray `(,(1+ ($first ipgridin)) ,(1+ ($second ipgridin))))) )  + + (when (not (subsetp (rest ($listofvars expr)) (list x y))) + (merror "draw2d (implicit): non defined variable")) (setq e (coercefloatfun (impplprepareexpr expr) `((mlist simp) ,x ,y))) (updateranges2d xmin xmax ymin ymax)  (sampledata e xmin xmax ymin ymax sample ipgrid) (do ((i 0 (1+ i))) ((= i ($first ipgrid))) @@ 1642,6 +1648,8 @@ (pts '()) (grouping '()) pltcmd ncols vertices) + (when (not (subsetp (rest ($listofvars expr)) (list par1 par2 par3))) + (merror "draw3d (implicit): non defined variable")) (checkenhanced3dmodel "implicit" '(0 3 99)) (when (= *drawenhanced3dtype* 99) (updateenhanced3dexpression (list '(mlist) par1 par2 par3))) @@ 1733,6 +1741,8 @@ ($numer t) (count 1) ncols result) + (when (not (subsetp (rest ($listofvars fcn)) (list par1 par2))) + (merror "draw2d (explicit): non defined variable")) (setq *plotrealpart* (getoption '$draw_realpart)) (checkenhanced3dmodel "explicit" '(0 2 3 99)) (when (= *drawenhanced3dtype* 99) @@ 2065,9 +2075,11 @@ (tt ($float parmin)) (eps (/ ( tmax tmin) ( nticks 1))) result f1 f2 xx yy)  (setq *plotrealpart* (getoption '$draw_realpart))  (if (< tmax tmin) + (when (< tmax tmin) (merror "draw2d (parametric): illegal range")) + (when (not (subsetp (append (rest ($listofvars xfun)) (rest ($listofvars yfun))) (list par))) + (merror "draw2d (parametric): non defined variable")) + (setq *plotrealpart* (getoption '$draw_realpart)) (setq f1 (coercefloatfun xfun `((mlist), par))) (setq f2 (coercefloatfun yfun `((mlist), par))) (setf result @@ 2216,6 +2228,8 @@ (eps (/ ( tmax tmin) ( nticks 1))) (count 1) ncols result f1 f2 f3 xx yy zz) + (when (not (subsetp (rest ($append ($listofvars xfun) ($listofvars yfun) ($listofvars zfun))) (list par1))) + (merror "draw3d (parametric): non defined variable")) (setq *plotrealpart* (getoption '$draw_realpart)) (checkenhanced3dmodel "parametric" '(0 1 3 99)) (when (= *drawenhanced3dtype* 99) @@ 2299,6 +2313,8 @@ (nv (+ vgrid 1)) (count 1) ncols result f1 f2 f3 xx yy zz uu vv) + (when (not (subsetp (rest ($append ($listofvars xfun) ($listofvars yfun) ($listofvars zfun))) (list par1 par2))) + (merror "draw3d (parametric_surface): non defined variable")) (setq *plotrealpart* (getoption '$draw_realpart)) (checkenhanced3dmodel "parametric_surface" '(0 2 3 99)) (when (= *drawenhanced3dtype* 99) @@ 2408,6 +2424,10 @@ uxold uyold uzold ttnext) (when (< tmax tmin) (merror "draw3d (tube): illegal range")) + (when (not (subsetp (rest ($append ($listofvars xfun) ($listofvars yfun) + ($listofvars zfun) ($listofvars rad))) + (list par1))) + (merror "draw3d (tube): non defined variable")) (checkenhanced3dmodel "tube" '(0 1 3 99)) (when (= *drawenhanced3dtype* 99) (updateenhanced3dexpression (list '(mlist) par1))) @@ 2919,7 +2939,9 @@ (format nil "set title '~a'~%" (getoption '$title)) (format nil "set xlabel '~a'~%" (getoption '$xlabel)) (format nil "set ylabel '~a'~%" (getoption '$ylabel))  (format nil "set zlabel '~a'~%" (getoption '$zlabel)) + (if (< (length (getoption '$zlabel)) 5) + (format nil "set zlabel '~a'~%" (getoption '$zlabel)) + (format nil "set zlabel '~a' rotate~%" (getoption '$zlabel)) ) (format nil "set datafile missing 'NIL'~%") (if (getoption '$logx) (format nil "set logscale x~%")  Summary of changes: share/draw/gnuplot.lisp  36 +++++++++++++++++++++++++++++ 1 files changed, 29 insertions(+), 7 deletions() hooks/postreceive  Maxima CAS 