emacs: lisp/calc/calc-units.el comparison

comparison lisp/calc/calc-units.el @ 58508:589dc235628a

(calc-convert-units): Make units a local variable. (calc-num-units, calc-den-units): New variables. (calc-explain-units, calc-explain-units-rec): Replace variables num-units and den-units by declared variables. (math-cu-unit-list): New variable. (math-build-units-table, math-compare-unit-names) (math-convert-units, math-convert-units-rec): Replace variable unit-list by declared variable. (math-fbu-base, math-fbu-entry): New variables. (math-find-base-units, math-find-base-units-rec): Replace variables base and entry by declared variables. (math-which-standard): New variable. (math-to-standard-units, math-to-standard-rec): Replace variable which-standard by declared variable. (math-fcu-u): New variable. (math-find-compatible-unit, math-find-compatible-unit-rec): Replace variable u by declared variable. (math-cu-new-units, math-cu-pure): New variables. (math-convert-units, math-convert-units-rec): Replace variables new-units and pure by declared variables. (math-try-cancel-units): New variable. (math-simplify-units-quotient): Replace variable try-cancel-units by declared variable.

author	Jay Belanger <jay.p.belanger@gmail.com>
date	Thu, 25 Nov 2004 05:53:35 +0000
parents	6ae80af2f94b
children	0a3797785946

comparison

equal deleted inserted replaced

-:c8e117d0c5ff
+:589dc235628a
 (defun calc-convert-units (&optional old-units new-units)
 (interactive)
 (calc-slow-wrapper
 (let ((expr (calc-top-n 1))
 	 (uoldname nil)
-	 unew)
+	 unew
+units)
 (unless (math-units-in-expr-p expr t)
 (let ((uold (or old-units
 		       (progn
 			 (setq uoldname (read-string "Old units: "))
 			 (if (equal uoldname "")
 (interactive)
 (calc-slow-wrapper
 (calc-enter-result 1 "rmun" (math-simplify-units
 				(math-extract-units (calc-top-n 1))))))
+;; The variables calc-num-units and calc-den-units are local to
+;; calc-explain-units, but are used by calc-explain-units-rec,
+;; which is called by calc-explain-units.
+(defvar calc-num-units)
+(defvar calc-den-units)
 (defun calc-explain-units ()
 (interactive)
 (calc-wrapper
-(let ((num-units nil)
+(let ((calc-num-units nil)
-	 (den-units nil))
+	 (calc-den-units nil))
 (calc-explain-units-rec (calc-top-n 1) 1)
-(and den-units (string-match "^[^(].* .*[^)]$" den-units)
+(and calc-den-units (string-match "^[^(].* .*[^)]$" calc-den-units)
-	  (setq den-units (concat "(" den-units ")")))
+	  (setq calc-den-units (concat "(" calc-den-units ")")))
-(if num-units
+(if calc-num-units
-	 (if den-units
+	 (if calc-den-units
-	     (message "%s per %s" num-units den-units)
+	     (message "%s per %s" calc-num-units calc-den-units)
-	   (message "%s" num-units))
+	   (message "%s" calc-num-units))
-(if den-units
+(if calc-den-units
-	   (message "1 per %s" den-units)
+	   (message "1 per %s" calc-den-units)
 	 (message "No units in expression"))))))
 (defun calc-explain-units-rec (expr pow)
 (let ((u (math-check-unit-name expr))
 	pos)
 		   (setq name (concat name "-cubed"))))
 		(t
 		 (setq name (concat name "^"
 				    (math-format-number (math-abs pow))))))
 	  (if (math-posp pow)
-	      (setq num-units (if num-units
+	      (setq calc-num-units (if calc-num-units
-				  (concat num-units " " name)
+				  (concat calc-num-units " " name)
 				name))
-	    (setq den-units (if den-units
+	    (setq calc-den-units (if calc-den-units
-				(concat den-units " " name)
+				(concat calc-den-units " " name)
 			      name))))
 (cond ((eq (car-safe expr) '*)
 	     (calc-explain-units-rec (nth 1 expr) pow)
 	     (calc-explain-units-rec (nth 2 expr) pow))
 	    ((eq (car-safe expr) '/)
 (insert ";;; (no custom units defined)\n"))
 (insert ";;; End of custom units\n")
 (save-buffer))))
+;; The variable math-cu-unit-list is local to math-build-units-table,
+;; but is used by math-compare-unit-names, which is called (indirectly)
+;; by math-build-units-table.
+;; math-cu-unit-list is also local to math-convert-units, but is used
+;; by math-convert-units-rec, which is called by math-convert-units.
+(defvar math-cu-unit-list)
 (defun math-build-units-table ()
 (or math-units-table
 (let* ((combined-units (append math-additional-units
 				     math-standard-units))
-	     (unit-list (mapcar 'car combined-units))
+	     (math-cu-unit-list (mapcar 'car combined-units))
 	     tab)
 	(message "Building units table...")
 	(setq math-units-table-buffer-valid nil)
 	(setq tab (mapcar (function
 			   (lambda (x)
 	(let ((math-units-table tab))
 	  (mapcar 'math-find-base-units tab))
 	(message "Building units table...done")
 	(setq math-units-table tab))))
+;; The variables math-fbu-base and math-fbu-entry are local to
+;; math-find-base-units, but are used by math-find-base-units-rec,
+;; which is called by math-find-base-units.
+(defvar math-fbu-base)
+(defvar math-fbu-entry)
 (defun math-find-base-units (entry)
 (if (eq (nth 4 entry) 'boom)
 (error "Circular definition involving unit %s" (car entry)))
 (or (nth 4 entry)
 (let (base)
 	(setq base (sort base 'math-compare-unit-names))
 	(setcar (nthcdr 4 entry) base)
 	base)))
 (defun math-compare-unit-names (a b)
-(memq (car b) (cdr (memq (car a) unit-list))))
+(memq (car b) (cdr (memq (car a) math-cu-unit-list))))
 (defun math-find-base-units-rec (expr pow)
 (let ((u (math-check-unit-name expr)))
 (cond (u
 	   (let ((ulist (math-find-base-units u)))
 			   (eq (aref name 1) ?e)
 			   (eq (aref name 2) ?g)
 			   (assq (intern (substring name 3))
 				 math-units-table))))))))
+;; The variable math-which-standard is local to math-to-standard-units,
-(defun math-to-standard-units (expr which-standard)
+;; but is used by math-to-standard-rec, which is called by
+;; math-to-standard-units.
+(defvar math-which-standard)
+(defun math-to-standard-units (expr math-which-standard)
 (math-to-standard-rec expr))
 (defun math-to-standard-rec (expr)
 (if (eq (car-safe expr) 'var)
 (let ((u (math-check-unit-name expr))
 	    (base (nth 1 expr)))
 	(if u
 	    (progn
 	      (if (nth 1 u)
 		  (setq expr (math-to-standard-rec (nth 1 u)))
-		(let ((st (assq (car u) which-standard)))
+		(let ((st (assq (car u) math-which-standard)))
 		  (if st
 		      (setq expr (nth 1 st))
 		    (setq expr (list 'var (car u)
 				     (intern (concat "var-"
 						     (symbol-name
 (cons unit
 	(math-is-multiple (math-simplify-units (math-to-standard-units
 						unit nil))
 			  t)))
+;; The variable math-fcu-u is local to math-find-compatible-unit,
+;; but is used by math-find-compatible-rec which is called by
+;; math-find-compatible-unit.
+(defvar math-fcu-u)
 (defun math-find-compatible-unit (expr unit)
-(let ((u (math-check-unit-name unit)))
+(let ((math-fcu-u (math-check-unit-name unit)))
-(if u
+(if math-fcu-u
 	(math-find-compatible-unit-rec expr 1))))
 (defun math-find-compatible-unit-rec (expr pow)
 (cond ((eq (car-safe expr) '*)
 	 (or (math-find-compatible-unit-rec (nth 1 expr) pow)
 	((and (eq (car-safe expr) '^)
 	      (integerp (nth 2 expr)))
 	 (math-find-compatible-unit-rec (nth 1 expr) (* pow (nth 2 expr))))
 	(t
 	 (let ((u2 (math-check-unit-name expr)))
-	   (if (equal (nth 4 u) (nth 4 u2))
+	   (if (equal (nth 4 math-fcu-u) (nth 4 u2))
 	       (cons expr pow))))))
-(defun math-convert-units (expr new-units &optional pure)
+;; The variables math-cu-new-units and math-cu-pure are local to
+;; math-convert-units, but are used by math-convert-units-rec,
+;; which is called by math-convert-units.
+(defvar math-cu-new-units)
+(defvar math-cu-pure)
+(defun math-convert-units (expr math-cu-new-units &optional math-cu-pure)
 (math-with-extra-prec 2
-(let ((compat (and (not pure) (math-find-compatible-unit expr new-units)))
+(let ((compat (and (not math-cu-pure)
-	  (unit-list nil)
+(math-find-compatible-unit expr math-cu-new-units)))
+	  (math-cu-unit-list nil)
 	  (math-combining-units nil))
 (if compat
 	  (math-simplify-units
 	   (math-mul (math-mul (math-simplify-units
 				(math-div expr (math-pow (car compat)
 							 (cdr compat))))
-			       (math-pow new-units (cdr compat)))
+			       (math-pow math-cu-new-units (cdr compat)))
 		     (math-simplify-units
 		      (math-to-standard-units
-		       (math-pow (math-div (car compat) new-units)
+		       (math-pow (math-div (car compat) math-cu-new-units)
 				 (cdr compat))
 		       nil))))
-	(when (setq unit-list (math-decompose-units new-units))
+	(when (setq math-cu-unit-list (math-decompose-units math-cu-new-units))
-	  (setq new-units (nth 2 (car unit-list))))
+	  (setq math-cu-new-units (nth 2 (car math-cu-unit-list))))
 	(when (eq (car-safe expr) '+)
 	  (setq expr (math-simplify-units expr)))
 	(if (math-units-in-expr-p expr t)
 	    (math-convert-units-rec expr)
 	  (math-apply-units (math-to-standard-units
-			     (list '/ expr new-units) nil)
+			     (list '/ expr math-cu-new-units) nil)
-			    new-units unit-list pure))))))
+			    math-cu-new-units math-cu-unit-list math-cu-pure))))))
 (defun math-convert-units-rec (expr)
 (if (math-units-in-expr-p expr nil)
-(math-apply-units (math-to-standard-units (list '/ expr new-units) nil)
+(math-apply-units (math-to-standard-units
-			new-units unit-list pure)
+(list '/ expr math-cu-new-units) nil)
+			math-cu-new-units math-cu-unit-list math-cu-pure)
 (if (Math-primp expr)
 	expr
 (cons (car expr)
 	    (mapcar 'math-convert-units-rec (cdr expr))))))
 				 (calcFunc-scf (nth 1 math-simplify-expr)
 					       (- uxpon pxpon))))
 		       (setcar unitp pname)
 		       math-simplify-expr)))))))
+(defvar math-try-cancel-units)
 (math-defsimplify /
 (and math-simplifying-units
 (let ((np (cdr math-simplify-expr))
-	     (try-cancel-units 0)
+	     (math-try-cancel-units 0)
 	     n nn)
 	 (setq n (if (eq (car-safe (nth 2 math-simplify-expr)) '*)
 		     (cdr (nth 2 math-simplify-expr))
 		   (nthcdr 2 math-simplify-expr)))
 	 (if (math-realp (car n))
 	       (setcar n 1)))
 	 (while (eq (car-safe (setq n (car np))) '*)
 	   (math-simplify-units-divisor (cdr n) (cdr (cdr math-simplify-expr)))
 	   (setq np (cdr (cdr n))))
 	 (math-simplify-units-divisor np (cdr (cdr math-simplify-expr)))
-	 (if (eq try-cancel-units 0)
+	 (if (eq math-try-cancel-units 0)
 	     (let* ((math-simplifying-units nil)
 		    (base (math-simplify
 (math-to-standard-units math-simplify-expr nil))))
 	       (if (Math-numberp base)
 		   (setq math-simplify-expr base))))
 		     ud (nth 4 ud))
 	       (while un
 		 (setq ud1 ud)
 		 (while ud1
 		   (and (eq (car (car un)) (car (car ud1)))
-			(setq try-cancel-units
+			(setq math-try-cancel-units
-			      (+ try-cancel-units
+			      (+ math-try-cancel-units
 				 (- (* (cdr (car un)) pow1)
 				    (* (cdr (car ud)) pow2)))))
 		   (setq ud1 (cdr ud1)))
 		 (setq un (cdr un)))
 	       nil))))))

Mercurial > emacs

comparison lisp/calc/calc-units.el @ 58508:589dc235628a