]> code.delx.au - gnu-emacs/blobdiff - lisp/calc/calcalg2.el
(calc-get-operator-history): New variable.
[gnu-emacs] / lisp / calc / calcalg2.el
index 18b6c1328d7b31403437fc4deb07dbd4ca6a10f6..f71e58e223a67239f9d4ac67679a08b0022cb3b2 100644 (file)
@@ -1,6 +1,7 @@
 ;;; calcalg2.el --- more algebraic functions for Calc
 
-;; Copyright (C) 1990, 1991, 1992, 1993, 2001 Free Software Foundation, Inc.
+;; Copyright (C) 1990, 1991, 1992, 1993, 2001, 2002, 2003, 2004,
+;;   2005, 2006 Free Software Foundation, Inc.
 
 ;; Author: David Gillespie <daveg@synaptics.com>
 ;; Maintainer: Jay Belanger <belanger@truman.edu>
        (setq expr (list func expr var)))
      (calc-enter-result n "derv" expr))))
 
-(defun calc-integral (var)
-  (interactive "sIntegration variable: ")
-  (calc-slow-wrapper
-   (if (or (equal var "") (equal var "$"))
-       (calc-enter-result 2 "intg" (list 'calcFunc-integ
-                                        (calc-top-n 2)
-                                        (calc-top-n 1)))
-     (let ((var (math-read-expr var)))
-       (if (eq (car-safe var) 'error)
-          (error "Bad format in expression: %s" (nth 1 var)))
-       (calc-enter-result 1 "intg" (list 'calcFunc-integ
-                                        (calc-top-n 1)
-                                        var))))))
+(defun calc-integral (var &optional arg)
+  (interactive "sIntegration variable: \nP")
+  (if arg
+      (calc-tabular-command 'calcFunc-integ "Integration" "intg" nil var nil nil)
+    (calc-slow-wrapper
+     (if (or (equal var "") (equal var "$"))
+         (calc-enter-result 2 "intg" (list 'calcFunc-integ
+                                           (calc-top-n 2)
+                                           (calc-top-n 1)))
+       (let ((var (math-read-expr var)))
+         (if (eq (car-safe var) 'error)
+             (error "Bad format in expression: %s" (nth 1 var)))
+         (calc-enter-result 1 "intg" (list 'calcFunc-integ
+                                           (calc-top-n 1)
+                                           var)))))))
 
 (defun calc-num-integral (&optional varname lowname highname)
   (interactive "sIntegration variable: ")
                                           (and step (list step)))))))
 
 (defun calc-solve-for (var)
-  (interactive "sVariable to solve for: ")
+  (interactive "sVariable(s) to solve for: ")
   (calc-slow-wrapper
    (let ((func (if (calc-is-inverse)
                   (if (calc-is-hyperbolic) 'calcFunc-ffinv 'calcFunc-finv)
 (defvar math-deriv-var)
 (defvar math-deriv-total)
 (defvar math-deriv-symb)
+(defvar math-decls-cache)
+(defvar math-decls-all)
 
 (defun math-derivative (expr)
   (cond ((equal expr math-deriv-var)
 
 (put 'calcFunc-tan\' 'math-derivative-1
      (function (lambda (u) (math-to-radians-2
-                           (math-div 1 (math-sqr
-                                        (math-normalize
-                                         (list 'calcFunc-cos u))))))))
+                           (math-sqr
+                             (math-normalize
+                              (list 'calcFunc-sec u)))))))
+
+(put 'calcFunc-sec\' 'math-derivative-1
+     (function (lambda (u) (math-to-radians-2 
+                            (math-mul
+                             (math-normalize
+                              (list 'calcFunc-sec u))
+                             (math-normalize
+                              (list 'calcFunc-tan u)))))))
+
+(put 'calcFunc-csc\' 'math-derivative-1
+     (function (lambda (u) (math-neg 
+                            (math-to-radians-2
+                             (math-mul
+                              (math-normalize
+                               (list 'calcFunc-csc u))
+                              (math-normalize
+                               (list 'calcFunc-cot u))))))))
+
+(put 'calcFunc-cot\' 'math-derivative-1
+     (function (lambda (u) (math-neg
+                            (math-to-radians-2
+                             (math-sqr
+                              (math-normalize
+                               (list 'calcFunc-csc u))))))))
 
 (put 'calcFunc-arcsin\' 'math-derivative-1
      (function (lambda (u)
      (function (lambda (u) (math-normalize (list 'calcFunc-sinh u)))))
 
 (put 'calcFunc-tanh\' 'math-derivative-1
-     (function (lambda (u) (math-div 1 (math-sqr
-                                       (math-normalize
-                                        (list 'calcFunc-cosh u)))))))
+     (function (lambda (u) (math-sqr
+                            (math-normalize
+                             (list 'calcFunc-sech u))))))
+
+(put 'calcFunc-sech\' 'math-derivative-1
+     (function (lambda (u) (math-neg
+                            (math-mul
+                             (math-normalize (list 'calcFunc-sech u))
+                             (math-normalize (list 'calcFunc-tanh u)))))))
+
+(put 'calcFunc-csch\' 'math-derivative-1
+     (function (lambda (u) (math-neg
+                            (math-mul
+                             (math-normalize (list 'calcFunc-csch u))
+                             (math-normalize (list 'calcFunc-coth u)))))))
+
+(put 'calcFunc-coth\' 'math-derivative-1
+     (function (lambda (u) (math-neg
+                            (math-sqr
+                             (math-normalize
+                              (list 'calcFunc-csch u)))))))
 
 (put 'calcFunc-arcsinh\' 'math-derivative-1
      (function (lambda (u)
               (while (and p
                           (memq (car (car p)) '(calcFunc-sin
                                                 calcFunc-cos
-                                                calcFunc-tan))
+                                                calcFunc-tan
+                                                 calcFunc-sec
+                                                 calcFunc-csc
+                                                 calcFunc-cot))
                           (equal (nth 1 (car p)) math-integ-var))
                 (setq p (cdr p)))
               (null p))
                           (memq (car (car p)) '(calcFunc-sinh
                                                 calcFunc-cosh
                                                 calcFunc-tanh
+                                                 calcFunc-sech
+                                                 calcFunc-csch
+                                                 calcFunc-coth
                                                 calcFunc-exp))
                           (equal (nth 1 (car p)) math-integ-var))
                 (setq p (cdr p)))
                        (calcFunc-expand temp)
                      (setq v (list 'var 'PARTS math-cur-record)
                            temp (let (calc-next-why)
-                                  (math-solve-for (math-sub v temp) 0 v nil)))
-                     (and temp (not (integerp temp))
-                          (math-simplify-extended temp)))))
+                                   (math-simplify-extended
+                                    (math-solve-for (math-sub v temp) 0 v nil)))
+                            temp (if (and (eq (car-safe temp) '/) 
+                                          (math-zerop (nth 2 temp))) 
+                                     nil temp)))))
           (setcar (cdr math-cur-record) 'busy)))))
 
 ;;; This tries two different formulations, hoping the algebraic simplifier
 
 (math-defintegral calcFunc-tan
   (and (equal u math-integ-var)
-       (math-neg (math-from-radians-2
-                 (list 'calcFunc-ln (list 'calcFunc-cos u))))))
+       (math-from-radians-2
+        (list 'calcFunc-ln (list 'calcFunc-sec u)))))
+
+(math-defintegral calcFunc-sec
+  (and (equal u math-integ-var)
+       (math-from-radians-2
+        (list 'calcFunc-ln 
+              (math-add
+               (list 'calcFunc-sec u)
+               (list 'calcFunc-tan u))))))
+
+(math-defintegral calcFunc-csc
+  (and (equal u math-integ-var)
+       (math-from-radians-2
+        (list 'calcFunc-ln 
+              (math-sub
+               (list 'calcFunc-csc u)
+               (list 'calcFunc-cot u))))))
+
+(math-defintegral calcFunc-cot
+  (and (equal u math-integ-var)
+       (math-from-radians-2
+        (list 'calcFunc-ln (list 'calcFunc-sin u)))))
 
 (math-defintegral calcFunc-arcsin
   (and (equal u math-integ-var)
   (and (equal u math-integ-var)
        (list 'calcFunc-ln (list 'calcFunc-cosh u))))
 
+(math-defintegral calcFunc-sech
+  (and (equal u math-integ-var)
+       (list 'calcFunc-arctan (list 'calcFunc-sinh u))))
+
+(math-defintegral calcFunc-csch
+  (and (equal u math-integ-var)
+       (list 'calcFunc-ln (list 'calcFunc-tanh (math-div u 2)))))
+
+(math-defintegral calcFunc-coth
+  (and (equal u math-integ-var)
+       (list 'calcFunc-ln (list 'calcFunc-sinh u))))
+
 (math-defintegral calcFunc-arcsinh
   (and (equal u math-integ-var)
        (math-sub (math-mul u (list 'calcFunc-arcsinh u))
                      n (1+ n)
                      t1 (cdr t1)))
              (setq n (math-build-polynomial-expr poly high))
-             (if (memq low '(0 1))
+             (if (= low 1)
                  n
                (math-sub n (math-build-polynomial-expr poly
                                                        (math-sub low 1))))))