emacs: lisp/calc/calc-ext.el comparison

comparison lisp/calc/calc-ext.el @ 84886:9e97aa608e01

(calc-init-extensions, calc-reset): Use `mapc' rather than `mapcar'.

author	Juanma Barranquero <lekktu@gmail.com>
date	Wed, 26 Sep 2007 00:05:27 +0000
parents	01eedbaaac05
children	29e75576e47f bdb3fe0ba9fa

comparison

equal deleted inserted replaced

-:69c173eabff4
+:9e97aa608e01
 (define-key calc-mode-map "Z=" 'calc-kbd-report)
 (define-key calc-mode-map "Z#" 'calc-kbd-query)
 (calc-init-prefixes)
-(mapcar (function
+(mapc (function
-	   (lambda (x)
+	 (lambda (x)
-	     (define-key calc-mode-map (format "c%c" x) 'calc-clean-num)
+	  (define-key calc-mode-map (format "c%c" x) 'calc-clean-num)
-	     (define-key calc-mode-map (format "j%c" x) 'calc-select-part)
+	  (define-key calc-mode-map (format "j%c" x) 'calc-select-part)
-	     (define-key calc-mode-map (format "r%c" x) 'calc-recall-quick)
+	  (define-key calc-mode-map (format "r%c" x) 'calc-recall-quick)
-	     (define-key calc-mode-map (format "s%c" x) 'calc-store-quick)
+	  (define-key calc-mode-map (format "s%c" x) 'calc-store-quick)
-	     (define-key calc-mode-map (format "t%c" x) 'calc-store-into-quick)
+	  (define-key calc-mode-map (format "t%c" x) 'calc-store-into-quick)
-	     (define-key calc-mode-map (format "u%c" x) 'calc-quick-units)))
+	  (define-key calc-mode-map (format "u%c" x) 'calc-quick-units)))
-	  "0123456789")
+	"0123456789")
 (let ((i ?A))
 (while (<= i ?z)
 (if (eq (car-safe (aref (nth 1 calc-mode-map) i)) 'keymap)
 	  (aset (nth 1 calc-mode-map) i
 		(cons 'keymap (cons (cons ?\e (aref (nth 1 calc-mode-map) i))
 				    (cdr (aref (nth 1 calc-mode-map) i))))))
 (setq i (1+ i))))
 (setq calc-alg-map (copy-keymap calc-mode-map)
 	calc-alg-esc-map (copy-keymap esc-map))
 (let ((i 32))
 (while (< i 127)
 (or (memq i '(?' ?` ?= ??))
 (define-key calc-alg-map "\e\t" 'calc-roll-up)
 (define-key calc-alg-map "\e\C-m" 'calc-last-args-stub)
 (define-key calc-alg-map "\e\177" 'calc-pop-above)
 ;;;; (Autoloads here)
-(mapcar (function (lambda (x)
+(mapc (function (lambda (x)
 (mapcar (function (lambda (func)
 (autoload func (car x)))) (cdr x))))
 '(
 ("calc-alg" calc-has-rules math-defsimplify
 ("calc-math" calc-arccos calc-arccosh calc-arcsin calc-arcsinh
 calc-arctan calc-arctan2 calc-arctanh calc-conj calc-cos calc-cosh
 calc-cot calc-coth calc-csc calc-csch
 calc-degrees-mode calc-exp calc-expm1 calc-hypot calc-ilog
 calc-imaginary calc-isqrt calc-ln calc-lnp1 calc-log calc-log10
 calc-pi calc-radians-mode calc-sec calc-sech
 calc-sin calc-sincos calc-sinh calc-sqrt
 calc-tan calc-tanh calc-to-degrees calc-to-radians)
 ("calc-mode" calc-alg-simplify-mode calc-algebraic-mode
 calc-always-load-extensions calc-auto-recompute calc-auto-why
 (setq calc-stack nil))
 (setq calc-undo-list nil
 calc-redo-list nil)
 (let (calc-stack calc-user-parse-tables calc-standard-date-formats
 calc-invocation-macro)
-(mapcar (function (lambda (v) (set v nil))) calc-local-var-list)
+(mapc (function (lambda (v) (set v nil))) calc-local-var-list)
 (if (and arg (<= arg 0))
 (calc-mode-var-list-restore-default-values)
 (calc-mode-var-list-restore-saved-values)))
 (calc-set-language nil nil t)
 (calc-mode)
 (eq major-mode 'calc-keypad-mode)
 (eq major-mode 'calc-trail-mode))
 (with-current-buffer calc-main-buffer
 calc-hyperbolic-flag)
 calc-hyperbolic-flag))
 (msg (if hyp-flag
 "Inverse Hyperbolic..."
 "Inverse...")))
 (calc-fancy-prefix 'calc-inverse-flag msg n)))
 (defconst calc-fancy-prefix-map
 (eq major-mode 'calc-keypad-mode)
 (eq major-mode 'calc-trail-mode))
 (with-current-buffer calc-main-buffer
 calc-inverse-flag)
 calc-inverse-flag))
 (msg (if inv-flag
 "Inverse Hyperbolic..."
 "Hyperbolic...")))
 (calc-fancy-prefix 'calc-hyperbolic-flag msg n)))
 (defun calc-hyperbolic-func ()
 		     (char-to-string (upcase key)))))
 	     (if (= (length calc-z-prefix-buf) 0)
 		 (setq calc-z-prefix-buf (concat (if (= flags 1) "SHIFT + " "")
 				   desc))
 	       (if (> (+ (length calc-z-prefix-buf) (length desc)) 58)
 		   (setq calc-z-prefix-msgs
 (cons calc-z-prefix-buf calc-z-prefix-msgs)
 			 calc-z-prefix-buf (concat (if (= flags 1) "SHIFT + " "")
 				     desc))
 		 (setq calc-z-prefix-buf (concat calc-z-prefix-buf ", " desc))))))
 	 (calc-user-function-list (cdr map) flags))))
 	(cache-val (intern (concat (symbol-name name) "-cache")))
 	(last-prec (intern (concat (symbol-name name) "-last-prec")))
 	(last-val (intern (concat (symbol-name name) "-last"))))
 (list 'progn
 ;	  (list 'defvar cache-prec (if init (math-numdigs (nth 1 init)) -100))
 	  (list 'defvar cache-prec
 `(cond
 ((consp ,init) (math-numdigs (nth 1 ,init)))
 (,init
 (nth 1 (math-numdigs (eval ,init))))
 (t
 -100)))
 	  (list 'defvar cache-val
 `(cond
 ((consp ,init) ,init)
 (,init (eval ,init))
 (t ,init)))
 	  (list 'defvar last-prec -100)
 (math-sqrt-float (math-two-pi)))
 (defconst math-approx-sqrt-e
 (math-read-number-simple "1.648721270700128146849")
 "An approximation for sqrt(3).")
 (math-defcache math-sqrt-e math-approx-sqrt-e
 (math-add-float '(float 1 0) (math-exp-minus-1-raw '(float 5 -1))))
 (math-defcache math-e nil
 (math-pow (math-sqrt-e) 2))
 (math-defcache math-phi nil
 (math-mul-float (math-add-float (math-sqrt-raw '(float 5 0)) '(float 1 0))
 		  '(float 5 -1)))
 (defconst math-approx-gamma-const
 (math-read-number-simple
 "0.5772156649015328606065120900824024310421593359399235988057672348848677267776646709369470632917467495")
 "An approximation for gamma.")
 (math-defcache math-gamma-const nil
 math-approx-gamma-const)
 (defun math-half-circle (symb)
 (if (eq calc-angle-mode 'rad)
 (if symb
 (defun math-ident-row-p (row n &optional a)
 (unless a
 (setq a 1))
 (and
 (not (memq nil (mapcar
 (lambda (x) (eq x 0))
 (nthcdr (1+ n) row))))
 (not (memq nil (mapcar
 (lambda (x) (eq x 0))
 (butlast
 (cdr row)
 (- (length row) n)))))
 (eq (elt row n) a)))
 ;;; True if A is any scalar data object.  [P x]
 "Get the mean value of the error form X.
 If X is not an error form, return X."
 (if (eq (car-safe x) 'sdev)
 (nth 1 x)
 x))
 (defun math-get-sdev (x &optional one)
 "Get the standard deviation of the error form X.
 If X is not an error form, return 1."
 (if (eq (car-safe x) 'sdev)
 (nth 2 x)
 	      math-simplify-only (car-safe (cdr-safe math-normalize-a)))
 	nil)
 (and (symbolp (car math-normalize-a))
 	 (or (eq calc-simplify-mode 'none)
 	     (and (eq calc-simplify-mode 'num)
 		  (let ((aptr (setq math-normalize-a
 (cons
 (car math-normalize-a)
 (mapcar 'math-normalize
 (cdr math-normalize-a))))))
 		    (while (and aptr (math-constp (car aptr)))
 		      (setq aptr (cdr aptr)))
 		    aptr)))
 	 (cons (car math-normalize-a)
 (mapcar 'math-normalize (cdr math-normalize-a))))))
 ;;; Normalize a bignum digit list by trimming high-end zeros.  [L l]
 (defun math-norm-bignum (a)
 	(while (not mmt-done)
 	  (while (and (/= math-mt-many 0)
 		      (setq mmt-nextval (funcall math-mt-func mmt-expr))
 		      (not (equal mmt-expr mmt-nextval)))
 	    (setq mmt-expr mmt-nextval
 		  math-mt-many (if (> math-mt-many 0)
 (1- math-mt-many)
 (1+ math-mt-many))))
 	  (if (or (Math-primp mmt-expr)
 		  (<= math-mt-many 0))
 	      (setq mmt-done t)
 	    (setq mmt-nextval (cons (car mmt-expr)
 	  (width 0)
 	  (math-read-big-err-msg nil)
 	  math-read-big-baseline math-read-big-h2
 	  new-pos p)
 (while (setq new-pos (string-match "\n" str pos))
 	(setq math-read-big-lines
 (cons (substring str pos new-pos) math-read-big-lines)
 	      pos (1+ new-pos)))
 (setq math-read-big-lines
 (nreverse (cons (substring str pos) math-read-big-lines))
 	    p math-read-big-lines)
 (while p
 	(setq width (max width (length (car p)))
 	      p (cdr p)))

Mercurial > emacs

comparison lisp/calc/calc-ext.el @ 84886:9e97aa608e01