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

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

;; Copyright (C) 1990, 1991, 1992, 1993, 2001 Free Software Foundation, Inc.

;; Author: David Gillespie <daveg@synaptics.com>
;; Maintainer: Jay Belanger <belanger@truman.edu>

;; This file is part of GNU Emacs.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY.  No author or distributor
;; accepts responsibility to anyone for the consequences of using it
;; or for whether it serves any particular purpose or works at all,
;; unless he says so in writing.  Refer to the GNU Emacs General Public
;; License for full details.

;; Everyone is granted permission to copy, modify and redistribute
;; GNU Emacs, but only under the conditions described in the
;; GNU Emacs General Public License.   A copy of this license is
;; supposed to have been given to you along with GNU Emacs so you
;; can know your rights and responsibilities.  It should be in a
;; file named COPYING.  Among other things, the copyright notice
;; and this notice must be preserved on all copies.

;;; 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-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)
   (mapcar (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
bf77c646	3	;; Copyright (C) 1990, 1991, 1992, 1993, 2001 Free Software Foundation, Inc.
3132f345 CW	4
3132f345 CW	5	;; Author: David Gillespie <daveg@synaptics.com>
32bac5ed	6	;; Maintainer: Jay Belanger <belanger@truman.edu>
136211a9 EZ	7
	8	;; This file is part of GNU Emacs.
	9
	10	;; GNU Emacs is distributed in the hope that it will be useful,
	11	;; but WITHOUT ANY WARRANTY. No author or distributor
	12	;; accepts responsibility to anyone for the consequences of using it
	13	;; or for whether it serves any particular purpose or works at all,
	14	;; unless he says so in writing. Refer to the GNU Emacs General Public
	15	;; License for full details.
	16
	17	;; Everyone is granted permission to copy, modify and redistribute
	18	;; GNU Emacs, but only under the conditions described in the
	19	;; GNU Emacs General Public License. A copy of this license is
	20	;; supposed to have been given to you along with GNU Emacs so you
	21	;; can know your rights and responsibilities. It should be in a
	22	;; file named COPYING. Among other things, the copyright notice
	23	;; and this notice must be preserved on all copies.
	24
3132f345	25	;;; Commentary:
136211a9	26
3132f345	27	;;; Code:
136211a9 EZ	28
136211a9 EZ	29	;; This file is autoloaded from calc-ext.el.
136211a9	30
a2e360d6	31	(require 'calc-ext)
136211a9 EZ	32	(require 'calc-macs)
136211a9 EZ	33
136211a9 EZ	34	(defun calc-num-prefix (n)
	35	"Use the number at the top of stack as the numeric prefix for the next command.
	36	With a prefix, push that prefix as a number onto the stack."
	37	(interactive "P")
	38	(calc-wrapper
	39	(if n
	40	(calc-enter-result 0 "" (prefix-numeric-value n))
	41	(let ((num (calc-top 1)))
	42	(if (math-messy-integerp num)
	43	(setq num (math-trunc num)))
	44	(or (integerp num)
	45	(error "Argument must be a small integer"))
	46	(calc-pop-stack 1)
	47	(setq prefix-arg num)
bf77c646	48	(message "%d-" num))))) ; a (lame) simulation of the real thing...
136211a9 EZ	49
	50
	51	(defun calc-more-recursion-depth (n)
	52	(interactive "P")
	53	(calc-wrapper
	54	(if (calc-is-inverse)
	55	(calc-less-recursion-depth n)
	56	(let ((n (if n (prefix-numeric-value n) 2)))
	57	(if (> n 1)
	58	(setq max-specpdl-size (* max-specpdl-size n)
	59	max-lisp-eval-depth (* max-lisp-eval-depth n))))
bf77c646	60	(message "max-lisp-eval-depth is now %d" max-lisp-eval-depth))))
136211a9 EZ	61
	62	(defun calc-less-recursion-depth (n)
	63	(interactive "P")
	64	(let ((n (if n (prefix-numeric-value n) 2)))
	65	(if (> n 1)
	66	(setq max-specpdl-size
	67	(max (/ max-specpdl-size n) 600)
	68	max-lisp-eval-depth
	69	(max (/ max-lisp-eval-depth n) 200))))
bf77c646	70	(message "max-lisp-eval-depth is now %d" max-lisp-eval-depth))
136211a9 EZ	71
136211a9 EZ	72
3132f345 CW	73	(defvar calc-which-why nil)
3132f345 CW	74	(defvar calc-last-why-command nil)
136211a9 EZ	75	(defun calc-explain-why (why &optional more)
	76	(if (eq (car why) '*)
	77	(setq why (cdr why)))
	78	(let* ((pred (car why))
	79	(arg (nth 1 why))
	80	(msg (cond ((not pred) "Wrong type of argument")
	81	((stringp pred) pred)
	82	((eq pred 'integerp) "Integer expected")
	83	((eq pred 'natnump)
	84	(if (and arg (Math-objvecp arg) (not (Math-integerp arg)))
	85	"Integer expected"
	86	"Nonnegative integer expected"))
	87	((eq pred 'posintp)
	88	(if (and arg (Math-objvecp arg) (not (Math-integerp arg)))
	89	"Integer expected"
	90	"Positive integer expected"))
	91	((eq pred 'fixnump)
	92	(if (and arg (Math-integerp arg))
	93	"Small integer expected"
	94	"Integer expected"))
	95	((eq pred 'fixnatnump)
	96	(if (and arg (Math-natnump arg))
	97	"Small integer expected"
	98	(if (and arg (Math-objvecp arg)
	99	(not (Math-integerp arg)))
	100	"Integer expected"
	101	"Nonnegative integer expected")))
	102	((eq pred 'fixposintp)
	103	(if (and arg (Math-integerp arg) (Math-posp arg))
	104	"Small integer expected"
	105	(if (and arg (Math-objvecp arg)
	106	(not (Math-integerp arg)))
	107	"Integer expected"
	108	"Positive integer expected")))
	109	((eq pred 'posp) "Positive number expected")
	110	((eq pred 'negp) "Negative number expected")
	111	((eq pred 'nonzerop) "Nonzero number expected")
	112	((eq pred 'realp) "Real number expected")
	113	((eq pred 'anglep) "Real number expected")
	114	((eq pred 'hmsp) "HMS form expected")
	115	((eq pred 'datep)
	116	(if (and arg (Math-objectp arg)
	117	(not (Math-realp arg)))
	118	"Real number or date form expected"
	119	"Date form expected"))
	120	((eq pred 'numberp) "Number expected")
	121	((eq pred 'scalarp) "Number expected")
	122	((eq pred 'vectorp) "Vector or matrix expected")
	123	((eq pred 'numvecp) "Number or vector expected")
	124	((eq pred 'matrixp) "Matrix expected")
	125	((eq pred 'square-matrixp)
	126	(if (and arg (math-matrixp arg))
	127	"Square matrix expected"
	128	"Matrix expected"))
	129	((eq pred 'objectp) "Number expected")
	130	((eq pred 'constp) "Constant expected")
	131	((eq pred 'range) "Argument out of range")
	132	(t (format "%s expected" pred))))
	133	(punc ": ")
	134	(calc-can-abbrev-vectors t))
	135	(while (setq why (cdr why))
	136	(and (car why)
	137	(setq msg (concat msg punc (if (stringp (car why))
	138	(car why)
139	(math-format-flat-expr (car why) 0)))
140	punc ", ")))
bf77c646	141	(message "%s%s" msg (if more " [w=more]" ""))))
136211a9 EZ	142
	143	(defun calc-why ()
	144	(interactive)
	145	(if (not (eq this-command last-command))
	146	(if (eq last-command calc-last-why-command)
	147	(setq calc-which-why (cdr calc-why))
	148	(setq calc-which-why calc-why)))
	149	(if calc-which-why
	150	(progn
	151	(calc-explain-why (car calc-which-why) (cdr calc-which-why))
	152	(setq calc-which-why (cdr calc-which-why)))
	153	(if calc-why
	154	(progn
	155	(message "(No further explanations available)")
	156	(setq calc-which-why calc-why))
bf77c646	157	(message "No explanations available"))))
136211a9 EZ	158
	159
	160	(defun calc-version ()
	161	(interactive)
3132f345	162	(message "Calc %s" calc-version))
136211a9	163
32bac5ed JB	164	;; The following caches are declared in other files, but are
	165	;; reset here.
	166	(defvar math-lud-cache) ; calc-mtx.el
	167	(defvar math-log2-cache) ; calc-bin.el
	168	(defvar math-radix-digits-cache) ; calc-bin.el
	169	(defvar math-radix-float-cache-tag) ; calc-bin.el
	170	(defvar math-random-cache) ; calc-comb.el
	171	(defvar math-max-digits-cache) ; calc-bin.el
	172	(defvar math-integral-cache) ; calcalg2.el
	173	(defvar math-units-table) ; calc-units.el
	174	(defvar math-format-date-cache) ; calc-forms.el
	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
	191	math-holidays-cache-tag t)
	192	(mapcar (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
ab5796a9	303	;;; arch-tag: 789332ef-a178-49d3-8fb7-5d7ed7e21f56
bf77c646	304	;;; calc-stuff.el ends here