# HG changeset patch
# User Jay Belanger <jay.p.belanger@gmail.com>
# Date 1287026078 18000
# Node ID c62e42a9ebc4d523f258b92d6274be2808c65946
# Parent  e0ac9a58795eb2348ad096d1eb1b82ef69e0c4aa
calc-alg.el (math-var): Renamed from `var'.
(math-is-polynomial, math-is-poly-rec): Replace `var' with `math-var'.

calcalg2.el (math-var): Renamed from `var'.
(calcFunc-table, math-scan-for-limits): Replace `var' with `math-var'.

diff -r e0ac9a58795e -r c62e42a9ebc4 lisp/ChangeLog
--- a/lisp/ChangeLog	Thu Oct 14 03:33:31 2010 +0200
+++ b/lisp/ChangeLog	Wed Oct 13 22:14:38 2010 -0500
@@ -1,3 +1,13 @@
+2010-10-14  Jay Belanger  <jay.p.belanger@gmail.com>
+
+	* calc/calc-alg.el (math-var): Renamed from `var'.
+	(math-is-polynomial, math-is-poly-rec): Replace `var'
+	with `math-var'.
+
+	* calc/calcalg2.el (math-var): Renamed from `var'.
+	(calcFunc-table, math-scan-for-limits): Replace `var'
+	with `math-var'.
+
 2010-10-13  Glenn Morris  <rgm@gnu.org>
 
 	* subr.el (last): Deal with dotted lists (reported in bug#7174).
diff -r e0ac9a58795e -r c62e42a9ebc4 lisp/calc/calc-alg.el
--- a/lisp/calc/calc-alg.el	Thu Oct 14 03:33:31 2010 +0200
+++ b/lisp/calc/calc-alg.el	Wed Oct 13 22:14:38 2010 -0500
@@ -1659,11 +1659,11 @@
 ;; math-is-poly-rec.
 (defvar math-is-poly-degree)
 (defvar math-is-poly-loose)
-(defvar var)
+(defvar math-var)
 
-(defun math-is-polynomial (expr var &optional math-is-poly-degree math-is-poly-loose)
+(defun math-is-polynomial (expr math-var &optional math-is-poly-degree math-is-poly-loose)
   (let* ((math-poly-base-variable (if math-is-poly-loose
-				      (if (eq math-is-poly-loose 'gen) var '(var XXX XXX))
+				      (if (eq math-is-poly-loose 'gen) math-var '(var XXX XXX))
 				    math-poly-base-variable))
 	 (poly (math-is-poly-rec expr math-poly-neg-powers)))
     (and (or (null math-is-poly-degree)
@@ -1672,11 +1672,11 @@
 
 (defun math-is-poly-rec (expr negpow)
   (math-poly-simplify
-   (or (cond ((or (equal expr var)
+   (or (cond ((or (equal expr math-var)
 		  (eq (car-safe expr) '^))
 	      (let ((pow 1)
 		    (expr expr))
-		(or (equal expr var)
+		(or (equal expr math-var)
 		    (setq pow (nth 2 expr)
 			  expr (nth 1 expr)))
 		(or (eq math-poly-mult-powers 1)
@@ -1690,7 +1690,7 @@
 					 (equal math-poly-mult-powers
 						(nth 1 m))
 				       (setq math-poly-mult-powers (nth 1 m)))
-				     (or (equal expr var)
+				     (or (equal expr math-var)
 					 (eq math-poly-mult-powers 1))
 				     (car m)))))
 		(if (consp pow)
@@ -1698,7 +1698,7 @@
 		      (setq pow (math-to-simple-fraction pow))
 		      (and (eq (car-safe pow) 'frac)
 			   math-poly-frac-powers
-			   (equal expr var)
+			   (equal expr math-var)
 			   (setq math-poly-frac-powers
 				 (calcFunc-lcm math-poly-frac-powers
 					       (nth 2 pow))))))
@@ -1706,10 +1706,10 @@
 		    (setq pow (math-mul pow math-poly-frac-powers)))
 		(if (integerp pow)
 		    (if (and (= pow 1)
-			     (equal expr var))
+			     (equal expr math-var))
 			(list 0 1)
 		      (if (natnump pow)
-			  (let ((p1 (if (equal expr var)
+			  (let ((p1 (if (equal expr math-var)
 					(list 0 1)
 				      (math-is-poly-rec expr nil)))
 				(n pow)
@@ -1749,7 +1749,7 @@
                                     math-is-poly-degree))
 			    (math-poly-mul p1 p2))))))
 	     ((eq (car expr) '/)
-	      (and (or (not (math-poly-depends (nth 2 expr) var))
+	      (and (or (not (math-poly-depends (nth 2 expr) math-var))
 		       (and negpow
 			    (math-is-poly-rec (nth 2 expr) nil)
 			    (setq math-poly-neg-powers
@@ -1759,13 +1759,13 @@
 		     (mapcar (function (lambda (x) (math-div x (nth 2 expr))))
 			     p1))))
 	     ((and (eq (car expr) 'calcFunc-exp)
-		   (equal var '(var e var-e)))
-	      (math-is-poly-rec (list '^ var (nth 1 expr)) negpow))
+		   (equal math-var '(var e var-e)))
+	      (math-is-poly-rec (list '^ math-var (nth 1 expr)) negpow))
 	     ((and (eq (car expr) 'calcFunc-sqrt)
 		   math-poly-frac-powers)
 	      (math-is-poly-rec (list '^ (nth 1 expr) '(frac 1 2)) negpow))
 	     (t nil))
-       (and (or (not (math-poly-depends expr var))
+       (and (or (not (math-poly-depends expr math-var))
 		math-is-poly-loose)
 	    (not (eq (car expr) 'vec))
 	    (list expr)))))
diff -r e0ac9a58795e -r c62e42a9ebc4 lisp/calc/calcalg2.el
--- a/lisp/calc/calcalg2.el	Thu Oct 14 03:33:31 2010 +0200
+++ b/lisp/calc/calcalg2.el	Wed Oct 13 22:14:38 2010 -0500
@@ -1886,9 +1886,9 @@
 ;; math-scan-for-limits.
 (defvar calc-low)
 (defvar calc-high)
-(defvar var)
+(defvar math-var)
 
-(defun calcFunc-table (expr var &optional calc-low calc-high step)
+(defun calcFunc-table (expr math-var &optional calc-low calc-high step)
   (or calc-low
       (setq calc-low '(neg (var inf var-inf)) calc-high '(var inf var-inf)))
   (or calc-high (setq calc-high calc-low calc-low 1))
@@ -1917,7 +1917,7 @@
 	      (math-working-step-2 (1+ count))
 	      (math-working-step 0))
 	  (setq expr (math-evaluate-expr
-		      (math-expr-subst expr var '(var DUMMY var-DUMMY))))
+		      (math-expr-subst expr math-var '(var DUMMY var-DUMMY))))
 	  (while (>= count 0)
 	    (setq math-working-step (1+ math-working-step)
 		  var-DUMMY calc-low
@@ -1940,7 +1940,7 @@
 	      (calc-record-why 'integerp calc-high))
 	  (calc-record-why 'integerp calc-low)))
       (append (list (or math-tabulate-function 'calcFunc-table)
-		    expr var)
+		    expr math-var)
 	      (and (not (and (equal calc-low '(neg (var inf var-inf)))
 			     (equal calc-high '(var inf var-inf))))
 		   (list calc-low calc-high))
@@ -1950,11 +1950,11 @@
   (cond ((Math-primp x))
 	((and (eq (car x) 'calcFunc-subscr)
 	      (Math-vectorp (nth 1 x))
-	      (math-expr-contains (nth 2 x) var))
+	      (math-expr-contains (nth 2 x) math-var))
 	 (let* ((calc-next-why nil)
-		(low-val (math-solve-for (nth 2 x) 1 var nil))
+		(low-val (math-solve-for (nth 2 x) 1 math-var nil))
 		(high-val (math-solve-for (nth 2 x) (1- (length (nth 1 x)))
-					  var nil))
+					  math-var nil))
 		temp)
 	   (and low-val (math-realp low-val)
 		high-val (math-realp high-val))