]> code.delx.au - gnu-emacs/blobdiff - lisp/calc/calcalg2.el
Merge from emacs-24; up to 2012-12-15T12:19:04Z!juri@jurta.org
[gnu-emacs] / lisp / calc / calcalg2.el
index 2b45ce1b2f0bcdea8520ec46f4d47becc76f3ff3..58a82bcf14381819bbf0a9b3b3647061fe6eb90d 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 Free Software Foundation, Inc.
+;; Copyright (C) 1990-1993, 2001-2013 Free Software Foundation, Inc.
 
 ;; Author: David Gillespie <daveg@synaptics.com>
 ;; Maintainer: Jay Belanger <jay.p.belanger@gmail.com>
 (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