(calc-poly-div): Made calc-poly-div-remainder a local variable.

(math-eval-rules-cache, math-eval-rules-cache-other):  Declared them.

(math-top-only):  New variable
(math-simplify, math-simplify-step):  Replace variable top-only by
declared variable math-top-only.

(math-simplify-expr):  Declared it.
Replaced argument expr in all calls of math-defsimplify by
math-simplify-expr.
(math-simplify-plus, math-simplify-times, math-simplify-divide)
(math-simplify-divisor, math-simplify-one-divisor)
(math-simplify-mod, math-simplify-ineq, math-simplify-sqrt)
(math-simplify-pow):  Replaced variable expr by declared variable
math-simplify-expr.

(math-simplify-divisor):  Removed local variables temp and op.
(math-simplify-one-divisor):  Made temp and op local variables.

(math-simplify-divisor-nover, math-simplify-divisor-dover):  New
variables.
(math-simplify-divisor, math-simplify-one-divisor):  Use declared
variables.

(math-expr-subst-new, math-expr-subst-old):  New variables.
(math-expr-subst, math-expr-subst-rec):  Use declared variables.

(math-is-poly-degree, math-is-poly-loose):  New variables.
(math-is-polynomial, math-is-poly-rec):  Use declared variables.

(math-poly-base-const-ok, math-poly-base-pred): New variables.
(math-polynomial-base, math-polynomial-base-rec):  Use declared
variables.

1 files changed, 437 insertions, 367 deletions

diff --git a/lisp/calc/calc-alg.el b/lisp/calc/calc-alg.el
index 45ffff8baca..014e7c3eddf 100644
--- a/lisp/calc/calc-alg.el
+++ b/lisp/calc/calc-alg.el
@@ -3,8 +3,7 @@
 ;; Copyright (C) 1990, 1991, 1992, 1993, 2001 Free Software Foundation, Inc.
 
 ;; Author: David Gillespie <daveg@synaptics.com>
-;; Maintainers: D. Goel <deego@gnufans.org>
-;;              Colin Walters <walters@debian.org>
+;; Maintainer: Jay Belanger  <belanger@truman.edu>
 
 ;; This file is part of GNU Emacs.
 
@@ -121,19 +120,20 @@
   (calc-slow-wrapper
    (calc-binary-op "pgcd" 'calcFunc-pgcd arg)))
 
+
 (defun calc-poly-div (arg)
   (interactive "P")
   (calc-slow-wrapper
-   (setq calc-poly-div-remainder nil)
-   (calc-binary-op "pdiv" 'calcFunc-pdiv arg)
-   (if (and calc-poly-div-remainder (null arg))
-       (progn
-         (calc-clear-command-flag 'clear-message)
-         (calc-record calc-poly-div-remainder "prem")
-         (if (not (Math-zerop calc-poly-div-remainder))
-             (message "(Remainder was %s)"
-                      (math-format-flat-expr calc-poly-div-remainder 0))
-           (message "(No remainder)"))))))
+   (let ((calc-poly-div-remainder nil))
+     (calc-binary-op "pdiv" 'calcFunc-pdiv arg)
+     (if (and calc-poly-div-remainder (null arg))
+         (progn
+           (calc-clear-command-flag 'clear-message)
+           (calc-record calc-poly-div-remainder "prem")
+           (if (not (Math-zerop calc-poly-div-remainder))
+               (message "(Remainder was %s)"
+                        (math-format-flat-expr calc-poly-div-remainder 0))
+             (message "(No remainder)")))))))
 
 (defun calc-poly-rem (arg)
   (interactive "P")
@@ -184,6 +184,11 @@
        (memq (car name) '(vec calcFunc-assign calcFunc-condition))
        name))
 
+;; math-eval-rules-cache and math-eval-rules-cache-other are
+;; declared in calc.el, but are used here by math-recompile-eval-rules.
+(defvar math-eval-rules-cache)
+(defvar math-eval-rules-cache-other)
+
 (defun math-recompile-eval-rules ()
   (setq math-eval-rules-cache (and (calc-has-rules 'var-EvalRules)
                                    (math-compile-rewrites
@@ -266,9 +271,13 @@
 
 (defalias 'calcFunc-esimplify 'math-simplify-extended)
 
+;; math-top-only is local to math-simplify, but is used by 
+;; math-simplify-step, which is called by math-simplify.
+(defvar math-top-only)
+
 (defun math-simplify (top-expr)
   (let ((math-simplifying t)
-        (top-only (consp calc-simplify-mode))
+        (math-top-only (consp calc-simplify-mode))
         (simp-rules (append (and (calc-has-rules 'var-AlgSimpRules)
                                  '((var AlgSimpRules var-AlgSimpRules)))
                             (and math-living-dangerously
@@ -281,7 +290,7 @@
                                  (calc-has-rules 'var-IntegSimpRules)
                                  '((var IntegSimpRules var-IntegSimpRules)))))
         res)
-    (if top-only
+    (if math-top-only
         (let ((r simp-rules))
           (setq res (math-simplify-step (math-normalize top-expr))
                 calc-simplify-mode '(nil)
@@ -308,7 +317,7 @@
 (defun math-simplify-step (a)
   (if (Math-primp a)
       a
-    (let ((aa (if (or top-only
+    (let ((aa (if (or math-top-only
                       (memq (car a) '(calcFunc-quote calcFunc-condition
                                                      calcFunc-evalto)))
                   a
@@ -328,151 +337,172 @@
 (defun math-need-std-simps ()
   nil)
 
+;; The function created by math-defsimplify uses the variable
+;; math-simplify-expr, and so is used by functions in math-defsimplify
+(defvar math-simplify-expr)
+
 (math-defsimplify (+ -)
   (math-simplify-plus))
 
 (defun math-simplify-plus ()
-  (cond ((and (memq (car-safe (nth 1 expr)) '(+ -))
-              (Math-numberp (nth 2 (nth 1 expr)))
-              (not (Math-numberp (nth 2 expr))))
-         (let ((x (nth 2 expr))
-               (op (car expr)))
-           (setcar (cdr (cdr expr)) (nth 2 (nth 1 expr)))
-           (setcar expr (car (nth 1 expr)))
-           (setcar (cdr (cdr (nth 1 expr))) x)
-           (setcar (nth 1 expr) op)))
-        ((and (eq (car expr) '+)
-              (Math-numberp (nth 1 expr))
-              (not (Math-numberp (nth 2 expr))))
-         (let ((x (nth 2 expr)))
-           (setcar (cdr (cdr expr)) (nth 1 expr))
-           (setcar (cdr expr) x))))
-  (let ((aa expr)
+  (cond ((and (memq (car-safe (nth 1 math-simplify-expr)) '(+ -))
+              (Math-numberp (nth 2 (nth 1 math-simplify-expr)))
+              (not (Math-numberp (nth 2 math-simplify-expr))))
+         (let ((x (nth 2 math-simplify-expr))
+               (op (car math-simplify-expr)))
+           (setcar (cdr (cdr math-simplify-expr)) (nth 2 (nth 1 math-simplify-expr)))
+           (setcar math-simplify-expr (car (nth 1 math-simplify-expr)))
+           (setcar (cdr (cdr (nth 1 math-simplify-expr))) x)
+           (setcar (nth 1 math-simplify-expr) op)))
+        ((and (eq (car math-simplify-expr) '+)
+              (Math-numberp (nth 1 math-simplify-expr))
+              (not (Math-numberp (nth 2 math-simplify-expr))))
+         (let ((x (nth 2 math-simplify-expr)))
+           (setcar (cdr (cdr math-simplify-expr)) (nth 1 math-simplify-expr))
+           (setcar (cdr math-simplify-expr) x))))
+  (let ((aa math-simplify-expr)
         aaa temp)
     (while (memq (car-safe (setq aaa (nth 1 aa))) '(+ -))
-      (if (setq temp (math-combine-sum (nth 2 aaa) (nth 2 expr)
-                                       (eq (car aaa) '-) (eq (car expr) '-) t))
+      (if (setq temp (math-combine-sum (nth 2 aaa) (nth 2 math-simplify-expr)
+                                       (eq (car aaa) '-) 
+                                       (eq (car math-simplify-expr) '-) t))
           (progn
-            (setcar (cdr (cdr expr)) temp)
-            (setcar expr '+)
+            (setcar (cdr (cdr math-simplify-expr)) temp)
+            (setcar math-simplify-expr '+)
             (setcar (cdr (cdr aaa)) 0)))
       (setq aa (nth 1 aa)))
-    (if (setq temp (math-combine-sum aaa (nth 2 expr)
-                                     nil (eq (car expr) '-) t))
+    (if (setq temp (math-combine-sum aaa (nth 2 math-simplify-expr)
+                                     nil (eq (car math-simplify-expr) '-) t))
         (progn
-          (setcar (cdr (cdr expr)) temp)
-          (setcar expr '+)
+          (setcar (cdr (cdr math-simplify-expr)) temp)
+          (setcar math-simplify-expr '+)
           (setcar (cdr aa) 0)))
-    expr))
+    math-simplify-expr))
 
 (math-defsimplify *
   (math-simplify-times))
 
 (defun math-simplify-times ()
-  (if (eq (car-safe (nth 2 expr)) '*)
-      (and (math-beforep (nth 1 (nth 2 expr)) (nth 1 expr))
-           (or (math-known-scalarp (nth 1 expr) t)
-               (math-known-scalarp (nth 1 (nth 2 expr)) t))
-           (let ((x (nth 1 expr)))
-             (setcar (cdr expr) (nth 1 (nth 2 expr)))
-             (setcar (cdr (nth 2 expr)) x)))
-    (and (math-beforep (nth 2 expr) (nth 1 expr))
-         (or (math-known-scalarp (nth 1 expr) t)
-             (math-known-scalarp (nth 2 expr) t))
-         (let ((x (nth 2 expr)))
-           (setcar (cdr (cdr expr)) (nth 1 expr))
-           (setcar (cdr expr) x))))
-  (let ((aa expr)
+  (if (eq (car-safe (nth 2 math-simplify-expr)) '*)
+      (and (math-beforep (nth 1 (nth 2 math-simplify-expr)) (nth 1 math-simplify-expr))
+           (or (math-known-scalarp (nth 1 math-simplify-expr) t)
+               (math-known-scalarp (nth 1 (nth 2 math-simplify-expr)) t))
+           (let ((x (nth 1 math-simplify-expr)))
+             (setcar (cdr math-simplify-expr) (nth 1 (nth 2 math-simplify-expr)))
+             (setcar (cdr (nth 2 math-simplify-expr)) x)))
+    (and (math-beforep (nth 2 math-simplify-expr) (nth 1 math-simplify-expr))
+         (or (math-known-scalarp (nth 1 math-simplify-expr) t)
+             (math-known-scalarp (nth 2 math-simplify-expr) t))
+         (let ((x (nth 2 math-simplify-expr)))
+           (setcar (cdr (cdr math-simplify-expr)) (nth 1 math-simplify-expr))
+           (setcar (cdr math-simplify-expr) x))))
+  (let ((aa math-simplify-expr)
         aaa temp
-        (safe t) (scalar (math-known-scalarp (nth 1 expr))))
-    (if (and (Math-ratp (nth 1 expr))
-             (setq temp (math-common-constant-factor (nth 2 expr))))
+        (safe t) (scalar (math-known-scalarp (nth 1 math-simplify-expr))))
+    (if (and (Math-ratp (nth 1 math-simplify-expr))
+             (setq temp (math-common-constant-factor (nth 2 math-simplify-expr))))
         (progn
-          (setcar (cdr (cdr expr))
-                  (math-cancel-common-factor (nth 2 expr) temp))
-          (setcar (cdr expr) (math-mul (nth 1 expr) temp))))
+          (setcar (cdr (cdr math-simplify-expr))
+                  (math-cancel-common-factor (nth 2 math-simplify-expr) temp))
+          (setcar (cdr math-simplify-expr) (math-mul (nth 1 math-simplify-expr) temp))))
     (while (and (eq (car-safe (setq aaa (nth 2 aa))) '*)
                 safe)
-      (if (setq temp (math-combine-prod (nth 1 expr) (nth 1 aaa) nil nil t))
+      (if (setq temp (math-combine-prod (nth 1 math-simplify-expr) 
+                                        (nth 1 aaa) nil nil t))
           (progn
-            (setcar (cdr expr) temp)
+            (setcar (cdr math-simplify-expr) temp)
             (setcar (cdr aaa) 1)))
       (setq safe (or scalar (math-known-scalarp (nth 1 aaa) t))
             aa (nth 2 aa)))
-    (if (and (setq temp (math-combine-prod aaa (nth 1 expr) nil nil t))
+    (if (and (setq temp (math-combine-prod aaa (nth 1 math-simplify-expr) nil nil t))
              safe)
         (progn
-          (setcar (cdr expr) temp)
+          (setcar (cdr math-simplify-expr) temp)
           (setcar (cdr (cdr aa)) 1)))
-    (if (and (eq (car-safe (nth 1 expr)) 'frac)
-             (memq (nth 1 (nth 1 expr)) '(1 -1)))
-        (math-div (math-mul (nth 2 expr) (nth 1 (nth 1 expr)))
-                  (nth 2 (nth 1 expr)))
-      expr)))
+    (if (and (eq (car-safe (nth 1 math-simplify-expr)) 'frac)
+             (memq (nth 1 (nth 1 math-simplify-expr)) '(1 -1)))
+        (math-div (math-mul (nth 2 math-simplify-expr) 
+                            (nth 1 (nth 1 math-simplify-expr)))
+                  (nth 2 (nth 1 math-simplify-expr)))
+      math-simplify-expr)))
 
 (math-defsimplify /
   (math-simplify-divide))
 
 (defun math-simplify-divide ()
-  (let ((np (cdr expr))
+  (let ((np (cdr math-simplify-expr))
         (nover nil)
-        (nn (and (or (eq (car expr) '/) (not (Math-realp (nth 2 expr))))
-                 (math-common-constant-factor (nth 2 expr))))
+        (nn (and (or (eq (car math-simplify-expr) '/) 
+                     (not (Math-realp (nth 2 math-simplify-expr))))
+                 (math-common-constant-factor (nth 2 math-simplify-expr))))
         n op)
     (if nn
         (progn
-          (setq n (and (or (eq (car expr) '/) (not (Math-realp (nth 1 expr))))
-                       (math-common-constant-factor (nth 1 expr))))
+          (setq n (and (or (eq (car math-simplify-expr) '/) 
+                           (not (Math-realp (nth 1 math-simplify-expr))))
+                       (math-common-constant-factor (nth 1 math-simplify-expr))))
           (if (and (eq (car-safe nn) 'frac) (eq (nth 1 nn) 1) (not n))
               (progn
-                (setcar (cdr expr) (math-mul (nth 2 nn) (nth 1 expr)))
-                (setcar (cdr (cdr expr))
-                        (math-cancel-common-factor (nth 2 expr) nn))
+                (setcar (cdr math-simplify-expr) 
+                        (math-mul (nth 2 nn) (nth 1 math-simplify-expr)))
+                (setcar (cdr (cdr math-simplify-expr))
+                        (math-cancel-common-factor (nth 2 math-simplify-expr) nn))
                 (if (and (math-negp nn)
-                         (setq op (assq (car expr) calc-tweak-eqn-table)))
-                    (setcar expr (nth 1 op))))
+                         (setq op (assq (car math-simplify-expr) calc-tweak-eqn-table)))
+                    (setcar math-simplify-expr (nth 1 op))))
             (if (and n (not (eq (setq n (math-frac-gcd n nn)) 1)))
                 (progn
-                  (setcar (cdr expr)
-                          (math-cancel-common-factor (nth 1 expr) n))
-                  (setcar (cdr (cdr expr))
-                          (math-cancel-common-factor (nth 2 expr) n))
+                  (setcar (cdr math-simplify-expr)
+                          (math-cancel-common-factor (nth 1 math-simplify-expr) n))
+                  (setcar (cdr (cdr math-simplify-expr))
+                          (math-cancel-common-factor (nth 2 math-simplify-expr) n))
                   (if (and (math-negp n)
-                           (setq op (assq (car expr) calc-tweak-eqn-table)))
-                      (setcar expr (nth 1 op))))))))
+                           (setq op (assq (car math-simplify-expr) 
+                                          calc-tweak-eqn-table)))
+                      (setcar math-simplify-expr (nth 1 op))))))))
     (if (and (eq (car-safe (car np)) '/)
-             (math-known-scalarp (nth 2 expr) t))
+             (math-known-scalarp (nth 2 math-simplify-expr) t))
         (progn
-          (setq np (cdr (nth 1 expr)))
+          (setq np (cdr (nth 1 math-simplify-expr)))
           (while (eq (car-safe (setq n (car np))) '*)
             (and (math-known-scalarp (nth 2 n) t)
-                 (math-simplify-divisor (cdr n) (cdr (cdr expr)) nil t))
+                 (math-simplify-divisor (cdr n) (cdr (cdr math-simplify-expr)) nil t))
             (setq np (cdr (cdr n))))
-          (math-simplify-divisor np (cdr (cdr expr)) nil t)
+          (math-simplify-divisor np (cdr (cdr math-simplify-expr)) nil t)
           (setq nover t
-                np (cdr (cdr (nth 1 expr))))))
+                np (cdr (cdr (nth 1 math-simplify-expr))))))
     (while (eq (car-safe (setq n (car np))) '*)
       (and (math-known-scalarp (nth 2 n) t)
-           (math-simplify-divisor (cdr n) (cdr (cdr expr)) nover t))
+           (math-simplify-divisor (cdr n) (cdr (cdr math-simplify-expr)) nover t))
       (setq np (cdr (cdr n))))
-    (math-simplify-divisor np (cdr (cdr expr)) nover t)
-    expr))
+    (math-simplify-divisor np (cdr (cdr math-simplify-expr)) nover t)
+    math-simplify-expr))
+
+;; The variables math-simplify-divisor-nover and math-simplify-divisor-dover
+;; are local variables for math-simplify-divisor, but are used by
+;; math-simplify-one-divisor.
+(defvar math-simplify-divisor-nover)
+(defvar math-simplify-divisor-dover)
 
-(defun math-simplify-divisor (np dp nover dover)
+(defun math-simplify-divisor (np dp math-simplify-divisor-nover 
+                                 math-simplify-divisor-dover)
   (cond ((eq (car-safe (car dp)) '/)
-         (math-simplify-divisor np (cdr (car dp)) nover dover)
+         (math-simplify-divisor np (cdr (car dp)) 
+                                math-simplify-divisor-nover 
+                                math-simplify-divisor-dover)
          (and (math-known-scalarp (nth 1 (car dp)) t)
               (math-simplify-divisor np (cdr (cdr (car dp)))
-                                     nover (not dover))))
-        ((or (or (eq (car expr) '/)
+                                     math-simplify-divisor-nover 
+                                     (not math-simplify-divisor-dover))))
+        ((or (or (eq (car math-simplify-expr) '/)
                  (let ((signs (math-possible-signs (car np))))
                    (or (memq signs '(1 4))
-                       (and (memq (car expr) '(calcFunc-eq calcFunc-neq))
+                       (and (memq (car math-simplify-expr) '(calcFunc-eq calcFunc-neq))
                             (eq signs 5))
                        math-living-dangerously)))
              (math-numberp (car np)))
          (let ((n (car np))
-               d dd temp op
+               d dd
                (safe t) (scalar (math-known-scalarp n)))
            (while (and (eq (car-safe (setq d (car dp))) '*)
                        safe)
@@ -483,21 +513,25 @@
                (math-simplify-one-divisor np dp))))))
 
 (defun math-simplify-one-divisor (np dp)
-  (if (setq temp (math-combine-prod (car np) (car dp) nover dover t))
-      (progn
-        (and (not (memq (car expr) '(/ calcFunc-eq calcFunc-neq)))
-             (math-known-negp (car dp))
-             (setq op (assq (car expr) calc-tweak-eqn-table))
-             (setcar expr (nth 1 op)))
-        (setcar np (if nover (math-div 1 temp) temp))
-        (setcar dp 1))
-    (and dover (not nover) (eq (car expr) '/)
-         (eq (car-safe (car dp)) 'calcFunc-sqrt)
-         (Math-integerp (nth 1 (car dp)))
-         (progn
-           (setcar np (math-mul (car np)
-                                (list 'calcFunc-sqrt (nth 1 (car dp)))))
-           (setcar dp (nth 1 (car dp)))))))
+  (let ((temp (math-combine-prod (car np) (car dp) math-simplify-divisor-nover 
+                                 math-simplify-divisor-dover t))
+        op)
+    (if temp 
+        (progn
+          (and (not (memq (car math-simplify-expr) '(/ calcFunc-eq calcFunc-neq)))
+               (math-known-negp (car dp))
+               (setq op (assq (car math-simplify-expr) calc-tweak-eqn-table))
+               (setcar math-simplify-expr (nth 1 op)))
+          (setcar np (if math-simplify-divisor-nover (math-div 1 temp) temp))
+          (setcar dp 1))
+      (and math-simplify-divisor-dover (not math-simplify-divisor-nover) 
+           (eq (car math-simplify-expr) '/)
+           (eq (car-safe (car dp)) 'calcFunc-sqrt)
+           (Math-integerp (nth 1 (car dp)))
+           (progn
+             (setcar np (math-mul (car np)
+                                  (list 'calcFunc-sqrt (nth 1 (car dp)))))
+             (setcar dp (nth 1 (car dp))))))))
 
 (defun math-common-constant-factor (expr)
   (if (Math-realp expr)
@@ -546,23 +580,23 @@
   (math-simplify-mod))
 
 (defun math-simplify-mod ()
-  (and (Math-realp (nth 2 expr))
-       (Math-posp (nth 2 expr))
-       (let ((lin (math-is-linear (nth 1 expr)))
+  (and (Math-realp (nth 2 math-simplify-expr))
+       (Math-posp (nth 2 math-simplify-expr))
+       (let ((lin (math-is-linear (nth 1 math-simplify-expr)))
              t1 t2 t3)
          (or (and lin
                   (or (math-negp (car lin))
-                      (not (Math-lessp (car lin) (nth 2 expr))))
+                      (not (Math-lessp (car lin) (nth 2 math-simplify-expr))))
                   (list '%
                         (list '+
                               (math-mul (nth 1 lin) (nth 2 lin))
-                              (math-mod (car lin) (nth 2 expr)))
-                        (nth 2 expr)))
+                              (math-mod (car lin) (nth 2 math-simplify-expr)))
+                        (nth 2 math-simplify-expr)))
              (and lin
                   (not (math-equal-int (nth 1 lin) 1))
                   (math-num-integerp (nth 1 lin))
-                  (math-num-integerp (nth 2 expr))
-                  (setq t1 (calcFunc-gcd (nth 1 lin) (nth 2 expr)))
+                  (math-num-integerp (nth 2 math-simplify-expr))
+                  (setq t1 (calcFunc-gcd (nth 1 lin) (nth 2 math-simplify-expr)))
                   (not (math-equal-int t1 1))
                   (list '*
                         t1
@@ -572,47 +606,48 @@
                                               (nth 2 lin))
                                     (let ((calc-prefer-frac t))
                                       (math-div (car lin) t1)))
-                              (math-div (nth 2 expr) t1))))
-             (and (math-equal-int (nth 2 expr) 1)
+                              (math-div (nth 2 math-simplify-expr) t1))))
+             (and (math-equal-int (nth 2 math-simplify-expr) 1)
                   (math-known-integerp (if lin
                                            (math-mul (nth 1 lin) (nth 2 lin))
-                                         (nth 1 expr)))
+                                         (nth 1 math-simplify-expr)))
                   (if lin (math-mod (car lin) 1) 0))))))
 
 (math-defsimplify (calcFunc-eq calcFunc-neq calcFunc-lt
                                calcFunc-gt calcFunc-leq calcFunc-geq)
-  (if (= (length expr) 3)
+  (if (= (length math-simplify-expr) 3)
       (math-simplify-ineq)))
 
 (defun math-simplify-ineq ()
-  (let ((np (cdr expr))
+  (let ((np (cdr math-simplify-expr))
         n)
     (while (memq (car-safe (setq n (car np))) '(+ -))
-      (math-simplify-add-term (cdr (cdr n)) (cdr (cdr expr))
+      (math-simplify-add-term (cdr (cdr n)) (cdr (cdr math-simplify-expr))
                               (eq (car n) '-) nil)
       (setq np (cdr n)))
-    (math-simplify-add-term np (cdr (cdr expr)) nil (eq np (cdr expr)))
+    (math-simplify-add-term np (cdr (cdr math-simplify-expr)) nil 
+                            (eq np (cdr math-simplify-expr)))
     (math-simplify-divide)
-    (let ((signs (math-possible-signs (cons '- (cdr expr)))))
-      (or (cond ((eq (car expr) 'calcFunc-eq)
+    (let ((signs (math-possible-signs (cons '- (cdr math-simplify-expr)))))
+      (or (cond ((eq (car math-simplify-expr) 'calcFunc-eq)
                  (or (and (eq signs 2) 1)
                      (and (memq signs '(1 4 5)) 0)))
-                ((eq (car expr) 'calcFunc-neq)
+                ((eq (car math-simplify-expr) 'calcFunc-neq)
                  (or (and (eq signs 2) 0)
                      (and (memq signs '(1 4 5)) 1)))
-                ((eq (car expr) 'calcFunc-lt)
+                ((eq (car math-simplify-expr) 'calcFunc-lt)
                  (or (and (eq signs 1) 1)
                      (and (memq signs '(2 4 6)) 0)))
-                ((eq (car expr) 'calcFunc-gt)
+                ((eq (car math-simplify-expr) 'calcFunc-gt)
                  (or (and (eq signs 4) 1)
                      (and (memq signs '(1 2 3)) 0)))
-                ((eq (car expr) 'calcFunc-leq)
+                ((eq (car math-simplify-expr) 'calcFunc-leq)
                  (or (and (eq signs 4) 0)
                      (and (memq signs '(1 2 3)) 1)))
-                ((eq (car expr) 'calcFunc-geq)
+                ((eq (car math-simplify-expr) 'calcFunc-geq)
                  (or (and (eq signs 1) 0)
                      (and (memq signs '(2 4 6)) 1))))
-          expr))))
+          math-simplify-expr))))
 
 (defun math-simplify-add-term (np dp minus lplain)
   (or (math-vectorp (car np))
@@ -644,25 +679,27 @@
                 (setcar dp (setq n (math-neg temp)))))))))
 
 (math-defsimplify calcFunc-sin
-  (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-arcsin)
-           (nth 1 (nth 1 expr)))
-      (and (math-looks-negp (nth 1 expr))
-           (math-neg (list 'calcFunc-sin (math-neg (nth 1 expr)))))
+  (or (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arcsin)
+           (nth 1 (nth 1 math-simplify-expr)))
+      (and (math-looks-negp (nth 1 math-simplify-expr))
+           (math-neg (list 'calcFunc-sin (math-neg (nth 1 math-simplify-expr)))))
       (and (eq calc-angle-mode 'rad)
-           (let ((n (math-linear-in (nth 1 expr) '(var pi var-pi))))
+           (let ((n (math-linear-in (nth 1 math-simplify-expr) '(var pi var-pi))))
              (and n
                   (math-known-sin (car n) (nth 1 n) 120 0))))
       (and (eq calc-angle-mode 'deg)
-           (let ((n (math-integer-plus (nth 1 expr))))
+           (let ((n (math-integer-plus (nth 1 math-simplify-expr))))
              (and n
                   (math-known-sin (car n) (nth 1 n) '(frac 2 3) 0))))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-arccos)
-           (list 'calcFunc-sqrt (math-sub 1 (math-sqr (nth 1 (nth 1 expr))))))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-arctan)
-           (math-div (nth 1 (nth 1 expr))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arccos)
+           (list 'calcFunc-sqrt (math-sub 1 (math-sqr 
+                                             (nth 1 (nth 1 math-simplify-expr))))))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arctan)
+           (math-div (nth 1 (nth 1 math-simplify-expr))
                      (list 'calcFunc-sqrt
-                           (math-add 1 (math-sqr (nth 1 (nth 1 expr)))))))
-      (let ((m (math-should-expand-trig (nth 1 expr))))
+                           (math-add 1 (math-sqr 
+                                        (nth 1 (nth 1 math-simplify-expr)))))))
+      (let ((m (math-should-expand-trig (nth 1 math-simplify-expr))))
         (and m (integerp (car m))
              (let ((n (car m)) (a (nth 1 m)))
                (list '+
@@ -672,25 +709,27 @@
                            (list 'calcFunc-sin a))))))))
 
 (math-defsimplify calcFunc-cos
-  (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-arccos)
-           (nth 1 (nth 1 expr)))
-      (and (math-looks-negp (nth 1 expr))
-           (list 'calcFunc-cos (math-neg (nth 1 expr))))
+  (or (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arccos)
+           (nth 1 (nth 1 math-simplify-expr)))
+      (and (math-looks-negp (nth 1 math-simplify-expr))
+           (list 'calcFunc-cos (math-neg (nth 1 math-simplify-expr))))
       (and (eq calc-angle-mode 'rad)
-           (let ((n (math-linear-in (nth 1 expr) '(var pi var-pi))))
+           (let ((n (math-linear-in (nth 1 math-simplify-expr) '(var pi var-pi))))
              (and n
                   (math-known-sin (car n) (nth 1 n) 120 300))))
       (and (eq calc-angle-mode 'deg)
-           (let ((n (math-integer-plus (nth 1 expr))))
+           (let ((n (math-integer-plus (nth 1 math-simplify-expr))))
              (and n
                   (math-known-sin (car n) (nth 1 n) '(frac 2 3) 300))))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-arcsin)
-           (list 'calcFunc-sqrt (math-sub 1 (math-sqr (nth 1 (nth 1 expr))))))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-arctan)
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arcsin)
+           (list 'calcFunc-sqrt 
+                 (math-sub 1 (math-sqr (nth 1 (nth 1 math-simplify-expr))))))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arctan)
            (math-div 1
                      (list 'calcFunc-sqrt
-                           (math-add 1 (math-sqr (nth 1 (nth 1 expr)))))))
-      (let ((m (math-should-expand-trig (nth 1 expr))))
+                           (math-add 1 
+                                     (math-sqr (nth 1 (nth 1 math-simplify-expr)))))))
+      (let ((m (math-should-expand-trig (nth 1 math-simplify-expr))))
         (and m (integerp (car m))
              (let ((n (car m)) (a (nth 1 m)))
                (list '-
@@ -752,33 +791,33 @@
                  (t nil))))))
 
 (math-defsimplify calcFunc-tan
-  (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-arctan)
-           (nth 1 (nth 1 expr)))
-      (and (math-looks-negp (nth 1 expr))
-           (math-neg (list 'calcFunc-tan (math-neg (nth 1 expr)))))
+  (or (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arctan)
+           (nth 1 (nth 1 math-simplify-expr)))
+      (and (math-looks-negp (nth 1 math-simplify-expr))
+           (math-neg (list 'calcFunc-tan (math-neg (nth 1 math-simplify-expr)))))
       (and (eq calc-angle-mode 'rad)
-           (let ((n (math-linear-in (nth 1 expr) '(var pi var-pi))))
+           (let ((n (math-linear-in (nth 1 math-simplify-expr) '(var pi var-pi))))
              (and n
                   (math-known-tan (car n) (nth 1 n) 120))))
       (and (eq calc-angle-mode 'deg)
-           (let ((n (math-integer-plus (nth 1 expr))))
+           (let ((n (math-integer-plus (nth 1 math-simplify-expr))))
              (and n
                   (math-known-tan (car n) (nth 1 n) '(frac 2 3)))))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-arcsin)
-           (math-div (nth 1 (nth 1 expr))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arcsin)
+           (math-div (nth 1 (nth 1 math-simplify-expr))
                      (list 'calcFunc-sqrt
-                           (math-sub 1 (math-sqr (nth 1 (nth 1 expr)))))))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-arccos)
+                           (math-sub 1 (math-sqr (nth 1 (nth 1 math-simplify-expr)))))))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arccos)
            (math-div (list 'calcFunc-sqrt
-                           (math-sub 1 (math-sqr (nth 1 (nth 1 expr)))))
-                     (nth 1 (nth 1 expr))))
-      (let ((m (math-should-expand-trig (nth 1 expr))))
+                           (math-sub 1 (math-sqr (nth 1 (nth 1 math-simplify-expr)))))
+                     (nth 1 (nth 1 math-simplify-expr))))
+      (let ((m (math-should-expand-trig (nth 1 math-simplify-expr))))
         (and m
              (if (equal (car m) '(frac 1 2))
                  (math-div (math-sub 1 (list 'calcFunc-cos (nth 1 m)))
                            (list 'calcFunc-sin (nth 1 m)))
-               (math-div (list 'calcFunc-sin (nth 1 expr))
-                         (list 'calcFunc-cos (nth 1 expr))))))))
+               (math-div (list 'calcFunc-sin (nth 1 math-simplify-expr))
+                         (list 'calcFunc-cos (nth 1 math-simplify-expr))))))))
 
 (defun math-known-tan (plus n mul)
   (setq n (math-mul n mul))
@@ -813,19 +852,20 @@
                  (t nil))))))
 
 (math-defsimplify calcFunc-sinh
-  (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-arcsinh)
-           (nth 1 (nth 1 expr)))
-      (and (math-looks-negp (nth 1 expr))
-           (math-neg (list 'calcFunc-sinh (math-neg (nth 1 expr)))))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-arccosh)
+  (or (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arcsinh)
+           (nth 1 (nth 1 math-simplify-expr)))
+      (and (math-looks-negp (nth 1 math-simplify-expr))
+           (math-neg (list 'calcFunc-sinh (math-neg (nth 1 math-simplify-expr)))))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arccosh)
            math-living-dangerously
-           (list 'calcFunc-sqrt (math-sub (math-sqr (nth 1 (nth 1 expr))) 1)))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-arctanh)
+           (list 'calcFunc-sqrt 
+                 (math-sub (math-sqr (nth 1 (nth 1 math-simplify-expr))) 1)))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arctanh)
            math-living-dangerously
-           (math-div (nth 1 (nth 1 expr))
+           (math-div (nth 1 (nth 1 math-simplify-expr))
                      (list 'calcFunc-sqrt
-                           (math-sub 1 (math-sqr (nth 1 (nth 1 expr)))))))
-      (let ((m (math-should-expand-trig (nth 1 expr) t)))
+                           (math-sub 1 (math-sqr (nth 1 (nth 1 math-simplify-expr)))))))
+      (let ((m (math-should-expand-trig (nth 1 math-simplify-expr) t)))
         (and m (integerp (car m))
              (let ((n (car m)) (a (nth 1 m)))
                (if (> n 1)
@@ -836,19 +876,20 @@
                                (list 'calcFunc-sinh a)))))))))
 
 (math-defsimplify calcFunc-cosh
-  (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-arccosh)
-           (nth 1 (nth 1 expr)))
-      (and (math-looks-negp (nth 1 expr))
-           (list 'calcFunc-cosh (math-neg (nth 1 expr))))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-arcsinh)
+  (or (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arccosh)
+           (nth 1 (nth 1 math-simplify-expr)))
+      (and (math-looks-negp (nth 1 math-simplify-expr))
+           (list 'calcFunc-cosh (math-neg (nth 1 math-simplify-expr))))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arcsinh)
            math-living-dangerously
-           (list 'calcFunc-sqrt (math-add (math-sqr (nth 1 (nth 1 expr))) 1)))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-arctanh)
+           (list 'calcFunc-sqrt 
+                 (math-add (math-sqr (nth 1 (nth 1 math-simplify-expr))) 1)))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arctanh)
            math-living-dangerously
            (math-div 1
                      (list 'calcFunc-sqrt
-                           (math-sub 1 (math-sqr (nth 1 (nth 1 expr)))))))
-      (let ((m (math-should-expand-trig (nth 1 expr) t)))
+                           (math-sub 1 (math-sqr (nth 1 (nth 1 math-simplify-expr)))))))
+      (let ((m (math-should-expand-trig (nth 1 math-simplify-expr) t)))
         (and m (integerp (car m))
              (let ((n (car m)) (a (nth 1 m)))
                (if (> n 1)
@@ -859,133 +900,136 @@
                                (list 'calcFunc-sinh a)))))))))
 
 (math-defsimplify calcFunc-tanh
-  (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-arctanh)
-           (nth 1 (nth 1 expr)))
-      (and (math-looks-negp (nth 1 expr))
-           (math-neg (list 'calcFunc-tanh (math-neg (nth 1 expr)))))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-arcsinh)
+  (or (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arctanh)
+           (nth 1 (nth 1 math-simplify-expr)))
+      (and (math-looks-negp (nth 1 math-simplify-expr))
+           (math-neg (list 'calcFunc-tanh (math-neg (nth 1 math-simplify-expr)))))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arcsinh)
            math-living-dangerously
-           (math-div (nth 1 (nth 1 expr))
+           (math-div (nth 1 (nth 1 math-simplify-expr))
                      (list 'calcFunc-sqrt
-                           (math-add (math-sqr (nth 1 (nth 1 expr))) 1))))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-arccosh)
+                           (math-add (math-sqr (nth 1 (nth 1 math-simplify-expr))) 1))))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-arccosh)
            math-living-dangerously
            (math-div (list 'calcFunc-sqrt
-                           (math-sub (math-sqr (nth 1 (nth 1 expr))) 1))
-                     (nth 1 (nth 1 expr))))
-      (let ((m (math-should-expand-trig (nth 1 expr) t)))
+                           (math-sub (math-sqr (nth 1 (nth 1 math-simplify-expr))) 1))
+                     (nth 1 (nth 1 math-simplify-expr))))
+      (let ((m (math-should-expand-trig (nth 1 math-simplify-expr) t)))
         (and m
              (if (equal (car m) '(frac 1 2))
                  (math-div (math-sub (list 'calcFunc-cosh (nth 1 m)) 1)
                            (list 'calcFunc-sinh (nth 1 m)))
-               (math-div (list 'calcFunc-sinh (nth 1 expr))
-                         (list 'calcFunc-cosh (nth 1 expr))))))))
+               (math-div (list 'calcFunc-sinh (nth 1 math-simplify-expr))
+                         (list 'calcFunc-cosh (nth 1 math-simplify-expr))))))))
 
 (math-defsimplify calcFunc-arcsin
-  (or (and (math-looks-negp (nth 1 expr))
-           (math-neg (list 'calcFunc-arcsin (math-neg (nth 1 expr)))))
-      (and (eq (nth 1 expr) 1)
+  (or (and (math-looks-negp (nth 1 math-simplify-expr))
+           (math-neg (list 'calcFunc-arcsin (math-neg (nth 1 math-simplify-expr)))))
+      (and (eq (nth 1 math-simplify-expr) 1)
            (math-quarter-circle t))
-      (and (equal (nth 1 expr) '(frac 1 2))
+      (and (equal (nth 1 math-simplify-expr) '(frac 1 2))
            (math-div (math-half-circle t) 6))
       (and math-living-dangerously
-           (eq (car-safe (nth 1 expr)) 'calcFunc-sin)
-           (nth 1 (nth 1 expr)))
+           (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-sin)
+           (nth 1 (nth 1 math-simplify-expr)))
       (and math-living-dangerously
-           (eq (car-safe (nth 1 expr)) 'calcFunc-cos)
+           (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-cos)
            (math-sub (math-quarter-circle t)
-                     (nth 1 (nth 1 expr))))))
+                     (nth 1 (nth 1 math-simplify-expr))))))
 
 (math-defsimplify calcFunc-arccos
-  (or (and (eq (nth 1 expr) 0)
+  (or (and (eq (nth 1 math-simplify-expr) 0)
            (math-quarter-circle t))
-      (and (eq (nth 1 expr) -1)
+      (and (eq (nth 1 math-simplify-expr) -1)
            (math-half-circle t))
-      (and (equal (nth 1 expr) '(frac 1 2))
+      (and (equal (nth 1 math-simplify-expr) '(frac 1 2))
            (math-div (math-half-circle t) 3))
-      (and (equal (nth 1 expr) '(frac -1 2))
+      (and (equal (nth 1 math-simplify-expr) '(frac -1 2))
            (math-div (math-mul (math-half-circle t) 2) 3))
       (and math-living-dangerously
-           (eq (car-safe (nth 1 expr)) 'calcFunc-cos)
-           (nth 1 (nth 1 expr)))
+           (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-cos)
+           (nth 1 (nth 1 math-simplify-expr)))
       (and math-living-dangerously
-           (eq (car-safe (nth 1 expr)) 'calcFunc-sin)
+           (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-sin)
            (math-sub (math-quarter-circle t)
-                     (nth 1 (nth 1 expr))))))
+                     (nth 1 (nth 1 math-simplify-expr))))))
 
 (math-defsimplify calcFunc-arctan
-  (or (and (math-looks-negp (nth 1 expr))
-           (math-neg (list 'calcFunc-arctan (math-neg (nth 1 expr)))))
-      (and (eq (nth 1 expr) 1)
+  (or (and (math-looks-negp (nth 1 math-simplify-expr))
+           (math-neg (list 'calcFunc-arctan (math-neg (nth 1 math-simplify-expr)))))
+      (and (eq (nth 1 math-simplify-expr) 1)
            (math-div (math-half-circle t) 4))
       (and math-living-dangerously
-           (eq (car-safe (nth 1 expr)) 'calcFunc-tan)
-           (nth 1 (nth 1 expr)))))
+           (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-tan)
+           (nth 1 (nth 1 math-simplify-expr)))))
 
 (math-defsimplify calcFunc-arcsinh
-  (or (and (math-looks-negp (nth 1 expr))
-           (math-neg (list 'calcFunc-arcsinh (math-neg (nth 1 expr)))))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-sinh)
+  (or (and (math-looks-negp (nth 1 math-simplify-expr))
+           (math-neg (list 'calcFunc-arcsinh (math-neg (nth 1 math-simplify-expr)))))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-sinh)
            (or math-living-dangerously
-               (math-known-realp (nth 1 (nth 1 expr))))
-           (nth 1 (nth 1 expr)))))
+               (math-known-realp (nth 1 (nth 1 math-simplify-expr))))
+           (nth 1 (nth 1 math-simplify-expr)))))
 
 (math-defsimplify calcFunc-arccosh
-  (and (eq (car-safe (nth 1 expr)) 'calcFunc-cosh)
+  (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-cosh)
        (or math-living-dangerously
-           (math-known-realp (nth 1 (nth 1 expr))))
-       (nth 1 (nth 1 expr))))
+           (math-known-realp (nth 1 (nth 1 math-simplify-expr))))
+       (nth 1 (nth 1 math-simplify-expr))))
 
 (math-defsimplify calcFunc-arctanh
-  (or (and (math-looks-negp (nth 1 expr))
-           (math-neg (list 'calcFunc-arctanh (math-neg (nth 1 expr)))))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-tanh)
+  (or (and (math-looks-negp (nth 1 math-simplify-expr))
+           (math-neg (list 'calcFunc-arctanh (math-neg (nth 1 math-simplify-expr)))))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-tanh)
            (or math-living-dangerously
-               (math-known-realp (nth 1 (nth 1 expr))))
-           (nth 1 (nth 1 expr)))))
+               (math-known-realp (nth 1 (nth 1 math-simplify-expr))))
+           (nth 1 (nth 1 math-simplify-expr)))))
 
 (math-defsimplify calcFunc-sqrt
   (math-simplify-sqrt))
 
 (defun math-simplify-sqrt ()
-  (or (and (eq (car-safe (nth 1 expr)) 'frac)
-           (math-div (list 'calcFunc-sqrt (math-mul (nth 1 (nth 1 expr))
-                                                    (nth 2 (nth 1 expr))))
-                     (nth 2 (nth 1 expr))))
-      (let ((fac (if (math-objectp (nth 1 expr))
-                     (math-squared-factor (nth 1 expr))
-                   (math-common-constant-factor (nth 1 expr)))))
+  (or (and (eq (car-safe (nth 1 math-simplify-expr)) 'frac)
+           (math-div (list 'calcFunc-sqrt 
+                           (math-mul (nth 1 (nth 1 math-simplify-expr))
+                                     (nth 2 (nth 1 math-simplify-expr))))
+                     (nth 2 (nth 1 math-simplify-expr))))
+      (let ((fac (if (math-objectp (nth 1 math-simplify-expr))
+                     (math-squared-factor (nth 1 math-simplify-expr))
+                   (math-common-constant-factor (nth 1 math-simplify-expr)))))
         (and fac (not (eq fac 1))
              (math-mul (math-normalize (list 'calcFunc-sqrt fac))
                        (math-normalize
                         (list 'calcFunc-sqrt
-                              (math-cancel-common-factor (nth 1 expr) fac))))))
+                              (math-cancel-common-factor 
+                               (nth 1 math-simplify-expr) fac))))))
       (and math-living-dangerously
-           (or (and (eq (car-safe (nth 1 expr)) '-)
-                    (math-equal-int (nth 1 (nth 1 expr)) 1)
-                    (eq (car-safe (nth 2 (nth 1 expr))) '^)
-                    (math-equal-int (nth 2 (nth 2 (nth 1 expr))) 2)
-                    (or (and (eq (car-safe (nth 1 (nth 2 (nth 1 expr))))
+           (or (and (eq (car-safe (nth 1 math-simplify-expr)) '-)
+                    (math-equal-int (nth 1 (nth 1 math-simplify-expr)) 1)
+                    (eq (car-safe (nth 2 (nth 1 math-simplify-expr))) '^)
+                    (math-equal-int (nth 2 (nth 2 (nth 1 math-simplify-expr))) 2)
+                    (or (and (eq (car-safe (nth 1 (nth 2 (nth 1 math-simplify-expr))))
                                  'calcFunc-sin)
                              (list 'calcFunc-cos
-                                   (nth 1 (nth 1 (nth 2 (nth 1 expr))))))
-                        (and (eq (car-safe (nth 1 (nth 2 (nth 1 expr))))
+                                   (nth 1 (nth 1 (nth 2 (nth 1 math-simplify-expr))))))
+                        (and (eq (car-safe (nth 1 (nth 2 (nth 1 math-simplify-expr))))
                                  'calcFunc-cos)
                              (list 'calcFunc-sin
-                                   (nth 1 (nth 1 (nth 2 (nth 1 expr))))))))
-               (and (eq (car-safe (nth 1 expr)) '-)
-                    (math-equal-int (nth 2 (nth 1 expr)) 1)
-                    (eq (car-safe (nth 1 (nth 1 expr))) '^)
-                    (math-equal-int (nth 2 (nth 1 (nth 1 expr))) 2)
-                    (and (eq (car-safe (nth 1 (nth 1 (nth 1 expr))))
+                                   (nth 1 (nth 1 (nth 2 
+                                                      (nth 1 math-simplify-expr))))))))
+               (and (eq (car-safe (nth 1 math-simplify-expr)) '-)
+                    (math-equal-int (nth 2 (nth 1 math-simplify-expr)) 1)
+                    (eq (car-safe (nth 1 (nth 1 math-simplify-expr))) '^)
+                    (math-equal-int (nth 2 (nth 1 (nth 1 math-simplify-expr))) 2)
+                    (and (eq (car-safe (nth 1 (nth 1 (nth 1 math-simplify-expr))))
                              'calcFunc-cosh)
                          (list 'calcFunc-sinh
-                               (nth 1 (nth 1 (nth 1 (nth 1 expr)))))))
-               (and (eq (car-safe (nth 1 expr)) '+)
-                    (let ((a (nth 1 (nth 1 expr)))
-                          (b (nth 2 (nth 1 expr))))
+                               (nth 1 (nth 1 (nth 1 (nth 1 math-simplify-expr)))))))
+               (and (eq (car-safe (nth 1 math-simplify-expr)) '+)
+                    (let ((a (nth 1 (nth 1 math-simplify-expr)))
+                          (b (nth 2 (nth 1 math-simplify-expr))))
                       (and (or (and (math-equal-int a 1)
-                                    (setq a b b (nth 1 (nth 1 expr))))
+                                    (setq a b b (nth 1 (nth 1 math-simplify-expr))))
                                (math-equal-int b 1))
                            (eq (car-safe a) '^)
                            (math-equal-int (nth 2 a) 2)
@@ -994,20 +1038,20 @@
                                (and (eq (car-safe (nth 1 a)) 'calcFunc-tan)
                                     (list '/ 1 (list 'calcFunc-cos
                                                      (nth 1 (nth 1 a)))))))))
-               (and (eq (car-safe (nth 1 expr)) '^)
+               (and (eq (car-safe (nth 1 math-simplify-expr)) '^)
                     (list '^
-                          (nth 1 (nth 1 expr))
-                          (math-div (nth 2 (nth 1 expr)) 2)))
-               (and (eq (car-safe (nth 1 expr)) 'calcFunc-sqrt)
-                    (list '^ (nth 1 (nth 1 expr)) (math-div 1 4)))
-               (and (memq (car-safe (nth 1 expr)) '(* /))
-                    (list (car (nth 1 expr))
-                          (list 'calcFunc-sqrt (nth 1 (nth 1 expr)))
-                          (list 'calcFunc-sqrt (nth 2 (nth 1 expr)))))
-               (and (memq (car-safe (nth 1 expr)) '(+ -))
-                    (not (math-any-floats (nth 1 expr)))
+                          (nth 1 (nth 1 math-simplify-expr))
+                          (math-div (nth 2 (nth 1 math-simplify-expr)) 2)))
+               (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-sqrt)
+                    (list '^ (nth 1 (nth 1 math-simplify-expr)) (math-div 1 4)))
+               (and (memq (car-safe (nth 1 math-simplify-expr)) '(* /))
+                    (list (car (nth 1 math-simplify-expr))
+                          (list 'calcFunc-sqrt (nth 1 (nth 1 math-simplify-expr)))
+                          (list 'calcFunc-sqrt (nth 2 (nth 1 math-simplify-expr)))))
+               (and (memq (car-safe (nth 1 math-simplify-expr)) '(+ -))
+                    (not (math-any-floats (nth 1 math-simplify-expr)))
                     (let ((f (calcFunc-factors (calcFunc-expand
-                                                (nth 1 expr)))))
+                                                (nth 1 math-simplify-expr)))))
                       (and (math-vectorp f)
                            (or (> (length f) 2)
                                (> (nth 2 (nth 1 f)) 1))
@@ -1043,7 +1087,7 @@
         fac)))
 
 (math-defsimplify calcFunc-exp
-  (math-simplify-exp (nth 1 expr)))
+  (math-simplify-exp (nth 1 math-simplify-expr)))
 
 (defun math-simplify-exp (x)
   (or (and (eq (car-safe x) 'calcFunc-ln)
@@ -1074,22 +1118,22 @@
                   (list '+ c (list '* s '(var i var-i))))))))
 
 (math-defsimplify calcFunc-ln
-  (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-exp)
+  (or (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-exp)
            (or math-living-dangerously
-               (math-known-realp (nth 1 (nth 1 expr))))
-           (nth 1 (nth 1 expr)))
-      (and (eq (car-safe (nth 1 expr)) '^)
-           (equal (nth 1 (nth 1 expr)) '(var e var-e))
+               (math-known-realp (nth 1 (nth 1 math-simplify-expr))))
+           (nth 1 (nth 1 math-simplify-expr)))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) '^)
+           (equal (nth 1 (nth 1 math-simplify-expr)) '(var e var-e))
            (or math-living-dangerously
-               (math-known-realp (nth 2 (nth 1 expr))))
-           (nth 2 (nth 1 expr)))
+               (math-known-realp (nth 2 (nth 1 math-simplify-expr))))
+           (nth 2 (nth 1 math-simplify-expr)))
       (and calc-symbolic-mode
-           (math-known-negp (nth 1 expr))
-           (math-add (list 'calcFunc-ln (math-neg (nth 1 expr)))
+           (math-known-negp (nth 1 math-simplify-expr))
+           (math-add (list 'calcFunc-ln (math-neg (nth 1 math-simplify-expr)))
                      '(* (var pi var-pi) (var i var-i))))
       (and calc-symbolic-mode
-           (math-known-imagp (nth 1 expr))
-           (let* ((ip (calcFunc-im (nth 1 expr)))
+           (math-known-imagp (nth 1 math-simplify-expr))
+           (let* ((ip (calcFunc-im (nth 1 math-simplify-expr)))
                   (ips (math-possible-signs ip)))
              (or (and (memq ips '(4 6))
                       (math-add (list 'calcFunc-ln ip)
@@ -1103,83 +1147,91 @@
 
 (defun math-simplify-pow ()
   (or (and math-living-dangerously
-           (or (and (eq (car-safe (nth 1 expr)) '^)
+           (or (and (eq (car-safe (nth 1 math-simplify-expr)) '^)
                     (list '^
-                          (nth 1 (nth 1 expr))
-                          (math-mul (nth 2 expr) (nth 2 (nth 1 expr)))))
-               (and (eq (car-safe (nth 1 expr)) 'calcFunc-sqrt)
+                          (nth 1 (nth 1 math-simplify-expr))
+                          (math-mul (nth 2 math-simplify-expr) 
+                                    (nth 2 (nth 1 math-simplify-expr)))))
+               (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-sqrt)
                     (list '^
-                          (nth 1 (nth 1 expr))
-                          (math-div (nth 2 expr) 2)))
-               (and (memq (car-safe (nth 1 expr)) '(* /))
-                    (list (car (nth 1 expr))
-                          (list '^ (nth 1 (nth 1 expr)) (nth 2 expr))
-                          (list '^ (nth 2 (nth 1 expr)) (nth 2 expr))))))
-      (and (math-equal-int (nth 1 expr) 10)
-           (eq (car-safe (nth 2 expr)) 'calcFunc-log10)
-           (nth 1 (nth 2 expr)))
-      (and (equal (nth 1 expr) '(var e var-e))
-           (math-simplify-exp (nth 2 expr)))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-exp)
+                          (nth 1 (nth 1 math-simplify-expr))
+                          (math-div (nth 2 math-simplify-expr) 2)))
+               (and (memq (car-safe (nth 1 math-simplify-expr)) '(* /))
+                    (list (car (nth 1 math-simplify-expr))
+                          (list '^ (nth 1 (nth 1 math-simplify-expr)) 
+                                (nth 2 math-simplify-expr))
+                          (list '^ (nth 2 (nth 1 math-simplify-expr)) 
+                                (nth 2 math-simplify-expr))))))
+      (and (math-equal-int (nth 1 math-simplify-expr) 10)
+           (eq (car-safe (nth 2 math-simplify-expr)) 'calcFunc-log10)
+           (nth 1 (nth 2 math-simplify-expr)))
+      (and (equal (nth 1 math-simplify-expr) '(var e var-e))
+           (math-simplify-exp (nth 2 math-simplify-expr)))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-exp)
            (not math-integrating)
-           (list 'calcFunc-exp (math-mul (nth 1 (nth 1 expr)) (nth 2 expr))))
-      (and (equal (nth 1 expr) '(var i var-i))
+           (list 'calcFunc-exp (math-mul (nth 1 (nth 1 math-simplify-expr)) 
+                                         (nth 2 math-simplify-expr))))
+      (and (equal (nth 1 math-simplify-expr) '(var i var-i))
            (math-imaginary-i)
-           (math-num-integerp (nth 2 expr))
-           (let ((x (math-mod (math-trunc (nth 2 expr)) 4)))
+           (math-num-integerp (nth 2 math-simplify-expr))
+           (let ((x (math-mod (math-trunc (nth 2 math-simplify-expr)) 4)))
              (cond ((eq x 0) 1)
-                   ((eq x 1) (nth 1 expr))
+                   ((eq x 1) (nth 1 math-simplify-expr))
                    ((eq x 2) -1)
-                   ((eq x 3) (math-neg (nth 1 expr))))))
+                   ((eq x 3) (math-neg (nth 1 math-simplify-expr))))))
       (and math-integrating
-           (integerp (nth 2 expr))
-           (>= (nth 2 expr) 2)
-           (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-cos)
-                    (math-mul (math-pow (nth 1 expr) (- (nth 2 expr) 2))
+           (integerp (nth 2 math-simplify-expr))
+           (>= (nth 2 math-simplify-expr) 2)
+           (or (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-cos)
+                    (math-mul (math-pow (nth 1 math-simplify-expr) 
+                                        (- (nth 2 math-simplify-expr) 2))
                               (math-sub 1
                                         (math-sqr
                                          (list 'calcFunc-sin
-                                               (nth 1 (nth 1 expr)))))))
-               (and (eq (car-safe (nth 1 expr)) 'calcFunc-cosh)
-                    (math-mul (math-pow (nth 1 expr) (- (nth 2 expr) 2))
+                                               (nth 1 (nth 1 math-simplify-expr)))))))
+               (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-cosh)
+                    (math-mul (math-pow (nth 1 math-simplify-expr) 
+                                        (- (nth 2 math-simplify-expr) 2))
                               (math-add 1
                                         (math-sqr
                                          (list 'calcFunc-sinh
-                                               (nth 1 (nth 1 expr)))))))))
-      (and (eq (car-safe (nth 2 expr)) 'frac)
-           (Math-ratp (nth 1 expr))
-           (Math-posp (nth 1 expr))
-           (if (equal (nth 2 expr) '(frac 1 2))
-               (list 'calcFunc-sqrt (nth 1 expr))
-             (let ((flr (math-floor (nth 2 expr))))
+                                               (nth 1 (nth 1 math-simplify-expr)))))))))
+      (and (eq (car-safe (nth 2 math-simplify-expr)) 'frac)
+           (Math-ratp (nth 1 math-simplify-expr))
+           (Math-posp (nth 1 math-simplify-expr))
+           (if (equal (nth 2 math-simplify-expr) '(frac 1 2))
+               (list 'calcFunc-sqrt (nth 1 math-simplify-expr))
+             (let ((flr (math-floor (nth 2 math-simplify-expr))))
                (and (not (Math-zerop flr))
-                    (list '* (list '^ (nth 1 expr) flr)
-                          (list '^ (nth 1 expr)
-                                (math-sub (nth 2 expr) flr)))))))
-      (and (eq (math-quarter-integer (nth 2 expr)) 2)
+                    (list '* (list '^ (nth 1 math-simplify-expr) flr)
+                          (list '^ (nth 1 math-simplify-expr)
+                                (math-sub (nth 2 math-simplify-expr) flr)))))))
+      (and (eq (math-quarter-integer (nth 2 math-simplify-expr)) 2)
            (let ((temp (math-simplify-sqrt)))
              (and temp
-                  (list '^ temp (math-mul (nth 2 expr) 2)))))))
+                  (list '^ temp (math-mul (nth 2 math-simplify-expr) 2)))))))
 
 (math-defsimplify calcFunc-log10
-  (and (eq (car-safe (nth 1 expr)) '^)
-       (math-equal-int (nth 1 (nth 1 expr)) 10)
+  (and (eq (car-safe (nth 1 math-simplify-expr)) '^)
+       (math-equal-int (nth 1 (nth 1 math-simplify-expr)) 10)
        (or math-living-dangerously
-           (math-known-realp (nth 2 (nth 1 expr))))
-       (nth 2 (nth 1 expr))))
+           (math-known-realp (nth 2 (nth 1 math-simplify-expr))))
+       (nth 2 (nth 1 math-simplify-expr))))
 
 
 (math-defsimplify calcFunc-erf
-  (or (and (math-looks-negp (nth 1 expr))
-           (math-neg (list 'calcFunc-erf (math-neg (nth 1 expr)))))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-conj)
-           (list 'calcFunc-conj (list 'calcFunc-erf (nth 1 (nth 1 expr)))))))
+  (or (and (math-looks-negp (nth 1 math-simplify-expr))
+           (math-neg (list 'calcFunc-erf (math-neg (nth 1 math-simplify-expr)))))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-conj)
+           (list 'calcFunc-conj 
+                 (list 'calcFunc-erf (nth 1 (nth 1 math-simplify-expr)))))))
 
 (math-defsimplify calcFunc-erfc
-  (or (and (math-looks-negp (nth 1 expr))
-           (math-sub 2 (list 'calcFunc-erfc (math-neg (nth 1 expr)))))
-      (and (eq (car-safe (nth 1 expr)) 'calcFunc-conj)
-           (list 'calcFunc-conj (list 'calcFunc-erfc (nth 1 (nth 1 expr)))))))
+  (or (and (math-looks-negp (nth 1 math-simplify-expr))
+           (math-sub 2 (list 'calcFunc-erfc (math-neg (nth 1 math-simplify-expr)))))
+      (and (eq (car-safe (nth 1 math-simplify-expr)) 'calcFunc-conj)
+           (list 'calcFunc-conj 
+                 (list 'calcFunc-erfc (nth 1 (nth 1 math-simplify-expr)))))))
 
 
 (defun math-linear-in (expr term &optional always)
@@ -1325,19 +1377,25 @@
     thing))
 
 ;;; Substitute all occurrences of old for new in expr (non-destructive).
-(defun math-expr-subst (expr old new)
+
+;; The variables math-expr-subst-old and math-expr-subst-new are local
+;; for math-expr-subst, but used by math-expr-subst-rec.
+(defvar math-expr-subst-old)
+(defvar math-expr-subst-new)
+
+(defun math-expr-subst (expr math-expr-subst-old math-expr-subst-new)
   (math-expr-subst-rec expr))
 
 (defalias 'calcFunc-subst 'math-expr-subst)
 
 (defun math-expr-subst-rec (expr)
-  (cond ((equal expr old) new)
+  (cond ((equal expr math-expr-subst-old) math-expr-subst-new)
         ((Math-primp expr) expr)
         ((memq (car expr) '(calcFunc-deriv
                             calcFunc-tderiv))
          (if (= (length expr) 2)
-             (if (equal (nth 1 expr) old)
-                 (append expr (list new))
+             (if (equal (nth 1 expr) math-expr-subst-old)
+                 (append expr (list math-expr-subst-new))
                expr)
            (list (car expr) (nth 1 expr)
                  (math-expr-subst-rec (nth 2 expr)))))
@@ -1375,15 +1433,21 @@
       expr)))
 
 ;;; If expr is of the form "a + bx + cx^2 + ...", return the list (a b c ...),
-;;; else return nil if not in polynomial form.  If "loose", coefficients
-;;; may contain x, e.g., sin(x) + cos(x) x^2 is a loose polynomial in x.
-(defun math-is-polynomial (expr var &optional degree loose)
-  (let* ((math-poly-base-variable (if loose
-                                      (if (eq loose 'gen) var '(var XXX XXX))
+;;; else return nil if not in polynomial form.  If "loose" (math-is-poly-loose), 
+;;; coefficients may contain x, e.g., sin(x) + cos(x) x^2 is a loose polynomial in x.
+
+;; The variables math-is-poly-degree and math-is-poly-loose are local to 
+;; math-is-polynomial, but are used by math-is-poly-rec
+(defvar math-is-poly-degree)
+(defvar math-is-poly-loose)
+
+(defun math-is-polynomial (expr 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))
                                     math-poly-base-variable))
          (poly (math-is-poly-rec expr math-poly-neg-powers)))
-    (and (or (null degree)
-             (<= (length poly) (1+ degree)))
+    (and (or (null math-is-poly-degree)
+             (<= (length poly) (1+ math-is-poly-degree)))
          poly)))
 
 (defun math-is-poly-rec (expr negpow)
@@ -1431,8 +1495,8 @@
                                 (n pow)
                                 (accum (list 1)))
                             (and p1
-                                 (or (null degree)
-                                     (<= (* (1- (length p1)) n) degree))
+                                 (or (null math-is-poly-degree)
+                                     (<= (* (1- (length p1)) n) math-is-poly-degree))
                                  (progn
                                    (while (>= n 1)
                                      (setq accum (math-poly-mul accum p1)
@@ -1460,8 +1524,9 @@
                 (and p1
                      (let ((p2 (math-is-poly-rec (nth 2 expr) negpow)))
                        (and p2
-                            (or (null degree)
-                                (<= (- (+ (length p1) (length p2)) 2) degree))
+                            (or (null math-is-poly-degree)
+                                (<= (- (+ (length p1) (length p2)) 2) 
+                                    math-is-poly-degree))
                             (math-poly-mul p1 p2))))))
              ((eq (car expr) '/)
               (and (or (not (math-poly-depends (nth 2 expr) var))
@@ -1481,7 +1546,7 @@
               (math-is-poly-rec (list '^ (nth 1 expr) '(frac 1 2)) negpow))
              (t nil))
        (and (or (not (math-poly-depends expr var))
-                loose)
+                math-is-poly-loose)
             (not (eq (car expr) 'vec))
             (list expr)))))
 
@@ -1517,13 +1582,18 @@
     (math-expr-depends expr var)))
 
 ;;; Find the variable (or sub-expression) which is the base of polynomial expr.
-(defun math-polynomial-base (mpb-top-expr &optional mpb-pred)
-  (or mpb-pred
-      (setq mpb-pred (function (lambda (base) (math-polynomial-p
+;; The variables math-poly-base-const-ok and math-poly-base-pred are
+;; local to math-polynomial-base, but are used by math-polynomial-base-rec.
+(defvar math-poly-base-const-ok)
+(defvar math-poly-base-pred)
+
+(defun math-polynomial-base (mpb-top-expr &optional math-poly-base-pred)
+  (or math-poly-base-pred
+      (setq math-poly-base-pred (function (lambda (base) (math-polynomial-p
                                                mpb-top-expr base)))))
-  (or (let ((const-ok nil))
+  (or (let ((math-poly-base-const-ok nil))
         (math-polynomial-base-rec mpb-top-expr))
-      (let ((const-ok t))
+      (let ((math-poly-base-const-ok t))
         (math-polynomial-base-rec mpb-top-expr))))
 
 (defun math-polynomial-base-rec (mpb-expr)
@@ -1537,8 +1607,8 @@
                 (math-polynomial-base-rec (nth 1 mpb-expr)))
            (and (eq (car mpb-expr) 'calcFunc-exp)
                 (math-polynomial-base-rec '(var e var-e)))
-           (and (or const-ok (math-expr-contains-vars mpb-expr))
-                (funcall mpb-pred mpb-expr)
+           (and (or math-poly-base-const-ok (math-expr-contains-vars mpb-expr))
+                (funcall math-poly-base-pred mpb-expr)
                 mpb-expr))))
 
 ;;; Return non-nil if expr refers to any variables.