]> code.delx.au - gnu-emacs/blobdiff - lisp/calc/calcalg2.el
Update copyright year to 2015
[gnu-emacs] / lisp / calc / calcalg2.el
index 3c59c4bc1058b8141fda29a9ab48eb59385e8430..55064a3552834aeaae22144fd4fa88e952c7deec 100644 (file)
@@ -1,7 +1,6 @@
 ;;; calcalg2.el --- more algebraic functions for Calc
 
-;; Copyright (C) 1990, 1991, 1992, 1993, 2001, 2002, 2003, 2004,
-;;   2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
+;; Copyright (C) 1990-1993, 2001-2015 Free Software Foundation, Inc.
 
 ;; Author: David Gillespie <daveg@synaptics.com>
 ;; Maintainer: Jay Belanger <jay.p.belanger@gmail.com>
 
 (put 'calcFunc-sin\' 'math-derivative-1
      (function (lambda (u) (math-to-radians-2 (math-normalize
-                                              (list 'calcFunc-cos u))))))
+                                              (list 'calcFunc-cos u)) t))))
 
 (put 'calcFunc-cos\' 'math-derivative-1
      (function (lambda (u) (math-neg (math-to-radians-2
                                      (math-normalize
-                                      (list 'calcFunc-sin u)))))))
+                                      (list 'calcFunc-sin u)) t)))))
 
 (put 'calcFunc-tan\' 'math-derivative-1
      (function (lambda (u) (math-to-radians-2
                            (math-sqr
                              (math-normalize
-                              (list 'calcFunc-sec u)))))))
+                              (list 'calcFunc-sec u))) t))))
 
 (put 'calcFunc-sec\' 'math-derivative-1
      (function (lambda (u) (math-to-radians-2
                              (math-normalize
                               (list 'calcFunc-sec u))
                              (math-normalize
-                              (list 'calcFunc-tan u)))))))
+                              (list 'calcFunc-tan u))) t))))
 
 (put 'calcFunc-csc\' 'math-derivative-1
      (function (lambda (u) (math-neg
                               (math-normalize
                                (list 'calcFunc-csc u))
                               (math-normalize
-                               (list 'calcFunc-cot u))))))))
+                               (list 'calcFunc-cot u))) t)))))
 
 (put 'calcFunc-cot\' 'math-derivative-1
      (function (lambda (u) (math-neg
                             (math-to-radians-2
                              (math-sqr
                               (math-normalize
-                               (list 'calcFunc-csc u))))))))
+                               (list 'calcFunc-csc u))) t)))))
 
 (put 'calcFunc-arcsin\' 'math-derivative-1
      (function (lambda (u)
                 (math-from-radians-2
                  (math-div 1 (math-normalize
                               (list 'calcFunc-sqrt
-                                    (math-sub 1 (math-sqr u)))))))))
+                                    (math-sub 1 (math-sqr u))))) t))))
 
 (put 'calcFunc-arccos\' 'math-derivative-1
      (function (lambda (u)
                 (math-from-radians-2
                  (math-div -1 (math-normalize
                                (list 'calcFunc-sqrt
-                                     (math-sub 1 (math-sqr u)))))))))
+                                     (math-sub 1 (math-sqr u))))) t))))
 
 (put 'calcFunc-arctan\' 'math-derivative-1
      (function (lambda (u) (math-from-radians-2
-                           (math-div 1 (math-add 1 (math-sqr u)))))))
+                           (math-div 1 (math-add 1 (math-sqr u))) t))))
 
 (put 'calcFunc-sinh\' 'math-derivative-1
      (function (lambda (u) (math-normalize (list 'calcFunc-cosh u)))))
 (defvar math-integral-limit)
 
 (defmacro math-tracing-integral (&rest parts)
-  (list 'and
-       'trace-buffer
-       (list 'with-current-buffer
-             'trace-buffer
-             '(goto-char (point-max))
-             (list 'and
-                   '(bolp)
-                   '(insert (make-string (- math-integral-limit
-                                            math-integ-level) 32)
-                            (format "%2d " math-integ-depth)
-                            (make-string math-integ-level 32)))
-             ;;(list 'condition-case 'err
-                   (cons 'insert parts)
-               ;;    '(error (insert (prin1-to-string err))))
-             '(sit-for 0))))
+  `(and trace-buffer
+       (with-current-buffer trace-buffer
+         (goto-char (point-max))
+         (and (bolp)
+              (insert (make-string (- math-integral-limit
+                                      math-integ-level) 32)
+                      (format "%2d " math-integ-depth)
+                      (make-string math-integ-level 32)))
+         ;;(condition-case err
+         (insert ,@parts)
+         ;;    (error (insert (prin1-to-string err))))
+         (sit-for 0))))
 
 ;;; The following wrapper caches results and avoids infinite recursion.
 ;;; Each cache entry is: ( A B )          Integral of A is B;
 ;; 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))
              (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
              (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))
   (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))
 
 (provide 'calcalg2)
 
-;; arch-tag: f2932ec8-dd63-418b-a542-11a644b9d4c4
 ;;; calcalg2.el ends here