[bpt/emacs.git] / lisp / calc / calc-stuff.el

;;; calc-stuff.el --- miscellaneous functions for Calc

;; Copyright (C) 1990, 1991, 1992, 1993, 2001, 2002, 2003, 2004,
;;   2005, 2006, 2007, 2008 Free Software Foundation, Inc.

;; Author: David Gillespie <daveg@synaptics.com>
;; Maintainer: Jay Belanger <jay.p.belanger@gmail.com>

;; This file is part of GNU Emacs.

;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;;; Code:

;; This file is autoloaded from calc-ext.el.

(require 'calc-ext)
(require 'calc-macs)

(defun calc-num-prefix (n)
  "Use the number at the top of stack as the numeric prefix for the next command.
With a prefix, push that prefix as a number onto the stack."
  (interactive "P")
  (calc-wrapper
   (if n
       (calc-enter-result 0 "" (prefix-numeric-value n))
     (let ((num (calc-top 1)))
       (if (math-messy-integerp num)
	   (setq num (math-trunc num)))
       (or (integerp num)
	   (error "Argument must be a small integer"))
       (calc-pop-stack 1)
       (setq prefix-arg num)
       (message "%d-" num)))))    ; a (lame) simulation of the real thing...


(defun calc-more-recursion-depth (n)
  (interactive "P")
  (calc-wrapper
   (if (calc-is-inverse)
       (calc-less-recursion-depth n)
     (let ((n (if n (prefix-numeric-value n) 2)))
       (if (> n 1)
	   (setq max-specpdl-size (* max-specpdl-size n)
		 max-lisp-eval-depth (* max-lisp-eval-depth n))))
     (message "max-lisp-eval-depth is now %d" max-lisp-eval-depth))))

(defun calc-less-recursion-depth (n)
  (interactive "P")
  (let ((n (if n (prefix-numeric-value n) 2)))
    (if (> n 1)
	(setq max-specpdl-size
	      (max (/ max-specpdl-size n) 600)
	      max-lisp-eval-depth
	      (max (/ max-lisp-eval-depth n) 200))))
  (message "max-lisp-eval-depth is now %d" max-lisp-eval-depth))


(defvar calc-which-why nil)
(defvar calc-last-why-command nil)
(defun calc-explain-why (why &optional more)
  (if (eq (car why) '*)
      (setq why (cdr why)))
  (let* ((pred (car why))
	 (arg (nth 1 why))
	 (msg (cond ((not pred) "Wrong type of argument")
		    ((stringp pred) pred)
		    ((eq pred 'integerp) "Integer expected")
		    ((eq pred 'natnump)
		     (if (and arg (Math-objvecp arg) (not (Math-integerp arg)))
			 "Integer expected"
		       "Nonnegative integer expected"))
		    ((eq pred 'posintp)
		     (if (and arg (Math-objvecp arg) (not (Math-integerp arg)))
			 "Integer expected"
		       "Positive integer expected"))
		    ((eq pred 'fixnump)
		     (if (and arg (Math-integerp arg))
			 "Small integer expected"
		       "Integer expected"))
		    ((eq pred 'fixnatnump)
		     (if (and arg (Math-natnump arg))
			 "Small integer expected"
		       (if (and arg (Math-objvecp arg)
				(not (Math-integerp arg)))
			   "Integer expected"
			 "Nonnegative integer expected")))
		    ((eq pred 'fixposintp)
		     (if (and arg (Math-integerp arg) (Math-posp arg))
			 "Small integer expected"
		       (if (and arg (Math-objvecp arg)
				(not (Math-integerp arg)))
			   "Integer expected"
			 "Positive integer expected")))
		    ((eq pred 'posp) "Positive number expected")
		    ((eq pred 'negp) "Negative number expected")
		    ((eq pred 'nonzerop) "Nonzero number expected")
		    ((eq pred 'realp) "Real number expected")
		    ((eq pred 'anglep) "Real number expected")
		    ((eq pred 'hmsp) "HMS form expected")
		    ((eq pred 'datep)
		     (if (and arg (Math-objectp arg)
			      (not (Math-realp arg)))
			 "Real number or date form expected"
		       "Date form expected"))
		    ((eq pred 'numberp) "Number expected")
		    ((eq pred 'scalarp) "Number expected")
		    ((eq pred 'vectorp) "Vector or matrix expected")
		    ((eq pred 'numvecp) "Number or vector expected")
		    ((eq pred 'matrixp) "Matrix expected")
		    ((eq pred 'square-matrixp)
		     (if (and arg (math-matrixp arg))
			 "Square matrix expected"
		       "Matrix expected"))
		    ((eq pred 'objectp) "Number expected")
		    ((eq pred 'constp) "Constant expected")
		    ((eq pred 'range) "Argument out of range")
		    (t (format "%s expected" pred))))
	 (punc ": ")
	 (calc-can-abbrev-vectors t))
    (while (setq why (cdr why))
      (and (car why)
	   (setq msg (concat msg punc (if (stringp (car why))
					  (car why)
					(math-format-flat-expr (car why) 0)))
		 punc ", ")))
    (message "%s%s" msg (if more "  [w=more]" ""))))

(defun calc-why ()
  (interactive)
  (if (not (eq this-command last-command))
      (if (eq last-command calc-last-why-command)
	  (setq calc-which-why (cdr calc-why))
	(setq calc-which-why calc-why)))
  (if calc-which-why
      (progn
	(calc-explain-why (car calc-which-why) (cdr calc-which-why))
	(setq calc-which-why (cdr calc-which-why)))
    (if calc-why
	(progn
	  (message "(No further explanations available)")
	  (setq calc-which-why calc-why))
      (message "No explanations available"))))


(defun calc-version ()
  (interactive)
  (message "Calc %s" calc-version))

;; The following caches are declared in other files, but are
;; reset here.
(defvar math-lud-cache) ; calc-mtx.el
(defvar math-log2-cache) ; calc-bin.el
(defvar math-radix-digits-cache) ; calc-bin.el
(defvar math-radix-float-cache-tag) ; calc-bin.el
(defvar math-random-cache) ; calc-comb.el
(defvar math-max-digits-cache) ; calc-bin.el
(defvar math-integral-cache) ; calcalg2.el
(defvar math-units-table) ; calc-units.el
(defvar math-decls-cache-tag) ; calc-arith.el
(defvar math-format-date-cache) ; calc-forms.el
(defvar math-holidays-cache-tag) ; calc-forms.el

(defun calc-flush-caches (&optional inhibit-msg)
  (interactive "P")
  (calc-wrapper
   (setq math-lud-cache nil
	 math-log2-cache nil
	 math-radix-digits-cache nil
	 math-radix-float-cache-tag nil
	 math-random-cache nil
	 math-max-digits-cache nil
	 math-integral-cache nil
	 math-units-table nil
	 math-decls-cache-tag nil
	 math-eval-rules-cache-tag t
	 math-format-date-cache nil
	 math-holidays-cache-tag t)
   (mapc (function (lambda (x) (set x -100))) math-cache-list)
   (unless inhibit-msg
     (message "All internal calculator caches have been reset"))))


;;; Conversions.

(defun calc-clean (n)
  (interactive "P")
  (calc-slow-wrapper
   (calc-with-default-simplification
    (let ((func (if (calc-is-hyperbolic) 'calcFunc-clean 'calcFunc-pclean)))
      (calc-enter-result 1 "cln"
			 (if n
			     (let ((n (prefix-numeric-value n)))
			       (list func
				     (calc-top-n 1)
				     (if (<= n 0)
					 (+ n calc-internal-prec)
				       n)))
			   (list func (calc-top-n 1))))))))

(defun calc-clean-num (num)
  (interactive "P")
  (calc-clean (- (if num
		     (prefix-numeric-value num)
		   (if (and (>= last-command-char ?0)
			    (<= last-command-char ?9))
		       (- last-command-char ?0)
		     (error "Number required"))))))


(defvar math-chopping-small nil)
(defun calcFunc-clean (a &optional prec)   ; [X X S] [Public]
  (if prec
      (cond ((Math-messy-integerp prec)
	     (calcFunc-clean a (math-trunc prec)))
	    ((or (not (integerp prec))
		 (< prec 3))
	     (calc-record-why "*Precision must be an integer 3 or above")
	     (list 'calcFunc-clean a prec))
	    ((not (Math-objvecp a))
	     (list 'calcFunc-clean a prec))
	    (t (let ((calc-internal-prec prec)
		     (math-chopping-small t))
		 (calcFunc-clean (math-normalize a)))))
    (cond ((eq (car-safe a) 'polar)
	   (let ((theta (math-mod (nth 2 a)
				  (if (eq calc-angle-mode 'rad)
				      (math-two-pi)
				    360))))
	     (math-neg
	      (math-neg
	       (math-normalize
		(list 'polar
		      (calcFunc-clean (nth 1 a))
		      (calcFunc-clean theta)))))))
	  ((memq (car-safe a) '(vec date hms))
	   (cons (car a) (mapcar 'calcFunc-clean (cdr a))))
	  ((memq (car-safe a) '(cplx mod sdev intv))
	   (math-normalize (cons (car a) (mapcar 'calcFunc-clean (cdr a)))))
	  ((eq (car-safe a) 'float)
	   (if math-chopping-small
	       (if (or (> (nth 2 a) (- calc-internal-prec))
		       (Math-lessp (- calc-internal-prec) (calcFunc-xpon a)))
		   (if (and (math-num-integerp a)
			    (math-lessp (calcFunc-xpon a) calc-internal-prec))
		       (math-trunc a)
		     a)
		 0)
	     a))
	  ((Math-objectp a) a)
	  ((math-infinitep a) a)
	  (t (list 'calcFunc-clean a)))))

(defun calcFunc-pclean (a &optional prec)
  (math-map-over-constants (function (lambda (x) (calcFunc-clean x prec)))
			   a))

(defun calcFunc-pfloat (a)
  (math-map-over-constants 'math-float a))

(defun calcFunc-pfrac (a &optional tol)
  (math-map-over-constants (function (lambda (x) (calcFunc-frac x tol)))
			   a))

;; The variable math-moc-func is local to math-map-over-constants,
;; but is used by math-map-over-constants-rec, which is called by
;; math-map-over-constants.
(defvar math-moc-func)

(defun math-map-over-constants (math-moc-func expr)
  (math-map-over-constants-rec expr))

(defun math-map-over-constants-rec (expr)
  (cond ((or (Math-primp expr)
	     (memq (car expr) '(intv sdev)))
	 (or (and (Math-objectp expr)
		  (funcall math-moc-func expr))
	     expr))
	((and (memq (car expr) '(^ calcFunc-subscr))
	      (eq math-moc-func 'math-float)
	      (= (length expr) 3)
	      (Math-integerp (nth 2 expr)))
	 (list (car expr)
	       (math-map-over-constants-rec (nth 1 expr))
	       (nth 2 expr)))
	(t (cons (car expr) (mapcar 'math-map-over-constants-rec (cdr expr))))))

(provide 'calc-stuff)

;; arch-tag: 789332ef-a178-49d3-8fb7-5d7ed7e21f56
;;; calc-stuff.el ends here
Commit	Line	Data
3132f345 CW	1	;;; calc-stuff.el --- miscellaneous functions for Calc
3132f345 CW	2
58ba2f8f	3	;; Copyright (C) 1990, 1991, 1992, 1993, 2001, 2002, 2003, 2004,
8b72699e	4	;; 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
3132f345 CW	5
3132f345 CW	6	;; Author: David Gillespie <daveg@synaptics.com>
e8fff8ed	7	;; Maintainer: Jay Belanger <jay.p.belanger@gmail.com>
136211a9 EZ	8
	9	;; This file is part of GNU Emacs.
	10
662c9c64	11	;; GNU Emacs is free software: you can redistribute it and/or modify
7c671b23	12	;; it under the terms of the GNU General Public License as published by
662c9c64 GM	13	;; the Free Software Foundation, either version 3 of the License, or
662c9c64 GM	14	;; (at your option) any later version.
7c671b23	15
136211a9	16	;; GNU Emacs is distributed in the hope that it will be useful,
7c671b23 GM	17	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	;; GNU General Public License for more details.
	20
	21	;; You should have received a copy of the GNU General Public License
662c9c64	22	;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
136211a9	23
3132f345	24	;;; Commentary:
136211a9	25
3132f345	26	;;; Code:
136211a9 EZ	27
136211a9 EZ	28	;; This file is autoloaded from calc-ext.el.
136211a9	29
a2e360d6	30	(require 'calc-ext)
136211a9 EZ	31	(require 'calc-macs)
136211a9 EZ	32
136211a9 EZ	33	(defun calc-num-prefix (n)
	34	"Use the number at the top of stack as the numeric prefix for the next command.
	35	With a prefix, push that prefix as a number onto the stack."
	36	(interactive "P")
	37	(calc-wrapper
	38	(if n
	39	(calc-enter-result 0 "" (prefix-numeric-value n))
	40	(let ((num (calc-top 1)))
	41	(if (math-messy-integerp num)
	42	(setq num (math-trunc num)))
	43	(or (integerp num)
	44	(error "Argument must be a small integer"))
	45	(calc-pop-stack 1)
	46	(setq prefix-arg num)
bf77c646	47	(message "%d-" num))))) ; a (lame) simulation of the real thing...
136211a9 EZ	48
	49
	50	(defun calc-more-recursion-depth (n)
	51	(interactive "P")
	52	(calc-wrapper
	53	(if (calc-is-inverse)
	54	(calc-less-recursion-depth n)
	55	(let ((n (if n (prefix-numeric-value n) 2)))
	56	(if (> n 1)
	57	(setq max-specpdl-size (* max-specpdl-size n)
	58	max-lisp-eval-depth (* max-lisp-eval-depth n))))
bf77c646	59	(message "max-lisp-eval-depth is now %d" max-lisp-eval-depth))))
136211a9 EZ	60
	61	(defun calc-less-recursion-depth (n)
	62	(interactive "P")
	63	(let ((n (if n (prefix-numeric-value n) 2)))
	64	(if (> n 1)
	65	(setq max-specpdl-size
	66	(max (/ max-specpdl-size n) 600)
	67	max-lisp-eval-depth
	68	(max (/ max-lisp-eval-depth n) 200))))
bf77c646	69	(message "max-lisp-eval-depth is now %d" max-lisp-eval-depth))
136211a9 EZ	70
136211a9 EZ	71
3132f345 CW	72	(defvar calc-which-why nil)
3132f345 CW	73	(defvar calc-last-why-command nil)
136211a9 EZ	74	(defun calc-explain-why (why &optional more)
	75	(if (eq (car why) '*)
	76	(setq why (cdr why)))
	77	(let* ((pred (car why))
	78	(arg (nth 1 why))
	79	(msg (cond ((not pred) "Wrong type of argument")
	80	((stringp pred) pred)
	81	((eq pred 'integerp) "Integer expected")
	82	((eq pred 'natnump)
	83	(if (and arg (Math-objvecp arg) (not (Math-integerp arg)))
	84	"Integer expected"
	85	"Nonnegative integer expected"))
	86	((eq pred 'posintp)
	87	(if (and arg (Math-objvecp arg) (not (Math-integerp arg)))
	88	"Integer expected"
	89	"Positive integer expected"))
	90	((eq pred 'fixnump)
	91	(if (and arg (Math-integerp arg))
	92	"Small integer expected"
	93	"Integer expected"))
	94	((eq pred 'fixnatnump)
	95	(if (and arg (Math-natnump arg))
	96	"Small integer expected"
	97	(if (and arg (Math-objvecp arg)
	98	(not (Math-integerp arg)))
	99	"Integer expected"
	100	"Nonnegative integer expected")))
	101	((eq pred 'fixposintp)
	102	(if (and arg (Math-integerp arg) (Math-posp arg))
	103	"Small integer expected"
	104	(if (and arg (Math-objvecp arg)
	105	(not (Math-integerp arg)))
	106	"Integer expected"
	107	"Positive integer expected")))
	108	((eq pred 'posp) "Positive number expected")
	109	((eq pred 'negp) "Negative number expected")
	110	((eq pred 'nonzerop) "Nonzero number expected")
	111	((eq pred 'realp) "Real number expected")
	112	((eq pred 'anglep) "Real number expected")
	113	((eq pred 'hmsp) "HMS form expected")
	114	((eq pred 'datep)
	115	(if (and arg (Math-objectp arg)
	116	(not (Math-realp arg)))
	117	"Real number or date form expected"
	118	"Date form expected"))
	119	((eq pred 'numberp) "Number expected")
	120	((eq pred 'scalarp) "Number expected")
	121	((eq pred 'vectorp) "Vector or matrix expected")
	122	((eq pred 'numvecp) "Number or vector expected")
	123	((eq pred 'matrixp) "Matrix expected")
	124	((eq pred 'square-matrixp)
	125	(if (and arg (math-matrixp arg))
	126	"Square matrix expected"
	127	"Matrix expected"))
	128	((eq pred 'objectp) "Number expected")
	129	((eq pred 'constp) "Constant expected")
	130	((eq pred 'range) "Argument out of range")
	131	(t (format "%s expected" pred))))
	132	(punc ": ")
	133	(calc-can-abbrev-vectors t))
	134	(while (setq why (cdr why))
	135	(and (car why)
	136	(setq msg (concat msg punc (if (stringp (car why))
	137	(car why)
138	(math-format-flat-expr (car why) 0)))
139	punc ", ")))
bf77c646	140	(message "%s%s" msg (if more " [w=more]" ""))))
136211a9 EZ	141
	142	(defun calc-why ()
	143	(interactive)
	144	(if (not (eq this-command last-command))
	145	(if (eq last-command calc-last-why-command)
	146	(setq calc-which-why (cdr calc-why))
	147	(setq calc-which-why calc-why)))
	148	(if calc-which-why
	149	(progn
	150	(calc-explain-why (car calc-which-why) (cdr calc-which-why))
	151	(setq calc-which-why (cdr calc-which-why)))
	152	(if calc-why
	153	(progn
	154	(message "(No further explanations available)")
	155	(setq calc-which-why calc-why))
bf77c646	156	(message "No explanations available"))))
136211a9 EZ	157
	158
	159	(defun calc-version ()
	160	(interactive)
3132f345	161	(message "Calc %s" calc-version))
136211a9	162
32bac5ed JB	163	;; The following caches are declared in other files, but are
	164	;; reset here.
	165	(defvar math-lud-cache) ; calc-mtx.el
	166	(defvar math-log2-cache) ; calc-bin.el
	167	(defvar math-radix-digits-cache) ; calc-bin.el
	168	(defvar math-radix-float-cache-tag) ; calc-bin.el
	169	(defvar math-random-cache) ; calc-comb.el
	170	(defvar math-max-digits-cache) ; calc-bin.el
	171	(defvar math-integral-cache) ; calcalg2.el
	172	(defvar math-units-table) ; calc-units.el
e206ee4c	173	(defvar math-decls-cache-tag) ; calc-arith.el
32bac5ed JB	174	(defvar math-format-date-cache) ; calc-forms.el
32bac5ed JB	175	(defvar math-holidays-cache-tag) ; calc-forms.el
136211a9	176
9b08ce78 CW	177	(defun calc-flush-caches (&optional inhibit-msg)
9b08ce78 CW	178	(interactive "P")
136211a9 EZ	179	(calc-wrapper
	180	(setq math-lud-cache nil
	181	math-log2-cache nil
	182	math-radix-digits-cache nil
	183	math-radix-float-cache-tag nil
	184	math-random-cache nil
	185	math-max-digits-cache nil
136211a9 EZ	186	math-integral-cache nil
	187	math-units-table nil
	188	math-decls-cache-tag nil
	189	math-eval-rules-cache-tag t
136211a9 EZ	190	math-format-date-cache nil
136211a9 EZ	191	math-holidays-cache-tag t)
4d2a9fe4	192	(mapc (function (lambda (x) (set x -100))) math-cache-list)
9b08ce78 CW	193	(unless inhibit-msg
9b08ce78 CW	194	(message "All internal calculator caches have been reset"))))
136211a9 EZ	195
	196
	197	;;; Conversions.
	198
	199	(defun calc-clean (n)
	200	(interactive "P")
	201	(calc-slow-wrapper
	202	(calc-with-default-simplification
	203	(let ((func (if (calc-is-hyperbolic) 'calcFunc-clean 'calcFunc-pclean)))
	204	(calc-enter-result 1 "cln"
	205	(if n
	206	(let ((n (prefix-numeric-value n)))
	207	(list func
	208	(calc-top-n 1)
	209	(if (<= n 0)
	210	(+ n calc-internal-prec)
	211	n)))
bf77c646	212	(list func (calc-top-n 1))))))))
136211a9 EZ	213
	214	(defun calc-clean-num (num)
	215	(interactive "P")
	216	(calc-clean (- (if num
a1506d29	217	(prefix-numeric-value num)
136211a9 EZ	218	(if (and (>= last-command-char ?0)
	219	(<= last-command-char ?9))
	220	(- last-command-char ?0)
bf77c646	221	(error "Number required"))))))
136211a9 EZ	222
136211a9 EZ	223
3132f345	224	(defvar math-chopping-small nil)
136211a9 EZ	225	(defun calcFunc-clean (a &optional prec) ; [X X S] [Public]
	226	(if prec
	227	(cond ((Math-messy-integerp prec)
	228	(calcFunc-clean a (math-trunc prec)))
	229	((or (not (integerp prec))
	230	(< prec 3))
	231	(calc-record-why "*Precision must be an integer 3 or above")
	232	(list 'calcFunc-clean a prec))
	233	((not (Math-objvecp a))
	234	(list 'calcFunc-clean a prec))
	235	(t (let ((calc-internal-prec prec)
	236	(math-chopping-small t))
	237	(calcFunc-clean (math-normalize a)))))
	238	(cond ((eq (car-safe a) 'polar)
	239	(let ((theta (math-mod (nth 2 a)
	240	(if (eq calc-angle-mode 'rad)
	241	(math-two-pi)
	242	360))))
	243	(math-neg
	244	(math-neg
	245	(math-normalize
	246	(list 'polar
	247	(calcFunc-clean (nth 1 a))
	248	(calcFunc-clean theta)))))))
	249	((memq (car-safe a) '(vec date hms))
	250	(cons (car a) (mapcar 'calcFunc-clean (cdr a))))
	251	((memq (car-safe a) '(cplx mod sdev intv))
	252	(math-normalize (cons (car a) (mapcar 'calcFunc-clean (cdr a)))))
	253	((eq (car-safe a) 'float)
	254	(if math-chopping-small
	255	(if (or (> (nth 2 a) (- calc-internal-prec))
	256	(Math-lessp (- calc-internal-prec) (calcFunc-xpon a)))
	257	(if (and (math-num-integerp a)
	258	(math-lessp (calcFunc-xpon a) calc-internal-prec))
	259	(math-trunc a)
	260	a)
	261	0)
	262	a))
	263	((Math-objectp a) a)
	264	((math-infinitep a) a)
bf77c646	265	(t (list 'calcFunc-clean a)))))
136211a9 EZ	266
	267	(defun calcFunc-pclean (a &optional prec)
	268	(math-map-over-constants (function (lambda (x) (calcFunc-clean x prec)))
bf77c646	269	a))
136211a9 EZ	270
136211a9 EZ	271	(defun calcFunc-pfloat (a)
bf77c646	272	(math-map-over-constants 'math-float a))
136211a9 EZ	273
	274	(defun calcFunc-pfrac (a &optional tol)
	275	(math-map-over-constants (function (lambda (x) (calcFunc-frac x tol)))
bf77c646	276	a))
136211a9	277
32bac5ed JB	278	;; The variable math-moc-func is local to math-map-over-constants,
	279	;; but is used by math-map-over-constants-rec, which is called by
	280	;; math-map-over-constants.
	281	(defvar math-moc-func)
	282
	283	(defun math-map-over-constants (math-moc-func expr)
bf77c646	284	(math-map-over-constants-rec expr))
136211a9 EZ	285
	286	(defun math-map-over-constants-rec (expr)
	287	(cond ((or (Math-primp expr)
	288	(memq (car expr) '(intv sdev)))
	289	(or (and (Math-objectp expr)
32bac5ed	290	(funcall math-moc-func expr))
136211a9 EZ	291	expr))
136211a9 EZ	292	((and (memq (car expr) '(^ calcFunc-subscr))
32bac5ed	293	(eq math-moc-func 'math-float)
136211a9 EZ	294	(= (length expr) 3)
	295	(Math-integerp (nth 2 expr)))
	296	(list (car expr)
	297	(math-map-over-constants-rec (nth 1 expr))
	298	(nth 2 expr)))
bf77c646	299	(t (cons (car expr) (mapcar 'math-map-over-constants-rec (cdr expr))))))
136211a9	300
a2e360d6 JB	301	(provide 'calc-stuff)
a2e360d6 JB	302
cbee283d	303	;; arch-tag: 789332ef-a178-49d3-8fb7-5d7ed7e21f56
bf77c646	304	;;; calc-stuff.el ends here