(calcFunc-write-out-power): Rename calcFunc-powerexpand.

(math-write-out-power): Rename math-powerexpand, have it handle
negative exponents.
(calc-writeoutpower): Rename calc-powerexpand.

diff --git a/lisp/calc/calc-alg.el b/lisp/calc/calc-alg.el
index 11d550bb5d2c032cd7d1d3a7353b7f6e7c9c205b..a57f7ede375eababce5f48dda11846e7512fd5ea 100644 (file)
--- a/lisp/calc/calc-alg.el
+++ b/lisp/calc/calc-alg.el
@@ -92,30 +92,39 @@
                              (and n (list (prefix-numeric-value n)))))))
 
 ;;; Write out powers (a*b*...)^n as a*b*...*a*b*...
-(defun calcFunc-writeoutpower (expr)
-  (math-normalize (math-map-tree 'math-write-out-power expr)))
+(defun calcFunc-powerexpand (expr)
+  (math-normalize (math-map-tree 'math-powerexpand expr)))
 
-(defun math-write-out-power (expr)
+(defun math-powerexpand (expr)
   (if (eq (car-safe expr) '^)
-      (let ((a (nth 1 expr))
-            (n (nth 2 expr))
-            (prod (nth 1 expr))
-            (i 1))
-        (if (and (integerp n)
-                 (> n 0))
-            (progn
-              (while (< i n)
-                (setq prod (math-mul prod a))
-                (setq i (1+ i)))
-              prod)
-          expr))
+      (let ((n (nth 2 expr)))
+        (cond ((and (integerp n)
+                    (> n 0))
+               (let ((i 1)
+                     (a (nth 1 expr))
+                     (prod (nth 1 expr)))
+                 (while (< i n)
+                   (setq prod (math-mul prod a))
+                   (setq i (1+ i)))
+                 prod))
+              ((and (integerp n)
+                    (< n 0))
+               (let ((i -1)
+                     (a (math-pow (nth 1 expr) -1))
+                     (prod (math-pow (nth 1 expr) -1)))
+                 (while (> i n)
+                   (setq prod (math-mul a prod))
+                   (setq i (1- i)))
+                 prod))
+              (t
+               expr)))
     expr))
 
-(defun calc-writeoutpower ()
+(defun calc-powerexpand ()
   (interactive)
   (calc-slow-wrapper
-   (calc-enter-result 1 "expp"
-                     (calcFunc-writeoutpower (calc-top-n 1)))))
+   (calc-enter-result 1 "pexp"
+                     (calcFunc-powerexpand (calc-top-n 1)))))
 
 (defun calc-collect (&optional var)
   (interactive "sCollect terms involving: ")