calc-2.02c/ 40755 22403 13 0 5547406711 10732 5ustar davegusercalc-2.02c/README100644 22403 13 14346 5547406460 11740 0ustar daveguser This directory contains version 2.02c of Calc, an advanced desk calculator for GNU Emacs. "Calc" Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc. Written and maintained by: Dave Gillespie c/o Synaptics, Inc. 2698 Orchard Parkway San Jose CA 95134 daveg@synaptics.com, uunet!synaptx!daveg From the introduction to the manual: "Calc" is an advanced calculator and mathematical tool that runs as part of the GNU Emacs environment. Very roughly based on the HP-28/48 series of calculators, its many features include: * Choice of algebraic or RPN (stack-based) entry of calculations. * Arbitrary precision integers and floating-point numbers. * Arithmetic on rational numbers, complex numbers (rectangular and polar), error forms with standard deviations, open and closed intervals, vectors and matrices, dates and times, infinities, sets, quantities with units, and algebraic formulas. * Mathematical operations such as logarithms and trigonometric functions. * Programmer's features (bitwise operations, non-decimal numbers). * Financial functions such as future value and internal rate of return. * Number theoretical features such as prime factorization and arithmetic modulo M for any M. * Algebraic manipulation features, including symbolic calculus. * Moving data to and from regular editing buffers. * "Embedded mode" for manipulating Calc formulas and data directly inside any editing buffer. * Graphics using GNUPLOT, a versatile (and free) plotting program. * Easy programming using keyboard macros, algebraic formulas, algebraic rewrite rules, or extended Emacs Lisp. To install Calc: 1. Type "uncompress calc-2.02.tar.Z" 2. Type "tar xvf calc-2.02.tar" 1,2. Alternatively: "zcat calc-2.02.tar.Z | tar xvf -" 3. Note that the Calc tar file now creates a "calc-2.02" subdirectory of the current directory in which to place its files. 4. Follow the instructions in the file "INSTALL". Calc is written entirely in Emacs Lisp, for maximum portability. You do not need to recompile Emacs to install and use Calc. You will need about six megabytes of disk space to install Calc and its Info documentation. See the file INSTALL for installation instructions. The instructions may seem long, but on typical systems you will only need to follow the steps shown in the first section. Don't even try to run Calc in uncompiled (.el) form! It's far too slow. I am anxious to hear about your experiences using Calc. Send mail to "daveg@synaptics.com". A bug report is most useful if you include the exact input and output that occurred, any modes in effect (such as the current precision), and so on. If you find Calc is difficult to operate in any way, or if you have other suggestions, don't hesitate to let me know. If you find errors (including simple typos) in the manual, let me know. Even if you find no bugs at all I would love to hear your opinions. The latest Calc tar files and patches are always available for anonymous FTP on prep.ai.mit.edu. Thanks, -- Dave Summary of changes to "Calc" ------- -- ------- -- ---- Version 2.02c: * Patch to port Calc to Lucid Emacs 19; still works with GNU 18 and GNU 19. * Fixed a bug that broke `C-x C-c' after Calc graphics had been used. Version 2.02b: * Minor patch to port Calc to GNU Emacs 19. Will be superseded by Calc 3.00. Version 2.02: * Revamped the manual a bit; rearranged some sections. * Added marginal notes for Key/Function Index refs in printed manual. * Changed `M-# r' to deal more gracefully with blank lines. * Made reductions like `V R +' and `M-# :' considerably faster. * Improved parsing and display of cases like "[a + b]". * Added `t +' and `t -' for doing business date arithmetic. * Added "syntax tables," the opposite of compositions. * Added another Rewrites Tutorial exercise. * Added the "vmatches" function. * Added the `Modes' variable and `m g' command. * Improved `u s' to cancel, e.g., "11 mph hr / yd" to get a number. * Added "quick units" commands "u 0" through "u 9". * Moved `M-%' to calc.el to avoid autoloading problems. * Added `M-=' during algebraic entry, acts like `RET ='. * Made `LFD' prevent evaluation when finishing a calc-edit command. * Changed calc-store commands to use `t .' mode for trail display. * Improved integrator to understand forms involving "erf". * Fixed parser to make sense of "[1....1e2]" input. * Fixed FORTRAN parser to treat a(i,j) as a_i_j if a is declared matrix. * Got rid of some version number stamps to reduce size of patches. * Fixed a bug in defmath treating "<=" and ">=" predicates. * Fixed a bug in which Calc crashed multiplying two date forms. * Fixed a bug in line breaker that crashed for large, nested formulas. * Fixed a bug using ` to edit string("foo"). * Fixed a bug where `M-# y' in Big mode copied stack level number. * Fixed a bug where `g O' used wrong default directory, no completion. * Fixed a bug where "foo_bar(i)" parsed in C mode but showed as foo#bar. * Fixed several bugs where large calculations got "computation too long." Version 2.01: * Added percentage commands `M-%', `b %', and `c %'. * Changed Big mode to force radix-10 in superscripts. * Improved display of fractions in various language modes. * Changed `a n' to work properly with equations and inequalities. * The problem with cross references to Index nodes in TeX has been fixed. * Fixed a bug where recursive esc-maps make calc-ext/-aent unloadable. * Fixed a bug in `M-# k', then `OFF' right away, with fresh Emacs. * Fixed a bug in which "S_i_j" was formatted wrong after `j s'. * Fixed a bug in which `h k u c' positioned cursor on wrong line. * Fixed a bug where `z ?' crashed if `z %' was defined. * Fixed a bug in `j O' (calc-select-once-maybe). * Fixed "make private" not to ask "Delete excess versions" and crash. Version 2.00: * First complete posting of Calc since 1.01. * Most parts of Calc have seen changes since version 1.07. See section "New for Calc 2.00" in the manual for a summary. In the FTP version of the Calc distribution, the file README.prev contains a detailed change history from 1.00 up to 2.00. calc-2.02c/macedit.el100644 22403 13 54060 5402631037 12773 0ustar daveguser;; Keyboard macro editor for GNU Emacs. Version 1.05. ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; Installation: ;; (autoload 'edit-kbd-macro "macedit" "Edit a named keyboard macro" t) ;; (autoload 'edit-last-kbd-macro "macedit" "Edit a keyboard macro" t) ;; (autoload 'read-kbd-macro "macedit" "Parse region as keyboard macro" t) ;; To use, type `M-x edit-last-kbd-macro' to edit the most recently ;; defined keyboard macro. If you have used `M-x name-last-kbd-macro' ;; to give a keyboard macro a name, type `M-x edit-kbd-macro' to edit ;; the macro by name. When you are done editing, type `C-c C-c' to ;; record your changes back into the original keyboard macro. ;;; The user-level commands for editing macros. ;;;###autoload (defun edit-last-kbd-macro (&optional prefix buffer hook) "Edit the most recently defined keyboard macro." (interactive "P") (MacEdit-edit-macro last-kbd-macro (function (lambda (x arg) (setq last-kbd-macro x))) prefix buffer hook) ) ;;;###autoload (defun edit-kbd-macro (cmd &optional prefix buffer hook in-hook out-hook) "Edit a keyboard macro which has been assigned a name by name-last-kbd-macro. \(See also edit-last-kbd-macro.)" (interactive "CCommand name: \nP") (and cmd (MacEdit-edit-macro (if in-hook (funcall in-hook cmd) (symbol-function cmd)) (or out-hook (list 'lambda '(x arg) (list 'fset (list 'quote cmd) 'x))) prefix buffer hook cmd)) ) ;;;###autoload (defun read-kbd-macro (start &optional end) "Read the region as a keyboard macro definition. The region is interpreted as spelled-out keystrokes, e.g., `M-x abc RET'. The resulting macro is installed as the \"current\" keyboard macro. Symbols: RET, SPC, TAB, DEL, LFD, NUL; C-key; M-key. (Must be uppercase.) REM marks the rest of a line as a comment. Whitespace is ignored; other characters are copied into the macro." (interactive "r") (if (stringp start) (setq last-kbd-macro (MacEdit-parse-keys start)) (setq last-kbd-macro (MacEdit-parse-keys (buffer-substring start end))) (if (and (string-match "\\`\C-x(" last-kbd-macro) (string-match "\C-x)\\'" last-kbd-macro)) (setq last-kbd-macro (substring last-kbd-macro 2 -2)))) ) ;;; Formatting a keyboard macro as human-readable text. (defun MacEdit-print-macro (macro-str local-map) (let ((save-map (current-local-map)) (print-escape-newlines t) key-symbol key-str key-last prefix-arg this-prefix) (unwind-protect (progn (use-local-map local-map) (while (MacEdit-peek-char) (MacEdit-read-key) (setq this-prefix prefix-arg) (or (memq key-symbol '(digit-argument negative-argument universal-argument)) (null prefix-arg) (progn (cond ((consp prefix-arg) (insert (format "prefix-arg (%d)\n" (car prefix-arg)))) ((eq prefix-arg '-) (insert "prefix-arg -\n")) ((numberp prefix-arg) (insert (format "prefix-arg %d\n" prefix-arg)))) (setq prefix-arg nil))) (cond ((null key-symbol) (insert "type \"") (MacEdit-insert-string macro-str) (insert "\"\n") (setq macro-str "")) ((stringp key-symbol) ; key defined by another kbd macro (insert "type \"") (MacEdit-insert-string key-symbol) (insert "\"\n")) ((eq key-symbol 'digit-argument) (MacEdit-prefix-arg key-last nil prefix-arg)) ((eq key-symbol 'negative-argument) (MacEdit-prefix-arg ?- nil prefix-arg)) ((eq key-symbol 'universal-argument) (let* ((c-u 4) (argstartchar key-last) (char (MacEdit-read-char))) (while (= char argstartchar) (setq c-u (* 4 c-u) char (MacEdit-read-char))) (MacEdit-prefix-arg char c-u nil))) ((eq key-symbol 'self-insert-command) (insert "insert ") (if (and (>= key-last 32) (<= key-last 126)) (let ((str "")) (while (or (and (eq key-symbol 'self-insert-command) (< (length str) 60) (>= key-last 32) (<= key-last 126)) (and (memq key-symbol '(backward-delete-char delete-backward-char backward-delete-char-untabify)) (> (length str) 0))) (if (eq key-symbol 'self-insert-command) (setq str (concat str (char-to-string key-last))) (setq str (substring str 0 -1))) (MacEdit-read-key)) (insert "\"" str "\"\n") (MacEdit-unread-chars key-str)) (insert "\"") (MacEdit-insert-string (char-to-string key-last)) (insert "\"\n"))) ((and (eq key-symbol 'quoted-insert) (MacEdit-peek-char)) (insert "quoted-insert\n") (let ((ch (MacEdit-read-char)) ch2) (if (and (>= ch ?0) (<= ch ?7)) (progn (setq ch (- ch ?0) ch2 (MacEdit-read-char)) (if ch2 (if (and (>= ch2 ?0) (<= ch2 ?7)) (progn (setq ch (+ (* ch 8) (- ch2 ?0)) ch2 (MacEdit-read-char)) (if ch2 (if (and (>= ch2 ?0) (<= ch2 ?7)) (setq ch (+ (* ch 8) (- ch2 ?0))) (MacEdit-unread-chars ch2)))) (MacEdit-unread-chars ch2))))) (if (or (and (>= ch ?0) (<= ch ?7)) (< ch 32) (> ch 126)) (insert (format "type \"\\%03o\"\n" ch)) (insert "type \"" (char-to-string ch) "\"\n")))) ((memq key-symbol '(isearch-forward isearch-backward isearch-forward-regexp isearch-backward-regexp)) (insert (symbol-name key-symbol) "\n") (MacEdit-isearch-argument)) ((eq key-symbol 'execute-extended-command) (MacEdit-read-argument obarray 'commandp)) (t (let ((cust (get key-symbol 'MacEdit-print))) (if cust (funcall cust) (insert (symbol-name key-symbol)) (indent-to 30) (insert " # ") (MacEdit-insert-string key-str) (insert "\n") (let ((int (MacEdit-get-interactive key-symbol))) (if (string-match "\\`\\*" int) (setq int (substring int 1))) (while (> (length int) 0) (cond ((= (aref int 0) ?a) (MacEdit-read-argument obarray nil)) ((memq (aref int 0) '(?b ?B ?D ?f ?F ?n ?s ?S ?x ?X)) (MacEdit-read-argument)) ((and (= (aref int 0) ?c) (MacEdit-peek-char)) (insert "type \"") (MacEdit-insert-string (char-to-string (MacEdit-read-char))) (insert "\"\n")) ((= (aref int 0) ?C) (MacEdit-read-argument obarray 'commandp)) ((= (aref int 0) ?k) (MacEdit-read-key) (if key-symbol (progn (insert "type \"") (MacEdit-insert-string key-str) (insert "\"\n")) (MacEdit-unread-chars key-str))) ((= (aref int 0) ?N) (or this-prefix (MacEdit-read-argument))) ((= (aref int 0) ?v) (MacEdit-read-argument obarray 'user-variable-p))) (let ((nl (string-match "\n" int))) (setq int (if nl (substring int (1+ nl)) ""))))))))))) (use-local-map save-map))) ) (defun MacEdit-prefix-arg (char c-u value) (let ((sign 1)) (if (and (numberp value) (< value 0)) (setq sign -1 value (- value))) (if (eq value '-) (setq sign -1 value nil)) (while (and char (= ?- char)) (setq sign (- sign) c-u nil) (setq char (MacEdit-read-char))) (while (and char (>= char ?0) (<= char ?9)) (setq value (+ (* (if (numberp value) value 0) 10) (- char ?0)) c-u nil) (setq char (MacEdit-read-char))) (setq prefix-arg (cond (c-u (list c-u)) ((numberp value) (* value sign)) ((= sign -1) '-))) (MacEdit-unread-chars char)) ) (defun MacEdit-insert-string (str) (let ((i 0) j ch) (while (< i (length str)) (if (and (> (setq ch (aref str i)) 127) (< ch 160)) (progn (setq ch (- ch 128)) (insert "\\M-"))) (if (< ch 32) (cond ((= ch 8) (insert "\\b")) ((= ch 9) (insert "\\t")) ((= ch 10) (insert "\\n")) ((= ch 13) (insert "\\r")) ((= ch 27) (insert "\\e")) (t (insert "\\C-" (char-to-string (downcase (+ ch 64)))))) (if (< ch 127) (if (or (= ch 34) (= ch 92)) (insert "\\" (char-to-string ch)) (setq j i) (while (and (< (setq i (1+ i)) (length str)) (>= (setq ch (aref str i)) 32) (/= ch 34) (/= ch 92) (< ch 127))) (insert (substring str j i)) (setq i (1- i))) (if (memq ch '(127 255)) (insert (format "\\%03o" ch)) (insert "\\M-" (char-to-string (- ch 128)))))) (setq i (1+ i)))) ) (defun MacEdit-lookup-key (map) (let ((loc (and map (lookup-key map macro-str))) (glob (lookup-key (current-global-map) macro-str)) (loc-str macro-str) (glob-str macro-str)) (and (integerp loc) (setq loc-str (substring macro-str 0 loc) loc (lookup-key map loc-str))) (and (consp loc) (setq loc nil)) (or loc (setq loc-str "")) (and (integerp glob) (setq glob-str (substring macro-str 0 glob) glob (lookup-key (current-global-map) glob-str))) (and (consp glob) (setq glob nil)) (or glob (setq glob-str "")) (if (> (length glob-str) (length loc-str)) (setq key-symbol glob key-str glob-str) (setq key-symbol loc key-str loc-str)) (setq key-last (and (> (length key-str) 0) (logand (aref key-str (1- (length key-str))) 127))) key-symbol) ) (defun MacEdit-read-argument (&optional obarray pred) ;; currently ignored (let ((str "") (min-bsp 0) (exec (eq key-symbol 'execute-extended-command)) str-base) (while (progn (MacEdit-lookup-key (current-global-map)) (or (and (eq key-symbol 'self-insert-command) (< (length str) 60)) (memq key-symbol '(backward-delete-char delete-backward-char backward-delete-char-untabify)) (eq key-last 9))) (setq macro-str (substring macro-str (length key-str))) (or (and (eq key-last 9) obarray (let ((comp (try-completion str obarray pred))) (and (stringp comp) (> (length comp) (length str)) (setq str comp)))) (if (or (eq key-symbol 'self-insert-command) (and (or (eq key-last 9) (<= (length str) min-bsp)) (setq min-bsp (+ (length str) (length key-str))))) (setq str (concat str key-str)) (setq str (substring str 0 -1))))) (setq str-base str str (concat str key-str) macro-str (substring macro-str (length key-str))) (if exec (let ((comp (try-completion str-base obarray pred))) (if (if (stringp comp) (and (commandp (intern comp)) (setq str-base comp)) (commandp (intern str-base))) (insert str-base "\n") (insert "execute-extended-command\n") (insert "type \"") (MacEdit-insert-string str) (insert "\"\n"))) (if (> (length str) 0) (progn (insert "type \"") (MacEdit-insert-string str) (insert "\"\n"))))) ) (defun MacEdit-isearch-argument () (let ((str "") (min-bsp 0) ch) (while (and (setq ch (MacEdit-read-char)) (or (<= ch 127) (not search-exit-option)) (not (eq ch search-exit-char)) (or (eq ch search-repeat-char) (eq ch search-reverse-char) (eq ch search-delete-char) (eq ch search-yank-word-char) (eq ch search-yank-line-char) (eq ch search-quote-char) (eq ch ?\r) (eq ch ?\t) (not search-exit-option) (and (/= ch 127) (>= ch 32)))) (if (and (eq ch search-quote-char) (MacEdit-peek-char)) (setq str (concat str (char-to-string ch) (char-to-string (MacEdit-read-char))) min-bsp (length str)) (if (or (and (< ch 127) (>= ch 32)) (eq ch search-yank-word-char) (eq ch search-yank-line-char) (and (or (not (eq ch search-delete-char)) (<= (length str) min-bsp)) (setq min-bsp (1+ (length str))))) (setq str (concat str (char-to-string ch))) (setq str (substring str 0 -1))))) (if (eq ch search-exit-char) (if (= (length str) 0) ;; non-incremental search (progn (setq str (concat str (char-to-string ch))) (and (eq (MacEdit-peek-char) ?\C-w) (progn (setq str (concat str "\C-w")) (MacEdit-read-char))) (if (> (length str) 0) (progn (insert "type \"") (MacEdit-insert-string str) (insert "\"\n"))) (MacEdit-read-argument) (setq str ""))) (MacEdit-unread-chars ch)) (if (> (length str) 0) (progn (insert "type \"") (MacEdit-insert-string str) (insert "\\e\"\n")))) ) ;;; Get the next keystroke-sequence from the input stream. ;;; Sets key-symbol, key-str, and key-last as a side effect. (defun MacEdit-read-key () (MacEdit-lookup-key (current-local-map)) (and key-symbol (setq macro-str (substring macro-str (length key-str)))) ) (defun MacEdit-peek-char () (and (> (length macro-str) 0) (aref macro-str 0)) ) (defun MacEdit-read-char () (and (> (length macro-str) 0) (prog1 (aref macro-str 0) (setq macro-str (substring macro-str 1)))) ) (defun MacEdit-unread-chars (chars) (and (integerp chars) (setq chars (char-to-string chars))) (and chars (setq macro-str (concat chars macro-str))) ) (defun MacEdit-dump (mac) (set-mark-command nil) (insert "\n\n") (MacEdit-print-macro mac (current-local-map)) ) ;;; Parse a string of spelled-out keystrokes, as produced by key-description. (defun MacEdit-parse-keys (str) (let ((pos 0) (mac "") part) (while (and (< pos (length str)) (string-match "[^ \t\n]+" str pos)) (setq pos (match-end 0) part (substring str (match-beginning 0) (match-end 0)) mac (concat mac (if (and (> (length part) 2) (= (aref part 1) ?-) (= (aref part 0) ?M)) (progn (setq part (substring part 2)) "\e") (if (and (> (length part) 4) (= (aref part 0) ?C) (= (aref part 1) ?-) (= (aref part 2) ?M) (= (aref part 3) ?-)) (progn (setq part (concat "C-" (substring part 4))) "\e") "")) (or (cdr (assoc part '( ( "NUL" . "\0" ) ( "RET" . "\r" ) ( "LFD" . "\n" ) ( "TAB" . "\t" ) ( "ESC" . "\e" ) ( "SPC" . " " ) ( "DEL" . "\177" ) ( "C-?" . "\177" ) ( "C-2" . "\0" ) ( "C-SPC" . "\0") ))) (and (equal part "REM") (setq pos (or (string-match "\n" str pos) (length str))) "") (and (= (length part) 3) (= (aref part 0) ?C) (= (aref part 1) ?-) (char-to-string (logand (aref part 2) 31))) part)))) mac) ) ;;; Parse a keyboard macro description in MacEdit-print-macro's format. (defun MacEdit-read-macro (&optional map) (or map (setq map (current-local-map))) (let ((macro-str "")) (while (not (progn (skip-chars-forward " \t\n") (eobp))) (cond ((looking-at "#")) ;; comment ((looking-at "prefix-arg[ \t]*-[ \t]*\n") (MacEdit-append-chars "\C-u-")) ((looking-at "prefix-arg[ \t]*\\(-?[0-9]+\\)[ \t]*\n") (MacEdit-append-chars (concat "\C-u" (MacEdit-match-string 1)))) ((looking-at "prefix-arg[ \t]*(\\([0-9]+\\))[ \t]*\n") (let ((val (string-to-int (MacEdit-match-string 1)))) (while (> val 1) (or (= (% val 4) 0) (error "Bad prefix argument value")) (MacEdit-append-chars "\C-u") (setq val (/ val 4))))) ((looking-at "prefix-arg") (error "Bad prefix argument syntax")) ((looking-at "insert ") (forward-char 7) (MacEdit-append-chars (read (current-buffer))) (if (< (current-column) 7) (forward-line -1))) ((looking-at "type ") (forward-char 5) (MacEdit-append-chars (read (current-buffer))) (if (< (current-column) 5) (forward-line -1))) ((looking-at "keys \\(.*\\)\n") (goto-char (1- (match-end 0))) (MacEdit-append-chars (MacEdit-parse-keys (buffer-substring (match-beginning 1) (match-end 1))))) ((looking-at "\\([-a-zA-z0-9_]+\\)[ \t]*\\(.*\\)\n") (let* ((func (intern (MacEdit-match-string 1))) (arg (MacEdit-match-string 2)) (cust (get func 'MacEdit-read))) (if cust (funcall cust arg) (or (commandp func) (error "Not an Emacs command")) (or (equal arg "") (string-match "\\`#" arg) (error "Unexpected argument to command")) (let ((keys (or (where-is-internal func map t) (where-is-internal func (current-global-map) t)))) (if keys (MacEdit-append-chars keys) (MacEdit-append-chars (concat "\ex" (symbol-name func) "\n"))))))) (t (error "Syntax error"))) (forward-line 1)) macro-str) ) (defun MacEdit-append-chars (chars) (setq macro-str (concat macro-str chars)) ) (defun MacEdit-match-string (n) (if (match-beginning n) (buffer-substring (match-beginning n) (match-end n)) "") ) (defun MacEdit-get-interactive (func) (if (symbolp func) (let ((cust (get func 'MacEdit-interactive))) (if cust cust (MacEdit-get-interactive (symbol-function func)))) (or (and (eq (car-safe func) 'lambda) (let ((int (if (consp (nth 2 func)) (nth 2 func) (nth 3 func)))) (and (eq (car-safe int) 'interactive) (stringp (nth 1 int)) (nth 1 int)))) "")) ) (put 'search-forward 'MacEdit-interactive "s") (put 'search-backward 'MacEdit-interactive "s") (put 'word-search-forward 'MacEdit-interactive "s") (put 'word-search-backward 'MacEdit-interactive "s") (put 're-search-forward 'MacEdit-interactive "s") (put 're-search-backward 'MacEdit-interactive "s") (put 'switch-to-buffer 'MacEdit-interactive "B") (put 'kill-buffer 'MacEdit-interactive "B") (put 'rename-buffer 'MacEdit-interactive "B\nB") (put 'goto-char 'MacEdit-interactive "N") (put 'global-set-key 'MacEdit-interactive "k\nC") (put 'global-unset-key 'MacEdit-interactive "k") (put 'local-set-key 'MacEdit-interactive "k\nC") (put 'local-unset-key 'MacEdit-interactive "k") ;;; Think about kbd-macro-query ;;; Edit a keyboard macro in another buffer. ;;; (Prefix argument is currently ignored.) (defun MacEdit-edit-macro (mac repl &optional prefix buffer hook arg) (or (stringp mac) (error "Not a keyboard macro")) (let ((oldbuf (current-buffer)) (from-calc (and (get-buffer-window "*Calculator*") (eq (lookup-key (current-global-map) "\e#") 'calc-dispatch))) (local (current-local-map)) (buf (get-buffer-create (or buffer "*Edit Macro*")))) (set-buffer buf) (kill-all-local-variables) (use-local-map MacEdit-mode-map) (setq buffer-read-only nil) (setq major-mode 'MacEdit-mode) (setq mode-name "Edit Macro") (make-local-variable 'MacEdit-original-buffer) (setq MacEdit-original-buffer oldbuf) (make-local-variable 'MacEdit-replace-function) (setq MacEdit-replace-function repl) (make-local-variable 'MacEdit-replace-argument) (setq MacEdit-replace-argument arg) (make-local-variable 'MacEdit-finish-hook) (setq MacEdit-finish-hook hook) (erase-buffer) (insert "# Keyboard Macro Editor. Press " (if from-calc "M-# M-#" "C-c C-c") " to finish; press " (if from-calc "M-# x" "C-x k RET") " to cancel.\n") (insert "# Original keys: " (key-description mac) "\n\n") (message "Formatting keyboard macro...") (MacEdit-print-macro mac local) (switch-to-buffer buf) (goto-char (point-min)) (forward-line 3) (recenter '(4)) (set-buffer-modified-p nil) (message "Formatting keyboard macro...done") (run-hooks 'MacEdit-format-hook)) ) (defun MacEdit-finish-edit () (interactive) (or (and (boundp 'MacEdit-original-buffer) (boundp 'MacEdit-replace-function) (boundp 'MacEdit-replace-argument) (boundp 'MacEdit-finish-hook) (eq major-mode 'MacEdit-mode)) (error "This command is valid only in buffers created by edit-kbd-macro.")) (let ((buf (current-buffer)) (str (buffer-string)) (func MacEdit-replace-function) (arg MacEdit-replace-argument) (hook MacEdit-finish-hook)) (goto-char (point-min)) (and (buffer-modified-p) func (progn (message "Compiling keyboard macro...") (run-hooks 'MacEdit-compile-hook) (let ((mac (MacEdit-read-macro (and (buffer-name MacEdit-original-buffer) (save-excursion (set-buffer MacEdit-original-buffer) (current-local-map)))))) (and (buffer-name MacEdit-original-buffer) (switch-to-buffer MacEdit-original-buffer)) (funcall func mac arg)) (message "Compiling keyboard macro...done"))) (kill-buffer buf) (if hook (funcall hook arg))) ) (defun MacEdit-cancel-edit () (interactive) (if (eq major-mode 'MacEdit-mode) (set-buffer-modified-p nil)) (MacEdit-finish-edit) (message "(Cancelled)") ) (defun MacEdit-mode () "Keyboard Macro Editing mode. Press C-c C-c to save and exit. To abort the edit, just kill this buffer with C-x k RET. The keyboard macro is represented as a series of M-x style command names. Keystrokes which do not correspond to simple M-x commands are written as \"type\" commands. When you press C-c C-c, MacEdit converts each command back into a suitable keystroke sequence; \"type\" commands are converted directly back into keystrokes." (interactive) (error "This mode can be enabled only by edit-kbd-macro or edit-last-kbd-macro.") ) (put 'MacEdit-mode 'mode-class 'special) (defvar MacEdit-mode-map nil) (if MacEdit-mode-map () (setq MacEdit-mode-map (make-sparse-keymap)) (define-key MacEdit-mode-map "\C-c\C-c" 'MacEdit-finish-edit) ) calc-2.02c/calc-aent.el100644 22403 13 106607 5547406462 13255 0ustar daveguser;; Calculator for GNU Emacs, part I [calc-aent.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc.el. (require 'calc) (require 'calc-macs) (defun calc-Need-calc-aent () nil) (defun calc-do-quick-calc () (calc-check-defines) (if (eq major-mode 'calc-mode) (calc-algebraic-entry t) (let (buf shortbuf) (save-excursion (calc-create-buffer) (let* ((calc-command-flags nil) (calc-dollar-values calc-quick-prev-results) (calc-dollar-used 0) (enable-recursive-minibuffers t) (calc-language (if (memq calc-language '(nil big)) 'flat calc-language)) (entry (calc-do-alg-entry "" "Quick calc: " t)) (alg-exp (mapcar (function (lambda (x) (if (and (not calc-extensions-loaded) calc-previous-alg-entry (string-match "\\`[-0-9._+*/^() ]+\\'" calc-previous-alg-entry)) (calc-normalize x) (calc-extensions) (math-evaluate-expr x)))) entry))) (if (and (= (length alg-exp) 1) (eq (car-safe (car alg-exp)) 'calcFunc-assign) (= (length (car alg-exp)) 3) (eq (car-safe (nth 1 (car alg-exp))) 'var)) (progn (calc-extensions) (set (nth 2 (nth 1 (car alg-exp))) (nth 2 (car alg-exp))) (calc-refresh-evaltos (nth 2 (nth 1 (car alg-exp)))) (setq alg-exp (list (nth 2 (car alg-exp)))))) (setq calc-quick-prev-results alg-exp buf (mapconcat (function (lambda (x) (math-format-value x 1000))) alg-exp " ") shortbuf buf) (if (and (= (length alg-exp) 1) (memq (car-safe (car alg-exp)) '(nil bigpos bigneg)) (< (length buf) 20) (= calc-number-radix 10)) (setq buf (concat buf " (" (let ((calc-number-radix 16)) (math-format-value (car alg-exp) 1000)) ", " (let ((calc-number-radix 8)) (math-format-value (car alg-exp) 1000)) (if (and (integerp (car alg-exp)) (> (car alg-exp) 0) (< (car alg-exp) 127)) (format ", \"%c\"" (car alg-exp)) "") ")"))) (if (and (< (length buf) (screen-width)) (= (length entry) 1) calc-extensions-loaded) (let ((long (concat (math-format-value (car entry) 1000) " => " buf))) (if (<= (length long) (- (screen-width) 8)) (setq buf long)))) (calc-handle-whys) (message "Result: %s" buf))) (if (eq last-command-char 10) (insert shortbuf) (setq kill-ring (cons shortbuf kill-ring)) (if (> (length kill-ring) kill-ring-max) (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil)) (setq kill-ring-yank-pointer kill-ring)))) ) (defun calc-do-calc-eval (str separator args) (calc-check-defines) (catch 'calc-error (save-excursion (calc-create-buffer) (cond ((and (consp str) (not (symbolp (car str)))) (let ((calc-language nil) (math-expr-opers math-standard-opers) (calc-internal-prec 12) (calc-word-size 32) (calc-symbolic-mode nil) (calc-matrix-mode nil) (calc-angle-mode 'deg) (calc-number-radix 10) (calc-leading-zeros nil) (calc-group-digits nil) (calc-point-char ".") (calc-frac-format '(":" nil)) (calc-prefer-frac nil) (calc-hms-format "%s@ %s' %s\"") (calc-date-format '((H ":" mm C SS pp " ") Www " " Mmm " " D ", " YYYY)) (calc-float-format '(float 0)) (calc-full-float-format '(float 0)) (calc-complex-format nil) (calc-matrix-just nil) (calc-full-vectors t) (calc-break-vectors nil) (calc-vector-commas ",") (calc-vector-brackets "[]") (calc-matrix-brackets '(R O)) (calc-complex-mode 'cplx) (calc-infinite-mode nil) (calc-display-strings nil) (calc-simplify-mode nil) (calc-display-working-message 'lots) (strp (cdr str))) (while strp (set (car strp) (nth 1 strp)) (setq strp (cdr (cdr strp)))) (calc-do-calc-eval (car str) separator args))) ((eq separator 'eval) (eval str)) ((eq separator 'macro) (calc-extensions) (let* ((calc-buffer (current-buffer)) (calc-window (get-buffer-window calc-buffer)) (save-window (selected-window))) (if calc-window (unwind-protect (progn (select-window calc-window) (calc-execute-kbd-macro str nil (car args))) (and (window-point save-window) (select-window save-window))) (save-window-excursion (select-window (get-largest-window)) (switch-to-buffer calc-buffer) (calc-execute-kbd-macro str nil (car args))))) nil) ((eq separator 'pop) (or (not (integerp str)) (= str 0) (calc-pop (min str (calc-stack-size)))) (calc-stack-size)) ((eq separator 'top) (and (integerp str) (> str 0) (<= str (calc-stack-size)) (math-format-value (calc-top-n str (car args)) 1000))) ((eq separator 'rawtop) (and (integerp str) (> str 0) (<= str (calc-stack-size)) (calc-top-n str (car args)))) (t (let* ((calc-command-flags nil) (calc-next-why nil) (calc-language (if (memq calc-language '(nil big)) 'flat calc-language)) (calc-dollar-values (mapcar (function (lambda (x) (if (stringp x) (progn (setq x (math-read-exprs x)) (if (eq (car-safe x) 'error) (throw 'calc-error (calc-eval-error (cdr x))) (car x))) x))) args)) (calc-dollar-used 0) (res (if (stringp str) (math-read-exprs str) (list str))) buf) (if (eq (car res) 'error) (calc-eval-error (cdr res)) (setq res (mapcar 'calc-normalize res)) (and (memq 'clear-message calc-command-flags) (message "")) (cond ((eq separator 'pred) (calc-extensions) (if (= (length res) 1) (math-is-true (car res)) (calc-eval-error '(0 "Single value expected")))) ((eq separator 'raw) (if (= (length res) 1) (car res) (calc-eval-error '(0 "Single value expected")))) ((eq separator 'list) res) ((memq separator '(num rawnum)) (if (= (length res) 1) (if (math-constp (car res)) (if (eq separator 'num) (math-format-value (car res) 1000) (car res)) (calc-eval-error (list 0 (if calc-next-why (calc-explain-why (car calc-next-why)) "Number expected")))) (calc-eval-error '(0 "Single value expected")))) ((eq separator 'push) (calc-push-list res) nil) (t (while res (setq buf (concat buf (and buf (or separator ", ")) (math-format-value (car res) 1000)) res (cdr res))) buf)))))))) ) (defun calc-eval-error (msg) (if (and (boundp 'calc-eval-error) calc-eval-error) (if (eq calc-eval-error 'string) (nth 1 msg) (error "%s" (nth 1 msg))) msg) ) ;;;; Reading an expression in algebraic form. (defun calc-auto-algebraic-entry (&optional prefix) (interactive "P") (calc-algebraic-entry prefix t) ) (defun calc-algebraic-entry (&optional prefix auto) (interactive "P") (calc-wrapper (let ((calc-language (if prefix nil calc-language)) (math-expr-opers (if prefix math-standard-opers math-expr-opers))) (calc-alg-entry (and auto (char-to-string last-command-char))))) ) (defun calc-alg-entry (&optional initial prompt) (let* ((sel-mode nil) (calc-dollar-values (mapcar 'calc-get-stack-element (nthcdr calc-stack-top calc-stack))) (calc-dollar-used 0) (calc-plain-entry t) (alg-exp (calc-do-alg-entry initial prompt t))) (if (stringp alg-exp) (progn (calc-extensions) (calc-alg-edit alg-exp)) (let* ((calc-simplify-mode (if (eq last-command-char ?\C-j) 'none calc-simplify-mode)) (nvals (mapcar 'calc-normalize alg-exp))) (while alg-exp (calc-record (if calc-extensions-loaded (car alg-exp) (car nvals)) "alg'") (calc-pop-push-record-list calc-dollar-used (and (not (equal (car alg-exp) (car nvals))) calc-extensions-loaded "") (list (car nvals))) (setq alg-exp (cdr alg-exp) nvals (cdr nvals) calc-dollar-used 0))) (calc-handle-whys))) ) (defun calc-do-alg-entry (&optional initial prompt no-normalize) (let* ((calc-buffer (current-buffer)) (blink-paren-hook 'calcAlg-blink-matching-open) (alg-exp 'error)) (if (boundp 'calc-alg-ent-map) () (setq calc-alg-ent-map (copy-keymap minibuffer-local-map)) (define-key calc-alg-ent-map "'" 'calcAlg-previous) (define-key calc-alg-ent-map "`" 'calcAlg-edit) (define-key calc-alg-ent-map "\C-m" 'calcAlg-enter) (define-key calc-alg-ent-map "\C-j" 'calcAlg-enter) (or calc-emacs-type-19 (let ((i 33)) (setq calc-alg-ent-esc-map (copy-sequence esc-map)) (while (< i 127) (aset calc-alg-ent-esc-map i 'calcAlg-escape) (setq i (1+ i)))))) (or calc-emacs-type-19 (define-key calc-alg-ent-map "\e" nil)) (if (eq calc-algebraic-mode 'total) (define-key calc-alg-ent-map "\e" calc-alg-ent-esc-map) (define-key calc-alg-ent-map "\ep" 'calcAlg-plus-minus) (define-key calc-alg-ent-map "\em" 'calcAlg-mod) (define-key calc-alg-ent-map "\e=" 'calcAlg-equals) (define-key calc-alg-ent-map "\e\r" 'calcAlg-equals) (define-key calc-alg-ent-map "\e%" 'self-insert-command)) (setq calc-aborted-prefix nil) (let ((buf (read-from-minibuffer (or prompt "Algebraic: ") (or initial "") calc-alg-ent-map nil))) (if (eq alg-exp 'error) (if (eq (car-safe (setq alg-exp (math-read-exprs buf))) 'error) (setq alg-exp nil))) (setq calc-aborted-prefix "alg'") (or no-normalize (and alg-exp (setq alg-exp (mapcar 'calc-normalize alg-exp)))) alg-exp)) ) (defun calcAlg-plus-minus () (interactive) (if (calc-minibuffer-contains ".* \\'") (insert "+/- ") (insert " +/- ")) ) (defun calcAlg-mod () (interactive) (if (not (calc-minibuffer-contains ".* \\'")) (insert " ")) (if (calc-minibuffer-contains ".* mod +\\'") (if calc-previous-modulo (insert (math-format-flat-expr calc-previous-modulo 0)) (beep)) (insert "mod ")) ) (defun calcAlg-previous () (interactive) (if (calc-minibuffer-contains "\\`\\'") (if calc-previous-alg-entry (insert calc-previous-alg-entry) (beep)) (insert "'")) ) (defun calcAlg-equals () (interactive) (unwind-protect (calcAlg-enter) (if (consp alg-exp) (progn (setq prefix-arg (length alg-exp)) (calc-unread-command ?=)))) ) (defun calcAlg-escape () (interactive) (calc-unread-command) (save-excursion (calc-select-buffer) (use-local-map calc-mode-map)) (calcAlg-enter) ) (defun calcAlg-edit () (interactive) (if (or (not calc-plain-entry) (calc-minibuffer-contains "\\`\\([^\"]*\"[^\"]*\"\\)*[^\"]*\"[^\"]*\\'")) (insert "`") (setq alg-exp (buffer-string)) (and (> (length alg-exp) 0) (setq calc-previous-alg-entry alg-exp)) (exit-minibuffer)) ) (setq calc-plain-entry nil) (defun calcAlg-enter () (interactive) (let* ((str (buffer-string)) (exp (and (> (length str) 0) (save-excursion (set-buffer calc-buffer) (math-read-exprs str))))) (if (eq (car-safe exp) 'error) (progn (goto-char (point-min)) (forward-char (nth 1 exp)) (beep) (calc-temp-minibuffer-message (concat " [" (or (nth 2 exp) "Error") "]")) (calc-clear-unread-commands)) (setq alg-exp (if (calc-minibuffer-contains "\\` *\\[ *\\'") '((incomplete vec)) exp)) (and (> (length str) 0) (setq calc-previous-alg-entry str)) (exit-minibuffer))) ) (defun calcAlg-blink-matching-open () (let ((oldpos (point)) (blinkpos nil)) (save-excursion (condition-case () (setq blinkpos (scan-sexps oldpos -1)) (error nil))) (if (and blinkpos (> oldpos (1+ (point-min))) (or (and (= (char-after (1- oldpos)) ?\)) (= (char-after blinkpos) ?\[)) (and (= (char-after (1- oldpos)) ?\]) (= (char-after blinkpos) ?\())) (save-excursion (goto-char blinkpos) (looking-at ".+\\(\\.\\.\\|\\\\dots\\|\\\\ldots\\)"))) (let ((saved (aref (syntax-table) (char-after blinkpos)))) (unwind-protect (progn (aset (syntax-table) (char-after blinkpos) (+ (logand saved 255) (lsh (char-after (1- oldpos)) 8))) (blink-matching-open)) (aset (syntax-table) (char-after blinkpos) saved))) (blink-matching-open))) ) (defun calc-alg-digit-entry () (calc-alg-entry (cond ((eq last-command-char ?e) (if (> calc-number-radix 14) (format "%d.^" calc-number-radix) "1e")) ((eq last-command-char ?#) (format "%d#" calc-number-radix)) ((eq last-command-char ?_) "-") ((eq last-command-char ?@) "0@ ") (t (char-to-string last-command-char)))) ) (defun calcDigit-algebraic () (interactive) (if (calc-minibuffer-contains ".*[@oh] *[^'m ]+[^'m]*\\'") (calcDigit-key) (setq calc-digit-value (buffer-string)) (exit-minibuffer)) ) (defun calcDigit-edit () (interactive) (calc-unread-command) (setq calc-digit-value (buffer-string)) (exit-minibuffer) ) ;;; Algebraic expression parsing. [Public] (defun math-read-exprs (exp-str) (let ((exp-pos 0) (exp-old-pos 0) (exp-keep-spaces nil) exp-token exp-data) (if calc-language-input-filter (setq exp-str (funcall calc-language-input-filter exp-str))) (while (setq exp-token (string-match "\\.\\.\\([^.]\\|.[^.]\\)" exp-str)) (setq exp-str (concat (substring exp-str 0 exp-token) "\\dots" (substring exp-str (+ exp-token 2))))) (math-build-parse-table) (math-read-token) (let ((val (catch 'syntax (math-read-expr-list)))) (if (stringp val) (list 'error exp-old-pos val) (if (equal exp-token 'end) val (list 'error exp-old-pos "Syntax error"))))) ) (defun math-read-expr-list () (let* ((exp-keep-spaces nil) (val (list (math-read-expr-level 0))) (last val)) (while (equal exp-data ",") (math-read-token) (let ((rest (list (math-read-expr-level 0)))) (setcdr last rest) (setq last rest))) val) ) (setq calc-user-parse-table nil) (setq calc-last-main-parse-table nil) (setq calc-last-lang-parse-table nil) (setq calc-user-tokens nil) (setq calc-user-token-chars nil) (defun math-build-parse-table () (let ((mtab (cdr (assq nil calc-user-parse-tables))) (ltab (cdr (assq calc-language calc-user-parse-tables)))) (or (and (eq mtab calc-last-main-parse-table) (eq ltab calc-last-lang-parse-table)) (let ((p (append mtab ltab)) (toks nil)) (setq calc-user-parse-table p) (setq calc-user-token-chars nil) (while p (math-find-user-tokens (car (car p))) (setq p (cdr p))) (setq calc-user-tokens (mapconcat 'identity (sort (mapcar 'car toks) (function (lambda (x y) (> (length x) (length y))))) "\\|") calc-last-main-parse-table mtab calc-last-lang-parse-table ltab)))) ) (defun math-find-user-tokens (p) ; uses "toks" (while p (cond ((and (stringp (car p)) (or (> (length (car p)) 1) (equal (car p) "$") (equal (car p) "\"")) (string-match "[^a-zA-Z0-9]" (car p))) (let ((s (regexp-quote (car p)))) (if (string-match "\\`[a-zA-Z0-9]" s) (setq s (concat "\\<" s))) (if (string-match "[a-zA-Z0-9]\\'" s) (setq s (concat s "\\>"))) (or (assoc s toks) (progn (setq toks (cons (list s) toks)) (or (memq (aref (car p) 0) calc-user-token-chars) (setq calc-user-token-chars (cons (aref (car p) 0) calc-user-token-chars))))))) ((consp (car p)) (math-find-user-tokens (nth 1 (car p))) (or (eq (car (car p)) '\?) (math-find-user-tokens (nth 2 (car p)))))) (setq p (cdr p))) ) (defun math-read-token () (if (>= exp-pos (length exp-str)) (setq exp-old-pos exp-pos exp-token 'end exp-data "\000") (let ((ch (aref exp-str exp-pos))) (setq exp-old-pos exp-pos) (cond ((memq ch '(32 10 9)) (setq exp-pos (1+ exp-pos)) (if exp-keep-spaces (setq exp-token 'space exp-data " ") (math-read-token))) ((and (memq ch calc-user-token-chars) (let ((case-fold-search nil)) (eq (string-match calc-user-tokens exp-str exp-pos) exp-pos))) (setq exp-token 'punc exp-data (math-match-substring exp-str 0) exp-pos (match-end 0))) ((or (and (>= ch ?a) (<= ch ?z)) (and (>= ch ?A) (<= ch ?Z))) (string-match (if (memq calc-language '(c fortran pascal maple)) "[a-zA-Z0-9_#]*" "[a-zA-Z0-9'#]*") exp-str exp-pos) (setq exp-token 'symbol exp-pos (match-end 0) exp-data (math-restore-dashes (math-match-substring exp-str 0))) (if (eq calc-language 'eqn) (let ((code (assoc exp-data math-eqn-ignore-words))) (cond ((null code)) ((null (cdr code)) (math-read-token)) ((consp (nth 1 code)) (math-read-token) (if (assoc exp-data (cdr code)) (setq exp-data (format "%s %s" (car code) exp-data)))) ((eq (nth 1 code) 'punc) (setq exp-token 'punc exp-data (nth 2 code))) (t (math-read-token) (math-read-token)))))) ((or (and (>= ch ?0) (<= ch ?9)) (and (eq ch '?\.) (eq (string-match "\\.[0-9]" exp-str exp-pos) exp-pos)) (and (eq ch '?_) (eq (string-match "_\\.?[0-9]" exp-str exp-pos) exp-pos) (or (eq exp-pos 0) (and (memq calc-language '(nil flat big unform tex eqn)) (eq (string-match "[^])}\"a-zA-Z0-9'$]_" exp-str (1- exp-pos)) (1- exp-pos)))))) (or (and (eq calc-language 'c) (string-match "0[xX][0-9a-fA-F]+" exp-str exp-pos)) (string-match "_?\\([0-9]+.?0*@ *\\)?\\([0-9]+.?0*' *\\)?\\(0*\\([2-9]\\|1[0-4]\\)\\(#\\|\\^\\^\\)[0-9a-dA-D.]+[eE][-+_]?[0-9]+\\|0*\\([2-9]\\|[0-2][0-9]\\|3[0-6]\\)\\(#\\|\\^\\^\\)[0-9a-zA-Z:.]+\\|[0-9]+:[0-9:]+\\|[0-9.]+\\([eE][-+_]?[0-9]+\\)?\"?\\)?" exp-str exp-pos)) (setq exp-token 'number exp-data (math-match-substring exp-str 0) exp-pos (match-end 0))) ((eq ch ?\$) (if (and (eq calc-language 'pascal) (eq (string-match "\\(\\$[0-9a-fA-F]+\\)\\($\\|[^0-9a-zA-Z]\\)" exp-str exp-pos) exp-pos)) (setq exp-token 'number exp-data (math-match-substring exp-str 1) exp-pos (match-end 1)) (if (eq (string-match "\\$\\([1-9][0-9]*\\)" exp-str exp-pos) exp-pos) (setq exp-data (- (string-to-int (math-match-substring exp-str 1)))) (string-match "\\$+" exp-str exp-pos) (setq exp-data (- (match-end 0) (match-beginning 0)))) (setq exp-token 'dollar exp-pos (match-end 0)))) ((eq ch ?\#) (if (eq (string-match "#\\([1-9][0-9]*\\)" exp-str exp-pos) exp-pos) (setq exp-data (string-to-int (math-match-substring exp-str 1)) exp-pos (match-end 0)) (setq exp-data 1 exp-pos (1+ exp-pos))) (setq exp-token 'hash)) ((eq (string-match "~=\\|<=\\|>=\\|<>\\|/=\\|\\+/-\\|\\\\dots\\|\\\\ldots\\|\\*\\*\\|<<\\|>>\\|==\\|!=\\|&&&\\||||\\|!!!\\|&&\\|||\\|!!\\|:=\\|::\\|=>" exp-str exp-pos) exp-pos) (setq exp-token 'punc exp-data (math-match-substring exp-str 0) exp-pos (match-end 0))) ((and (eq ch ?\") (string-match "\\(\"\\([^\"\\]\\|\\\\.\\)*\\)\\(\"\\|\\'\\)" exp-str exp-pos)) (if (eq calc-language 'eqn) (progn (setq exp-str (copy-sequence exp-str)) (aset exp-str (match-beginning 1) ?\{) (if (< (match-end 1) (length exp-str)) (aset exp-str (match-end 1) ?\})) (math-read-token)) (setq exp-token 'string exp-data (math-match-substring exp-str 1) exp-pos (match-end 0)))) ((and (= ch ?\\) (eq calc-language 'tex) (< exp-pos (1- (length exp-str)))) (or (string-match "\\\\hbox *{\\([a-zA-Z0-9]+\\)}" exp-str exp-pos) (string-match "\\(\\\\\\([a-zA-Z]+\\|[^a-zA-Z]\\)\\)" exp-str exp-pos)) (setq exp-token 'symbol exp-pos (match-end 0) exp-data (math-restore-dashes (math-match-substring exp-str 1))) (let ((code (assoc exp-data math-tex-ignore-words))) (cond ((null code)) ((null (cdr code)) (math-read-token)) ((eq (nth 1 code) 'punc) (setq exp-token 'punc exp-data (nth 2 code))) ((and (eq (nth 1 code) 'mat) (string-match " *{" exp-str exp-pos)) (setq exp-pos (match-end 0) exp-token 'punc exp-data "[") (let ((right (string-match "}" exp-str exp-pos))) (and right (setq exp-str (copy-sequence exp-str)) (aset exp-str right ?\]))))))) ((and (= ch ?\.) (eq calc-language 'fortran) (eq (string-match "\\.[a-zA-Z][a-zA-Z][a-zA-Z]?\\." exp-str exp-pos) exp-pos)) (setq exp-token 'punc exp-data (upcase (math-match-substring exp-str 0)) exp-pos (match-end 0))) ((and (eq calc-language 'math) (eq (string-match "\\[\\[\\|->\\|:>" exp-str exp-pos) exp-pos)) (setq exp-token 'punc exp-data (math-match-substring exp-str 0) exp-pos (match-end 0))) ((and (eq calc-language 'eqn) (eq (string-match "->\\|<-\\|+-\\|\\\\dots\\|~\\|\\^" exp-str exp-pos) exp-pos)) (setq exp-token 'punc exp-data (math-match-substring exp-str 0) exp-pos (match-end 0)) (and (eq (string-match "\\\\dots\\." exp-str exp-pos) exp-pos) (setq exp-pos (match-end 0))) (if (memq (aref exp-data 0) '(?~ ?^)) (math-read-token))) ((eq (string-match "%%.*$" exp-str exp-pos) exp-pos) (setq exp-pos (match-end 0)) (math-read-token)) (t (if (and (eq ch ?\{) (memq calc-language '(tex eqn))) (setq ch ?\()) (if (and (eq ch ?\}) (memq calc-language '(tex eqn))) (setq ch ?\))) (if (and (eq ch ?\&) (eq calc-language 'tex)) (setq ch ?\,)) (setq exp-token 'punc exp-data (char-to-string ch) exp-pos (1+ exp-pos)))))) ) (defun math-read-expr-level (exp-prec &optional exp-term) (let* ((x (math-read-factor)) (first t) op op2) (while (and (or (and calc-user-parse-table (setq op (calc-check-user-syntax x exp-prec)) (setq x op op '("2x" ident 999999 -1))) (and (setq op (assoc exp-data math-expr-opers)) (/= (nth 2 op) -1) (or (and (setq op2 (assoc exp-data (cdr (memq op math-expr-opers)))) (eq (= (nth 3 op) -1) (/= (nth 3 op2) -1)) (eq (= (nth 3 op2) -1) (not (math-factor-after))) (setq op op2)) t)) (and (or (eq (nth 2 op) -1) (memq exp-token '(symbol number dollar hash)) (equal exp-data "(") (and (equal exp-data "[") (not (eq calc-language 'math)) (not (and exp-keep-spaces (eq (car-safe x) 'vec))))) (or (not (setq op (assoc exp-data math-expr-opers))) (/= (nth 2 op) -1)) (or (not calc-user-parse-table) (not (eq exp-token 'symbol)) (let ((p calc-user-parse-table)) (while (and p (or (not (integerp (car (car (car p))))) (not (equal (nth 1 (car (car p))) exp-data)))) (setq p (cdr p))) (not p))) (setq op (assoc "2x" math-expr-opers)))) (not (and exp-term (equal exp-data exp-term))) (>= (nth 2 op) exp-prec)) (if (not (equal (car op) "2x")) (math-read-token)) (and (memq (nth 1 op) '(sdev mod)) (calc-extensions)) (setq x (cond ((consp (nth 1 op)) (funcall (car (nth 1 op)) x op)) ((eq (nth 3 op) -1) (if (eq (nth 1 op) 'ident) x (if (eq (nth 1 op) 'closing) (if (eq (nth 2 op) exp-prec) (progn (setq exp-prec 1000) x) (throw 'syntax "Mismatched delimiters")) (list (nth 1 op) x)))) ((and (not first) (memq (nth 1 op) math-alg-inequalities) (memq (car-safe x) math-alg-inequalities)) (calc-extensions) (math-composite-inequalities x op)) (t (list (nth 1 op) x (math-read-expr-level (nth 3 op) exp-term)))) first nil)) x) ) (defun calc-check-user-syntax (&optional x prec) (let ((p calc-user-parse-table) (matches nil) match rule) (while (and p (or (not (progn (setq rule (car (car p))) (if x (and (integerp (car rule)) (>= (car rule) prec) (equal exp-data (car (setq rule (cdr rule))))) (equal exp-data (car rule))))) (let ((save-exp-pos exp-pos) (save-exp-old-pos exp-old-pos) (save-exp-token exp-token) (save-exp-data exp-data)) (or (not (listp (setq matches (calc-match-user-syntax rule)))) (let ((args (progn (calc-extensions) calc-arg-values)) (conds nil) temp) (if x (setq matches (cons x matches))) (setq match (cdr (car p))) (while (and (eq (car-safe match) 'calcFunc-condition) (= (length match) 3)) (setq conds (append (math-flatten-lands (nth 2 match)) conds) match (nth 1 match))) (while (and conds match) (calc-extensions) (cond ((eq (car-safe (car conds)) 'calcFunc-let) (setq temp (car conds)) (or (= (length temp) 3) (and (= (length temp) 2) (eq (car-safe (nth 1 temp)) 'calcFunc-assign) (= (length (nth 1 temp)) 3) (setq temp (nth 1 temp))) (setq match nil)) (setq matches (cons (math-normalize (math-multi-subst (nth 2 temp) args matches)) matches) args (cons (nth 1 temp) args))) ((and (eq (car-safe (car conds)) 'calcFunc-matches) (= (length (car conds)) 3)) (setq temp (calcFunc-vmatches (math-multi-subst (nth 1 (car conds)) args matches) (nth 2 (car conds)))) (if (eq temp 0) (setq match nil) (while (setq temp (cdr temp)) (setq matches (cons (nth 2 (car temp)) matches) args (cons (nth 1 (car temp)) args))))) (t (or (math-is-true (math-simplify (math-multi-subst (car conds) args matches))) (setq match nil)))) (setq conds (cdr conds))) (if match (not (setq match (math-multi-subst match args matches))) (setq exp-old-pos save-exp-old-pos exp-token save-exp-token exp-data save-exp-data exp-pos save-exp-pos))))))) (setq p (cdr p))) (and p match)) ) (defun calc-match-user-syntax (p &optional term) (let ((matches nil) (save-exp-pos exp-pos) (save-exp-old-pos exp-old-pos) (save-exp-token exp-token) (save-exp-data exp-data)) (while (and p (cond ((stringp (car p)) (and (equal exp-data (car p)) (progn (math-read-token) t))) ((integerp (car p)) (and (setq m (catch 'syntax (math-read-expr-level (car p) (if (cdr p) (if (consp (nth 1 p)) (car (nth 1 (nth 1 p))) (nth 1 p)) term)))) (not (stringp m)) (setq matches (nconc matches (list m))))) ((eq (car (car p)) '\?) (setq m (calc-match-user-syntax (nth 1 (car p)))) (or (nth 2 (car p)) (setq matches (nconc matches (list (cons 'vec (and (listp m) m)))))) (or (listp m) (not (nth 2 (car p))) (not (eq (aref (car (nth 2 (car p))) 0) ?\$)) (eq exp-token 'end))) (t (setq m (calc-match-user-syntax (nth 1 (car p)) (car (nth 2 (car p))))) (if (listp m) (let ((vec (cons 'vec m)) opos mm) (while (and (listp (setq opos exp-pos mm (calc-match-user-syntax (or (nth 2 (car p)) (nth 1 (car p))) (car (nth 2 (car p)))))) (> exp-pos opos)) (setq vec (nconc vec mm))) (setq matches (nconc matches (list vec)))) (and (eq (car (car p)) '*) (setq matches (nconc matches (list '(vec))))))))) (setq p (cdr p))) (if p (setq exp-pos save-exp-pos exp-old-pos save-exp-old-pos exp-token save-exp-token exp-data save-exp-data matches "Failed")) matches) ) (defconst math-alg-inequalities '(calcFunc-lt calcFunc-gt calcFunc-leq calcFunc-geq calcFunc-eq calcFunc-neq)) (defun math-remove-dashes (x) (if (string-match "\\`\\(.*\\)-\\(.*\\)\\'" x) (math-remove-dashes (concat (math-match-substring x 1) "#" (math-match-substring x 2))) x) ) (defun math-restore-dashes (x) (if (string-match "\\`\\(.*\\)[#_]\\(.*\\)\\'" x) (math-restore-dashes (concat (math-match-substring x 1) "-" (math-match-substring x 2))) x) ) (defun math-read-if (cond op) (let ((then (math-read-expr-level 0))) (or (equal exp-data ":") (throw 'syntax "Expected ':'")) (math-read-token) (list 'calcFunc-if cond then (math-read-expr-level (nth 3 op)))) ) (defun math-factor-after () (let ((exp-pos exp-pos) exp-old-pos exp-token exp-data) (math-read-token) (or (memq exp-token '(number symbol dollar hash string)) (and (assoc exp-data '(("-") ("+") ("!") ("|") ("/"))) (assoc (concat "u" exp-data) math-expr-opers)) (eq (nth 2 (assoc exp-data math-expr-opers)) -1) (assoc exp-data '(("(") ("[") ("{"))))) ) (defun math-read-factor () (let (op) (cond ((eq exp-token 'number) (let ((num (math-read-number exp-data))) (if (not num) (progn (setq exp-old-pos exp-pos) (throw 'syntax "Bad format"))) (math-read-token) (if (and math-read-expr-quotes (consp num)) (list 'quote num) num))) ((and calc-user-parse-table (setq op (calc-check-user-syntax))) op) ((or (equal exp-data "-") (equal exp-data "+") (equal exp-data "!") (equal exp-data "|") (equal exp-data "/")) (setq exp-data (concat "u" exp-data)) (math-read-factor)) ((and (setq op (assoc exp-data math-expr-opers)) (eq (nth 2 op) -1)) (if (consp (nth 1 op)) (funcall (car (nth 1 op)) op) (math-read-token) (let ((val (math-read-expr-level (nth 3 op)))) (cond ((eq (nth 1 op) 'ident) val) ((and (Math-numberp val) (equal (car op) "u-")) (math-neg val)) (t (list (nth 1 op) val)))))) ((eq exp-token 'symbol) (let ((sym (intern exp-data))) (math-read-token) (if (equal exp-data calc-function-open) (let ((f (assq sym math-expr-function-mapping))) (math-read-token) (if (consp (cdr f)) (funcall (car (cdr f)) f sym) (let ((args (if (or (equal exp-data calc-function-close) (eq exp-token 'end)) nil (math-read-expr-list)))) (if (not (or (equal exp-data calc-function-close) (eq exp-token 'end))) (throw 'syntax "Expected `)'")) (math-read-token) (if (and (eq calc-language 'fortran) args (calc-extensions) (let ((calc-matrix-mode 'scalar)) (math-known-matrixp (list 'var sym (intern (concat "var-" (symbol-name sym))))))) (math-parse-fortran-subscr sym args) (if f (setq sym (cdr f)) (and (= (aref (symbol-name sym) 0) ?\\) (< (prefix-numeric-value calc-language-option) 0) (setq sym (intern (substring (symbol-name sym) 1)))) (or (string-match "-" (symbol-name sym)) (setq sym (intern (concat "calcFunc-" (symbol-name sym)))))) (cons sym args))))) (if math-read-expr-quotes sym (let ((val (list 'var (intern (math-remove-dashes (symbol-name sym))) (if (string-match "-" (symbol-name sym)) sym (intern (concat "var-" (symbol-name sym))))))) (let ((v (assq (nth 1 val) math-expr-variable-mapping))) (and v (setq val (if (consp (cdr v)) (funcall (car (cdr v)) v val) (list 'var (intern (substring (symbol-name (cdr v)) 4)) (cdr v)))))) (while (and (memq calc-language '(c pascal maple)) (equal exp-data "[")) (math-read-token) (setq val (append (list 'calcFunc-subscr val) (math-read-expr-list))) (if (equal exp-data "]") (math-read-token) (throw 'syntax "Expected ']'"))) val))))) ((eq exp-token 'dollar) (let ((abs (if (> exp-data 0) exp-data (- exp-data)))) (if (>= (length calc-dollar-values) abs) (let ((num exp-data)) (math-read-token) (setq calc-dollar-used (max calc-dollar-used num)) (math-check-complete (nth (1- abs) calc-dollar-values))) (throw 'syntax (if calc-dollar-values "Too many $'s" "$'s not allowed in this context"))))) ((eq exp-token 'hash) (or calc-hashes-used (throw 'syntax "#'s not allowed in this context")) (calc-extensions) (if (<= exp-data (length calc-arg-values)) (let ((num exp-data)) (math-read-token) (setq calc-hashes-used (max calc-hashes-used num)) (nth (1- num) calc-arg-values)) (throw 'syntax "Too many # arguments"))) ((equal exp-data "(") (let* ((exp (let ((exp-keep-spaces nil)) (math-read-token) (if (or (equal exp-data "\\dots") (equal exp-data "\\ldots")) '(neg (var inf var-inf)) (math-read-expr-level 0))))) (let ((exp-keep-spaces nil)) (cond ((equal exp-data ",") (progn (math-read-token) (let ((exp2 (math-read-expr-level 0))) (setq exp (if (and exp2 (Math-realp exp) (Math-realp exp2)) (math-normalize (list 'cplx exp exp2)) (list '+ exp (list '* exp2 '(var i var-i)))))))) ((equal exp-data ";") (progn (math-read-token) (let ((exp2 (math-read-expr-level 0))) (setq exp (if (and exp2 (Math-realp exp) (Math-anglep exp2)) (math-normalize (list 'polar exp exp2)) (calc-extensions) (list '* exp (list 'calcFunc-exp (list '* (math-to-radians-2 exp2) '(var i var-i))))))))) ((or (equal exp-data "\\dots") (equal exp-data "\\ldots")) (progn (math-read-token) (let ((exp2 (if (or (equal exp-data ")") (equal exp-data "]") (eq exp-token 'end)) '(var inf var-inf) (math-read-expr-level 0)))) (setq exp (list 'intv (if (equal exp-data ")") 0 1) exp exp2))))))) (if (not (or (equal exp-data ")") (and (equal exp-data "]") (eq (car-safe exp) 'intv)) (eq exp-token 'end))) (throw 'syntax "Expected `)'")) (math-read-token) exp)) ((eq exp-token 'string) (calc-extensions) (math-read-string)) ((equal exp-data "[") (calc-extensions) (math-read-brackets t "]")) ((equal exp-data "{") (calc-extensions) (math-read-brackets nil "}")) ((equal exp-data "<") (calc-extensions) (math-read-angle-brackets)) (t (throw 'syntax "Expected a number")))) ) calc-2.02c/calc-stuff.el100644 22403 13 21777 5402630766 13435 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-stuff.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-stuff () nil) (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) ) (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"))) ) (setq calc-which-why nil) (setq calc-last-why-command nil) (defun calc-version () (interactive) (message "Calc %s, installed %s" calc-version calc-installed-date)) (defun calc-flush-caches () (interactive) (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-checked-rewrites nil math-integral-cache nil math-units-table nil math-decls-cache-tag nil math-eval-rules-cache-tag t math-graph-var-cache nil math-graph-data-cache nil math-format-date-cache nil math-holidays-cache-tag t) (mapcar (function (lambda (x) (set x -100))) math-cache-list) (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"))))) ) (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)))) ) (setq math-chopping-small nil) (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) ) (defun math-map-over-constants (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 func expr)) expr)) ((and (memq (car expr) '(^ calcFunc-subscr)) (eq 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))))) ) calc-2.02c/calc-forms.el100644 22403 13 170235 5402630577 13446 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-forms.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-forms () nil) (defun calc-time () (interactive) (calc-wrapper (let ((time (current-time-string))) (calc-enter-result 0 "time" (list 'mod (list 'hms (string-to-int (substring time 11 13)) (string-to-int (substring time 14 16)) (string-to-int (substring time 17 19))) (list 'hms 24 0 0))))) ) (defun calc-to-hms (arg) (interactive "P") (calc-wrapper (if (calc-is-inverse) (if (eq calc-angle-mode 'rad) (calc-unary-op ">rad" 'calcFunc-rad arg) (calc-unary-op ">deg" 'calcFunc-deg arg)) (calc-unary-op ">hms" 'calcFunc-hms arg))) ) (defun calc-from-hms (arg) (interactive "P") (calc-invert-func) (calc-to-hms arg) ) (defun calc-hms-notation (fmt) (interactive "sHours-minutes-seconds format (hms, @ ' \", etc.): ") (calc-wrapper (if (string-match "\\`\\([^,; ]+\\)\\([,; ]*\\)\\([^,; ]\\)\\([,; ]*\\)\\([^,; ]\\)\\'" fmt) (progn (calc-change-mode 'calc-hms-format (concat "%s" (math-match-substring fmt 1) (math-match-substring fmt 2) "%s" (math-match-substring fmt 3) (math-match-substring fmt 4) "%s" (math-match-substring fmt 5)) t) (setq-default calc-hms-format calc-hms-format)) ; for minibuffer (error "Bad hours-minutes-seconds format."))) ) (defun calc-date-notation (fmt arg) (interactive "sDate format (e.g., M/D/YY h:mm:ss): \nP") (calc-wrapper (if (equal fmt "") (setq fmt "1")) (if (string-match "\\` *[0-9] *\\'" fmt) (setq fmt (nth (string-to-int fmt) calc-standard-date-formats))) (or (string-match "[a-zA-Z]" fmt) (error "Bad date format specifier")) (and arg (>= (setq arg (prefix-numeric-value arg)) 0) (<= arg 9) (setq calc-standard-date-formats (copy-sequence calc-standard-date-formats)) (setcar (nthcdr arg calc-standard-date-formats) fmt)) (let ((case-fold-search nil)) (and (not (string-match "<.*>" fmt)) (string-match "\\`[^hHspP]*\\([^ac-gi-lnoqrt-zAC-GI-OQRT-Z]*[bBhHmpPsS]+[^ac-gi-lnoqrt-zAC-GI-OQRT-Z]*\\)[^hHspP]*\\'" fmt) (string-match (concat "[^ac-gi-lnoqrt-zAC-GI-OQRT-Z]*" (regexp-quote (math-match-substring fmt 1)) "[^ac-gi-lnoqrt-zAC-GI-OQRT-Z]*") fmt) (setq fmt (concat (substring fmt 0 (match-beginning 0)) "<" (substring fmt (match-beginning 0) (match-end 0)) ">" (substring fmt (match-end 0)))))) (let ((lfmt nil) (fullfmt nil) (time nil) pos pos2 sym temp) (let ((case-fold-search nil)) (and (setq temp (string-match ":[BS]S" fmt)) (aset fmt temp ?C))) (while (setq pos (string-match "[<>a-zA-Z]" fmt)) (if (> pos 0) (setq lfmt (cons (substring fmt 0 pos) lfmt))) (setq pos2 (1+ pos)) (cond ((= (aref fmt pos) ?\<) (and time (error "Nested <'s not allowed")) (and lfmt (setq fullfmt (nconc lfmt fullfmt) lfmt nil)) (setq time t)) ((= (aref fmt pos) ?\>) (or time (error "Misplaced > in format")) (and lfmt (setq fullfmt (cons (nreverse lfmt) fullfmt) lfmt nil)) (setq time nil)) (t (if (string-match "\\`[^a-zA-Z]*[bB][a-zA-Z]" fmt) (setq pos2 (1+ pos2))) (while (and (< pos2 (length fmt)) (= (upcase (aref fmt pos2)) (upcase (aref fmt (1- pos2))))) (setq pos2 (1+ pos2))) (setq sym (intern (substring fmt pos pos2))) (or (memq sym '(Y YY BY YYY YYYY aa AA aaa AAA aaaa AAAA bb BB bbb BBB bbbb BBBB M MM BM mmm Mmm Mmmm MMM MMMM D DD BD d ddd bdd W www Www Wwww WWW WWWW h hh bh H HH BH p P pp PP pppp PPPP m mm bm s ss bss SS BS C N n J j U b)) (and (eq sym 'X) (not lfmt) (not fullfmt)) (error "Bad format code: %s" sym)) (and (memq sym '(bb BB bbb BBB bbbb BBBB)) (setq lfmt (cons 'b lfmt))) (setq lfmt (cons sym lfmt)))) (setq fmt (substring fmt pos2))) (or (equal fmt "") (setq lfmt (cons fmt lfmt))) (and lfmt (if time (setq fullfmt (cons (nreverse lfmt) fullfmt)) (setq fullfmt (nconc lfmt fullfmt)))) (calc-change-mode 'calc-date-format (nreverse fullfmt) t))) ) (defun calc-hms-mode () (interactive) (calc-wrapper (calc-change-mode 'calc-angle-mode 'hms) (message "Angles measured in degrees-minutes-seconds.")) ) (defun calc-now (arg) (interactive "P") (calc-date-zero-args "now" 'calcFunc-now arg) ) (defun calc-date-part (arg) (interactive "NPart code (1-9 = Y,M,D,H,M,S,Wd,Yd,Hms): ") (if (or (< arg 1) (> arg 9)) (error "Part code out of range")) (calc-wrapper (calc-enter-result 1 (nth arg '(nil "year" "mnth" "day" "hour" "minu" "sec" "wday" "yday" "hmst")) (list (nth arg '(nil calcFunc-year calcFunc-month calcFunc-day calcFunc-hour calcFunc-minute calcFunc-second calcFunc-weekday calcFunc-yearday calcFunc-time)) (calc-top-n 1)))) ) (defun calc-date (arg) (interactive "p") (if (or (< arg 1) (> arg 6)) (error "Between one and six arguments are allowed")) (calc-wrapper (calc-enter-result arg "date" (cons 'calcFunc-date (calc-top-list-n arg)))) ) (defun calc-julian (arg) (interactive "P") (calc-date-one-arg "juln" 'calcFunc-julian arg) ) (defun calc-unix-time (arg) (interactive "P") (calc-date-one-arg "unix" 'calcFunc-unixtime arg) ) (defun calc-time-zone (arg) (interactive "P") (calc-date-zero-args "zone" 'calcFunc-tzone arg) ) (defun calc-convert-time-zones (old &optional new) (interactive "sFrom time zone: ") (calc-wrapper (if (equal old "$") (calc-enter-result 3 "tzcv" (cons 'calcFunc-tzconv (calc-top-list-n 3))) (if (equal old "") (setq old "local")) (or new (setq new (read-string (concat "From time zone: " old ", to zone: ")))) (if (stringp old) (setq old (math-read-expr old))) (if (eq (car-safe old) 'error) (error "Error in expression: " (nth 1 old))) (if (equal new "") (setq new "local")) (if (stringp new) (setq new (math-read-expr new))) (if (eq (car-safe new) 'error) (error "Error in expression: " (nth 1 new))) (calc-enter-result 1 "tzcv" (list 'calcFunc-tzconv (calc-top-n 1) old new)))) ) (defun calc-new-week (arg) (interactive "P") (calc-date-one-arg "nwwk" 'calcFunc-newweek arg) ) (defun calc-new-month (arg) (interactive "P") (calc-date-one-arg "nwmn" 'calcFunc-newmonth arg) ) (defun calc-new-year (arg) (interactive "P") (calc-date-one-arg "nwyr" 'calcFunc-newyear arg) ) (defun calc-inc-month (arg) (interactive "p") (calc-date-one-arg "incm" 'calcFunc-incmonth arg) ) (defun calc-business-days-plus (arg) (interactive "P") (calc-wrapper (calc-binary-op "bus+" 'calcFunc-badd arg)) ) (defun calc-business-days-minus (arg) (interactive "P") (calc-wrapper (calc-binary-op "bus-" 'calcFunc-bsub arg)) ) (defun calc-date-zero-args (prefix func arg) (calc-wrapper (if (consp arg) (calc-enter-result 1 prefix (list func (calc-top-n 1))) (calc-enter-result 0 prefix (if arg (list func (prefix-numeric-value arg)) (list func))))) ) (defun calc-date-one-arg (prefix func arg) (calc-wrapper (if (consp arg) (calc-enter-result 2 prefix (cons func (calc-top-list-n 2))) (calc-enter-result 1 prefix (if arg (list func (calc-top-n 1) (prefix-numeric-value arg)) (list func (calc-top-n 1)))))) ) ;;;; Hours-minutes-seconds forms. (defun math-normalize-hms (a) (let ((h (math-normalize (nth 1 a))) (m (math-normalize (nth 2 a))) (s (let ((calc-internal-prec (max (- calc-internal-prec 4) 3))) (math-normalize (nth 3 a))))) (if (math-negp h) (progn (if (math-posp s) (setq s (math-add s -60) m (math-add m 1))) (if (math-posp m) (setq m (math-add m -60) h (math-add h 1))) (if (not (Math-lessp -60 s)) (setq s (math-add s 60) m (math-add m -1))) (if (not (Math-lessp -60 m)) (setq m (math-add m 60) h (math-add h -1)))) (if (math-negp s) (setq s (math-add s 60) m (math-add m -1))) (if (math-negp m) (setq m (math-add m 60) h (math-add h -1))) (if (not (Math-lessp s 60)) (setq s (math-add s -60) m (math-add m 1))) (if (not (Math-lessp m 60)) (setq m (math-add m -60) h (math-add h 1)))) (if (and (eq (car-safe s) 'float) (<= (+ (math-numdigs (nth 1 s)) (nth 2 s)) (- 2 calc-internal-prec))) (setq s 0)) (list 'hms h m s)) ) ;;; Convert A from ANG or current angular mode to HMS format. (defun math-to-hms (a &optional ang) ; [X R] [Public] (cond ((eq (car-safe a) 'hms) a) ((eq (car-safe a) 'sdev) (math-make-sdev (math-to-hms (nth 1 a)) (math-to-hms (nth 2 a)))) ((not (Math-numberp a)) (list 'calcFunc-hms a)) ((math-negp a) (math-neg (math-to-hms (math-neg a) ang))) ((eq (or ang calc-angle-mode) 'rad) (math-to-hms (math-div a (math-pi-over-180)) 'deg)) ((memq (car-safe a) '(cplx polar)) a) (t ;(setq a (let ((calc-internal-prec (max (1- calc-internal-prec) 3))) ; (math-normalize a))) (math-normalize (let* ((b (math-mul a 3600)) (hm (math-trunc (math-div b 60))) (hmd (math-idivmod hm 60))) (list 'hms (car hmd) (cdr hmd) (math-sub b (math-mul hm 60))))))) ) (defun calcFunc-hms (h &optional m s) (or (Math-realp h) (math-reject-arg h 'realp)) (or m (setq m 0)) (or (Math-realp m) (math-reject-arg m 'realp)) (or s (setq s 0)) (or (Math-realp s) (math-reject-arg s 'realp)) (if (and (not (Math-lessp m 0)) (Math-lessp m 60) (not (Math-lessp s 0)) (Math-lessp s 60)) (math-add (math-to-hms h) (list 'hms 0 m s)) (math-to-hms (math-add h (math-add (math-div (or m 0) 60) (math-div (or s 0) 3600))) 'deg)) ) ;;; Convert A from HMS format to ANG or current angular mode. (defun math-from-hms (a &optional ang) ; [R X] [Public] (cond ((not (eq (car-safe a) 'hms)) (if (Math-numberp a) a (if (eq (car-safe a) 'sdev) (math-make-sdev (math-from-hms (nth 1 a) ang) (math-from-hms (nth 2 a) ang)) (if (eq (or ang calc-angle-mode) 'rad) (list 'calcFunc-rad a) (list 'calcFunc-deg a))))) ((math-negp a) (math-neg (math-from-hms (math-neg a) ang))) ((eq (or ang calc-angle-mode) 'rad) (math-mul (math-from-hms a 'deg) (math-pi-over-180))) (t (math-add (math-div (math-add (math-div (nth 3 a) '(float 6 1)) (nth 2 a)) 60) (nth 1 a)))) ) ;;;; Date forms. ;;; Some of these functions are adapted from Edward Reingold's "calendar.el". ;;; These versions are rewritten to use arbitrary-size integers. ;;; The Julian calendar is used up to 9/2/1752, after which the Gregorian ;;; calendar is used; the first day after 9/2/1752 is 9/14/1752. ;;; A numerical date is the number of days since midnight on ;;; the morning of January 1, 1 A.D. If the date is a non-integer, ;;; it represents a specific date and time. ;;; A "dt" is a list of the form, (year month day), corresponding to ;;; an integer code, or (year month day hour minute second), corresponding ;;; to a non-integer code. (defun math-date-to-dt (value) (if (eq (car-safe value) 'date) (setq value (nth 1 value))) (or (math-realp value) (math-reject-arg value 'datep)) (let* ((parts (math-date-parts value)) (date (car parts)) (time (nth 1 parts)) (month 1) day (year (math-quotient (math-add date (if (Math-lessp date 711859) 365 ; for speed, we take -108)) ; >1950 as a special case (if (math-negp value) 366 365))) ; this result may be an overestimate temp) (while (Math-lessp date (setq temp (math-absolute-from-date year 1 1))) (setq year (math-add year -1))) (if (eq year 0) (setq year -1)) (setq date (1+ (math-sub date temp))) (and (eq year 1752) (>= date 247) (setq date (+ date 11))) (setq temp (if (math-leap-year-p year) [1 32 61 92 122 153 183 214 245 275 306 336 999] [1 32 60 91 121 152 182 213 244 274 305 335 999])) (while (>= date (aref temp month)) (setq month (1+ month))) (setq day (1+ (- date (aref temp (1- month))))) (if (math-integerp value) (list year month day) (list year month day (/ time 3600) (% (/ time 60) 60) (math-add (% time 60) (nth 2 parts))))) ) (defun math-dt-to-date (dt) (or (integerp (nth 1 dt)) (math-reject-arg (nth 1 dt) 'fixnump)) (if (or (< (nth 1 dt) 1) (> (nth 1 dt) 12)) (math-reject-arg (nth 1 dt) "Month value is out of range")) (or (integerp (nth 2 dt)) (math-reject-arg (nth 2 dt) 'fixnump)) (if (or (< (nth 2 dt) 1) (> (nth 2 dt) 31)) (math-reject-arg (nth 2 dt) "Day value is out of range")) (let ((date (math-absolute-from-date (car dt) (nth 1 dt) (nth 2 dt)))) (if (nth 3 dt) (math-add (math-float date) (math-div (math-add (+ (* (nth 3 dt) 3600) (* (nth 4 dt) 60)) (nth 5 dt)) '(float 864 2))) date)) ) (defun math-date-parts (value &optional offset) (let* ((date (math-floor value)) (time (math-round (math-mul (math-sub value (or offset date)) 86400) (and (> calc-internal-prec 12) (- calc-internal-prec 12)))) (ftime (math-floor time))) (list date ftime (math-sub time ftime))) ) (defun math-this-year () (string-to-int (substring (current-time-string) -4)) ) (defun math-leap-year-p (year) (if (Math-lessp year 1752) (if (math-negp year) (= (math-imod (math-neg year) 4) 1) (= (math-imod year 4) 0)) (setq year (math-imod year 400)) (or (and (= (% year 4) 0) (/= (% year 100) 0)) (= year 0))) ) (defun math-days-in-month (year month) (if (and (= month 2) (math-leap-year-p year)) 29 (aref [31 28 31 30 31 30 31 31 30 31 30 31] (1- month))) ) (defun math-day-number (year month day) (let ((day-of-year (+ day (* 31 (1- month))))) (if (> month 2) (progn (setq day-of-year (- day-of-year (/ (+ 23 (* 4 month)) 10))) (if (math-leap-year-p year) (setq day-of-year (1+ day-of-year))))) (and (eq year 1752) (or (> month 9) (and (= month 9) (>= day 14))) (setq day-of-year (- day-of-year 11))) day-of-year) ) (defun math-absolute-from-date (year month day) (if (eq year 0) (setq year -1)) (let ((yearm1 (math-sub year 1))) (math-sub (math-add (math-day-number year month day) (math-add (math-mul 365 yearm1) (if (math-posp year) (math-quotient yearm1 4) (math-sub 365 (math-quotient (math-sub 3 year) 4))))) (if (or (Math-lessp year 1753) (and (eq year 1752) (<= month 9))) 1 (let ((correction (math-mul (math-quotient yearm1 100) 3))) (let ((res (math-idivmod correction 4))) (math-add (if (= (cdr res) 0) -1 0) (car res))))))) ) ;;; It is safe to redefine these in your .emacs file to use a different ;;; language. (defvar math-long-weekday-names '( "Sunday" "Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" )) (defvar math-short-weekday-names '( "Sun" "Mon" "Tue" "Wed" "Thu" "Fri" "Sat" )) (defvar math-long-month-names '( "January" "February" "March" "April" "May" "June" "July" "August" "September" "October" "November" "December" )) (defvar math-short-month-names '( "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec" )) (defun math-format-date (date) (if (eq (car-safe date) 'date) (setq date (nth 1 date))) (let ((entry (list date calc-internal-prec calc-date-format))) (or (cdr (assoc entry math-format-date-cache)) (let* ((dt nil) (calc-group-digits nil) (calc-leading-zeros nil) (calc-number-radix 10) year month day weekday hour minute second (bc-flag nil) (fmt (apply 'concat (mapcar 'math-format-date-part calc-date-format)))) (setq math-format-date-cache (cons (cons entry fmt) math-format-date-cache)) (and (setq dt (nthcdr 10 math-format-date-cache)) (setcdr dt nil)) fmt))) ) (setq math-format-date-cache nil) (defun math-format-date-part (x) (cond ((stringp x) x) ((listp x) (if (math-integerp date) "" (apply 'concat (mapcar 'math-format-date-part x)))) ((eq x 'X) "") ((eq x 'N) (math-format-number date)) ((eq x 'n) (math-format-number (math-floor date))) ((eq x 'J) (math-format-number (math-add date '(float (bigpos 235 214 17) -1)))) ((eq x 'j) (math-format-number (math-add (math-floor date) '(bigpos 424 721 1)))) ((eq x 'U) (math-format-number (nth 1 (math-date-parts date 719164)))) ((progn (or dt (progn (setq dt (math-date-to-dt date) year (car dt) month (nth 1 dt) day (nth 2 dt) weekday (math-mod (math-add (math-floor date) 6) 7) hour (nth 3 dt) minute (nth 4 dt) second (nth 5 dt)) (and (memq 'b calc-date-format) (math-negp year) (setq year (math-neg year) bc-flag t)))) (memq x '(Y YY BY))) (if (and (integerp year) (> year 1940) (< year 2040)) (format (cond ((eq x 'YY) "%02d") ((eq x 'BYY) "%2d") (t "%d")) (% year 100)) (if (and (natnump year) (< year 100)) (format "+%d" year) (math-format-number year)))) ((eq x 'YYY) (math-format-number year)) ((eq x 'YYYY) (if (and (natnump year) (< year 100)) (format "+%d" year) (math-format-number year))) ((eq x 'b) "") ((eq x 'aa) (and (not bc-flag) "ad")) ((eq x 'AA) (and (not bc-flag) "AD")) ((eq x 'aaa) (and (not bc-flag) "ad ")) ((eq x 'AAA) (and (not bc-flag) "AD ")) ((eq x 'aaaa) (and (not bc-flag) "a.d.")) ((eq x 'AAAA) (and (not bc-flag) "A.D.")) ((eq x 'bb) (and bc-flag "bc")) ((eq x 'BB) (and bc-flag "BC")) ((eq x 'bbb) (and bc-flag " bc")) ((eq x 'BBB) (and bc-flag " BC")) ((eq x 'bbbb) (and bc-flag "b.c.")) ((eq x 'BBBB) (and bc-flag "B.C.")) ((eq x 'M) (format "%d" month)) ((eq x 'MM) (format "%02d" month)) ((eq x 'BM) (format "%2d" month)) ((eq x 'mmm) (downcase (nth (1- month) math-short-month-names))) ((eq x 'Mmm) (nth (1- month) math-short-month-names)) ((eq x 'MMM) (upcase (nth (1- month) math-short-month-names))) ((eq x 'Mmmm) (nth (1- month) math-long-month-names)) ((eq x 'MMMM) (upcase (nth (1- month) math-long-month-names))) ((eq x 'D) (format "%d" day)) ((eq x 'DD) (format "%02d" day)) ((eq x 'BD) (format "%2d" day)) ((eq x 'W) (format "%d" weekday)) ((eq x 'www) (downcase (nth weekday math-short-weekday-names))) ((eq x 'Www) (nth weekday math-short-weekday-names)) ((eq x 'WWW) (upcase (nth weekday math-short-weekday-names))) ((eq x 'Wwww) (nth weekday math-long-weekday-names)) ((eq x 'WWWW) (upcase (nth weekday math-long-weekday-names))) ((eq x 'd) (format "%d" (math-day-number year month day))) ((eq x 'ddd) (format "%03d" (math-day-number year month day))) ((eq x 'bdd) (format "%3d" (math-day-number year month day))) ((eq x 'h) (and hour (format "%d" hour))) ((eq x 'hh) (and hour (format "%02d" hour))) ((eq x 'bh) (and hour (format "%2d" hour))) ((eq x 'H) (and hour (format "%d" (1+ (% (+ hour 11) 12))))) ((eq x 'HH) (and hour (format "%02d" (1+ (% (+ hour 11) 12))))) ((eq x 'BH) (and hour (format "%2d" (1+ (% (+ hour 11) 12))))) ((eq x 'p) (and hour (if (< hour 12) "a" "p"))) ((eq x 'P) (and hour (if (< hour 12) "A" "P"))) ((eq x 'pp) (and hour (if (< hour 12) "am" "pm"))) ((eq x 'PP) (and hour (if (< hour 12) "AM" "PM"))) ((eq x 'pppp) (and hour (if (< hour 12) "a.m." "p.m."))) ((eq x 'PPPP) (and hour (if (< hour 12) "A.M." "P.M."))) ((eq x 'm) (and minute (format "%d" minute))) ((eq x 'mm) (and minute (format "%02d" minute))) ((eq x 'bm) (and minute (format "%2d" minute))) ((eq x 'C) (and second (not (math-zerop second)) ":")) ((memq x '(s ss bs SS BS)) (and second (not (and (memq x '(SS BS)) (math-zerop second))) (if (integerp second) (format (cond ((memq x '(ss SS)) "%02d") ((memq x '(bs BS)) "%2d") (t "%d")) second) (concat (if (Math-lessp second 10) (cond ((memq x '(ss SS)) "0") ((memq x '(bs BS)) " ") (t "")) "") (let ((calc-float-format (list 'fix (min (- 12 calc-internal-prec) 0)))) (math-format-number second))))))) ) (defun math-parse-date (str) (catch 'syntax (or (math-parse-standard-date str t) (math-parse-standard-date str nil) (and (string-match "\\`[^-+/0-9a-zA-Z]*\\([-+]?[0-9]+\\.?[0-9]*\\([eE][-+]?[0-9]+\\)?\\)[^-+/0-9a-zA-Z]*\\'" str) (list 'date (math-read-number (math-match-substring str 1)))) (let ((case-fold-search t) (year nil) (month nil) (day nil) (weekday nil) (hour nil) (minute nil) (second nil) (bc-flag nil) (a nil) (b nil) (c nil) (bigyear nil) temp) ;; Extract the time, if any. (if (or (string-match "\\([0-9][0-9]?\\):\\([0-9][0-9]?\\)\\(:\\([0-9][0-9]?\\(\\.[0-9]+\\)?\\)\\)? *\\([ap]m?\\|[ap]\\. *m\\.\\|noon\\|n\\>\\|midnight\\|mid\\>\\|m\\>\\)?" str) (string-match "\\([0-9][0-9]?\\)\\(\\)\\(\\(\\(\\)\\)\\) *\\([ap]m?\\|[ap]\\. *m\\.\\|noon\\|n\\>\\|midnight\\|mid\\>\\|m\\>\\)" str)) (let ((ampm (math-match-substring str 6))) (setq hour (string-to-int (math-match-substring str 1)) minute (math-match-substring str 2) second (math-match-substring str 4) str (concat (substring str 0 (match-beginning 0)) (substring str (match-end 0)))) (if (equal minute "") (setq minute 0) (setq minute (string-to-int minute))) (if (equal second "") (setq second 0) (setq second (math-read-number second))) (if (equal ampm "") (if (> hour 23) (throw 'syntax "Hour value out of range")) (setq ampm (upcase (aref ampm 0))) (if (memq ampm '(?N ?M)) (if (and (= hour 12) (= minute 0) (eq second 0)) (if (eq ampm ?M) (setq hour 0)) (throw 'syntax "Time must be 12:00:00 in this context")) (if (or (= hour 0) (> hour 12)) (throw 'syntax "Hour value out of range")) (if (eq (= ampm ?A) (= hour 12)) (setq hour (% (+ hour 12) 24))))))) ;; Rewrite xx-yy-zz to xx/yy/zz to avoid seeing "-" as a minus sign. (while (string-match "[0-9a-zA-Z]\\(-\\)[0-9a-zA-Z]" str) (progn (setq str (copy-sequence str)) (aset str (match-beginning 1) ?\/))) ;; Extract obvious month or weekday names. (if (string-match "[a-zA-Z]" str) (progn (setq month (math-parse-date-word math-long-month-names)) (setq weekday (math-parse-date-word math-long-weekday-names)) (or month (setq month (math-parse-date-word math-short-month-names))) (or weekday (math-parse-date-word math-short-weekday-names)) (or hour (if (setq temp (math-parse-date-word '( "noon" "midnight" "mid" ))) (setq hour (if (= temp 1) 12 0) minute 0 second 0))) (or (math-parse-date-word '( "ad" "a.d." )) (if (math-parse-date-word '( "bc" "b.c." )) (setq bc-flag t))) (if (string-match "[a-zA-Z]+" str) (throw 'syntax (format "Bad word in date: \"%s\"" (math-match-substring str 0)))))) ;; If there is a huge number other than the year, ignore it. (while (and (string-match "[-+]?0*[1-9][0-9][0-9][0-9][0-9]+" str) (setq temp (concat (substring str 0 (match-beginning 0)) (substring str (match-end 0)))) (string-match "[4-9][0-9]\\|[0-9][0-9][0-9]\\|[-+][0-9]+[^-]*\\'" temp)) (setq str temp)) ;; If there is a number with a sign or a large number, it is a year. (if (or (string-match "\\([-+][0-9]+\\)[^-]*\\'" str) (string-match "\\(0*[1-9][0-9][0-9]+\\)" str)) (setq year (math-match-substring str 1) str (concat (substring str 0 (match-beginning 1)) (substring str (match-end 1))) year (math-read-number year) bigyear t)) ;; Collect remaining numbers. (setq temp 0) (while (string-match "[0-9]+" str temp) (and c (throw 'syntax "Too many numbers in date")) (setq c (string-to-int (math-match-substring str 0))) (or b (setq b c c nil)) (or a (setq a b b nil)) (setq temp (match-end 0))) ;; Check that we have the right amount of information. (setq temp (+ (if year 1 0) (if month 1 0) (if day 1 0) (if a 1 0) (if b 1 0) (if c 1 0))) (if (> temp 3) (throw 'syntax "Too many numbers in date") (if (or (< temp 2) (and year (= temp 2))) (throw 'syntax "Not enough numbers in date") (if (= temp 2) ; if year omitted, assume current year (setq year (math-this-year))))) ;; A large number must be a year. (or year (if (and a (or (> a 31) (< a 1))) (setq year a a b b c c nil) (if (and b (or (> b 31) (< b 1))) (setq year b b c c nil) (if (and c (or (> c 31) (< c 1))) (setq year c c nil))))) ;; A medium-large number must be a day. (if year (if (and a (> a 12)) (setq day a a b b c c nil) (if (and b (> b 12)) (setq day b b c c nil) (if (and c (> c 12)) (setq day c c nil))))) ;; We may know enough to sort it out now. (if (and year day) (or month (setq month a)) (if (and year month) (setq day a) ;; Interpret order of numbers as same as for display format. (setq temp calc-date-format) (while temp (cond ((not (symbolp (car temp)))) ((memq (car temp) '(Y YY BY YYY YYYY)) (or year (setq year a a b b c))) ((memq (car temp) '(M MM BM mmm Mmm Mmmm MMM MMMM)) (or month (setq month a a b b c))) ((memq (car temp) '(D DD BD)) (or day (setq day a a b b c)))) (setq temp (cdr temp))) ;; If display format was not complete, assume American style. (or month (setq month a a b b c)) (or day (setq day a a b b c)) (or year (setq year a a b b c)))) (if bc-flag (setq year (math-neg (math-abs year)))) (math-parse-date-validate year bigyear month day hour minute second)))) ) (defun math-parse-date-validate (year bigyear month day hour minute second) (and (not bigyear) (natnump year) (< year 100) (setq year (+ year (if (< year 40) 2000 1900)))) (if (eq year 0) (throw 'syntax "Year value is out of range")) (if (or (< month 1) (> month 12)) (throw 'syntax "Month value is out of range")) (if (or (< day 1) (> day (math-days-in-month year month))) (throw 'syntax "Day value is out of range")) (and hour (progn (if (or (< hour 0) (> hour 23)) (throw 'syntax "Hour value is out of range")) (if (or (< minute 0) (> minute 59)) (throw 'syntax "Minute value is out of range")) (if (or (math-negp second) (not (Math-lessp second 60))) (throw 'syntax "Seconds value is out of range")))) (list 'date (math-dt-to-date (append (list year month day) (and hour (list hour minute second))))) ) (defun math-parse-date-word (names &optional front) (let ((n 1)) (while (and names (not (string-match (if (equal (car names) "Sep") "Sept?" (regexp-quote (car names))) str))) (setq names (cdr names) n (1+ n))) (and names (or (not front) (= (match-beginning 0) 0)) (progn (setq str (concat (substring str 0 (match-beginning 0)) (if front "" " ") (substring str (match-end 0)))) n))) ) (defun math-parse-standard-date (str with-time) (let ((case-fold-search t) (okay t) num (fmt calc-date-format) this next (gnext nil) (year nil) (month nil) (day nil) (bigyear nil) (yearday nil) (hour nil) (minute nil) (second nil) (bc-flag nil)) (while (and fmt okay) (setq this (car fmt) fmt (setq fmt (or (cdr fmt) (prog1 gnext (setq gnext nil)))) next (car fmt)) (if (consp next) (setq next (car next))) (or (cond ((listp this) (or (not with-time) (not this) (setq gnext fmt fmt this))) ((stringp this) (if (and (<= (length this) (length str)) (equal this (substring str 0 (length this)))) (setq str (substring str (length this))))) ((eq this 'X) t) ((memq this '(n N j J)) (and (string-match "\\`[-+]?[0-9.]+\\([eE][-+]?[0-9]+\\)?" str) (setq num (math-match-substring str 0) str (substring str (match-end 0)) num (math-date-to-dt (math-read-number num)) num (math-sub num (if (memq this '(n N)) 0 (if (or (eq this 'j) (math-integerp num)) '(bigpos 424 721 1) '(float (bigpos 235 214 17) -1)))) hour (or (nth 3 num) hour) minute (or (nth 4 num) minute) second (or (nth 5 num) second) year (car num) month (nth 1 num) day (nth 2 num)))) ((eq this 'U) (and (string-match "\\`[-+]?[0-9]+" str) (setq num (math-match-substring str 0) str (substring str (match-end 0)) num (math-date-to-dt (math-add 719164 (math-div (math-read-number num) '(float 864 2)))) hour (nth 3 num) minute (nth 4 num) second (nth 5 num) year (car num) month (nth 1 num) day (nth 2 num)))) ((memq this '(mmm Mmm MMM)) (setq month (math-parse-date-word math-short-month-names t))) ((memq this '(Mmmm MMMM)) (setq month (math-parse-date-word math-long-month-names t))) ((memq this '(www Www WWW)) (math-parse-date-word math-short-weekday-names t)) ((memq this '(Wwww WWWW)) (math-parse-date-word math-long-weekday-names t)) ((memq this '(p P)) (if (string-match "\\`a" str) (setq hour (if (= hour 12) 0 hour) str (substring str 1)) (if (string-match "\\`p" str) (setq hour (if (= hour 12) 12 (% (+ hour 12) 24)) str (substring str 1))))) ((memq this '(pp PP pppp PPPP)) (if (string-match "\\`am\\|a\\.m\\." str) (setq hour (if (= hour 12) 0 hour) str (substring str (match-end 0))) (if (string-match "\\`pm\\|p\\.m\\." str) (setq hour (if (= hour 12) 12 (% (+ hour 12) 24)) str (substring str (match-end 0)))))) ((memq this '(Y YY BY YYY YYYY)) (and (if (memq next '(MM DD ddd hh HH mm ss SS)) (if (memq this '(Y YY BYY)) (string-match "\\` *[0-9][0-9]" str) (string-match "\\`[0-9][0-9][0-9][0-9]" str)) (string-match "\\`[-+]?[0-9]+" str)) (setq year (math-match-substring str 0) bigyear (or (eq this 'YYY) (memq (aref str 0) '(?\+ ?\-))) str (substring str (match-end 0)) year (math-read-number year)))) ((eq this 'b) t) ((memq this '(aa AA aaaa AAAA)) (if (string-match "\\` *\\(ad\\|a\\.d\\.\\)" str) (setq str (substring str (match-end 0))))) ((memq this '(aaa AAA)) (if (string-match "\\` *ad *" str) (setq str (substring str (match-end 0))))) ((memq this '(bb BB bbb BBB bbbb BBBB)) (if (string-match "\\` *\\(bc\\|b\\.c\\.\\)" str) (setq str (substring str (match-end 0)) bc-flag t))) ((memq this '(s ss bs SS BS)) (and (if (memq next '(YY YYYY MM DD hh HH mm)) (string-match "\\` *[0-9][0-9]\\(\\.[0-9]+\\)?" str) (string-match "\\` *[0-9][0-9]?\\(\\.[0-9]+\\)?" str)) (setq second (math-match-substring str 0) str (substring str (match-end 0)) second (math-read-number second)))) ((eq this 'C) (if (string-match "\\`:[0-9][0-9]" str) (setq str (substring str 1)) t)) ((or (not (if (and (memq this '(ddd MM DD hh HH mm)) (memq next '(YY YYYY MM DD ddd hh HH mm ss SS))) (if (eq this 'ddd) (string-match "\\` *[0-9][0-9][0-9]" str) (string-match "\\` *[0-9][0-9]" str)) (string-match "\\` *[0-9]+" str))) (and (setq num (string-to-int (math-match-substring str 0)) str (substring str (match-end 0))) nil)) nil) ((eq this 'W) (and (>= num 0) (< num 7))) ((memq this '(d ddd bdd)) (setq yearday num)) ((memq this '(M MM BM)) (setq month num)) ((memq this '(D DD BD)) (setq day num)) ((memq this '(h hh bh H HH BH)) (setq hour num)) ((memq this '(m mm bm)) (setq minute num))) (setq okay nil))) (if yearday (if (and month day) (setq yearday nil) (setq month 1 day 1))) (if (and okay (equal str "")) (and month day (or (not (or hour minute second)) (and hour minute)) (progn (or year (setq year (math-this-year))) (or second (setq second 0)) (if bc-flag (setq year (math-neg (math-abs year)))) (setq day (math-parse-date-validate year bigyear month day hour minute second)) (if yearday (setq day (math-add day (1- yearday)))) day)))) ) (defun calcFunc-now (&optional zone) (let ((date (let ((calc-date-format nil)) (math-parse-date (current-time-string))))) (if (consp date) (if zone (math-add date (math-div (math-sub (calcFunc-tzone nil date) (calcFunc-tzone zone date)) '(float 864 2))) date) (calc-record-why "*Unable to interpret current date from system") (append (list 'calcFunc-now) (and zone (list zone))))) ) (defun calcFunc-year (date) (car (math-date-to-dt date)) ) (defun calcFunc-month (date) (nth 1 (math-date-to-dt date)) ) (defun calcFunc-day (date) (nth 2 (math-date-to-dt date)) ) (defun calcFunc-weekday (date) (if (eq (car-safe date) 'date) (setq date (nth 1 date))) (or (math-realp date) (math-reject-arg date 'datep)) (math-mod (math-add (math-floor date) 6) 7) ) (defun calcFunc-yearday (date) (let ((dt (math-date-to-dt date))) (math-day-number (car dt) (nth 1 dt) (nth 2 dt))) ) (defun calcFunc-hour (date) (if (eq (car-safe date) 'hms) (nth 1 date) (or (nth 3 (math-date-to-dt date)) 0)) ) (defun calcFunc-minute (date) (if (eq (car-safe date) 'hms) (nth 2 date) (or (nth 4 (math-date-to-dt date)) 0)) ) (defun calcFunc-second (date) (if (eq (car-safe date) 'hms) (nth 3 date) (or (nth 5 (math-date-to-dt date)) 0)) ) (defun calcFunc-time (date) (let ((dt (math-date-to-dt date))) (if (nth 3 dt) (cons 'hms (nthcdr 3 dt)) (list 'hms 0 0 0))) ) (defun calcFunc-date (date &optional month day hour minute second) (and (math-messy-integerp month) (setq month (math-trunc month))) (and month (not (integerp month)) (math-reject-arg month 'fixnump)) (and (math-messy-integerp day) (setq day (math-trunc day))) (and day (not (integerp day)) (math-reject-arg day 'fixnump)) (if (and (eq (car-safe hour) 'hms) (not minute)) (setq second (nth 3 hour) minute (nth 2 hour) hour (nth 1 hour))) (and (math-messy-integerp hour) (setq hour (math-trunc hour))) (and hour (not (integerp hour)) (math-reject-arg hour 'fixnump)) (and (math-messy-integerp minute) (setq minute (math-trunc minute))) (and minute (not (integerp minute)) (math-reject-arg minute 'fixnump)) (and (math-messy-integerp second) (setq second (math-trunc second))) (and second (not (math-realp second)) (math-reject-arg second 'realp)) (if month (progn (and (math-messy-integerp date) (setq date (math-trunc date))) (and date (not (math-integerp date)) (math-reject-arg date 'integerp)) (if day (if hour (list 'date (math-dt-to-date (list date month day hour (or minute 0) (or second 0)))) (list 'date (math-dt-to-date (list date month day)))) (list 'date (math-dt-to-date (list (math-this-year) date month))))) (if (math-realp date) (list 'date date) (if (eq (car date) 'date) (nth 1 date) (math-reject-arg date 'datep)))) ) (defun calcFunc-julian (date &optional zone) (if (math-realp date) (list 'date (if (math-integerp date) (math-sub date '(bigpos 424 721 1)) (setq date (math-sub date '(float (bigpos 235 214 17) -1))) (math-sub date (math-div (calcFunc-tzone zone date) '(float 864 2))))) (if (eq (car date) 'date) (math-add (nth 1 date) (if (math-integerp (nth 1 date)) '(bigpos 424 721 1) (math-add '(float (bigpos 235 214 17) -1) (math-div (calcFunc-tzone zone date) '(float 864 2))))) (math-reject-arg date 'datep))) ) (defun calcFunc-unixtime (date &optional zone) (if (math-realp date) (progn (setq date (math-add 719164 (math-div date '(float 864 2)))) (list 'date (math-sub date (math-div (calcFunc-tzone zone date) '(float 864 2))))) (if (eq (car date) 'date) (math-add (nth 1 (math-date-parts (nth 1 date) 719164)) (calcFunc-tzone zone date)) (math-reject-arg date 'datep))) ) (defun calcFunc-tzone (&optional zone date) (if zone (cond ((math-realp zone) (math-round (math-mul zone 3600))) ((eq (car zone) 'hms) (math-round (math-mul (math-from-hms zone 'deg) 3600))) ((eq (car zone) '+) (math-add (calcFunc-tzone (nth 1 zone) date) (calcFunc-tzone (nth 2 zone) date))) ((eq (car zone) '-) (math-sub (calcFunc-tzone (nth 1 zone) date) (calcFunc-tzone (nth 2 zone) date))) ((eq (car zone) 'var) (let ((name (upcase (symbol-name (nth 1 zone)))) found) (if (setq found (assoc name math-tzone-names)) (calcFunc-tzone (math-add (nth 1 found) (if (integerp (nth 2 found)) (nth 2 found) (or (math-daylight-savings-adjust date (car found)) 0))) date) (if (equal name "LOCAL") (calcFunc-tzone nil date) (math-reject-arg zone "*Unrecognized time zone name"))))) (t (math-reject-arg zone "*Expected a time zone"))) (if (calc-var-value 'var-TimeZone) (calcFunc-tzone (calc-var-value 'var-TimeZone) date) (let ((p math-tzone-names) (offset 0) (tz '(var error var-error))) (save-excursion (set-buffer (get-buffer-create " *Calc Temporary*")) (erase-buffer) (call-process "date" nil t) (goto-char 1) (let ((case-fold-search t)) (while (and p (not (search-forward (car (car p)) nil t))) (setq p (cdr p)))) (if (looking-at "\\([-+][0-9]?[0-9]\\)\\([0-9][0-9]\\)?\\(\\'\\|[^0-9]\\)") (setq offset (math-add (string-to-int (buffer-substring (match-beginning 1) (match-end 1))) (if (match-beginning 2) (math-div (string-to-int (buffer-substring (match-beginning 2) (match-end 2))) 60) 0))))) (if p (progn (setq p (car p)) ;; Try to convert to a generalized time zone. (if (integerp (nth 2 p)) (let ((gen math-tzone-names)) (while (and gen (not (equal (nth 2 (car gen)) (car p))) (not (equal (nth 3 (car gen)) (car p))) (not (equal (nth 4 (car gen)) (car p))) (not (equal (nth 5 (car gen)) (car p)))) (setq gen (cdr gen))) (and gen (setq gen (car gen)) (equal (math-daylight-savings-adjust nil (car gen)) (nth 2 p)) (setq p gen)))) (setq tz (math-add (list 'var (intern (car p)) (intern (concat "var-" (car p)))) offset)))) (kill-buffer " *Calc Temporary*") (setq var-TimeZone tz) (calc-refresh-evaltos 'var-TimeZone) (calcFunc-tzone tz date)))) ) ;;; Note: Longer names must appear before shorter names which are ;;; substrings of them. (defvar math-tzone-names '( ( "MEGT" -1 "MET" "METDST" ) ; Middle Europe ( "METDST" -1 -1 ) ( "MET" -1 0 ) ( "MEGZ" -1 "MEZ" "MESZ" ) ( "MEZ" -1 0 ) ( "MESZ" -1 -1 ) ( "WEGT" 0 "WET" "WETDST" ) ; Western Europe ( "WETDST" 0 -1 ) ( "WET" 0 0 ) ( "BGT" 0 "GMT" "BST" ) ( "GMT" 0 0 ) ( "BST" 0 -1 ) ; Britain ( "NGT" (float 35 -1) "NST" "NDT" ) ; Newfoundland ( "NST" (float 35 -1) 0 ) ( "NDT" (float 35 -1) -1 ) ( "AGT" 4 "AST" "ADT" ) ( "AST" 4 0 ) ( "ADT" 4 -1 ) ; Atlantic ( "EGT" 5 "EST" "EDT" ) ( "EST" 5 0 ) ( "EDT" 5 -1 ) ; Eastern ( "CGT" 6 "CST" "CDT" ) ( "CST" 6 0 ) ( "CDT" 6 -1 ) ; Central ( "MGT" 7 "MST" "MDT" ) ( "MST" 7 0 ) ( "MDT" 7 -1 ) ; Mountain ( "PGT" 8 "PST" "PDT" ) ( "PST" 8 0 ) ( "PDT" 8 -1 ) ; Pacific ( "YGT" 9 "YST" "YDT" ) ( "YST" 9 0 ) ( "YDT" 9 -1 ) ; Yukon )) (defun math-daylight-savings-adjust (date zone &optional dt) (or date (setq date (nth 1 (calcFunc-now)))) (let (bump) (if (eq (car-safe date) 'date) (setq bump 0 date (nth 1 date)) (if (and date (math-realp date)) (let ((zadj (assoc zone math-tzone-names))) (if zadj (setq bump -1 date (math-sub date (math-div (nth 1 zadj) '(float 24 0)))))) (math-reject-arg date 'datep))) (setq date (math-float date)) (or dt (setq dt (math-date-to-dt date))) (and math-daylight-savings-hook (funcall math-daylight-savings-hook date dt zone bump))) ) (defun calcFunc-dsadj (date &optional zone) (if zone (or (eq (car-safe zone) 'var) (math-reject-arg zone "*Time zone variable expected")) (setq zone (or (calc-var-value 'var-TimeZone) (progn (calcFunc-tzone) (calc-var-value 'var-TimeZone))))) (setq zone (and (eq (car-safe zone) 'var) (upcase (symbol-name (nth 1 zone))))) (let ((zadj (assoc zone math-tzone-names))) (or zadj (math-reject-arg zone "*Unrecognized time zone name")) (if (integerp (nth 2 zadj)) (nth 2 zadj) (math-daylight-savings-adjust date zone))) ) (defun calcFunc-tzconv (date z1 z2) (if (math-realp date) (nth 1 (calcFunc-tzconv (list 'date date) z1 z2)) (calcFunc-unixtime (calcFunc-unixtime date z1) z2)) ) (defvar math-daylight-savings-hook 'math-std-daylight-savings) (defun math-std-daylight-savings (date dt zone bump) "Standard North American daylight savings algorithm. This implements the rules for the U.S. and Canada as of 1987. Daylight savings begins on the first Sunday of April at 2 a.m., and ends on the last Sunday of October at 2 a.m." (cond ((< (nth 1 dt) 4) 0) ((= (nth 1 dt) 4) (let ((sunday (math-prev-weekday-in-month date dt 7 0))) (cond ((< (nth 2 dt) sunday) 0) ((= (nth 2 dt) sunday) (if (>= (nth 3 dt) (+ 3 bump)) -1 0)) (t -1)))) ((< (nth 1 dt) 10) -1) ((= (nth 1 dt) 10) (let ((sunday (math-prev-weekday-in-month date dt 31 0))) (cond ((< (nth 2 dt) sunday) -1) ((= (nth 2 dt) sunday) (if (>= (nth 3 dt) (+ 2 bump)) 0 -1)) (t 0)))) (t 0)) ) ;;; Compute the day (1-31) of the WDAY (0-6) on or preceding the given ;;; day of the given month. (defun math-prev-weekday-in-month (date dt day wday) (or day (setq day (nth 2 dt))) (if (> day (math-days-in-month (car dt) (nth 1 dt))) (setq day (math-days-in-month (car dt) (nth 1 dt)))) (let ((zeroth (math-sub (math-floor date) (nth 2 dt)))) (math-sub (nth 1 (calcFunc-newweek (math-add zeroth day))) zeroth)) ) (defun calcFunc-pwday (date &optional day weekday) (if (eq (car-safe date) 'date) (setq date (nth 1 date))) (or (math-realp date) (math-reject-arg date 'datep)) (if (math-messy-integerp day) (setq day (math-trunc day))) (or (integerp day) (math-reject-arg day 'fixnump)) (if (= day 0) (setq day 31)) (and (or (< day 7) (> day 31)) (math-reject-arg day 'range)) (math-prev-weekday-in-month date (math-date-to-dt date) day (or weekday 0)) ) (defun calcFunc-newweek (date &optional weekday) (if (eq (car-safe date) 'date) (setq date (nth 1 date))) (or (math-realp date) (math-reject-arg date 'datep)) (or weekday (setq weekday 0)) (and (math-messy-integerp weekday) (setq weekday (math-trunc weekday))) (or (integerp weekday) (math-reject-arg weekday 'fixnump)) (and (or (< weekday 0) (> weekday 6)) (math-reject-arg weekday 'range)) (setq date (math-floor date)) (list 'date (math-sub date (calcFunc-weekday (math-sub date weekday)))) ) (defun calcFunc-newmonth (date &optional day) (or day (setq day 1)) (and (math-messy-integerp day) (setq day (math-trunc day))) (or (integerp day) (math-reject-arg day 'fixnump)) (and (or (< day 0) (> day 31)) (math-reject-arg day 'range)) (let ((dt (math-date-to-dt date))) (if (or (= day 0) (> day (math-days-in-month (car dt) (nth 1 dt)))) (setq day (math-days-in-month (car dt) (nth 1 dt)))) (and (eq (car dt) 1752) (= (nth 1 dt) 9) (if (>= day 14) (setq day (- day 11)))) (list 'date (math-add (math-dt-to-date (list (car dt) (nth 1 dt) 1)) (1- day)))) ) (defun calcFunc-newyear (date &optional day) (or day (setq day 1)) (and (math-messy-integerp day) (setq day (math-trunc day))) (or (integerp day) (math-reject-arg day 'fixnump)) (let ((dt (math-date-to-dt date))) (if (and (>= day 0) (<= day 366)) (let ((max (if (eq (car dt) 1752) 355 (if (math-leap-year-p (car dt)) 366 365)))) (if (or (= day 0) (> day max)) (setq day max)) (list 'date (math-add (math-dt-to-date (list (car dt) 1 1)) (1- day)))) (if (and (>= day -12) (<= day -1)) (list 'date (math-dt-to-date (list (car dt) (- day) 1))) (math-reject-arg day 'range)))) ) (defun calcFunc-incmonth (date &optional step) (or step (setq step 1)) (and (math-messy-integerp step) (setq step (math-trunc step))) (or (math-integerp step) (math-reject-arg step 'integerp)) (let* ((dt (math-date-to-dt date)) (year (car dt)) (month (math-add (1- (nth 1 dt)) step)) (extra (calcFunc-idiv month 12)) (day (nth 2 dt))) (setq month (1+ (math-sub month (math-mul extra 12))) year (math-add year extra) day (min day (math-days-in-month year month))) (and (math-posp (car dt)) (not (math-posp year)) (setq year (math-sub year 1))) ; did we go past the year zero? (and (math-negp (car dt)) (not (math-negp year)) (setq year (math-add year 1))) (list 'date (math-dt-to-date (cons year (cons month (cons day (cdr (cdr (cdr dt))))))))) ) (defun calcFunc-incyear (date &optional step) (calcFunc-incmonth date (math-mul (or step 1) 12)) ) (defun calcFunc-bsub (a b) (or (eq (car-safe a) 'date) (math-reject-arg a 'datep)) (if (eq (car-safe b) 'date) (if (math-lessp (nth 1 a) (nth 1 b)) (math-neg (calcFunc-bsub b a)) (math-setup-holidays b) (let* ((da (math-to-business-day a)) (db (math-to-business-day b))) (math-add (math-sub (car da) (car db)) (if (and (cdr db) (not (cdr da))) 1 0)))) (calcFunc-badd a (math-neg b))) ) (defun calcFunc-badd (a b) (if (eq (car-safe b) 'date) (if (eq (car-safe a) 'date) (math-reject-arg nil "*Illegal combination in date arithmetic") (calcFunc-badd b a)) (if (eq (car-safe a) 'date) (if (Math-realp b) (if (Math-zerop b) a (let* ((d (math-to-business-day a)) (bb (math-add (car d) (if (and (cdr d) (Math-posp b)) (math-sub b 1) b)))) (or (math-from-business-day bb) (calcFunc-badd a b)))) (if (eq (car-safe b) 'hms) (let ((hours (nth 7 math-holidays-cache))) (setq b (math-div (math-from-hms b 'deg) 24)) (if hours (setq b (math-div b (cdr hours)))) (calcFunc-badd a b)) (math-reject-arg nil "*Illegal combination in date arithmetic"))) (math-reject-arg a 'datep))) ) (defun calcFunc-holiday (a) (if (cdr (math-to-business-day a)) 1 0) ) (setq math-holidays-cache nil) (setq math-holidays-cache-tag t) ;;; Compute the number of business days since Jan 1, 1 AD. (defun math-to-business-day (date &optional need-year) (if (eq (car-safe date) 'date) (setq date (nth 1 date))) (or (Math-realp date) (math-reject-arg date 'datep)) (let* ((day (math-floor date)) (time (math-sub date day)) (dt (math-date-to-dt day)) (delta 0) (holiday nil)) (or (not need-year) (eq (car dt) need-year) (math-reject-arg (list 'date day) "*Generated holiday has wrong year")) (math-setup-holidays date) (let ((days (car math-holidays-cache))) (while (and (setq days (cdr days)) (< (car days) day)) (setq delta (1+ delta))) (and days (= day (car days)) (setq holiday t))) (let* ((weekdays (nth 3 math-holidays-cache)) (weeks (1- (/ (+ day 6) 7))) (wkday (- day 1 (* weeks 7)))) (setq delta (+ delta (* weeks (length weekdays)))) (while (and weekdays (< (car weekdays) wkday)) (setq weekdays (cdr weekdays) delta (1+ delta))) (and weekdays (eq wkday (car weekdays)) (setq holiday t))) (let ((hours (nth 7 math-holidays-cache))) (if hours (progn (setq time (math-div (math-sub time (car hours)) (cdr hours))) (if (Math-lessp time 0) (setq time 0)) (or (Math-lessp time 1) (setq time (math-sub 1 (math-div 1 (math-mul 86400 (cdr hours))))))))) (cons (math-add (math-sub day delta) time) holiday)) ) ;;; Compute the date a certain number of business days since Jan 1, 1 AD. ;;; If this returns NIL, holiday table was adjusted; redo calculation. (defun math-from-business-day (num) (let* ((day (math-floor num)) (time (math-sub num day))) (or (integerp day) (math-reject-arg nil "*Date is outside valid range")) (math-setup-holidays) (let ((days (nth 1 math-holidays-cache)) (delta 0)) (while (and (setq days (cdr days)) (< (car days) day)) (setq delta (1+ delta))) (setq day (+ day delta))) (let* ((weekdays (nth 3 math-holidays-cache)) (bweek (- 7 (length weekdays))) (weeks (1- (/ (+ day (1- bweek)) bweek))) (wkday (- day 1 (* weeks bweek))) (w 0)) (setq day (+ day (* weeks (length weekdays)))) (while (if (memq w weekdays) (setq day (1+ day)) (> (setq wkday (1- wkday)) 0)) (setq w (1+ w))) (let ((hours (nth 7 math-holidays-cache))) (if hours (setq time (math-add (math-mul time (cdr hours)) (car hours))))) (and (not (math-setup-holidays day)) (list 'date (math-add day time))))) ) (defun math-setup-holidays (&optional date) (or (eq (calc-var-value 'var-Holidays) math-holidays-cache-tag) (let ((h (calc-var-value 'var-Holidays)) (wdnames '( (sun . 0) (mon . 1) (tue . 2) (wed . 3) (thu . 4) (fri . 5) (sat . 6) )) (days nil) (weekdays nil) (exprs nil) (limit nil) (hours nil)) (or (math-vectorp h) (math-reject-arg h "*Holidays variable must be a vector")) (while (setq h (cdr h)) (cond ((or (and (eq (car-safe (car h)) 'date) (integerp (nth 1 (car h)))) (and (eq (car-safe (car h)) 'intv) (eq (car-safe (nth 2 (car h))) 'date)) (eq (car-safe (car h)) 'vec)) (setq days (cons (car h) days))) ((and (eq (car-safe (car h)) 'var) (assq (nth 1 (car h)) wdnames)) (setq weekdays (cons (cdr (assq (nth 1 (car h)) wdnames)) weekdays))) ((and (eq (car-safe (car h)) 'intv) (eq (car-safe (nth 2 (car h))) 'hms) (eq (car-safe (nth 3 (car h))) 'hms)) (if hours (math-reject-arg (car h) "*Only one hours interval allowed in Holidays")) (setq hours (math-div (car h) '(hms 24 0 0))) (if (or (Math-lessp (nth 2 hours) 0) (Math-lessp 1 (nth 3 hours))) (math-reject-arg (car h) "*Hours interval out of range")) (setq hours (cons (nth 2 hours) (math-sub (nth 3 hours) (nth 2 hours)))) (if (Math-zerop (cdr hours)) (math-reject-arg (car h) "*Degenerate hours interval"))) ((or (and (eq (car-safe (car h)) 'intv) (Math-integerp (nth 2 (car h))) (Math-integerp (nth 3 (car h)))) (and (integerp (car h)) (> (car h) 1900) (< (car h) 2100))) (if limit (math-reject-arg (car h) "*Only one limit allowed in Holidays")) (setq limit (calcFunc-vint (car h) '(intv 3 1 2737))) (if (equal limit '(vec)) (math-reject-arg (car h) "*Limit is out of range"))) ((or (math-expr-contains (car h) '(var y var-y)) (math-expr-contains (car h) '(var m var-m))) (setq exprs (cons (car h) exprs))) (t (math-reject-arg (car h) "*Holidays must contain a vector of holidays")))) (if (= (length weekdays) 7) (math-reject-arg nil "*Too many weekend days")) (setq math-holidays-cache (list (list -1) ; 0: days list (list -1) ; 1: inverse-days list nil ; 2: exprs (sort weekdays '<) (or limit '(intv 3 1 2737)) nil ; 5: (lo.hi) expanded years (cons exprs days) hours) ; 7: business hours math-holidays-cache-tag (calc-var-value 'var-Holidays)))) (if date (let ((year (calcFunc-year date)) (limits (nth 5 math-holidays-cache)) (done nil)) (or (eq (calcFunc-in year (nth 4 math-holidays-cache)) 1) (progn (or (eq (car-safe date) 'date) (setq date (list 'date date))) (math-reject-arg date "*Date is outside valid range"))) (unwind-protect (let ((days (nth 6 math-holidays-cache))) (if days (let ((year nil)) ; see below (setcar (nthcdr 6 math-holidays-cache) nil) (math-setup-add-holidays (cons 'vec (cdr days))) (setcar (nthcdr 2 math-holidays-cache) (car days)))) (cond ((not (nth 2 math-holidays-cache)) (setq done t) nil) ((not limits) (setcar (nthcdr 5 math-holidays-cache) (cons year year)) (math-setup-year-holidays year) (setq done t)) ((< year (car limits)) (message "Computing holidays, %d .. %d" year (1- (car limits))) (calc-set-command-flag 'clear-message) (while (< year (car limits)) (setcar limits (1- (car limits))) (math-setup-year-holidays (car limits))) (setq done t)) ((> year (cdr limits)) (message "Computing holidays, %d .. %d" (1+ (cdr limits)) year) (calc-set-command-flag 'clear-message) (while (> year (cdr limits)) (setcdr limits (1+ (cdr limits))) (math-setup-year-holidays (cdr limits))) (setq done t)) (t (setq done t) nil))) (or done (setq math-holidays-cache-tag t))))) ) (defun math-setup-year-holidays (year) (let ((exprs (nth 2 math-holidays-cache))) (while exprs (let* ((var-y year) (var-m nil) (expr (math-evaluate-expr (car exprs)))) (if (math-expr-contains expr '(var m var-m)) (let ((var-m 0)) (while (<= (setq var-m (1+ var-m)) 12) (math-setup-add-holidays (math-evaluate-expr expr)))) (math-setup-add-holidays expr))) (setq exprs (cdr exprs)))) ) (defun math-setup-add-holidays (days) ; uses "year" (cond ((eq (car-safe days) 'vec) (while (setq days (cdr days)) (math-setup-add-holidays (car days)))) ((eq (car-safe days) 'intv) (let ((day (math-ceiling (nth 2 days)))) (or (eq (calcFunc-in day days) 1) (setq day (math-add day 1))) (while (eq (calcFunc-in day days) 1) (math-setup-add-holidays day) (setq day (math-add day 1))))) ((eq (car-safe days) 'date) (math-setup-add-holidays (nth 1 days))) ((eq days 0)) ((integerp days) (let ((b (math-to-business-day days year))) (or (cdr b) ; don't register holidays twice! (let ((prev (car math-holidays-cache)) (iprev (nth 1 math-holidays-cache))) (while (and (cdr prev) (< (nth 1 prev) days)) (setq prev (cdr prev) iprev (cdr iprev))) (setcdr prev (cons days (cdr prev))) (setcdr iprev (cons (car b) (cdr iprev))) (while (setq iprev (cdr iprev)) (setcar iprev (1- (car iprev)))))))) ((Math-realp days) (math-reject-arg (list 'date days) "*Invalid holiday value")) (t (math-reject-arg days "*Holiday formula failed to evaluate"))) ) ;;;; Error forms. ;;; Build a standard deviation form. [X X X] (defun math-make-sdev (x sigma) (if (memq (car-safe x) '(date mod sdev intv vec)) (math-reject-arg x 'realp)) (if (memq (car-safe sigma) '(date mod sdev intv vec)) (math-reject-arg sigma 'realp)) (if (or (Math-negp sigma) (memq (car-safe sigma) '(cplx polar))) (setq sigma (math-abs sigma))) (if (and (Math-zerop sigma) (Math-scalarp x)) x (list 'sdev x sigma)) ) (defun calcFunc-sdev (x sigma) (math-make-sdev x sigma) ) ;;;; Modulo forms. (defun math-normalize-mod (a) (let ((n (math-normalize (nth 1 a))) (m (math-normalize (nth 2 a)))) (if (and (math-anglep n) (math-anglep m) (math-posp m)) (math-make-mod n m) (math-normalize (list 'calcFunc-makemod n m)))) ) ;;; Build a modulo form. [N R R] (defun math-make-mod (n m) (setq calc-previous-modulo m) (and n (cond ((not (Math-anglep m)) (math-reject-arg m 'anglep)) ((not (math-posp m)) (math-reject-arg m 'posp)) ((Math-anglep n) (if (or (Math-negp n) (not (Math-lessp n m))) (list 'mod (math-mod n m) m) (list 'mod n m))) ((memq (car n) '(+ - / vec neg)) (math-normalize (cons (car n) (mapcar (function (lambda (x) (math-make-mod x m))) (cdr n))))) ((and (eq (car n) '*) (Math-anglep (nth 1 n))) (math-mul (math-make-mod (nth 1 n) m) (nth 2 n))) ((memq (car n) '(* ^ var calcFunc-subscr)) (math-mul (math-make-mod 1 m) n)) (t (math-reject-arg n 'anglep)))) ) (defun calcFunc-makemod (n m) (math-make-mod n m) ) ;;;; Interval forms. ;;; Build an interval form. [X S X X] (defun math-make-intv (mask lo hi) (if (memq (car-safe lo) '(cplx polar mod sdev intv vec)) (math-reject-arg lo 'realp)) (if (memq (car-safe hi) '(cplx polar mod sdev intv vec)) (math-reject-arg hi 'realp)) (or (eq (eq (car-safe lo) 'date) (eq (car-safe hi) 'date)) (math-reject-arg (if (eq (car-safe lo) 'date) hi lo) 'datep)) (if (and (or (Math-realp lo) (eq (car lo) 'date)) (or (Math-realp hi) (eq (car hi) 'date))) (let ((cmp (math-compare lo hi))) (if (= cmp 0) (if (= mask 3) lo (list 'intv mask lo hi)) (if (> cmp 0) (if (= mask 3) (list 'intv 2 lo lo) (list 'intv mask lo lo)) (list 'intv mask lo hi)))) (list 'intv mask lo hi)) ) (defun calcFunc-intv (mask lo hi) (if (math-messy-integerp mask) (setq mask (math-trunc mask))) (or (natnump mask) (math-reject-arg mask 'fixnatnump)) (or (<= mask 3) (math-reject-arg mask 'range)) (math-make-intv mask lo hi) ) (defun math-sort-intv (mask lo hi) (if (Math-lessp hi lo) (math-make-intv (aref [0 2 1 3] mask) hi lo) (math-make-intv mask lo hi)) ) (defun math-combine-intervals (a am b bm c cm d dm) (let (res) (if (= (setq res (math-compare a c)) 1) (setq a c am cm) (if (= res 0) (setq am (or am cm)))) (if (= (setq res (math-compare b d)) -1) (setq b d bm dm) (if (= res 0) (setq bm (or bm dm)))) (math-make-intv (+ (if am 2 0) (if bm 1 0)) a b)) ) (defun math-div-mod (a b m) ; [R R R R] (Returns nil if no solution) (and (Math-integerp a) (Math-integerp b) (Math-integerp m) (let ((u1 1) (u3 b) (v1 0) (v3 m)) (while (not (eq v3 0)) ; See Knuth sec 4.5.2, exercise 15 (let* ((q (math-idivmod u3 v3)) (t1 (math-sub u1 (math-mul v1 (car q))))) (setq u1 v1 u3 v3 v1 t1 v3 (cdr q)))) (let ((q (math-idivmod a u3))) (and (eq (cdr q) 0) (math-mod (math-mul (car q) u1) m))))) ) (defun math-mod-intv (a b) (let* ((q1 (math-floor (math-div (nth 2 a) b))) (q2 (math-floor (math-div (nth 3 a) b))) (m1 (math-sub (nth 2 a) (math-mul q1 b))) (m2 (math-sub (nth 3 a) (math-mul q2 b)))) (cond ((equal q1 q2) (math-sort-intv (nth 1 a) m1 m2)) ((and (math-equal-int (math-sub q2 q1) 1) (math-zerop m2) (memq (nth 1 a) '(0 2))) (math-make-intv (nth 1 a) m1 b)) (t (math-make-intv 2 0 b)))) ) (defun math-read-angle-brackets () (let* ((last (or (math-check-for-commas t) (length exp-str))) (str (substring exp-str exp-pos last)) (res (if (string-match "\\` *\\([a-zA-Z#][a-zA-Z0-9#]* *,? *\\)*:" str) (let ((str1 (substring str 0 (1- (match-end 0)))) (str2 (substring str (match-end 0))) (calc-hashes-used 0)) (setq str1 (math-read-expr (concat "[" str1 "]"))) (if (eq (car-safe str1) 'error) str1 (setq str2 (math-read-expr str2)) (if (eq (car-safe str2) 'error) str2 (append '(calcFunc-lambda) (cdr str1) (list str2))))) (if (string-match "#" str) (let ((calc-hashes-used 0)) (and (setq str (math-read-expr str)) (if (eq (car-safe str) 'error) str (append '(calcFunc-lambda) (calc-invent-args calc-hashes-used) (list str))))) (math-parse-date str))))) (if (stringp res) (throw 'syntax res)) (if (eq (car-safe res) 'error) (throw 'syntax (nth 2 res))) (setq exp-pos (1+ last)) (math-read-token) res) ) calc-2.02c/calc-incom.el100644 22403 13 16002 5402630631 13363 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-incom.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-incom () nil) ;;; Incomplete forms. (defun calc-begin-complex () (interactive) (calc-wrapper (if (or calc-algebraic-mode calc-incomplete-algebraic-mode) (calc-alg-entry "(") (calc-push (list 'incomplete calc-complex-mode)))) ) (defun calc-end-complex () (interactive) (calc-comma t) (calc-wrapper (let ((top (calc-top 1))) (if (and (eq (car-safe top) 'incomplete) (eq (nth 1 top) 'intv)) (progn (if (< (length top) 4) (setq top (append top '((neg (var inf var-inf)))))) (if (< (length top) 5) (setq top (append top '((var inf var-inf))))) (calc-enter-result 1 "..)" (cdr top))) (if (not (and (eq (car-safe top) 'incomplete) (memq (nth 1 top) '(cplx polar)))) (error "Not entering a complex number")) (while (< (length top) 4) (setq top (append top '(0)))) (if (not (and (math-realp (nth 2 top)) (math-anglep (nth 3 top)))) (error "Components must be real")) (calc-enter-result 1 "()" (cdr top))))) ) (defun calc-begin-vector () (interactive) (calc-wrapper (if (or calc-algebraic-mode calc-incomplete-algebraic-mode) (calc-alg-entry "[") (calc-push '(incomplete vec)))) ) (defun calc-end-vector () (interactive) (calc-comma t) (calc-wrapper (let ((top (calc-top 1))) (if (and (eq (car-safe top) 'incomplete) (eq (nth 1 top) 'intv)) (progn (if (< (length top) 4) (setq top (append top '((neg (var inf var-inf)))))) (if (< (length top) 5) (setq top (append top '((var inf var-inf))))) (setcar (cdr (cdr top)) (1+ (nth 2 top))) (calc-enter-result 1 "..]" (cdr top))) (if (not (and (eq (car-safe top) 'incomplete) (eq (nth 1 top) 'vec))) (error "Not entering a vector")) (calc-pop-push-record 1 "[]" (cdr top))))) ) (defun calc-comma (&optional allow-polar) (interactive) (calc-wrapper (let ((num (calc-find-first-incomplete (nthcdr calc-stack-top calc-stack) 1))) (if (= num 0) (error "Not entering a vector or complex number")) (let* ((inc (calc-top num)) (stuff (calc-top-list (1- num))) (new (append inc stuff))) (if (and (null stuff) (not allow-polar) (or (eq (nth 1 inc) 'vec) (< (length new) 4))) (setq new (append new (if (= (length new) 2) '(0) (nthcdr (1- (length new)) new))))) (or allow-polar (if (eq (nth 1 new) 'polar) (setq new (append '(incomplete cplx) (cdr (cdr new)))) (if (eq (nth 1 new) 'intv) (setq new (append '(incomplete cplx) (cdr (cdr (cdr new)))))))) (if (and (memq (nth 1 new) '(cplx polar)) (> (length new) 4)) (error "Too many components in complex number")) (if (and (eq (nth 1 new) 'intv) (> (length new) 5)) (error "Too many components in interval form")) (calc-pop-push num new)))) ) (defun calc-semi () (interactive) (calc-wrapper (let ((num (calc-find-first-incomplete (nthcdr calc-stack-top calc-stack) 1))) (if (= num 0) (error "Not entering a vector or complex number")) (let ((inc (calc-top num)) (stuff (calc-top-list (1- num)))) (if (eq (nth 1 inc) 'cplx) (setq inc (append '(incomplete polar) (cdr (cdr inc)))) (if (eq (nth 1 inc) 'intv) (setq inc (append '(incomplete polar) (cdr (cdr (cdr inc))))))) (cond ((eq (nth 1 inc) 'polar) (let ((new (append inc stuff))) (if (> (length new) 4) (error "Too many components in complex number") (if (= (length new) 2) (setq new (append new '(1))))) (calc-pop-push num new))) ((null stuff) (if (> (length inc) 2) (if (math-vectorp (nth 2 inc)) (calc-comma) (calc-pop-push 1 (list 'incomplete 'vec (cdr (cdr inc))) (list 'incomplete 'vec))))) ((math-vectorp (car stuff)) (calc-comma)) ((eq (car-safe (car-safe (nth (+ num calc-stack-top) calc-stack))) 'incomplete) (calc-end-vector) (calc-comma) (let ((calc-algebraic-mode nil) (calc-incomplete-algebraic-mode nil)) (calc-begin-vector))) ((or (= (length inc) 2) (math-vectorp (nth 2 inc))) (calc-pop-push num (append inc (list (cons 'vec stuff))) (list 'incomplete 'vec))) (t (calc-pop-push num (list 'incomplete 'vec (cons 'vec (append (cdr (cdr inc)) stuff))) (list 'incomplete 'vec))))))) ) (defun calc-digit-dots () (if (eq calc-prev-char ?.) (progn (delete-backward-char 1) (if (calc-minibuffer-contains ".*\\.\\'") (delete-backward-char 1)) (setq calc-prev-char 'dots last-command-char 32) (if calc-prev-prev-char (calcDigit-nondigit) (setq calc-digit-value nil) (erase-buffer) (exit-minibuffer))) ;; just ignore extra decimal point, anticipating ".." (delete-backward-char 1)) ) (defun calc-dots () (interactive) (calc-wrapper (let ((num (calc-find-first-incomplete (nthcdr calc-stack-top calc-stack) 1))) (if (= num 0) (error "Not entering an interval form")) (let* ((inc (calc-top num)) (stuff (calc-top-list (1- num))) (new (append inc stuff))) (if (not (eq (nth 1 new) 'intv)) (setq new (append '(incomplete intv) (if (eq (nth 1 new) 'vec) '(2) '(0)) (cdr (cdr new))))) (if (and (null stuff) (= (length new) 3)) (setq new (append new '((neg (var inf var-inf)))))) (if (> (length new) 5) (error "Too many components in interval form")) (calc-pop-push num new)))) ) (defun calc-find-first-incomplete (stack n) (cond ((null stack) 0) ((eq (car-safe (car-safe (car stack))) 'incomplete) n) (t (calc-find-first-incomplete (cdr stack) (1+ n)))) ) (defun calc-incomplete-error (a) (cond ((memq (nth 1 a) '(cplx polar)) (error "Complex number is incomplete")) ((eq (nth 1 a) 'vec) (error "Vector is incomplete")) ((eq (nth 1 a) 'intv) (error "Interval form is incomplete")) (t (error "Object is incomplete"))) ) calc-2.02c/calc-undo.el100644 22403 13 11077 5402630776 13244 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-undo.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-undo () nil) ;;; Undo. (defun calc-undo (n) (interactive "p") (and calc-executing-macro (error "Use C-x e, not X, to run a keyboard macro that uses Undo.")) (if (<= n 0) (if (< n 0) (calc-redo (- n)) (calc-last-args 1)) (calc-wrapper (if (null (nthcdr (1- n) calc-undo-list)) (error "No further undo information available")) (setq calc-undo-list (prog1 (nthcdr n calc-undo-list) (let ((saved-stack-top calc-stack-top)) (let ((calc-stack-top 0)) (calc-handle-undos calc-undo-list n)) (setq calc-stack-top saved-stack-top)))) (message "Undo!"))) ) (defun calc-handle-undos (cl n) (if (> n 0) (progn (let ((old-redo calc-redo-list)) (setq calc-undo-list nil) (calc-handle-undo (car cl)) (setq calc-redo-list (append calc-undo-list old-redo))) (calc-handle-undos (cdr cl) (1- n)))) ) (defun calc-handle-undo (list) (and list (let ((action (car list))) (cond ((eq (car action) 'push) (calc-pop-stack 1 (nth 1 action) t)) ((eq (car action) 'pop) (calc-push-list (nth 2 action) (nth 1 action))) ((eq (car action) 'set) (calc-record-undo (list 'set (nth 1 action) (symbol-value (nth 1 action)))) (set (nth 1 action) (nth 2 action))) ((eq (car action) 'store) (let ((v (intern (nth 1 action)))) (calc-record-undo (list 'store (nth 1 action) (and (boundp v) (symbol-value v)))) (if (y-or-n-p (format "Un-store variable %s? " (nth 1 action))) (progn (if (nth 2 action) (set v (nth 2 action)) (makunbound v)) (calc-refresh-evaltos v))))) ((eq (car action) 'eval) (calc-record-undo (append (list 'eval (nth 2 action) (nth 1 action)) (cdr (cdr (cdr action))))) (apply (nth 1 action) (cdr (cdr (cdr action)))))) (calc-handle-undo (cdr list)))) ) (defun calc-redo (n) (interactive "p") (and calc-executing-macro (error "Use C-x e, not X, to run a keyboard macro that uses Redo.")) (if (<= n 0) (calc-undo (- n)) (calc-wrapper (if (null (nthcdr (1- n) calc-redo-list)) (error "Unable to redo")) (setq calc-redo-list (prog1 (nthcdr n calc-redo-list) (let ((saved-stack-top calc-stack-top)) (let ((calc-stack-top 0)) (calc-handle-redos calc-redo-list n)) (setq calc-stack-top saved-stack-top)))) (message "Redo!"))) ) (defun calc-handle-redos (cl n) (if (> n 0) (progn (let ((old-undo calc-undo-list)) (setq calc-undo-list nil) (calc-handle-undo (car cl)) (setq calc-undo-list (append calc-undo-list old-undo))) (calc-handle-redos (cdr cl) (1- n)))) ) (defun calc-last-args (n) (interactive "p") (and calc-executing-macro (error "Use C-x e, not X, to run a keyboard macro that uses last-args.")) (calc-wrapper (let ((urec (calc-find-last-x calc-undo-list n))) (if urec (calc-handle-last-x urec) (error "Not enough undo information available")))) ) (defun calc-handle-last-x (list) (and list (let ((action (car list))) (if (eq (car action) 'pop) (calc-pop-push-record-list 0 "larg" (delq 'top-of-stack (nth 2 action)))) (calc-handle-last-x (cdr list)))) ) (defun calc-find-last-x (ul n) (and ul (if (calc-undo-does-pushes (car ul)) (if (<= n 1) (car ul) (calc-find-last-x (cdr ul) (1- n))) (calc-find-last-x (cdr ul) n))) ) (defun calc-undo-does-pushes (list) (and list (or (eq (car (car list)) 'pop) (calc-undo-does-pushes (cdr list)))) ) calc-2.02c/calc-arith.el100644 22403 13 251277 5402630520 13421 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-arith.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-arith () nil) ;;; Arithmetic. (defun calc-min (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "min" 'calcFunc-min arg '(var inf var-inf))) ) (defun calc-max (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "max" 'calcFunc-max arg '(neg (var inf var-inf)))) ) (defun calc-abs (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "abs" 'calcFunc-abs arg)) ) (defun calc-idiv (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "\\" 'calcFunc-idiv arg 1)) ) (defun calc-floor (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-inverse) (if (calc-is-hyperbolic) (calc-unary-op "ceil" 'calcFunc-fceil arg) (calc-unary-op "ceil" 'calcFunc-ceil arg)) (if (calc-is-hyperbolic) (calc-unary-op "flor" 'calcFunc-ffloor arg) (calc-unary-op "flor" 'calcFunc-floor arg)))) ) (defun calc-ceiling (arg) (interactive "P") (calc-invert-func) (calc-floor arg) ) (defun calc-round (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-inverse) (if (calc-is-hyperbolic) (calc-unary-op "trnc" 'calcFunc-ftrunc arg) (calc-unary-op "trnc" 'calcFunc-trunc arg)) (if (calc-is-hyperbolic) (calc-unary-op "rond" 'calcFunc-fround arg) (calc-unary-op "rond" 'calcFunc-round arg)))) ) (defun calc-trunc (arg) (interactive "P") (calc-invert-func) (calc-round arg) ) (defun calc-mant-part (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "mant" 'calcFunc-mant arg)) ) (defun calc-xpon-part (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "xpon" 'calcFunc-xpon arg)) ) (defun calc-scale-float (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "scal" 'calcFunc-scf arg)) ) (defun calc-abssqr (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "absq" 'calcFunc-abssqr arg)) ) (defun calc-sign (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "sign" 'calcFunc-sign arg)) ) (defun calc-increment (arg) (interactive "p") (calc-wrapper (calc-enter-result 1 "incr" (list 'calcFunc-incr (calc-top-n 1) arg))) ) (defun calc-decrement (arg) (interactive "p") (calc-wrapper (calc-enter-result 1 "decr" (list 'calcFunc-decr (calc-top-n 1) arg))) ) (defun math-abs-approx (a) (cond ((Math-negp a) (math-neg a)) ((Math-anglep a) a) ((eq (car a) 'cplx) (math-add (math-abs (nth 1 a)) (math-abs (nth 2 a)))) ((eq (car a) 'polar) (nth 1 a)) ((eq (car a) 'sdev) (math-abs-approx (nth 1 a))) ((eq (car a) 'intv) (math-max (math-abs (nth 2 a)) (math-abs (nth 3 a)))) ((eq (car a) 'date) a) ((eq (car a) 'vec) (math-reduce-vec 'math-add-abs-approx a)) ((eq (car a) 'calcFunc-abs) (car a)) (t a)) ) (defun math-add-abs-approx (a b) (math-add (math-abs-approx a) (math-abs-approx b)) ) ;;;; Declarations. (setq math-decls-cache-tag nil) (setq math-decls-cache nil) (setq math-decls-all nil) ;;; Math-decls-cache is an a-list where each entry is a list of the form: ;;; (VAR TYPES RANGE) ;;; where VAR is a variable name (with var- prefix) or function name; ;;; TYPES is a list of type symbols (any, int, frac, ...) ;;; RANGE is a sorted vector of intervals describing the range. (defun math-setup-declarations () (or (eq math-decls-cache-tag (calc-var-value 'var-Decls)) (let ((p (calc-var-value 'var-Decls)) vec type range) (setq math-decls-cache-tag p math-decls-cache nil) (and (eq (car-safe p) 'vec) (while (setq p (cdr p)) (and (eq (car-safe (car p)) 'vec) (setq vec (nth 2 (car p))) (condition-case err (let ((v (nth 1 (car p)))) (setq type nil range nil) (or (eq (car-safe vec) 'vec) (setq vec (list 'vec vec))) (while (and (setq vec (cdr vec)) (not (Math-objectp (car vec)))) (and (eq (car-safe (car vec)) 'var) (let ((st (assq (nth 1 (car vec)) math-super-types))) (cond (st (setq type (append type st))) ((eq (nth 1 (car vec)) 'pos) (setq type (append type '(real number)) range '(intv 1 0 (var inf var-inf)))) ((eq (nth 1 (car vec)) 'nonneg) (setq type (append type '(real number)) range '(intv 3 0 (var inf var-inf)))))))) (if vec (setq type (append type '(real number)) range (math-prepare-set (cons 'vec vec)))) (setq type (list type range)) (or (eq (car-safe v) 'vec) (setq v (list 'vec v))) (while (setq v (cdr v)) (if (or (eq (car-safe (car v)) 'var) (not (Math-primp (car v)))) (setq math-decls-cache (cons (cons (if (eq (car (car v)) 'var) (nth 2 (car v)) (car (car v))) type) math-decls-cache))))) (error nil))))) (setq math-decls-all (assq 'var-All math-decls-cache)))) ) (defvar math-super-types '( ( int numint rat real number ) ( numint real number ) ( frac rat real number ) ( rat real number ) ( float real number ) ( real number ) ( number ) ( scalar ) ( matrix vector ) ( vector ) ( const ) )) (defun math-known-scalarp (a &optional assume-scalar) (math-setup-declarations) (if (if calc-matrix-mode (eq calc-matrix-mode 'scalar) assume-scalar) (not (math-check-known-matrixp a)) (math-check-known-scalarp a)) ) (defun math-known-matrixp (a) (and (not (Math-scalarp a)) (not (math-known-scalarp a t))) ) ;;; Try to prove that A is a scalar (i.e., a non-vector). (defun math-check-known-scalarp (a) (cond ((Math-objectp a) t) ((memq (car a) math-scalar-functions) t) ((memq (car a) math-real-scalar-functions) t) ((memq (car a) math-scalar-if-args-functions) (while (and (setq a (cdr a)) (math-check-known-scalarp (car a)))) (null a)) ((eq (car a) '^) (math-check-known-scalarp (nth 1 a))) ((math-const-var a) t) (t (let ((decl (if (eq (car a) 'var) (or (assq (nth 2 a) math-decls-cache) math-decls-all) (assq (car a) math-decls-cache)))) (memq 'scalar (nth 1 decl))))) ) ;;; Try to prove that A is *not* a scalar. (defun math-check-known-matrixp (a) (cond ((Math-objectp a) nil) ((memq (car a) math-nonscalar-functions) t) ((memq (car a) math-scalar-if-args-functions) (while (and (setq a (cdr a)) (not (math-check-known-matrixp (car a))))) a) ((eq (car a) '^) (math-check-known-matrixp (nth 1 a))) ((math-const-var a) nil) (t (let ((decl (if (eq (car a) 'var) (or (assq (nth 2 a) math-decls-cache) math-decls-all) (assq (car a) math-decls-cache)))) (memq 'vector (nth 1 decl))))) ) ;;; Try to prove that A is a real (i.e., not complex). (defun math-known-realp (a) (< (math-possible-signs a) 8) ) ;;; Try to prove that A is real and positive. (defun math-known-posp (a) (eq (math-possible-signs a) 4) ) ;;; Try to prove that A is real and negative. (defun math-known-negp (a) (eq (math-possible-signs a) 1) ) ;;; Try to prove that A is real and nonnegative. (defun math-known-nonnegp (a) (memq (math-possible-signs a) '(2 4 6)) ) ;;; Try to prove that A is real and nonpositive. (defun math-known-nonposp (a) (memq (math-possible-signs a) '(1 2 3)) ) ;;; Try to prove that A is nonzero. (defun math-known-nonzerop (a) (memq (math-possible-signs a) '(1 4 5 8 9 12 13)) ) ;;; Return true if A is negative, or looks negative but we don't know. (defun math-guess-if-neg (a) (let ((sgn (math-possible-signs a))) (if (memq sgn '(1 3)) t (if (memq sgn '(2 4 6)) nil (math-looks-negp a)))) ) ;;; Find the possible signs of A, assuming A is a number of some kind. ;;; Returns an integer with bits: 1 may be negative, ;;; 2 may be zero, ;;; 4 may be positive, ;;; 8 may be nonreal. (defun math-possible-signs (a &optional origin) (cond ((Math-objectp a) (if origin (setq a (math-sub a origin))) (cond ((Math-posp a) 4) ((Math-negp a) 1) ((Math-zerop a) 2) ((eq (car a) 'intv) (cond ((Math-zerop (nth 2 a)) 6) ((Math-zerop (nth 3 a)) 3) (t 7))) ((eq (car a) 'sdev) (if (math-known-realp (nth 1 a)) 7 15)) (t 8))) ((memq (car a) '(+ -)) (cond ((Math-realp (nth 1 a)) (if (eq (car a) '-) (math-neg-signs (math-possible-signs (nth 2 a) (if origin (math-add origin (nth 1 a)) (nth 1 a)))) (math-possible-signs (nth 2 a) (if origin (math-sub origin (nth 1 a)) (math-neg (nth 1 a)))))) ((Math-realp (nth 2 a)) (let ((org (if (eq (car a) '-) (nth 2 a) (math-neg (nth 2 a))))) (math-possible-signs (nth 1 a) (if origin (math-add origin org) org)))) (t (let ((s1 (math-possible-signs (nth 1 a) origin)) (s2 (math-possible-signs (nth 2 a)))) (if (eq (car a) '-) (setq s2 (math-neg-signs s2))) (cond ((eq s1 s2) s1) ((eq s1 2) s2) ((eq s2 2) s1) ((>= s1 8) 15) ((>= s2 8) 15) ((and (eq s1 4) (eq s2 6)) 4) ((and (eq s2 4) (eq s1 6)) 4) ((and (eq s1 1) (eq s2 3)) 1) ((and (eq s2 1) (eq s1 3)) 1) (t 7)))))) ((eq (car a) 'neg) (math-neg-signs (math-possible-signs (nth 1 a) (and origin (math-neg origin))))) ((and origin (Math-zerop origin) (setq origin nil) nil)) ((and (or (eq (car a) '*) (and (eq (car a) '/) origin)) (Math-realp (nth 1 a))) (let ((s (if (eq (car a) '*) (if (Math-zerop (nth 1 a)) (math-possible-signs 0 origin) (math-possible-signs (nth 2 a) (math-div (or origin 0) (nth 1 a)))) (math-neg-signs (math-possible-signs (nth 2 a) (math-div (nth 1 a) origin)))))) (if (Math-negp (nth 1 a)) (math-neg-signs s) s))) ((and (memq (car a) '(* /)) (Math-realp (nth 2 a))) (let ((s (math-possible-signs (nth 1 a) (if (eq (car a) '*) (math-mul (or origin 0) (nth 2 a)) (math-div (or origin 0) (nth 2 a)))))) (if (Math-negp (nth 2 a)) (math-neg-signs s) s))) ((eq (car a) 'vec) (let ((signs 0)) (while (and (setq a (cdr a)) (< signs 15)) (setq signs (logior signs (math-possible-signs (car a) origin)))) signs)) (t (let ((sign (cond ((memq (car a) '(* /)) (let ((s1 (math-possible-signs (nth 1 a))) (s2 (math-possible-signs (nth 2 a)))) (cond ((>= s1 8) 15) ((>= s2 8) 15) ((and (eq (car a) '/) (memq s2 '(2 3 6 7))) 15) (t (logior (if (memq s1 '(4 5 6 7)) s2 0) (if (memq s1 '(2 3 6 7)) 2 0) (if (memq s1 '(1 3 5 7)) (math-neg-signs s2) 0)))))) ((eq (car a) '^) (let ((s1 (math-possible-signs (nth 1 a))) (s2 (math-possible-signs (nth 2 a)))) (cond ((>= s1 8) 15) ((>= s2 8) 15) ((eq s1 4) 4) ((eq s1 2) (if (eq s2 4) 2 15)) ((eq s2 2) (if (memq s1 '(1 5)) 2 15)) ((Math-integerp (nth 2 a)) (if (math-evenp (nth 2 a)) (if (memq s1 '(3 6 7)) 6 4) s1)) ((eq s1 6) (if (eq s2 4) 6 15)) (t 7)))) ((eq (car a) '%) (let ((s2 (math-possible-signs (nth 2 a)))) (cond ((>= s2 8) 7) ((eq s2 2) 2) ((memq s2 '(4 6)) 6) ((memq s2 '(1 3)) 3) (t 7)))) ((and (memq (car a) '(calcFunc-abs calcFunc-abssqr)) (= (length a) 2)) (let ((s1 (math-possible-signs (nth 1 a)))) (cond ((eq s1 2) 2) ((memq s1 '(1 4 5)) 4) (t 6)))) ((and (eq (car a) 'calcFunc-exp) (= (length a) 2)) (let ((s1 (math-possible-signs (nth 1 a)))) (if (>= s1 8) 15 (if (or (not origin) (math-negp origin)) 4 (setq origin (math-sub (or origin 0) 1)) (if (Math-zerop origin) (setq origin nil)) s1)))) ((or (and (memq (car a) '(calcFunc-ln calcFunc-log10)) (= (length a) 2)) (and (eq (car a) 'calcFunc-log) (= (length a) 3) (math-known-posp (nth 2 a)))) (if (math-known-nonnegp (nth 1 a)) (math-possible-signs (nth 1 a) 1) 15)) ((and (eq (car a) 'calcFunc-sqrt) (= (length a) 2)) (let ((s1 (math-possible-signs (nth 1 a)))) (if (memq s1 '(2 4 6)) s1 15))) ((memq (car a) math-nonnegative-functions) 6) ((memq (car a) math-positive-functions) 4) ((memq (car a) math-real-functions) 7) ((memq (car a) math-real-scalar-functions) 7) ((and (memq (car a) math-real-if-arg-functions) (= (length a) 2)) (if (math-known-realp (nth 1 a)) 7 15))))) (cond (sign (if origin (+ (logand sign 8) (if (Math-posp origin) (if (memq sign '(1 2 3 8 9 10 11)) 1 7) (if (memq sign '(2 4 6 8 10 12 14)) 4 7))) sign)) ((math-const-var a) (cond ((eq (nth 2 a) 'var-pi) (if origin (math-possible-signs (math-pi) origin) 4)) ((eq (nth 2 a) 'var-e) (if origin (math-possible-signs (math-e) origin) 4)) ((eq (nth 2 a) 'var-inf) 4) ((eq (nth 2 a) 'var-uinf) 13) ((eq (nth 2 a) 'var-i) 8) (t 15))) (t (math-setup-declarations) (let ((decl (if (eq (car a) 'var) (or (assq (nth 2 a) math-decls-cache) math-decls-all) (assq (car a) math-decls-cache)))) (if (and origin (memq 'int (nth 1 decl)) (not (Math-num-integerp origin))) 5 (if (nth 2 decl) (math-possible-signs (nth 2 decl) origin) (if (memq 'real (nth 1 decl)) 7 15))))))))) ) (defun math-neg-signs (s1) (if (>= s1 8) (+ 8 (math-neg-signs (- s1 8))) (+ (if (memq s1 '(1 3 5 7)) 4 0) (if (memq s1 '(2 3 6 7)) 2 0) (if (memq s1 '(4 5 6 7)) 1 0))) ) ;;; Try to prove that A is an integer. (defun math-known-integerp (a) (eq (math-possible-types a) 1) ) (defun math-known-num-integerp (a) (<= (math-possible-types a t) 3) ) (defun math-known-imagp (a) (= (math-possible-types a) 16) ) ;;; Find the possible types of A. ;;; Returns an integer with bits: 1 may be integer. ;;; 2 may be integer-valued float. ;;; 4 may be fraction. ;;; 8 may be non-integer-valued float. ;;; 16 may be imaginary. ;;; 32 may be non-real, non-imaginary. ;;; Real infinities count as integers for the purposes of this function. (defun math-possible-types (a &optional num) (cond ((Math-objectp a) (cond ((Math-integerp a) (if num 3 1)) ((Math-messy-integerp a) (if num 3 2)) ((eq (car a) 'frac) (if num 12 4)) ((eq (car a) 'float) (if num 12 8)) ((eq (car a) 'intv) (if (equal (nth 2 a) (nth 3 a)) (math-possible-types (nth 2 a)) 15)) ((eq (car a) 'sdev) (if (math-known-realp (nth 1 a)) 15 63)) ((eq (car a) 'cplx) (if (math-zerop (nth 1 a)) 16 32)) ((eq (car a) 'polar) (if (or (Math-equal (nth 2 a) (math-quarter-circle nil)) (Math-equal (nth 2 a) (math-neg (math-quarter-circle nil)))) 16 48)) (t 63))) ((eq (car a) '/) (let* ((t1 (math-possible-types (nth 1 a) num)) (t2 (math-possible-types (nth 2 a) num)) (t12 (logior t1 t2))) (if (< t12 16) (if (> (logand t12 10) 0) 10 (if (or (= t1 4) (= t2 4) calc-prefer-frac) 5 15)) (if (< t12 32) (if (= t1 16) (if (= t2 16) 15 (if (< t2 16) 16 31)) (if (= t2 16) (if (< t1 16) 16 31) 31)) 63)))) ((memq (car a) '(+ - * %)) (let* ((t1 (math-possible-types (nth 1 a) num)) (t2 (math-possible-types (nth 2 a) num)) (t12 (logior t1 t2))) (if (eq (car a) '%) (setq t1 (logand t1 15) t2 (logand t2 15) t12 (logand t12 15))) (if (< t12 16) (let ((mask (if (<= t12 3) 1 (if (and (or (and (<= t1 3) (= (logand t2 3) 0)) (and (<= t2 3) (= (logand t1 3) 0))) (memq (car a) '(+ -))) 4 5)))) (if num (* mask 3) (logior (if (and (> (logand t1 5) 0) (> (logand t2 5) 0)) mask 0) (if (> (logand t12 10) 0) (* mask 2) 0)))) (if (< t12 32) (if (eq (car a) '*) (if (= t1 16) (if (= t2 16) 15 (if (< t2 16) 16 31)) (if (= t2 16) (if (< t1 16) 16 31) 31)) (if (= t12 16) 16 (if (or (and (= t1 16) (< t2 16)) (and (= t2 16) (< t1 16))) 32 63))) 63)))) ((eq (car a) 'neg) (math-possible-types (nth 1 a))) ((eq (car a) '^) (let* ((t1 (math-possible-types (nth 1 a) num)) (t2 (math-possible-types (nth 2 a) num)) (t12 (logior t1 t2))) (if (and (<= t2 3) (math-known-nonnegp (nth 2 a)) (< t1 16)) (let ((mask (logior (if (> (logand t1 3) 0) 1 0) (logand t1 4) (if (> (logand t1 12) 0) 5 0)))) (if num (* mask 3) (logior (if (and (> (logand t1 5) 0) (> (logand t2 5) 0)) mask 0) (if (> (logand t12 10) 0) (* mask 2) 0)))) (if (and (math-known-nonnegp (nth 1 a)) (math-known-posp (nth 2 a))) 15 63)))) ((eq (car a) 'calcFunc-sqrt) (let ((t1 (math-possible-signs (nth 1 a)))) (logior (if (> (logand t1 2) 0) 3 0) (if (> (logand t1 1) 0) 16 0) (if (> (logand t1 4) 0) 15 0) (if (> (logand t1 8) 0) 32 0)))) ((eq (car a) 'vec) (let ((types 0)) (while (and (setq a (cdr a)) (< types 63)) (setq types (logior types (math-possible-types (car a) t)))) types)) ((or (memq (car a) math-integer-functions) (and (memq (car a) math-rounding-functions) (math-known-nonnegp (or (nth 2 a) 0)))) 1) ((or (memq (car a) math-num-integer-functions) (and (memq (car a) math-float-rounding-functions) (math-known-nonnegp (or (nth 2 a) 0)))) 2) ((eq (car a) 'calcFunc-frac) 5) ((and (eq (car a) 'calcFunc-float) (= (length a) 2)) (let ((t1 (math-possible-types (nth 1 a)))) (logior (if (> (logand t1 3) 0) 2 0) (if (> (logand t1 12) 0) 8 0) (logand t1 48)))) ((and (memq (car a) '(calcFunc-abs calcFunc-abssqr)) (= (length a) 2)) (let ((t1 (math-possible-types (nth 1 a)))) (if (>= t1 16) 15 t1))) ((math-const-var a) (cond ((memq (nth 2 a) '(var-e var-pi var-phi var-gamma)) 8) ((eq (nth 2 a) 'var-inf) 1) ((eq (nth 2 a) 'var-i) 16) (t 63))) (t (math-setup-declarations) (let ((decl (if (eq (car a) 'var) (or (assq (nth 2 a) math-decls-cache) math-decls-all) (assq (car a) math-decls-cache)))) (cond ((memq 'int (nth 1 decl)) 1) ((memq 'numint (nth 1 decl)) 3) ((memq 'frac (nth 1 decl)) 4) ((memq 'rat (nth 1 decl)) 5) ((memq 'float (nth 1 decl)) 10) ((nth 2 decl) (math-possible-types (nth 2 decl))) ((memq 'real (nth 1 decl)) 15) (t 63))))) ) (defun math-known-evenp (a) (cond ((Math-integerp a) (math-evenp a)) ((Math-messy-integerp a) (or (> (nth 2 a) 0) (math-evenp (math-trunc a)))) ((eq (car a) '*) (if (math-known-evenp (nth 1 a)) (math-known-num-integerp (nth 2 a)) (if (math-known-num-integerp (nth 1 a)) (math-known-evenp (nth 2 a))))) ((memq (car a) '(+ -)) (or (and (math-known-evenp (nth 1 a)) (math-known-evenp (nth 2 a))) (and (math-known-oddp (nth 1 a)) (math-known-oddp (nth 2 a))))) ((eq (car a) 'neg) (math-known-evenp (nth 1 a)))) ) (defun math-known-oddp (a) (cond ((Math-integerp a) (math-oddp a)) ((Math-messy-integerp a) (and (<= (nth 2 a) 0) (math-oddp (math-trunc a)))) ((memq (car a) '(+ -)) (or (and (math-known-evenp (nth 1 a)) (math-known-oddp (nth 2 a))) (and (math-known-oddp (nth 1 a)) (math-known-evenp (nth 2 a))))) ((eq (car a) 'neg) (math-known-oddp (nth 1 a)))) ) (defun calcFunc-dreal (expr) (let ((types (math-possible-types expr))) (if (< types 16) 1 (if (= (logand types 15) 0) 0 (math-reject-arg expr 'realp 'quiet)))) ) (defun calcFunc-dimag (expr) (let ((types (math-possible-types expr))) (if (= types 16) 1 (if (= (logand types 16) 0) 0 (math-reject-arg expr "Expected an imaginary number")))) ) (defun calcFunc-dpos (expr) (let ((signs (math-possible-signs expr))) (if (eq signs 4) 1 (if (memq signs '(1 2 3)) 0 (math-reject-arg expr 'posp 'quiet)))) ) (defun calcFunc-dneg (expr) (let ((signs (math-possible-signs expr))) (if (eq signs 1) 1 (if (memq signs '(2 4 6)) 0 (math-reject-arg expr 'negp 'quiet)))) ) (defun calcFunc-dnonneg (expr) (let ((signs (math-possible-signs expr))) (if (memq signs '(2 4 6)) 1 (if (eq signs 1) 0 (math-reject-arg expr 'posp 'quiet)))) ) (defun calcFunc-dnonzero (expr) (let ((signs (math-possible-signs expr))) (if (memq signs '(1 4 5 8 9 12 13)) 1 (if (eq signs 2) 0 (math-reject-arg expr 'nonzerop 'quiet)))) ) (defun calcFunc-dint (expr) (let ((types (math-possible-types expr))) (if (= types 1) 1 (if (= (logand types 1) 0) 0 (math-reject-arg expr 'integerp 'quiet)))) ) (defun calcFunc-dnumint (expr) (let ((types (math-possible-types expr t))) (if (<= types 3) 1 (if (= (logand types 3) 0) 0 (math-reject-arg expr 'integerp 'quiet)))) ) (defun calcFunc-dnatnum (expr) (let ((res (calcFunc-dint expr))) (if (eq res 1) (calcFunc-dnonneg expr) res)) ) (defun calcFunc-deven (expr) (if (math-known-evenp expr) 1 (if (or (math-known-oddp expr) (= (logand (math-possible-types expr) 3) 0)) 0 (math-reject-arg expr "Can't tell if expression is odd or even"))) ) (defun calcFunc-dodd (expr) (if (math-known-oddp expr) 1 (if (or (math-known-evenp expr) (= (logand (math-possible-types expr) 3) 0)) 0 (math-reject-arg expr "Can't tell if expression is odd or even"))) ) (defun calcFunc-drat (expr) (let ((types (math-possible-types expr))) (if (memq types '(1 4 5)) 1 (if (= (logand types 5) 0) 0 (math-reject-arg expr "Rational number expected")))) ) (defun calcFunc-drange (expr) (math-setup-declarations) (let (range) (if (Math-realp expr) (list 'vec expr) (if (eq (car-safe expr) 'intv) expr (if (eq (car-safe expr) 'var) (setq range (nth 2 (or (assq (nth 2 expr) math-decls-cache) math-decls-all))) (setq range (nth 2 (assq (car-safe expr) math-decls-cache)))) (if range (math-clean-set (copy-sequence range)) (setq range (math-possible-signs expr)) (if (< range 8) (aref [(vec) (intv 2 (neg (var inf var-inf)) 0) (vec 0) (intv 3 (neg (var inf var-inf)) 0) (intv 1 0 (var inf var-inf)) (vec (intv 2 (neg (var inf var-inf)) 0) (intv 1 0 (var inf var-inf))) (intv 3 0 (var inf var-inf)) (intv 3 (neg (var inf var-inf)) (var inf var-inf))] range) (math-reject-arg expr 'realp 'quiet)))))) ) (defun calcFunc-dscalar (a) (if (math-known-scalarp a) 1 (if (math-known-matrixp a) 0 (math-reject-arg a 'objectp 'quiet))) ) ;;; The following lists are not exhaustive. (defvar math-scalar-functions '(calcFunc-det calcFunc-cnorm calcFunc-rnorm calcFunc-vlen calcFunc-vcount calcFunc-vsum calcFunc-vprod calcFunc-vmin calcFunc-vmax )) (defvar math-nonscalar-functions '(vec calcFunc-idn calcFunc-diag calcFunc-cvec calcFunc-index calcFunc-trn | calcFunc-append calcFunc-cons calcFunc-rcons calcFunc-tail calcFunc-rhead )) (defvar math-scalar-if-args-functions '(+ - * / neg)) (defvar math-real-functions '(calcFunc-arg calcFunc-re calcFunc-im calcFunc-floor calcFunc-ceil calcFunc-trunc calcFunc-round calcFunc-rounde calcFunc-roundu calcFunc-ffloor calcFunc-fceil calcFunc-ftrunc calcFunc-fround calcFunc-frounde calcFunc-froundu )) (defvar math-positive-functions '( )) (defvar math-nonnegative-functions '(calcFunc-cnorm calcFunc-rnorm calcFunc-vlen calcFunc-vcount )) (defvar math-real-scalar-functions '(% calcFunc-idiv calcFunc-abs calcFunc-choose calcFunc-perm calcFunc-eq calcFunc-neq calcFunc-lt calcFunc-gt calcFunc-leq calcFunc-geq calcFunc-lnot calcFunc-max calcFunc-min )) (defvar math-real-if-arg-functions '(calcFunc-sin calcFunc-cos calcFunc-tan calcFunc-arctan calcFunc-sinh calcFunc-cosh calcFunc-tanh calcFunc-exp calcFunc-gamma calcFunc-fact )) (defvar math-integer-functions '(calcFunc-idiv calcFunc-isqrt calcFunc-ilog calcFunc-vlen calcFunc-vcount )) (defvar math-num-integer-functions '( )) (defvar math-rounding-functions '(calcFunc-floor calcFunc-ceil calcFunc-round calcFunc-trunc calcFunc-rounde calcFunc-roundu )) (defvar math-float-rounding-functions '(calcFunc-ffloor calcFunc-fceil calcFunc-fround calcFunc-ftrunc calcFunc-frounde calcFunc-froundu )) (defvar math-integer-if-args-functions '(+ - * % neg calcFunc-abs calcFunc-min calcFunc-max calcFunc-choose calcFunc-perm )) ;;;; Arithmetic. (defun calcFunc-neg (a) (math-normalize (list 'neg a)) ) (defun math-neg-fancy (a) (cond ((eq (car a) 'polar) (list 'polar (nth 1 a) (if (math-posp (nth 2 a)) (math-sub (nth 2 a) (math-half-circle nil)) (math-add (nth 2 a) (math-half-circle nil))))) ((eq (car a) 'mod) (if (math-zerop (nth 1 a)) a (list 'mod (math-sub (nth 2 a) (nth 1 a)) (nth 2 a)))) ((eq (car a) 'sdev) (list 'sdev (math-neg (nth 1 a)) (nth 2 a))) ((eq (car a) 'intv) (math-make-intv (aref [0 2 1 3] (nth 1 a)) (math-neg (nth 3 a)) (math-neg (nth 2 a)))) ((and math-simplify-only (not (equal a math-simplify-only))) (list 'neg a)) ((eq (car a) '+) (math-sub (math-neg (nth 1 a)) (nth 2 a))) ((eq (car a) '-) (math-sub (nth 2 a) (nth 1 a))) ((and (memq (car a) '(* /)) (math-okay-neg (nth 1 a))) (list (car a) (math-neg (nth 1 a)) (nth 2 a))) ((and (memq (car a) '(* /)) (math-okay-neg (nth 2 a))) (list (car a) (nth 1 a) (math-neg (nth 2 a)))) ((and (memq (car a) '(* /)) (or (math-objectp (nth 1 a)) (and (eq (car (nth 1 a)) '*) (math-objectp (nth 1 (nth 1 a)))))) (list (car a) (math-neg (nth 1 a)) (nth 2 a))) ((and (eq (car a) '/) (or (math-objectp (nth 2 a)) (and (eq (car (nth 2 a)) '*) (math-objectp (nth 1 (nth 2 a)))))) (list (car a) (nth 1 a) (math-neg (nth 2 a)))) ((and (eq (car a) 'var) (memq (nth 2 a) '(var-uinf var-nan))) a) ((eq (car a) 'neg) (nth 1 a)) (t (list 'neg a))) ) (defun math-okay-neg (a) (or (math-looks-negp a) (eq (car-safe a) '-)) ) (defun math-neg-float (a) (list 'float (Math-integer-neg (nth 1 a)) (nth 2 a)) ) (defun calcFunc-add (&rest rest) (if rest (let ((a (car rest))) (while (setq rest (cdr rest)) (setq a (list '+ a (car rest)))) (math-normalize a)) 0) ) (defun calcFunc-sub (&rest rest) (if rest (let ((a (car rest))) (while (setq rest (cdr rest)) (setq a (list '- a (car rest)))) (math-normalize a)) 0) ) (defun math-add-objects-fancy (a b) (cond ((and (Math-numberp a) (Math-numberp b)) (let ((aa (math-complex a)) (bb (math-complex b))) (math-normalize (let ((res (list 'cplx (math-add (nth 1 aa) (nth 1 bb)) (math-add (nth 2 aa) (nth 2 bb))))) (if (math-want-polar a b) (math-polar res) res))))) ((or (Math-vectorp a) (Math-vectorp b)) (math-map-vec-2 'math-add a b)) ((eq (car-safe a) 'sdev) (if (eq (car-safe b) 'sdev) (math-make-sdev (math-add (nth 1 a) (nth 1 b)) (math-hypot (nth 2 a) (nth 2 b))) (and (or (Math-scalarp b) (not (Math-objvecp b))) (math-make-sdev (math-add (nth 1 a) b) (nth 2 a))))) ((and (eq (car-safe b) 'sdev) (or (Math-scalarp a) (not (Math-objvecp a)))) (math-make-sdev (math-add a (nth 1 b)) (nth 2 b))) ((eq (car-safe a) 'intv) (if (eq (car-safe b) 'intv) (math-make-intv (logior (logand (nth 1 a) (nth 1 b)) (if (equal (nth 2 a) '(neg (var inf var-inf))) (logand (nth 1 a) 2) 0) (if (equal (nth 2 b) '(neg (var inf var-inf))) (logand (nth 1 b) 2) 0) (if (equal (nth 3 a) '(var inf var-inf)) (logand (nth 1 a) 1) 0) (if (equal (nth 3 b) '(var inf var-inf)) (logand (nth 1 b) 1) 0)) (math-add (nth 2 a) (nth 2 b)) (math-add (nth 3 a) (nth 3 b))) (and (or (Math-anglep b) (eq (car b) 'date) (not (Math-objvecp b))) (math-make-intv (nth 1 a) (math-add (nth 2 a) b) (math-add (nth 3 a) b))))) ((and (eq (car-safe b) 'intv) (or (Math-anglep a) (eq (car a) 'date) (not (Math-objvecp a)))) (math-make-intv (nth 1 b) (math-add a (nth 2 b)) (math-add a (nth 3 b)))) ((eq (car-safe a) 'date) (cond ((eq (car-safe b) 'date) (math-add (nth 1 a) (nth 1 b))) ((eq (car-safe b) 'hms) (let ((parts (math-date-parts (nth 1 a)))) (list 'date (math-add (car parts) ; this minimizes roundoff (math-div (math-add (math-add (nth 1 parts) (nth 2 parts)) (math-add (math-mul (nth 1 b) 3600) (math-add (math-mul (nth 2 b) 60) (nth 3 b)))) 86400))))) ((Math-realp b) (list 'date (math-add (nth 1 a) b))) (t nil))) ((eq (car-safe b) 'date) (math-add-objects-fancy b a)) ((and (eq (car-safe a) 'mod) (eq (car-safe b) 'mod) (equal (nth 2 a) (nth 2 b))) (math-make-mod (math-add (nth 1 a) (nth 1 b)) (nth 2 a))) ((and (eq (car-safe a) 'mod) (Math-anglep b)) (math-make-mod (math-add (nth 1 a) b) (nth 2 a))) ((and (eq (car-safe b) 'mod) (Math-anglep a)) (math-make-mod (math-add a (nth 1 b)) (nth 2 b))) ((and (or (eq (car-safe a) 'hms) (eq (car-safe b) 'hms)) (and (Math-anglep a) (Math-anglep b))) (or (eq (car-safe a) 'hms) (setq a (math-to-hms a))) (or (eq (car-safe b) 'hms) (setq b (math-to-hms b))) (math-normalize (if (math-negp a) (math-neg (math-add (math-neg a) (math-neg b))) (if (math-negp b) (let* ((s (math-add (nth 3 a) (nth 3 b))) (m (math-add (nth 2 a) (nth 2 b))) (h (math-add (nth 1 a) (nth 1 b)))) (if (math-negp s) (setq s (math-add s 60) m (math-add m -1))) (if (math-negp m) (setq m (math-add m 60) h (math-add h -1))) (if (math-negp h) (math-add b a) (list 'hms h m s))) (let* ((s (math-add (nth 3 a) (nth 3 b))) (m (math-add (nth 2 a) (nth 2 b))) (h (math-add (nth 1 a) (nth 1 b)))) (list 'hms h m s)))))) (t (calc-record-why "*Incompatible arguments for +" a b))) ) (defun math-add-symb-fancy (a b) (or (and math-simplify-only (not (equal a math-simplify-only)) (list '+ a b)) (and (eq (car-safe b) '+) (math-add (math-add a (nth 1 b)) (nth 2 b))) (and (eq (car-safe b) '-) (math-sub (math-add a (nth 1 b)) (nth 2 b))) (and (eq (car-safe b) 'neg) (eq (car-safe (nth 1 b)) '+) (math-sub (math-sub a (nth 1 (nth 1 b))) (nth 2 (nth 1 b)))) (and (or (and (Math-vectorp a) (math-known-scalarp b)) (and (Math-vectorp b) (math-known-scalarp a))) (math-map-vec-2 'math-add a b)) (let ((inf (math-infinitep a))) (cond (inf (let ((inf2 (math-infinitep b))) (if inf2 (if (or (memq (nth 2 inf) '(var-uinf var-nan)) (memq (nth 2 inf2) '(var-uinf var-nan))) '(var nan var-nan) (let ((dir (math-infinite-dir a inf)) (dir2 (math-infinite-dir b inf2))) (if (and (Math-objectp dir) (Math-objectp dir2)) (if (Math-equal dir dir2) a '(var nan var-nan))))) (if (and (equal a '(var inf var-inf)) (eq (car-safe b) 'intv) (memq (nth 1 b) '(2 3)) (equal (nth 2 b) '(neg (var inf var-inf)))) (list 'intv 3 (nth 2 b) a) (if (and (equal a '(neg (var inf var-inf))) (eq (car-safe b) 'intv) (memq (nth 1 b) '(1 3)) (equal (nth 3 b) '(var inf var-inf))) (list 'intv 3 a (nth 3 b)) a))))) ((math-infinitep b) (if (eq (car-safe a) 'intv) (math-add b a) b)) ((eq (car-safe a) '+) (let ((temp (math-combine-sum (nth 2 a) b nil nil t))) (and temp (math-add (nth 1 a) temp)))) ((eq (car-safe a) '-) (let ((temp (math-combine-sum (nth 2 a) b t nil t))) (and temp (math-add (nth 1 a) temp)))) ((and (Math-objectp a) (Math-objectp b)) nil) (t (math-combine-sum a b nil nil nil)))) (and (Math-looks-negp b) (list '- a (math-neg b))) (and (Math-looks-negp a) (list '- b (math-neg a))) (and (eq (car-safe a) 'calcFunc-idn) (= (length a) 2) (or (and (eq (car-safe b) 'calcFunc-idn) (= (length b) 2) (list 'calcFunc-idn (math-add (nth 1 a) (nth 1 b)))) (and (math-square-matrixp b) (math-add (math-mimic-ident (nth 1 a) b) b)) (and (math-known-scalarp b) (math-add (nth 1 a) b)))) (and (eq (car-safe b) 'calcFunc-idn) (= (length a) 2) (or (and (math-square-matrixp a) (math-add a (math-mimic-ident (nth 1 b) a))) (and (math-known-scalarp a) (math-add a (nth 1 b))))) (list '+ a b)) ) (defun calcFunc-mul (&rest rest) (if rest (let ((a (car rest))) (while (setq rest (cdr rest)) (setq a (list '* a (car rest)))) (math-normalize a)) 1) ) (defun math-mul-objects-fancy (a b) (cond ((and (Math-numberp a) (Math-numberp b)) (math-normalize (if (math-want-polar a b) (let ((a (math-polar a)) (b (math-polar b))) (list 'polar (math-mul (nth 1 a) (nth 1 b)) (math-fix-circular (math-add (nth 2 a) (nth 2 b))))) (setq a (math-complex a) b (math-complex b)) (list 'cplx (math-sub (math-mul (nth 1 a) (nth 1 b)) (math-mul (nth 2 a) (nth 2 b))) (math-add (math-mul (nth 1 a) (nth 2 b)) (math-mul (nth 2 a) (nth 1 b))))))) ((Math-vectorp a) (if (Math-vectorp b) (if (math-matrixp a) (if (math-matrixp b) (if (= (length (nth 1 a)) (length b)) (math-mul-mats a b) (math-dimension-error)) (if (= (length (nth 1 a)) 2) (if (= (length a) (length b)) (math-mul-mats a (list 'vec b)) (math-dimension-error)) (if (= (length (nth 1 a)) (length b)) (math-mul-mat-vec a b) (math-dimension-error)))) (if (math-matrixp b) (if (= (length a) (length b)) (nth 1 (math-mul-mats (list 'vec a) b)) (math-dimension-error)) (if (= (length a) (length b)) (math-dot-product a b) (math-dimension-error)))) (math-map-vec-2 'math-mul a b))) ((Math-vectorp b) (math-map-vec-2 'math-mul a b)) ((eq (car-safe a) 'sdev) (if (eq (car-safe b) 'sdev) (math-make-sdev (math-mul (nth 1 a) (nth 1 b)) (math-hypot (math-mul (nth 2 a) (nth 1 b)) (math-mul (nth 2 b) (nth 1 a)))) (and (or (Math-scalarp b) (not (Math-objvecp b))) (math-make-sdev (math-mul (nth 1 a) b) (math-mul (nth 2 a) b))))) ((and (eq (car-safe b) 'sdev) (or (Math-scalarp a) (not (Math-objvecp a)))) (math-make-sdev (math-mul a (nth 1 b)) (math-mul a (nth 2 b)))) ((and (eq (car-safe a) 'intv) (Math-anglep b)) (if (Math-negp b) (math-neg (math-mul a (math-neg b))) (math-make-intv (nth 1 a) (math-mul (nth 2 a) b) (math-mul (nth 3 a) b)))) ((and (eq (car-safe b) 'intv) (Math-anglep a)) (math-mul b a)) ((and (eq (car-safe a) 'intv) (math-intv-constp a) (eq (car-safe b) 'intv) (math-intv-constp b)) (let ((lo (math-mul a (nth 2 b))) (hi (math-mul a (nth 3 b)))) (or (eq (car-safe lo) 'intv) (setq lo (list 'intv (if (memq (nth 1 b) '(2 3)) 3 0) lo lo))) (or (eq (car-safe hi) 'intv) (setq hi (list 'intv (if (memq (nth 1 b) '(1 3)) 3 0) hi hi))) (math-combine-intervals (nth 2 lo) (and (or (memq (nth 1 b) '(2 3)) (math-infinitep (nth 2 lo))) (memq (nth 1 lo) '(2 3))) (nth 3 lo) (and (or (memq (nth 1 b) '(2 3)) (math-infinitep (nth 3 lo))) (memq (nth 1 lo) '(1 3))) (nth 2 hi) (and (or (memq (nth 1 b) '(1 3)) (math-infinitep (nth 2 hi))) (memq (nth 1 hi) '(2 3))) (nth 3 hi) (and (or (memq (nth 1 b) '(1 3)) (math-infinitep (nth 3 hi))) (memq (nth 1 hi) '(1 3)))))) ((and (eq (car-safe a) 'mod) (eq (car-safe b) 'mod) (equal (nth 2 a) (nth 2 b))) (math-make-mod (math-mul (nth 1 a) (nth 1 b)) (nth 2 a))) ((and (eq (car-safe a) 'mod) (Math-anglep b)) (math-make-mod (math-mul (nth 1 a) b) (nth 2 a))) ((and (eq (car-safe b) 'mod) (Math-anglep a)) (math-make-mod (math-mul a (nth 1 b)) (nth 2 b))) ((and (eq (car-safe a) 'hms) (Math-realp b)) (math-with-extra-prec 2 (math-to-hms (math-mul (math-from-hms a 'deg) b) 'deg))) ((and (eq (car-safe b) 'hms) (Math-realp a)) (math-mul b a)) (t (calc-record-why "*Incompatible arguments for *" a b))) ) ;;; Fast function to multiply floating-point numbers. (defun math-mul-float (a b) ; [F F F] (math-make-float (math-mul (nth 1 a) (nth 1 b)) (+ (nth 2 a) (nth 2 b))) ) (defun math-sqr-float (a) ; [F F] (math-make-float (math-mul (nth 1 a) (nth 1 a)) (+ (nth 2 a) (nth 2 a))) ) (defun math-intv-constp (a &optional finite) (and (or (Math-anglep (nth 2 a)) (and (equal (nth 2 a) '(neg (var inf var-inf))) (or (not finite) (memq (nth 1 a) '(0 1))))) (or (Math-anglep (nth 3 a)) (and (equal (nth 3 a) '(var inf var-inf)) (or (not finite) (memq (nth 1 a) '(0 2)))))) ) (defun math-mul-zero (a b) (if (math-known-matrixp b) (if (math-vectorp b) (math-map-vec-2 'math-mul a b) (math-mimic-ident 0 b)) (if (math-infinitep b) '(var nan var-nan) (let ((aa nil) (bb nil)) (if (and (eq (car-safe b) 'intv) (progn (and (equal (nth 2 b) '(neg (var inf var-inf))) (memq (nth 1 b) '(2 3)) (setq aa (nth 2 b))) (and (equal (nth 3 b) '(var inf var-inf)) (memq (nth 1 b) '(1 3)) (setq bb (nth 3 b))) (or aa bb))) (if (or (math-posp a) (and (math-zerop a) (or (memq calc-infinite-mode '(-1 1)) (setq aa '(neg (var inf var-inf)) bb '(var inf var-inf))))) (list 'intv 3 (or aa 0) (or bb 0)) (if (math-negp a) (math-neg (list 'intv 3 (or aa 0) (or bb 0))) '(var nan var-nan))) (if (or (math-floatp a) (math-floatp b)) '(float 0 0) 0))))) ) (defun math-mul-symb-fancy (a b) (or (and math-simplify-only (not (equal a math-simplify-only)) (list '* a b)) (and (Math-equal-int a 1) b) (and (Math-equal-int a -1) (math-neg b)) (and (or (and (Math-vectorp a) (math-known-scalarp b)) (and (Math-vectorp b) (math-known-scalarp a))) (math-map-vec-2 'math-mul a b)) (and (Math-objectp b) (not (Math-objectp a)) (math-mul b a)) (and (eq (car-safe a) 'neg) (math-neg (math-mul (nth 1 a) b))) (and (eq (car-safe b) 'neg) (math-neg (math-mul a (nth 1 b)))) (and (eq (car-safe a) '*) (math-mul (nth 1 a) (math-mul (nth 2 a) b))) (and (eq (car-safe a) '^) (Math-looks-negp (nth 2 a)) (not (and (eq (car-safe b) '^) (Math-looks-negp (nth 2 b)))) (math-known-scalarp b t) (math-div b (math-normalize (list '^ (nth 1 a) (math-neg (nth 2 a)))))) (and (eq (car-safe b) '^) (Math-looks-negp (nth 2 b)) (not (and (eq (car-safe a) '^) (Math-looks-negp (nth 2 a)))) (math-div a (math-normalize (list '^ (nth 1 b) (math-neg (nth 2 b)))))) (and (eq (car-safe a) '/) (or (math-known-scalarp a t) (math-known-scalarp b t)) (let ((temp (math-combine-prod (nth 2 a) b t nil t))) (if temp (math-mul (nth 1 a) temp) (math-div (math-mul (nth 1 a) b) (nth 2 a))))) (and (eq (car-safe b) '/) (math-div (math-mul a (nth 1 b)) (nth 2 b))) (and (eq (car-safe b) '+) (Math-numberp a) (or (Math-numberp (nth 1 b)) (Math-numberp (nth 2 b))) (math-add (math-mul a (nth 1 b)) (math-mul a (nth 2 b)))) (and (eq (car-safe b) '-) (Math-numberp a) (or (Math-numberp (nth 1 b)) (Math-numberp (nth 2 b))) (math-sub (math-mul a (nth 1 b)) (math-mul a (nth 2 b)))) (and (eq (car-safe b) '*) (Math-numberp (nth 1 b)) (not (Math-numberp a)) (math-mul (nth 1 b) (math-mul a (nth 2 b)))) (and (eq (car-safe a) 'calcFunc-idn) (= (length a) 2) (or (and (eq (car-safe b) 'calcFunc-idn) (= (length b) 2) (list 'calcFunc-idn (math-mul (nth 1 a) (nth 1 b)))) (and (math-known-scalarp b) (list 'calcFunc-idn (math-mul (nth 1 a) b))) (and (math-known-matrixp b) (math-mul (nth 1 a) b)))) (and (eq (car-safe b) 'calcFunc-idn) (= (length b) 2) (or (and (math-known-scalarp a) (list 'calcFunc-idn (math-mul a (nth 1 b)))) (and (math-known-matrixp a) (math-mul a (nth 1 b))))) (and (math-looks-negp b) (math-mul (math-neg a) (math-neg b))) (and (eq (car-safe b) '-) (math-looks-negp a) (math-mul (math-neg a) (math-neg b))) (cond ((eq (car-safe b) '*) (let ((temp (math-combine-prod a (nth 1 b) nil nil t))) (and temp (math-mul temp (nth 2 b))))) (t (math-combine-prod a b nil nil nil))) (and (equal a '(var nan var-nan)) a) (and (equal b '(var nan var-nan)) b) (and (equal a '(var uinf var-uinf)) a) (and (equal b '(var uinf var-uinf)) b) (and (equal b '(var inf var-inf)) (let ((s1 (math-possible-signs a))) (cond ((eq s1 4) b) ((eq s1 6) '(intv 3 0 (var inf var-inf))) ((eq s1 1) (math-neg b)) ((eq s1 3) '(intv 3 (neg (var inf var-inf)) 0)) ((and (eq (car a) 'intv) (math-intv-constp a)) '(intv 3 (neg (var inf var-inf)) (var inf var-inf))) ((and (eq (car a) 'cplx) (math-zerop (nth 1 a))) (list '* (list 'cplx 0 (calcFunc-sign (nth 2 a))) b)) ((eq (car a) 'polar) (list '* (list 'polar 1 (nth 2 a)) b))))) (and (equal a '(var inf var-inf)) (math-mul b a)) (list '* a b)) ) (defun calcFunc-div (a &rest rest) (while rest (setq a (list '/ a (car rest)) rest (cdr rest))) (math-normalize a) ) (defun math-div-objects-fancy (a b) (cond ((and (Math-numberp a) (Math-numberp b)) (math-normalize (cond ((math-want-polar a b) (let ((a (math-polar a)) (b (math-polar b))) (list 'polar (math-div (nth 1 a) (nth 1 b)) (math-fix-circular (math-sub (nth 2 a) (nth 2 b)))))) ((Math-realp b) (setq a (math-complex a)) (list 'cplx (math-div (nth 1 a) b) (math-div (nth 2 a) b))) (t (setq a (math-complex a) b (math-complex b)) (math-div (list 'cplx (math-add (math-mul (nth 1 a) (nth 1 b)) (math-mul (nth 2 a) (nth 2 b))) (math-sub (math-mul (nth 2 a) (nth 1 b)) (math-mul (nth 1 a) (nth 2 b)))) (math-add (math-sqr (nth 1 b)) (math-sqr (nth 2 b)))))))) ((math-matrixp b) (if (math-square-matrixp b) (let ((n1 (length b))) (if (Math-vectorp a) (if (math-matrixp a) (if (= (length a) n1) (math-lud-solve (math-matrix-lud b) a b) (if (= (length (nth 1 a)) n1) (math-transpose (math-lud-solve (math-matrix-lud (math-transpose b)) (math-transpose a) b)) (math-dimension-error))) (if (= (length a) n1) (math-mat-col (math-lud-solve (math-matrix-lud b) (math-col-matrix a) b) 1) (math-dimension-error))) (if (Math-equal-int a 1) (calcFunc-inv b) (math-mul a (calcFunc-inv b))))) (math-reject-arg b 'square-matrixp))) ((and (Math-vectorp a) (Math-objectp b)) (math-map-vec-2 'math-div a b)) ((eq (car-safe a) 'sdev) (if (eq (car-safe b) 'sdev) (let ((x (math-div (nth 1 a) (nth 1 b)))) (math-make-sdev x (math-div (math-hypot (nth 2 a) (math-mul (nth 2 b) x)) (nth 1 b)))) (if (or (Math-scalarp b) (not (Math-objvecp b))) (math-make-sdev (math-div (nth 1 a) b) (math-div (nth 2 a) b)) (math-reject-arg 'realp b)))) ((and (eq (car-safe b) 'sdev) (or (Math-scalarp a) (not (Math-objvecp a)))) (let ((x (math-div a (nth 1 b)))) (math-make-sdev x (math-div (math-mul (nth 2 b) x) (nth 1 b))))) ((and (eq (car-safe a) 'intv) (Math-anglep b)) (if (Math-negp b) (math-neg (math-div a (math-neg b))) (math-make-intv (nth 1 a) (math-div (nth 2 a) b) (math-div (nth 3 a) b)))) ((and (eq (car-safe b) 'intv) (Math-anglep a)) (if (or (Math-posp (nth 2 b)) (and (Math-zerop (nth 2 b)) (or (memq (nth 1 b) '(0 1)) calc-infinite-mode))) (if (Math-negp a) (math-neg (math-div (math-neg a) b)) (let ((calc-infinite-mode 1)) (math-make-intv (aref [0 2 1 3] (nth 1 b)) (math-div a (nth 3 b)) (math-div a (nth 2 b))))) (if (or (Math-negp (nth 3 b)) (and (Math-zerop (nth 3 b)) (or (memq (nth 1 b) '(0 2)) calc-infinite-mode))) (math-neg (math-div a (math-neg b))) (if calc-infinite-mode '(intv 3 (neg (var inf var-inf)) (var inf var-inf)) (math-reject-arg b "*Division by zero"))))) ((and (eq (car-safe a) 'intv) (math-intv-constp a) (eq (car-safe b) 'intv) (math-intv-constp b)) (if (or (Math-posp (nth 2 b)) (and (Math-zerop (nth 2 b)) (or (memq (nth 1 b) '(0 1)) calc-infinite-mode))) (let* ((calc-infinite-mode 1) (lo (math-div a (nth 2 b))) (hi (math-div a (nth 3 b)))) (or (eq (car-safe lo) 'intv) (setq lo (list 'intv (if (memq (nth 1 b) '(2 3)) 3 0) lo lo))) (or (eq (car-safe hi) 'intv) (setq hi (list 'intv (if (memq (nth 1 b) '(1 3)) 3 0) hi hi))) (math-combine-intervals (nth 2 lo) (and (or (memq (nth 1 b) '(2 3)) (and (math-infinitep (nth 2 lo)) (not (math-zerop (nth 2 b))))) (memq (nth 1 lo) '(2 3))) (nth 3 lo) (and (or (memq (nth 1 b) '(2 3)) (and (math-infinitep (nth 3 lo)) (not (math-zerop (nth 2 b))))) (memq (nth 1 lo) '(1 3))) (nth 2 hi) (and (or (memq (nth 1 b) '(1 3)) (and (math-infinitep (nth 2 hi)) (not (math-zerop (nth 3 b))))) (memq (nth 1 hi) '(2 3))) (nth 3 hi) (and (or (memq (nth 1 b) '(1 3)) (and (math-infinitep (nth 3 hi)) (not (math-zerop (nth 3 b))))) (memq (nth 1 hi) '(1 3))))) (if (or (Math-negp (nth 3 b)) (and (Math-zerop (nth 3 b)) (or (memq (nth 1 b) '(0 2)) calc-infinite-mode))) (math-neg (math-div a (math-neg b))) (if calc-infinite-mode '(intv 3 (neg (var inf var-inf)) (var inf var-inf)) (math-reject-arg b "*Division by zero"))))) ((and (eq (car-safe a) 'mod) (eq (car-safe b) 'mod) (equal (nth 2 a) (nth 2 b))) (math-make-mod (math-div-mod (nth 1 a) (nth 1 b) (nth 2 a)) (nth 2 a))) ((and (eq (car-safe a) 'mod) (Math-anglep b)) (math-make-mod (math-div-mod (nth 1 a) b (nth 2 a)) (nth 2 a))) ((and (eq (car-safe b) 'mod) (Math-anglep a)) (math-make-mod (math-div-mod a (nth 1 b) (nth 2 b)) (nth 2 b))) ((eq (car-safe a) 'hms) (if (eq (car-safe b) 'hms) (math-with-extra-prec 1 (math-div (math-from-hms a 'deg) (math-from-hms b 'deg))) (math-with-extra-prec 2 (math-to-hms (math-div (math-from-hms a 'deg) b) 'deg)))) (t (calc-record-why "*Incompatible arguments for /" a b))) ) (defun math-div-by-zero (a b) (if (math-infinitep a) (if (or (equal a '(var nan var-nan)) (equal b '(var uinf var-uinf)) (memq calc-infinite-mode '(-1 1))) a '(var uinf var-uinf)) (if calc-infinite-mode (if (math-zerop a) '(var nan var-nan) (if (eq calc-infinite-mode 1) (math-mul a '(var inf var-inf)) (if (eq calc-infinite-mode -1) (math-mul a '(neg (var inf var-inf))) (if (eq (car-safe a) 'intv) '(intv 3 (neg (var inf var-inf)) (var inf var-inf)) '(var uinf var-uinf))))) (math-reject-arg a "*Division by zero"))) ) (defun math-div-zero (a b) (if (math-known-matrixp b) (if (math-vectorp b) (math-map-vec-2 'math-div a b) (math-mimic-ident 0 b)) (if (equal b '(var nan var-nan)) b (if (and (eq (car-safe b) 'intv) (math-intv-constp b) (not (math-posp b)) (not (math-negp b))) (if calc-infinite-mode (list 'intv 3 (if (and (math-zerop (nth 2 b)) (memq calc-infinite-mode '(1 -1))) (nth 2 b) '(neg (var inf var-inf))) (if (and (math-zerop (nth 3 b)) (memq calc-infinite-mode '(1 -1))) (nth 3 b) '(var inf var-inf))) (math-reject-arg b "*Division by zero")) a))) ) (defun math-div-symb-fancy (a b) (or (and math-simplify-only (not (equal a math-simplify-only)) (list '/ a b)) (and (Math-equal-int b 1) a) (and (Math-equal-int b -1) (math-neg a)) (and (Math-vectorp a) (math-known-scalarp b) (math-map-vec-2 'math-div a b)) (and (eq (car-safe b) '^) (or (Math-looks-negp (nth 2 b)) (Math-equal-int a 1)) (math-mul a (math-normalize (list '^ (nth 1 b) (math-neg (nth 2 b)))))) (and (eq (car-safe a) 'neg) (math-neg (math-div (nth 1 a) b))) (and (eq (car-safe b) 'neg) (math-neg (math-div a (nth 1 b)))) (and (eq (car-safe a) '/) (math-div (nth 1 a) (math-mul (nth 2 a) b))) (and (eq (car-safe b) '/) (or (math-known-scalarp (nth 1 b) t) (math-known-scalarp (nth 2 b) t)) (math-div (math-mul a (nth 2 b)) (nth 1 b))) (and (eq (car-safe b) 'frac) (math-mul (math-make-frac (nth 2 b) (nth 1 b)) a)) (and (eq (car-safe a) '+) (or (Math-numberp (nth 1 a)) (Math-numberp (nth 2 a))) (Math-numberp b) (math-add (math-div (nth 1 a) b) (math-div (nth 2 a) b))) (and (eq (car-safe a) '-) (or (Math-numberp (nth 1 a)) (Math-numberp (nth 2 a))) (Math-numberp b) (math-sub (math-div (nth 1 a) b) (math-div (nth 2 a) b))) (and (or (eq (car-safe a) '-) (math-looks-negp a)) (math-looks-negp b) (math-div (math-neg a) (math-neg b))) (and (eq (car-safe b) '-) (math-looks-negp a) (math-div (math-neg a) (math-neg b))) (and (eq (car-safe a) 'calcFunc-idn) (= (length a) 2) (or (and (eq (car-safe b) 'calcFunc-idn) (= (length b) 2) (list 'calcFunc-idn (math-div (nth 1 a) (nth 1 b)))) (and (math-known-scalarp b) (list 'calcFunc-idn (math-div (nth 1 a) b))) (and (math-known-matrixp b) (math-div (nth 1 a) b)))) (and (eq (car-safe b) 'calcFunc-idn) (= (length b) 2) (or (and (math-known-scalarp a) (list 'calcFunc-idn (math-div a (nth 1 b)))) (and (math-known-matrixp a) (math-div a (nth 1 b))))) (if (and calc-matrix-mode (or (math-known-matrixp a) (math-known-matrixp b))) (math-combine-prod a b nil t nil) (if (eq (car-safe a) '*) (if (eq (car-safe b) '*) (let ((c (math-combine-prod (nth 1 a) (nth 1 b) nil t t))) (and c (math-div (math-mul c (nth 2 a)) (nth 2 b)))) (let ((c (math-combine-prod (nth 1 a) b nil t t))) (and c (math-mul c (nth 2 a))))) (if (eq (car-safe b) '*) (let ((c (math-combine-prod a (nth 1 b) nil t t))) (and c (math-div c (nth 2 b)))) (math-combine-prod a b nil t nil)))) (and (math-infinitep a) (if (math-infinitep b) '(var nan var-nan) (if (or (equal a '(var nan var-nan)) (equal a '(var uinf var-uinf))) a (if (equal a '(var inf var-inf)) (if (or (math-posp b) (and (eq (car-safe b) 'intv) (math-zerop (nth 2 b)))) (if (and (eq (car-safe b) 'intv) (not (math-intv-constp b t))) '(intv 3 0 (var inf var-inf)) a) (if (or (math-negp b) (and (eq (car-safe b) 'intv) (math-zerop (nth 3 b)))) (if (and (eq (car-safe b) 'intv) (not (math-intv-constp b t))) '(intv 3 (neg (var inf var-inf)) 0) (math-neg a)) (if (and (eq (car-safe b) 'intv) (math-negp (nth 2 b)) (math-posp (nth 3 b))) '(intv 3 (neg (var inf var-inf)) (var inf var-inf))))))))) (and (math-infinitep b) (if (equal b '(var nan var-nan)) b (let ((calc-infinite-mode 1)) (math-mul-zero b a)))) (list '/ a b)) ) (defun calcFunc-mod (a b) (math-normalize (list '% a b)) ) (defun math-mod-fancy (a b) (cond ((equal b '(var inf var-inf)) (if (or (math-posp a) (math-zerop a)) a (if (math-negp a) b (if (eq (car-safe a) 'intv) (if (math-negp (nth 2 a)) '(intv 3 0 (var inf var-inf)) a) (list '% a b))))) ((and (eq (car-safe a) 'mod) (Math-realp b) (math-posp b)) (math-make-mod (nth 1 a) b)) ((and (eq (car-safe a) 'intv) (math-intv-constp a t) (math-posp b)) (math-mod-intv a b)) (t (if (Math-anglep a) (calc-record-why 'anglep b) (calc-record-why 'anglep a)) (list '% a b))) ) (defun calcFunc-pow (a b) (math-normalize (list '^ a b)) ) (defun math-pow-of-zero (a b) (if (Math-zerop b) (if calc-infinite-mode '(var nan var-nan) (math-reject-arg (list '^ a b) "*Indeterminate form")) (if (math-floatp b) (setq a (math-float a))) (if (math-posp b) a (if (math-negp b) (math-div 1 a) (if (math-infinitep b) '(var nan var-nan) (if (and (eq (car b) 'intv) (math-intv-constp b) calc-infinite-mode) '(intv 3 (neg (var inf var-inf)) (var inf var-inf)) (if (math-objectp b) (list '^ a b) a)))))) ) (defun math-pow-zero (a b) (if (eq (car-safe a) 'mod) (math-make-mod 1 (nth 2 a)) (if (math-known-matrixp a) (math-mimic-ident 1 a) (if (math-infinitep a) '(var nan var-nan) (if (and (eq (car a) 'intv) (math-intv-constp a) (or (and (not (math-posp a)) (not (math-negp a))) (not (math-intv-constp a t)))) '(intv 3 (neg (var inf var-inf)) (var inf var-inf)) (if (or (math-floatp a) (math-floatp b)) '(float 1 0) 1))))) ) (defun math-pow-fancy (a b) (cond ((and (Math-numberp a) (Math-numberp b)) (or (if (memq (math-quarter-integer b) '(1 2 3)) (let ((sqrt (math-sqrt (if (math-floatp b) (math-float a) a)))) (and (Math-numberp sqrt) (math-pow sqrt (math-mul 2 b)))) (and (eq (car b) 'frac) (integerp (nth 2 b)) (<= (nth 2 b) 10) (let ((root (math-nth-root a (nth 2 b)))) (and root (math-ipow root (nth 1 b)))))) (and (or (eq a 10) (equal a '(float 1 1))) (math-num-integerp b) (calcFunc-scf '(float 1 0) b)) (and calc-symbolic-mode (list '^ a b)) (math-with-extra-prec 2 (math-exp-raw (math-float (math-mul b (math-ln-raw (math-float a)))))))) ((or (not (Math-objvecp a)) (not (Math-objectp b))) (let (temp) (cond ((and math-simplify-only (not (equal a math-simplify-only))) (list '^ a b)) ((and (eq (car-safe a) '*) (or (math-known-num-integerp b) (math-known-nonnegp (nth 1 a)) (math-known-nonnegp (nth 2 a)))) (math-mul (math-pow (nth 1 a) b) (math-pow (nth 2 a) b))) ((and (eq (car-safe a) '/) (or (math-known-num-integerp b) (math-known-nonnegp (nth 2 a)))) (math-div (math-pow (nth 1 a) b) (math-pow (nth 2 a) b))) ((and (eq (car-safe a) '/) (math-known-nonnegp (nth 1 a)) (not (math-equal-int (nth 1 a) 1))) (math-mul (math-pow (nth 1 a) b) (math-pow (math-div 1 (nth 2 a)) b))) ((and (eq (car-safe a) '^) (or (math-known-num-integerp b) (math-known-nonnegp (nth 1 a)))) (math-pow (nth 1 a) (math-mul (nth 2 a) b))) ((and (eq (car-safe a) 'calcFunc-sqrt) (or (math-known-num-integerp b) (math-known-nonnegp (nth 1 a)))) (math-pow (nth 1 a) (math-div b 2))) ((and (eq (car-safe a) '^) (math-known-evenp (nth 2 a)) (memq (math-quarter-integer b) '(1 2 3)) (math-known-realp (nth 1 a))) (math-abs (math-pow (nth 1 a) (math-mul (nth 2 a) b)))) ((and (math-looks-negp a) (math-known-integerp b) (setq temp (or (and (math-known-evenp b) (math-pow (math-neg a) b)) (and (math-known-oddp b) (math-neg (math-pow (math-neg a) b)))))) temp) ((and (eq (car-safe a) 'calcFunc-abs) (math-known-realp (nth 1 a)) (math-known-evenp b)) (math-pow (nth 1 a) b)) ((math-infinitep a) (cond ((equal a '(var nan var-nan)) a) ((eq (car a) 'neg) (math-mul (math-pow -1 b) (math-pow (nth 1 a) b))) ((math-posp b) a) ((math-negp b) (if (math-floatp b) '(float 0 0) 0)) ((and (eq (car-safe b) 'intv) (math-intv-constp b)) '(intv 3 0 (var inf var-inf))) (t '(var nan var-nan)))) ((math-infinitep b) (let (scale) (cond ((math-negp b) (math-pow (math-div 1 a) (math-neg b))) ((not (math-posp b)) '(var nan var-nan)) ((math-equal-int (setq scale (calcFunc-abssqr a)) 1) '(var nan var-nan)) ((Math-lessp scale 1) (if (math-floatp a) '(float 0 0) 0)) ((Math-lessp 1 a) b) ((Math-lessp a -1) '(var uinf var-uinf)) ((and (eq (car a) 'intv) (math-intv-constp a)) (if (Math-lessp -1 a) (if (math-equal-int (nth 3 a) 1) '(intv 3 0 1) '(intv 3 0 (var inf var-inf))) '(intv 3 (neg (var inf var-inf)) (var inf var-inf)))) (t (list '^ a b))))) ((and (eq (car-safe a) 'calcFunc-idn) (= (length a) 2) (math-known-num-integerp b)) (list 'calcFunc-idn (math-pow (nth 1 a) b))) (t (if (Math-objectp a) (calc-record-why 'objectp b) (calc-record-why 'objectp a)) (list '^ a b))))) ((and (eq (car-safe a) 'sdev) (eq (car-safe b) 'sdev)) (if (and (math-constp a) (math-constp b)) (math-with-extra-prec 2 (let* ((ln (math-ln-raw (math-float (nth 1 a)))) (pow (math-exp-raw (math-float (math-mul (nth 1 b) ln))))) (math-make-sdev pow (math-mul pow (math-hypot (math-mul (nth 2 a) (math-div (nth 1 b) (nth 1 a))) (math-mul (nth 2 b) ln)))))) (let ((pow (math-pow (nth 1 a) (nth 1 b)))) (math-make-sdev pow (math-mul pow (math-hypot (math-mul (nth 2 a) (math-div (nth 1 b) (nth 1 a))) (math-mul (nth 2 b) (calcFunc-ln (nth 1 a))))))))) ((and (eq (car-safe a) 'sdev) (Math-numberp b)) (if (math-constp a) (math-with-extra-prec 2 (let ((pow (math-pow (nth 1 a) (math-sub b 1)))) (math-make-sdev (math-mul pow (nth 1 a)) (math-mul pow (math-mul (nth 2 a) b))))) (math-make-sdev (math-pow (nth 1 a) b) (math-mul (math-pow (nth 1 a) (math-add b -1)) (math-mul (nth 2 a) b))))) ((and (eq (car-safe b) 'sdev) (Math-numberp a)) (math-with-extra-prec 2 (let* ((ln (math-ln-raw (math-float a))) (pow (calcFunc-exp (math-mul (nth 1 b) ln)))) (math-make-sdev pow (math-mul pow (math-mul (nth 2 b) ln)))))) ((and (eq (car-safe a) 'intv) (math-intv-constp a) (Math-realp b) (or (Math-natnump b) (Math-posp (nth 2 a)) (and (math-zerop (nth 2 a)) (or (Math-posp b) (and (Math-integerp b) calc-infinite-mode))) (Math-negp (nth 3 a)) (and (math-zerop (nth 3 a)) (or (Math-posp b) (and (Math-integerp b) calc-infinite-mode))))) (if (math-evenp b) (setq a (math-abs a))) (let ((calc-infinite-mode (if (math-zerop (nth 3 a)) -1 1))) (math-sort-intv (nth 1 a) (math-pow (nth 2 a) b) (math-pow (nth 3 a) b)))) ((and (eq (car-safe b) 'intv) (math-intv-constp b) (Math-realp a) (Math-posp a)) (math-sort-intv (nth 1 b) (math-pow a (nth 2 b)) (math-pow a (nth 3 b)))) ((and (eq (car-safe a) 'intv) (math-intv-constp a) (eq (car-safe b) 'intv) (math-intv-constp b) (or (and (not (Math-negp (nth 2 a))) (not (Math-negp (nth 2 b)))) (and (Math-posp (nth 2 a)) (not (Math-posp (nth 3 b)))))) (let ((lo (math-pow a (nth 2 b))) (hi (math-pow a (nth 3 b)))) (or (eq (car-safe lo) 'intv) (setq lo (list 'intv (if (memq (nth 1 b) '(2 3)) 3 0) lo lo))) (or (eq (car-safe hi) 'intv) (setq hi (list 'intv (if (memq (nth 1 b) '(1 3)) 3 0) hi hi))) (math-combine-intervals (nth 2 lo) (and (or (memq (nth 1 b) '(2 3)) (math-infinitep (nth 2 lo))) (memq (nth 1 lo) '(2 3))) (nth 3 lo) (and (or (memq (nth 1 b) '(2 3)) (math-infinitep (nth 3 lo))) (memq (nth 1 lo) '(1 3))) (nth 2 hi) (and (or (memq (nth 1 b) '(1 3)) (math-infinitep (nth 2 hi))) (memq (nth 1 hi) '(2 3))) (nth 3 hi) (and (or (memq (nth 1 b) '(1 3)) (math-infinitep (nth 3 hi))) (memq (nth 1 hi) '(1 3)))))) ((and (eq (car-safe a) 'mod) (eq (car-safe b) 'mod) (equal (nth 2 a) (nth 2 b))) (math-make-mod (math-pow-mod (nth 1 a) (nth 1 b) (nth 2 a)) (nth 2 a))) ((and (eq (car-safe a) 'mod) (Math-anglep b)) (math-make-mod (math-pow-mod (nth 1 a) b (nth 2 a)) (nth 2 a))) ((and (eq (car-safe b) 'mod) (Math-anglep a)) (math-make-mod (math-pow-mod a (nth 1 b) (nth 2 b)) (nth 2 b))) ((not (Math-numberp a)) (math-reject-arg a 'numberp)) (t (math-reject-arg b 'numberp))) ) (defun math-quarter-integer (x) (if (Math-integerp x) 0 (if (math-negp x) (progn (setq x (math-quarter-integer (math-neg x))) (and x (- 4 x))) (if (eq (car x) 'frac) (if (eq (nth 2 x) 2) 2 (and (eq (nth 2 x) 4) (progn (setq x (nth 1 x)) (% (if (consp x) (nth 1 x) x) 4)))) (if (eq (car x) 'float) (if (>= (nth 2 x) 0) 0 (if (= (nth 2 x) -1) (progn (setq x (nth 1 x)) (and (= (% (if (consp x) (nth 1 x) x) 10) 5) 2)) (if (= (nth 2 x) -2) (progn (setq x (nth 1 x) x (% (if (consp x) (nth 1 x) x) 100)) (if (= x 25) 1 (if (= x 75) 3)))))))))) ) ;;; This assumes A < M and M > 0. (defun math-pow-mod (a b m) ; [R R R R] (if (and (Math-integerp a) (Math-integerp b) (Math-integerp m)) (if (Math-negp b) (math-div-mod 1 (math-pow-mod a (Math-integer-neg b) m) m) (if (eq m 1) 0 (math-pow-mod-step a b m))) (math-mod (math-pow a b) m)) ) (defun math-pow-mod-step (a n m) ; [I I I I] (math-working "pow" a) (let ((val (cond ((eq n 0) 1) ((eq n 1) a) (t (let ((rest (math-pow-mod-step (math-imod (math-mul a a) m) (math-div2 n) m))) (if (math-evenp n) rest (math-mod (math-mul a rest) m))))))) (math-working "pow" val) val) ) ;;; Compute the minimum of two real numbers. [R R R] [Public] (defun math-min (a b) (if (and (consp a) (eq (car a) 'intv)) (if (and (consp b) (eq (car b) 'intv)) (let ((lo (nth 2 a)) (lom (memq (nth 1 a) '(2 3))) (hi (nth 3 a)) (him (memq (nth 1 a) '(1 3))) res) (if (= (setq res (math-compare (nth 2 b) lo)) -1) (setq lo (nth 2 b) lom (memq (nth 1 b) '(2 3))) (if (= res 0) (setq lom (or lom (memq (nth 1 b) '(2 3)))))) (if (= (setq res (math-compare (nth 3 b) hi)) -1) (setq hi (nth 3 b) him (memq (nth 1 b) '(1 3))) (if (= res 0) (setq him (or him (memq (nth 1 b) '(1 3)))))) (math-make-intv (+ (if lom 2 0) (if him 1 0)) lo hi)) (math-min a (list 'intv 3 b b))) (if (and (consp b) (eq (car b) 'intv)) (math-min (list 'intv 3 a a) b) (let ((res (math-compare a b))) (if (= res 1) b (if (= res 2) '(var nan var-nan) a))))) ) (defun calcFunc-min (&optional a &rest b) (if (not a) '(var inf var-inf) (if (not (or (Math-anglep a) (eq (car a) 'date) (and (eq (car a) 'intv) (math-intv-constp a)) (math-infinitep a))) (math-reject-arg a 'anglep)) (math-min-list a b)) ) (defun math-min-list (a b) (if b (if (or (Math-anglep (car b)) (eq (car b) 'date) (and (eq (car (car b)) 'intv) (math-intv-constp (car b))) (math-infinitep (car b))) (math-min-list (math-min a (car b)) (cdr b)) (math-reject-arg (car b) 'anglep)) a) ) ;;; Compute the maximum of two real numbers. [R R R] [Public] (defun math-max (a b) (if (or (and (consp a) (eq (car a) 'intv)) (and (consp b) (eq (car b) 'intv))) (math-neg (math-min (math-neg a) (math-neg b))) (let ((res (math-compare a b))) (if (= res -1) b (if (= res 2) '(var nan var-nan) a)))) ) (defun calcFunc-max (&optional a &rest b) (if (not a) '(neg (var inf var-inf)) (if (not (or (Math-anglep a) (eq (car a) 'date) (and (eq (car a) 'intv) (math-intv-constp a)) (math-infinitep a))) (math-reject-arg a 'anglep)) (math-max-list a b)) ) (defun math-max-list (a b) (if b (if (or (Math-anglep (car b)) (eq (car b) 'date) (and (eq (car (car b)) 'intv) (math-intv-constp (car b))) (math-infinitep (car b))) (math-max-list (math-max a (car b)) (cdr b)) (math-reject-arg (car b) 'anglep)) a) ) ;;; Compute the absolute value of A. [O O; r r] [Public] (defun math-abs (a) (cond ((Math-negp a) (math-neg a)) ((Math-anglep a) a) ((eq (car a) 'cplx) (math-hypot (nth 1 a) (nth 2 a))) ((eq (car a) 'polar) (nth 1 a)) ((eq (car a) 'vec) (if (cdr (cdr (cdr a))) (math-sqrt (calcFunc-abssqr a)) (if (cdr (cdr a)) (math-hypot (nth 1 a) (nth 2 a)) (if (cdr a) (math-abs (nth 1 a)) a)))) ((eq (car a) 'sdev) (list 'sdev (math-abs (nth 1 a)) (nth 2 a))) ((and (eq (car a) 'intv) (math-intv-constp a)) (if (Math-posp a) a (let* ((nlo (math-neg (nth 2 a))) (res (math-compare nlo (nth 3 a)))) (cond ((= res 1) (math-make-intv (if (memq (nth 1 a) '(0 1)) 2 3) 0 nlo)) ((= res 0) (math-make-intv (if (eq (nth 1 a) 0) 2 3) 0 nlo)) (t (math-make-intv (if (memq (nth 1 a) '(0 2)) 2 3) 0 (nth 3 a))))))) ((math-looks-negp a) (list 'calcFunc-abs (math-neg a))) ((let ((signs (math-possible-signs a))) (or (and (memq signs '(2 4 6)) a) (and (memq signs '(1 3)) (math-neg a))))) ((let ((inf (math-infinitep a))) (and inf (if (equal inf '(var nan var-nan)) inf '(var inf var-inf))))) (t (calc-record-why 'numvecp a) (list 'calcFunc-abs a))) ) (fset 'calcFunc-abs (symbol-function 'math-abs)) (defun math-float-fancy (a) (cond ((eq (car a) 'intv) (cons (car a) (cons (nth 1 a) (mapcar 'math-float (nthcdr 2 a))))) ((and (memq (car a) '(* /)) (math-numberp (nth 1 a))) (list (car a) (math-float (nth 1 a)) (list 'calcFunc-float (nth 2 a)))) ((and (eq (car a) '/) (eq (car (nth 1 a)) '*) (math-numberp (nth 1 (nth 1 a)))) (list '* (math-float (nth 1 (nth 1 a))) (list 'calcFunc-float (list '/ (nth 2 (nth 1 a)) (nth 2 a))))) ((math-infinitep a) a) ((eq (car a) 'calcFunc-float) a) ((let ((func (assq (car a) '((calcFunc-floor . calcFunc-ffloor) (calcFunc-ceil . calcFunc-fceil) (calcFunc-trunc . calcFunc-ftrunc) (calcFunc-round . calcFunc-fround) (calcFunc-rounde . calcFunc-frounde) (calcFunc-roundu . calcFunc-froundu))))) (and func (cons (cdr func) (cdr a))))) (t (math-reject-arg a 'objectp))) ) (fset 'calcFunc-float (symbol-function 'math-float)) (defun math-trunc-fancy (a) (cond ((eq (car a) 'frac) (math-quotient (nth 1 a) (nth 2 a))) ((eq (car a) 'cplx) (math-trunc (nth 1 a))) ((eq (car a) 'polar) (math-trunc (math-complex a))) ((eq (car a) 'hms) (list 'hms (nth 1 a) 0 0)) ((eq (car a) 'date) (list 'date (math-trunc (nth 1 a)))) ((eq (car a) 'mod) (if (math-messy-integerp (nth 2 a)) (math-trunc (math-make-mod (nth 1 a) (math-trunc (nth 2 a)))) (math-make-mod (math-trunc (nth 1 a)) (nth 2 a)))) ((eq (car a) 'intv) (math-make-intv (+ (if (and (equal (nth 2 a) '(neg (var inf var-inf))) (memq (nth 1 a) '(0 1))) 0 2) (if (and (equal (nth 3 a) '(var inf var-inf)) (memq (nth 1 a) '(0 2))) 0 1)) (if (and (Math-negp (nth 2 a)) (Math-num-integerp (nth 2 a)) (memq (nth 1 a) '(0 1))) (math-add (math-trunc (nth 2 a)) 1) (math-trunc (nth 2 a))) (if (and (Math-posp (nth 3 a)) (Math-num-integerp (nth 3 a)) (memq (nth 1 a) '(0 2))) (math-add (math-trunc (nth 3 a)) -1) (math-trunc (nth 3 a))))) ((math-provably-integerp a) a) ((Math-vectorp a) (math-map-vec (function (lambda (x) (math-trunc x prec))) a)) ((math-infinitep a) (if (or (math-posp a) (math-negp a)) a '(var nan var-nan))) ((math-to-integer a)) (t (math-reject-arg a 'numberp))) ) (defun math-trunc-special (a prec) (if (Math-messy-integerp prec) (setq prec (math-trunc prec))) (or (integerp prec) (math-reject-arg prec 'fixnump)) (if (and (<= prec 0) (math-provably-integerp a)) a (calcFunc-scf (math-trunc (let ((calc-prefer-frac t)) (calcFunc-scf a prec))) (- prec))) ) (defun math-to-integer (a) (let ((func (assq (car-safe a) '((calcFunc-ffloor . calcFunc-floor) (calcFunc-fceil . calcFunc-ceil) (calcFunc-ftrunc . calcFunc-trunc) (calcFunc-fround . calcFunc-round) (calcFunc-frounde . calcFunc-rounde) (calcFunc-froundu . calcFunc-roundu))))) (and func (= (length a) 2) (cons (cdr func) (cdr a)))) ) (defun calcFunc-ftrunc (a &optional prec) (if (and (Math-messy-integerp a) (or (not prec) (and (integerp prec) (<= prec 0)))) a (math-float (math-trunc a prec))) ) (defun math-floor-fancy (a) (cond ((math-provably-integerp a) a) ((eq (car a) 'hms) (if (or (math-posp a) (and (math-zerop (nth 2 a)) (math-zerop (nth 3 a)))) (math-trunc a) (math-add (math-trunc a) -1))) ((eq (car a) 'date) (list 'date (math-floor (nth 1 a)))) ((eq (car a) 'intv) (math-make-intv (+ (if (and (equal (nth 2 a) '(neg (var inf var-inf))) (memq (nth 1 a) '(0 1))) 0 2) (if (and (equal (nth 3 a) '(var inf var-inf)) (memq (nth 1 a) '(0 2))) 0 1)) (math-floor (nth 2 a)) (if (and (Math-num-integerp (nth 3 a)) (memq (nth 1 a) '(0 2))) (math-add (math-floor (nth 3 a)) -1) (math-floor (nth 3 a))))) ((Math-vectorp a) (math-map-vec (function (lambda (x) (math-floor x prec))) a)) ((math-infinitep a) (if (or (math-posp a) (math-negp a)) a '(var nan var-nan))) ((math-to-integer a)) (t (math-reject-arg a 'anglep))) ) (defun math-floor-special (a prec) (if (Math-messy-integerp prec) (setq prec (math-trunc prec))) (or (integerp prec) (math-reject-arg prec 'fixnump)) (if (and (<= prec 0) (math-provably-integerp a)) a (calcFunc-scf (math-floor (let ((calc-prefer-frac t)) (calcFunc-scf a prec))) (- prec))) ) (defun calcFunc-ffloor (a &optional prec) (if (and (Math-messy-integerp a) (or (not prec) (and (integerp prec) (<= prec 0)))) a (math-float (math-floor a prec))) ) ;;; Coerce A to be an integer (by truncation toward plus infinity). [I N] (defun math-ceiling (a &optional prec) ; [Public] (cond (prec (if (Math-messy-integerp prec) (setq prec (math-trunc prec))) (or (integerp prec) (math-reject-arg prec 'fixnump)) (if (and (<= prec 0) (math-provably-integerp a)) a (calcFunc-scf (math-ceiling (let ((calc-prefer-frac t)) (calcFunc-scf a prec))) (- prec)))) ((Math-integerp a) a) ((Math-messy-integerp a) (math-trunc a)) ((Math-realp a) (if (Math-posp a) (math-add (math-trunc a) 1) (math-trunc a))) ((math-provably-integerp a) a) ((eq (car a) 'hms) (if (or (math-negp a) (and (math-zerop (nth 2 a)) (math-zerop (nth 3 a)))) (math-trunc a) (math-add (math-trunc a) 1))) ((eq (car a) 'date) (list 'date (math-ceiling (nth 1 a)))) ((eq (car a) 'intv) (math-make-intv (+ (if (and (equal (nth 2 a) '(neg (var inf var-inf))) (memq (nth 1 a) '(0 1))) 0 2) (if (and (equal (nth 3 a) '(var inf var-inf)) (memq (nth 1 a) '(0 2))) 0 1)) (if (and (Math-num-integerp (nth 2 a)) (memq (nth 1 a) '(0 1))) (math-add (math-floor (nth 2 a)) 1) (math-ceiling (nth 2 a))) (math-ceiling (nth 3 a)))) ((Math-vectorp a) (math-map-vec (function (lambda (x) (math-ceiling x prec))) a)) ((math-infinitep a) (if (or (math-posp a) (math-negp a)) a '(var nan var-nan))) ((math-to-integer a)) (t (math-reject-arg a 'anglep))) ) (fset 'calcFunc-ceil (symbol-function 'math-ceiling)) (defun calcFunc-fceil (a &optional prec) (if (and (Math-messy-integerp a) (or (not prec) (and (integerp prec) (<= prec 0)))) a (math-float (math-ceiling a prec))) ) (setq math-rounding-mode nil) ;;; Coerce A to be an integer (by rounding to nearest integer). [I N] [Public] (defun math-round (a &optional prec) (cond (prec (if (Math-messy-integerp prec) (setq prec (math-trunc prec))) (or (integerp prec) (math-reject-arg prec 'fixnump)) (if (and (<= prec 0) (math-provably-integerp a)) a (calcFunc-scf (math-round (let ((calc-prefer-frac t)) (calcFunc-scf a prec))) (- prec)))) ((Math-anglep a) (if (Math-num-integerp a) (math-trunc a) (if (and (Math-negp a) (not (eq math-rounding-mode 'up))) (math-neg (math-round (math-neg a))) (setq a (let ((calc-angle-mode 'deg)) ; in case of HMS forms (math-add a (if (Math-ratp a) '(frac 1 2) '(float 5 -1))))) (if (and (Math-num-integerp a) (eq math-rounding-mode 'even)) (progn (setq a (math-floor a)) (or (math-evenp a) (setq a (math-sub a 1))) a) (math-floor a))))) ((math-provably-integerp a) a) ((eq (car a) 'date) (list 'date (math-round (nth 1 a)))) ((eq (car a) 'intv) (math-floor (math-add a '(frac 1 2)))) ((Math-vectorp a) (math-map-vec (function (lambda (x) (math-round x prec))) a)) ((math-infinitep a) (if (or (math-posp a) (math-negp a)) a '(var nan var-nan))) ((math-to-integer a)) (t (math-reject-arg a 'anglep))) ) (fset 'calcFunc-round (symbol-function 'math-round)) (defun calcFunc-rounde (a &optional prec) (let ((math-rounding-mode 'even)) (math-round a prec)) ) (defun calcFunc-roundu (a &optional prec) (let ((math-rounding-mode 'up)) (math-round a prec)) ) (defun calcFunc-fround (a &optional prec) (if (and (Math-messy-integerp a) (or (not prec) (and (integerp prec) (<= prec 0)))) a (math-float (math-round a prec))) ) (defun calcFunc-frounde (a &optional prec) (let ((math-rounding-mode 'even)) (calcFunc-fround a prec)) ) (defun calcFunc-froundu (a &optional prec) (let ((math-rounding-mode 'up)) (calcFunc-fround a prec)) ) ;;; Pull floating-point values apart into mantissa and exponent. (defun calcFunc-mant (x) (if (Math-realp x) (if (or (Math-ratp x) (eq (nth 1 x) 0)) x (list 'float (nth 1 x) (- 1 (math-numdigs (nth 1 x))))) (calc-record-why 'realp x) (list 'calcFunc-mant x)) ) (defun calcFunc-xpon (x) (if (Math-realp x) (if (or (Math-ratp x) (eq (nth 1 x) 0)) 0 (math-normalize (+ (nth 2 x) (1- (math-numdigs (nth 1 x)))))) (calc-record-why 'realp x) (list 'calcFunc-xpon x)) ) (defun calcFunc-scf (x n) (if (integerp n) (cond ((eq n 0) x) ((Math-integerp x) (if (> n 0) (math-scale-int x n) (math-div x (math-scale-int 1 (- n))))) ((eq (car x) 'frac) (if (> n 0) (math-make-frac (math-scale-int (nth 1 x) n) (nth 2 x)) (math-make-frac (nth 1 x) (math-scale-int (nth 2 x) (- n))))) ((eq (car x) 'float) (math-make-float (nth 1 x) (+ (nth 2 x) n))) ((memq (car x) '(cplx sdev)) (math-normalize (list (car x) (calcFunc-scf (nth 1 x) n) (calcFunc-scf (nth 2 x) n)))) ((memq (car x) '(polar mod)) (math-normalize (list (car x) (calcFunc-scf (nth 1 x) n) (nth 2 x)))) ((eq (car x) 'intv) (math-normalize (list (car x) (nth 1 x) (calcFunc-scf (nth 2 x) n) (calcFunc-scf (nth 3 x) n)))) ((eq (car x) 'vec) (math-map-vec (function (lambda (x) (calcFunc-scf x n))) x)) ((math-infinitep x) x) (t (calc-record-why 'realp x) (list 'calcFunc-scf x n))) (if (math-messy-integerp n) (if (< (nth 2 n) 10) (calcFunc-scf x (math-trunc n)) (math-overflow n)) (if (math-integerp n) (math-overflow n) (calc-record-why 'integerp n) (list 'calcFunc-scf x n)))) ) (defun calcFunc-incr (x &optional step relative-to) (or step (setq step 1)) (cond ((not (Math-integerp step)) (math-reject-arg step 'integerp)) ((Math-integerp x) (math-add x step)) ((eq (car x) 'float) (if (and (math-zerop x) (eq (car-safe relative-to) 'float)) (math-mul step (calcFunc-scf relative-to (- 1 calc-internal-prec))) (math-add-float x (math-make-float step (+ (nth 2 x) (- (math-numdigs (nth 1 x)) calc-internal-prec)))))) ((eq (car x) 'date) (if (Math-integerp (nth 1 x)) (math-add x step) (math-add x (list 'hms 0 0 step)))) (t (math-reject-arg x 'realp))) ) (defun calcFunc-decr (x &optional step relative-to) (calcFunc-incr x (math-neg (or step 1)) relative-to) ) (defun calcFunc-percent (x) (if (math-objectp x) (let ((calc-prefer-frac nil)) (math-div x 100)) (list 'calcFunc-percent x)) ) (defun calcFunc-relch (x y) (if (and (math-objectp x) (math-objectp y)) (math-div (math-sub y x) x) (list 'calcFunc-relch x y)) ) ;;; Compute the absolute value squared of A. [F N] [Public] (defun calcFunc-abssqr (a) (cond ((Math-realp a) (math-mul a a)) ((eq (car a) 'cplx) (math-add (math-sqr (nth 1 a)) (math-sqr (nth 2 a)))) ((eq (car a) 'polar) (math-sqr (nth 1 a))) ((and (memq (car a) '(sdev intv)) (math-constp a)) (math-sqr (math-abs a))) ((eq (car a) 'vec) (math-reduce-vec 'math-add (math-map-vec 'calcFunc-abssqr a))) ((math-known-realp a) (math-pow a 2)) ((let ((inf (math-infinitep a))) (and inf (math-mul (calcFunc-abssqr (math-infinite-dir a inf)) inf)))) (t (calc-record-why 'numvecp a) (list 'calcFunc-abssqr a))) ) (defun math-sqr (a) (math-mul a a) ) ;;;; Number theory. (defun calcFunc-idiv (a b) ; [I I I] [Public] (cond ((and (Math-natnump a) (Math-natnump b) (not (eq b 0))) (math-quotient a b)) ((Math-realp a) (if (Math-realp b) (let ((calc-prefer-frac t)) (math-floor (math-div a b))) (math-reject-arg b 'realp))) ((eq (car-safe a) 'hms) (if (eq (car-safe b) 'hms) (let ((calc-prefer-frac t)) (math-floor (math-div a b))) (math-reject-arg b 'hmsp))) ((and (or (eq (car-safe a) 'intv) (Math-realp a)) (or (eq (car-safe b) 'intv) (Math-realp b))) (math-floor (math-div a b))) ((or (math-infinitep a) (math-infinitep b)) (math-div a b)) (t (math-reject-arg a 'anglep))) ) ;;; Combine two terms being added, if possible. (defun math-combine-sum (a b nega negb scalar-okay) (if (and scalar-okay (Math-objvecp a) (Math-objvecp b)) (math-add-or-sub a b nega negb) (let ((amult 1) (bmult 1)) (and (consp a) (cond ((and (eq (car a) '*) (Math-objectp (nth 1 a))) (setq amult (nth 1 a) a (nth 2 a))) ((and (eq (car a) '/) (Math-objectp (nth 2 a))) (setq amult (if (Math-integerp (nth 2 a)) (list 'frac 1 (nth 2 a)) (math-div 1 (nth 2 a))) a (nth 1 a))) ((eq (car a) 'neg) (setq amult -1 a (nth 1 a))))) (and (consp b) (cond ((and (eq (car b) '*) (Math-objectp (nth 1 b))) (setq bmult (nth 1 b) b (nth 2 b))) ((and (eq (car b) '/) (Math-objectp (nth 2 b))) (setq bmult (if (Math-integerp (nth 2 b)) (list 'frac 1 (nth 2 b)) (math-div 1 (nth 2 b))) b (nth 1 b))) ((eq (car b) 'neg) (setq bmult -1 b (nth 1 b))))) (and (if math-simplifying (Math-equal a b) (equal a b)) (progn (if nega (setq amult (math-neg amult))) (if negb (setq bmult (math-neg bmult))) (setq amult (math-add amult bmult)) (math-mul amult a))))) ) (defun math-add-or-sub (a b aneg bneg) (if aneg (setq a (math-neg a))) (if bneg (setq b (math-neg b))) (if (or (Math-vectorp a) (Math-vectorp b)) (math-normalize (list '+ a b)) (math-add a b)) ) ;;; The following is expanded out four ways for speed. (defun math-combine-prod (a b inva invb scalar-okay) (cond ((or (and inva (Math-zerop a)) (and invb (Math-zerop b))) nil) ((and scalar-okay (Math-objvecp a) (Math-objvecp b)) (setq a (math-mul-or-div a b inva invb)) (and (Math-objvecp a) a)) ((and (eq (car-safe a) '^) inva (math-looks-negp (nth 2 a))) (math-mul (math-pow (nth 1 a) (math-neg (nth 2 a))) b)) ((and (eq (car-safe b) '^) invb (math-looks-negp (nth 2 b))) (math-mul a (math-pow (nth 1 b) (math-neg (nth 2 b))))) (t (let ((apow 1) (bpow 1)) (and (consp a) (cond ((and (eq (car a) '^) (or math-simplifying (Math-numberp (nth 2 a)))) (setq apow (nth 2 a) a (nth 1 a))) ((eq (car a) 'calcFunc-sqrt) (setq apow '(frac 1 2) a (nth 1 a))) ((and (eq (car a) 'calcFunc-exp) (or math-simplifying (Math-numberp (nth 1 a)))) (setq apow (nth 1 a) a math-combine-prod-e)))) (and (consp a) (eq (car a) 'frac) (Math-lessp (nth 1 a) (nth 2 a)) (setq a (math-div 1 a) apow (math-neg apow))) (and (consp b) (cond ((and (eq (car b) '^) (or math-simplifying (Math-numberp (nth 2 b)))) (setq bpow (nth 2 b) b (nth 1 b))) ((eq (car b) 'calcFunc-sqrt) (setq bpow '(frac 1 2) b (nth 1 b))) ((and (eq (car b) 'calcFunc-exp) (or math-simplifying (Math-numberp (nth 1 b)))) (setq bpow (nth 1 b) b math-combine-prod-e)))) (and (consp b) (eq (car b) 'frac) (Math-lessp (nth 1 b) (nth 2 b)) (setq b (math-div 1 b) bpow (math-neg bpow))) (if inva (setq apow (math-neg apow))) (if invb (setq bpow (math-neg bpow))) (or (and (if math-simplifying (math-commutative-equal a b) (equal a b)) (let ((sumpow (math-add apow bpow))) (and (or (not (Math-integerp a)) (Math-zerop sumpow) (eq (eq (car-safe apow) 'frac) (eq (car-safe bpow) 'frac))) (progn (and (math-looks-negp sumpow) (Math-ratp a) (Math-posp a) (setq a (math-div 1 a) sumpow (math-neg sumpow))) (cond ((equal sumpow '(frac 1 2)) (list 'calcFunc-sqrt a)) ((equal sumpow '(frac -1 2)) (math-div 1 (list 'calcFunc-sqrt a))) ((and (eq a math-combine-prod-e) (eq a b)) (list 'calcFunc-exp sumpow)) (t (condition-case err (math-pow a sumpow) (inexact-result (list '^ a sumpow))))))))) (and math-simplifying-units math-combining-units (let* ((ua (math-check-unit-name a)) ub) (and ua (eq ua (setq ub (math-check-unit-name b))) (progn (setq ua (if (eq (nth 1 a) (car ua)) 1 (nth 1 (assq (aref (symbol-name (nth 1 a)) 0) math-unit-prefixes))) ub (if (eq (nth 1 b) (car ub)) 1 (nth 1 (assq (aref (symbol-name (nth 1 b)) 0) math-unit-prefixes)))) (if (Math-lessp ua ub) (let (temp) (setq temp a a b b temp temp ua ua ub ub temp temp apow apow bpow bpow temp))) (math-mul (math-pow (math-div ua ub) apow) (math-pow b (math-add apow bpow))))))) (and (equal apow bpow) (Math-natnump a) (Math-natnump b) (cond ((equal apow '(frac 1 2)) (list 'calcFunc-sqrt (math-mul a b))) ((equal apow '(frac -1 2)) (math-div 1 (list 'calcFunc-sqrt (math-mul a b)))) (t (setq a (math-mul a b)) (condition-case err (math-pow a apow) (inexact-result (list '^ a apow)))))))))) ) (setq math-combine-prod-e '(var e var-e)) (defun math-mul-or-div (a b ainv binv) (if (or (Math-vectorp a) (Math-vectorp b)) (math-normalize (if ainv (if binv (list '/ (math-div 1 a) b) (list '/ b a)) (if binv (list '/ a b) (list '* a b)))) (if ainv (if binv (math-div (math-div 1 a) b) (math-div b a)) (if binv (math-div a b) (math-mul a b)))) ) (defun math-commutative-equal (a b) (if (memq (car-safe a) '(+ -)) (and (memq (car-safe b) '(+ -)) (let ((bterms nil) aterms p) (math-commutative-collect b nil) (setq aterms bterms bterms nil) (math-commutative-collect a nil) (and (= (length aterms) (length bterms)) (progn (while (and aterms (progn (setq p bterms) (while (and p (not (equal (car aterms) (car p)))) (setq p (cdr p))) p)) (setq bterms (delq (car p) bterms) aterms (cdr aterms))) (not aterms))))) (equal a b)) ) (defun math-commutative-collect (b neg) (if (eq (car-safe b) '+) (progn (math-commutative-collect (nth 1 b) neg) (math-commutative-collect (nth 2 b) neg)) (if (eq (car-safe b) '-) (progn (math-commutative-collect (nth 1 b) neg) (math-commutative-collect (nth 2 b) (not neg))) (setq bterms (cons (if neg (math-neg b) b) bterms)))) ) calc-2.02c/calc-math.el100644 22403 13 146775 5402630673 13262 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-math.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-math () nil) (defun calc-sqrt (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-inverse) (calc-unary-op "^2" 'calcFunc-sqr arg) (calc-unary-op "sqrt" 'calcFunc-sqrt arg))) ) (defun calc-isqrt (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-inverse) (calc-unary-op "^2" 'calcFunc-sqr arg) (calc-unary-op "isqt" 'calcFunc-isqrt arg))) ) (defun calc-hypot (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "hypt" 'calcFunc-hypot arg)) ) (defun calc-ln (arg) (interactive "P") (calc-invert-func) (calc-exp arg) ) (defun calc-log10 (arg) (interactive "P") (calc-hyperbolic-func) (calc-ln arg) ) (defun calc-log (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-inverse) (calc-binary-op "alog" 'calcFunc-alog arg) (calc-binary-op "log" 'calcFunc-log arg))) ) (defun calc-ilog (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-inverse) (calc-binary-op "alog" 'calcFunc-alog arg) (calc-binary-op "ilog" 'calcFunc-ilog arg))) ) (defun calc-lnp1 (arg) (interactive "P") (calc-invert-func) (calc-expm1 arg) ) (defun calc-exp (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-hyperbolic) (if (calc-is-inverse) (calc-unary-op "lg10" 'calcFunc-log10 arg) (calc-unary-op "10^" 'calcFunc-exp10 arg)) (if (calc-is-inverse) (calc-unary-op "ln" 'calcFunc-ln arg) (calc-unary-op "exp" 'calcFunc-exp arg)))) ) (defun calc-expm1 (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-inverse) (calc-unary-op "ln+1" 'calcFunc-lnp1 arg) (calc-unary-op "ex-1" 'calcFunc-expm1 arg))) ) (defun calc-pi () (interactive) (calc-slow-wrapper (if (calc-is-inverse) (if (calc-is-hyperbolic) (if calc-symbolic-mode (calc-pop-push-record 0 "phi" '(var phi var-phi)) (calc-pop-push-record 0 "phi" (math-phi))) (if calc-symbolic-mode (calc-pop-push-record 0 "gmma" '(var gamma var-gamma)) (calc-pop-push-record 0 "gmma" (math-gamma-const)))) (if (calc-is-hyperbolic) (if calc-symbolic-mode (calc-pop-push-record 0 "e" '(var e var-e)) (calc-pop-push-record 0 "e" (math-e))) (if calc-symbolic-mode (calc-pop-push-record 0 "pi" '(var pi var-pi)) (calc-pop-push-record 0 "pi" (math-pi)))))) ) (defun calc-sin (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-hyperbolic) (if (calc-is-inverse) (calc-unary-op "asnh" 'calcFunc-arcsinh arg) (calc-unary-op "sinh" 'calcFunc-sinh arg)) (if (calc-is-inverse) (calc-unary-op "asin" 'calcFunc-arcsin arg) (calc-unary-op "sin" 'calcFunc-sin arg)))) ) (defun calc-arcsin (arg) (interactive "P") (calc-invert-func) (calc-sin arg) ) (defun calc-sinh (arg) (interactive "P") (calc-hyperbolic-func) (calc-sin arg) ) (defun calc-arcsinh (arg) (interactive "P") (calc-invert-func) (calc-hyperbolic-func) (calc-sin arg) ) (defun calc-cos (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-hyperbolic) (if (calc-is-inverse) (calc-unary-op "acsh" 'calcFunc-arccosh arg) (calc-unary-op "cosh" 'calcFunc-cosh arg)) (if (calc-is-inverse) (calc-unary-op "acos" 'calcFunc-arccos arg) (calc-unary-op "cos" 'calcFunc-cos arg)))) ) (defun calc-arccos (arg) (interactive "P") (calc-invert-func) (calc-cos arg) ) (defun calc-cosh (arg) (interactive "P") (calc-hyperbolic-func) (calc-cos arg) ) (defun calc-arccosh (arg) (interactive "P") (calc-invert-func) (calc-hyperbolic-func) (calc-cos arg) ) (defun calc-sincos () (interactive) (calc-slow-wrapper (if (calc-is-inverse) (calc-enter-result 1 "asnc" (list 'calcFunc-arcsincos (calc-top-n 1))) (calc-enter-result 1 "sncs" (list 'calcFunc-sincos (calc-top-n 1))))) ) (defun calc-tan (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-hyperbolic) (if (calc-is-inverse) (calc-unary-op "atnh" 'calcFunc-arctanh arg) (calc-unary-op "tanh" 'calcFunc-tanh arg)) (if (calc-is-inverse) (calc-unary-op "atan" 'calcFunc-arctan arg) (calc-unary-op "tan" 'calcFunc-tan arg)))) ) (defun calc-arctan (arg) (interactive "P") (calc-invert-func) (calc-tan arg) ) (defun calc-tanh (arg) (interactive "P") (calc-hyperbolic-func) (calc-tan arg) ) (defun calc-arctanh (arg) (interactive "P") (calc-invert-func) (calc-hyperbolic-func) (calc-tan arg) ) (defun calc-arctan2 () (interactive) (calc-slow-wrapper (calc-enter-result 2 "atn2" (cons 'calcFunc-arctan2 (calc-top-list-n 2)))) ) (defun calc-conj (arg) (interactive "P") (calc-wrapper (calc-unary-op "conj" 'calcFunc-conj arg)) ) (defun calc-imaginary () (interactive) (calc-slow-wrapper (calc-pop-push-record 1 "i*" (math-imaginary (calc-top-n 1)))) ) (defun calc-to-degrees (arg) (interactive "P") (calc-wrapper (calc-unary-op ">deg" 'calcFunc-deg arg)) ) (defun calc-to-radians (arg) (interactive "P") (calc-wrapper (calc-unary-op ">rad" 'calcFunc-rad arg)) ) (defun calc-degrees-mode (arg) (interactive "p") (cond ((= arg 1) (calc-wrapper (calc-change-mode 'calc-angle-mode 'deg) (message "Angles measured in degrees."))) ((= arg 2) (calc-radians-mode)) ((= arg 3) (calc-hms-mode)) (t (error "Prefix argument out of range"))) ) (defun calc-radians-mode () (interactive) (calc-wrapper (calc-change-mode 'calc-angle-mode 'rad) (message "Angles measured in radians.")) ) ;;; Compute the integer square-root floor(sqrt(A)). A > 0. [I I] [Public] ;;; This method takes advantage of the fact that Newton's method starting ;;; with an overestimate always works, even using truncating integer division! (defun math-isqrt (a) (cond ((Math-zerop a) a) ((not (math-natnump a)) (math-reject-arg a 'natnump)) ((integerp a) (math-isqrt-small a)) (t (math-normalize (cons 'bigpos (cdr (math-isqrt-bignum (cdr a))))))) ) (defun calcFunc-isqrt (a) (if (math-realp a) (math-isqrt (math-floor a)) (math-floor (math-sqrt a))) ) ;;; This returns (flag . result) where the flag is T if A is a perfect square. (defun math-isqrt-bignum (a) ; [P.l L] (let ((len (length a))) (if (= (% len 2) 0) (let* ((top (nthcdr (- len 2) a))) (math-isqrt-bignum-iter a (math-scale-bignum-3 (math-bignum-big (1+ (math-isqrt-small (+ (* (nth 1 top) 1000) (car top))))) (1- (/ len 2))))) (let* ((top (nth (1- len) a))) (math-isqrt-bignum-iter a (math-scale-bignum-3 (list (1+ (math-isqrt-small top))) (/ len 2)))))) ) (defun math-isqrt-bignum-iter (a guess) ; [l L l] (math-working "isqrt" (cons 'bigpos guess)) (let* ((q (math-div-bignum a guess)) (s (math-add-bignum (car q) guess)) (g2 (math-div2-bignum s)) (comp (math-compare-bignum g2 guess))) (if (< comp 0) (math-isqrt-bignum-iter a g2) (cons (and (= comp 0) (math-zerop-bignum (cdr q)) (= (% (car s) 2) 0)) guess))) ) (defun math-zerop-bignum (a) (and (eq (car a) 0) (progn (while (eq (car (setq a (cdr a))) 0)) (null a))) ) (defun math-scale-bignum-3 (a n) ; [L L S] (while (> n 0) (setq a (cons 0 a) n (1- n))) a ) (defun math-isqrt-small (a) ; A > 0. [S S] (let ((g (cond ((>= a 10000) 1000) ((>= a 100) 100) (t 10))) g2) (while (< (setq g2 (/ (+ g (/ a g)) 2)) g) (setq g g2)) g) ) ;;; Compute the square root of a number. ;;; [T N] if possible, else [F N] if possible, else [C N]. [Public] (defun math-sqrt (a) (or (and (Math-zerop a) a) (and (math-known-nonposp a) (math-imaginary (math-sqrt (math-neg a)))) (and (integerp a) (let ((sqrt (math-isqrt-small a))) (if (= (* sqrt sqrt) a) sqrt (if calc-symbolic-mode (list 'calcFunc-sqrt a) (math-sqrt-float (math-float a) (math-float sqrt)))))) (and (eq (car-safe a) 'bigpos) (let* ((res (math-isqrt-bignum (cdr a))) (sqrt (math-normalize (cons 'bigpos (cdr res))))) (if (car res) sqrt (if calc-symbolic-mode (list 'calcFunc-sqrt a) (math-sqrt-float (math-float a) (math-float sqrt)))))) (and (eq (car-safe a) 'frac) (let* ((num-res (math-isqrt-bignum (cdr (Math-bignum-test (nth 1 a))))) (num-sqrt (math-normalize (cons 'bigpos (cdr num-res)))) (den-res (math-isqrt-bignum (cdr (Math-bignum-test (nth 2 a))))) (den-sqrt (math-normalize (cons 'bigpos (cdr den-res))))) (if (and (car num-res) (car den-res)) (list 'frac num-sqrt den-sqrt) (if calc-symbolic-mode (if (or (car num-res) (car den-res)) (math-div (if (car num-res) num-sqrt (list 'calcFunc-sqrt (nth 1 a))) (if (car den-res) den-sqrt (list 'calcFunc-sqrt (nth 2 a)))) (list 'calcFunc-sqrt a)) (math-sqrt-float (math-float a) (math-div (math-float num-sqrt) den-sqrt)))))) (and (eq (car-safe a) 'float) (if calc-symbolic-mode (if (= (% (nth 2 a) 2) 0) (let ((res (math-isqrt-bignum (cdr (Math-bignum-test (nth 1 a)))))) (if (car res) (math-make-float (math-normalize (cons 'bigpos (cdr res))) (/ (nth 2 a) 2)) (signal 'inexact-result nil))) (signal 'inexact-result nil)) (math-sqrt-float a))) (and (eq (car-safe a) 'cplx) (math-with-extra-prec 2 (let* ((d (math-abs a)) (imag (math-sqrt (math-mul (math-sub d (nth 1 a)) '(float 5 -1))))) (list 'cplx (math-sqrt (math-mul (math-add d (nth 1 a)) '(float 5 -1))) (if (math-negp (nth 2 a)) (math-neg imag) imag))))) (and (eq (car-safe a) 'polar) (list 'polar (math-sqrt (nth 1 a)) (math-mul (nth 2 a) '(float 5 -1)))) (and (eq (car-safe a) 'sdev) (let ((sqrt (math-sqrt (nth 1 a)))) (math-make-sdev sqrt (math-div (nth 2 a) (math-mul sqrt 2))))) (and (eq (car-safe a) 'intv) (not (math-negp (nth 2 a))) (math-make-intv (nth 1 a) (math-sqrt (nth 2 a)) (math-sqrt (nth 3 a)))) (and (eq (car-safe a) '*) (or (math-known-nonnegp (nth 1 a)) (math-known-nonnegp (nth 2 a))) (math-mul (math-sqrt (nth 1 a)) (math-sqrt (nth 2 a)))) (and (eq (car-safe a) '/) (or (and (math-known-nonnegp (nth 2 a)) (math-div (math-sqrt (nth 1 a)) (math-sqrt (nth 2 a)))) (and (math-known-nonnegp (nth 1 a)) (not (math-equal-int (nth 1 a) 1)) (math-mul (math-sqrt (nth 1 a)) (math-sqrt (math-div 1 (nth 2 a))))))) (and (eq (car-safe a) '^) (math-known-evenp (nth 2 a)) (math-known-realp (nth 1 a)) (math-abs (math-pow (nth 1 a) (math-div (nth 2 a) 2)))) (let ((inf (math-infinitep a))) (and inf (math-mul (math-sqrt (math-infinite-dir a inf)) inf))) (progn (calc-record-why 'numberp a) (list 'calcFunc-sqrt a))) ) (fset 'calcFunc-sqrt (symbol-function 'math-sqrt)) (defun math-infinite-dir (a &optional inf) (or inf (setq inf (math-infinitep a))) (math-normalize (math-expr-subst a inf 1)) ) (defun math-sqrt-float (a &optional guess) ; [F F F] (if calc-symbolic-mode (signal 'inexact-result nil) (math-with-extra-prec 1 (math-sqrt-raw a guess))) ) (defun math-sqrt-raw (a &optional guess) ; [F F F] (if (not (Math-posp a)) (math-sqrt a) (if (null guess) (let ((ldiff (- (math-numdigs (nth 1 a)) 6))) (or (= (% (+ (nth 2 a) ldiff) 2) 0) (setq ldiff (1+ ldiff))) (setq guess (math-make-float (math-isqrt-small (math-scale-int (nth 1 a) (- ldiff))) (/ (+ (nth 2 a) ldiff) 2))))) (math-sqrt-float-iter a guess)) ) (defun math-sqrt-float-iter (a guess) ; [F F F] (math-working "sqrt" guess) (let ((g2 (math-mul-float (math-add-float guess (math-div-float a guess)) '(float 5 -1)))) (if (math-nearly-equal-float g2 guess) g2 (math-sqrt-float-iter a g2))) ) ;;; True if A and B differ only in the last digit of precision. [P F F] (defun math-nearly-equal-float (a b) (let ((ediff (- (nth 2 a) (nth 2 b)))) (cond ((= ediff 0) ;; Expanded out for speed (setq ediff (math-add (Math-integer-neg (nth 1 a)) (nth 1 b))) (or (eq ediff 0) (and (not (consp ediff)) (< ediff 10) (> ediff -10) (= (math-numdigs (nth 1 a)) calc-internal-prec)))) ((= ediff 1) (setq ediff (math-add (Math-integer-neg (nth 1 b)) (math-scale-int (nth 1 a) 1))) (and (not (consp ediff)) (< ediff 10) (> ediff -10) (= (math-numdigs (nth 1 b)) calc-internal-prec))) ((= ediff -1) (setq ediff (math-add (Math-integer-neg (nth 1 a)) (math-scale-int (nth 1 b) 1))) (and (not (consp ediff)) (< ediff 10) (> ediff -10) (= (math-numdigs (nth 1 a)) calc-internal-prec))))) ) (defun math-nearly-equal (a b) ; [P N N] [Public] (setq a (math-float a)) (setq b (math-float b)) (if (eq (car a) 'polar) (setq a (math-complex a))) (if (eq (car b) 'polar) (setq b (math-complex b))) (if (eq (car a) 'cplx) (if (eq (car b) 'cplx) (and (or (math-nearly-equal-float (nth 1 a) (nth 1 b)) (and (math-nearly-zerop-float (nth 1 a) (nth 2 a)) (math-nearly-zerop-float (nth 1 b) (nth 2 b)))) (or (math-nearly-equal-float (nth 2 a) (nth 2 b)) (and (math-nearly-zerop-float (nth 2 a) (nth 1 a)) (math-nearly-zerop-float (nth 2 b) (nth 1 b))))) (and (math-nearly-equal-float (nth 1 a) b) (math-nearly-zerop-float (nth 2 a) b))) (if (eq (car b) 'cplx) (and (math-nearly-equal-float a (nth 1 b)) (math-nearly-zerop-float a (nth 2 b))) (math-nearly-equal-float a b))) ) ;;; True if A is nearly zero compared to B. [P F F] (defun math-nearly-zerop-float (a b) (or (eq (nth 1 a) 0) (<= (+ (math-numdigs (nth 1 a)) (nth 2 a)) (1+ (- (+ (math-numdigs (nth 1 b)) (nth 2 b)) calc-internal-prec)))) ) (defun math-nearly-zerop (a b) ; [P N R] [Public] (setq a (math-float a)) (setq b (math-float b)) (if (eq (car a) 'cplx) (and (math-nearly-zerop-float (nth 1 a) b) (math-nearly-zerop-float (nth 2 a) b)) (if (eq (car a) 'polar) (math-nearly-zerop-float (nth 1 a) b) (math-nearly-zerop-float a b))) ) ;;; This implementation could be improved, accuracy-wise. (defun math-hypot (a b) (cond ((Math-zerop a) (math-abs b)) ((Math-zerop b) (math-abs a)) ((not (Math-scalarp a)) (if (math-infinitep a) (if (math-infinitep b) (if (equal a b) a '(var nan var-nan)) a) (calc-record-why 'scalarp a) (list 'calcFunc-hypot a b))) ((not (Math-scalarp b)) (if (math-infinitep b) b (calc-record-why 'scalarp b) (list 'calcFunc-hypot a b))) ((and (Math-numberp a) (Math-numberp b)) (math-with-extra-prec 1 (math-sqrt (math-add (calcFunc-abssqr a) (calcFunc-abssqr b))))) ((eq (car-safe a) 'hms) (if (eq (car-safe b) 'hms) ; this helps sdev's of hms forms (math-to-hms (math-hypot (math-from-hms a 'deg) (math-from-hms b 'deg))) (math-to-hms (math-hypot (math-from-hms a 'deg) b)))) ((eq (car-safe b) 'hms) (math-to-hms (math-hypot a (math-from-hms b 'deg)))) (t nil)) ) (fset 'calcFunc-hypot (symbol-function 'math-hypot)) (defun calcFunc-sqr (x) (math-pow x 2) ) (defun math-nth-root (a n) (cond ((= n 2) (math-sqrt a)) ((Math-zerop a) a) ((Math-negp a) nil) ((Math-integerp a) (let ((root (math-nth-root-integer a n))) (if (car root) (cdr root) (and (not calc-symbolic-mode) (math-nth-root-float (math-float a) n (math-float (cdr root))))))) ((eq (car-safe a) 'frac) (let* ((num-root (math-nth-root-integer (nth 1 a) n)) (den-root (math-nth-root-integer (nth 2 a) n))) (if (and (car num-root) (car den-root)) (list 'frac (cdr num-root) (cdr den-root)) (and (not calc-symbolic-mode) (math-nth-root-float (math-float a) n (math-div-float (math-float (cdr num-root)) (math-float (cdr den-root)))))))) ((eq (car-safe a) 'float) (and (not calc-symbolic-mode) (math-nth-root-float a n))) ((eq (car-safe a) 'polar) (let ((root (math-nth-root (nth 1 a) n))) (and root (list 'polar root (math-div (nth 2 a) n))))) (t nil)) ) (defun math-nth-root-float (a n &optional guess) (math-inexact-result) (math-with-extra-prec 1 (let ((nf (math-float n)) (nfm1 (math-float (1- n)))) (math-nth-root-float-iter a (or guess (math-make-float 1 (/ (+ (math-numdigs (nth 1 a)) (nth 2 a) (/ n 2)) n)))))) ) (defun math-nth-root-float-iter (a guess) ; uses "n", "nf", "nfm1" (math-working "root" guess) (let ((g2 (math-div-float (math-add-float (math-mul nfm1 guess) (math-div-float a (math-ipow guess (1- n)))) nf))) (if (math-nearly-equal-float g2 guess) g2 (math-nth-root-float-iter a g2))) ) (defun math-nth-root-integer (a n &optional guess) ; [I I S] (math-nth-root-int-iter a (or guess (math-scale-int 1 (/ (+ (math-numdigs a) (1- n)) n)))) ) (defun math-nth-root-int-iter (a guess) ; uses "n" (math-working "root" guess) (let* ((q (math-idivmod a (math-ipow guess (1- n)))) (s (math-add (car q) (math-mul (1- n) guess))) (g2 (math-idivmod s n))) (if (Math-natnum-lessp (car g2) guess) (math-nth-root-int-iter a (car g2)) (cons (and (equal (car g2) guess) (eq (cdr q) 0) (eq (cdr g2) 0)) guess))) ) (defun calcFunc-nroot (x n) (calcFunc-pow x (if (integerp n) (math-make-frac 1 n) (math-div 1 n))) ) ;;;; Transcendental functions. ;;; All of these functions are defined on the complex plane. ;;; (Branch cuts, etc. follow Steele's Common Lisp book.) ;;; Most functions increase calc-internal-prec by 2 digits, then round ;;; down afterward. "-raw" functions use the current precision, require ;;; their arguments to be in float (or complex float) format, and always ;;; work in radians (where applicable). (defun math-to-radians (a) ; [N N] (cond ((eq (car-safe a) 'hms) (math-from-hms a 'rad)) ((memq calc-angle-mode '(deg hms)) (math-mul a (math-pi-over-180))) (t a)) ) (defun math-from-radians (a) ; [N N] (cond ((eq calc-angle-mode 'deg) (if (math-constp a) (math-div a (math-pi-over-180)) (list 'calcFunc-deg a))) ((eq calc-angle-mode 'hms) (math-to-hms a 'rad)) (t a)) ) (defun math-to-radians-2 (a) ; [N N] (cond ((eq (car-safe a) 'hms) (math-from-hms a 'rad)) ((memq calc-angle-mode '(deg hms)) (if calc-symbolic-mode (math-div (math-mul a '(var pi var-pi)) 180) (math-mul a (math-pi-over-180)))) (t a)) ) (defun math-from-radians-2 (a) ; [N N] (cond ((memq calc-angle-mode '(deg hms)) (if calc-symbolic-mode (math-div (math-mul 180 a) '(var pi var-pi)) (math-div a (math-pi-over-180)))) (t a)) ) ;;; Sine, cosine, and tangent. (defun calcFunc-sin (x) ; [N N] [Public] (cond ((and (integerp x) (if (eq calc-angle-mode 'deg) (= (% x 90) 0) (= x 0))) (aref [0 1 0 -1] (math-mod (/ x 90) 4))) ((Math-scalarp x) (math-with-extra-prec 2 (math-sin-raw (math-to-radians (math-float x))))) ((eq (car x) 'sdev) (if (math-constp x) (math-with-extra-prec 2 (let* ((xx (math-to-radians (math-float (nth 1 x)))) (xs (math-to-radians (math-float (nth 2 x)))) (sc (math-sin-cos-raw xx))) (math-make-sdev (car sc) (math-mul xs (cdr sc))))) (math-make-sdev (calcFunc-sin (nth 1 x)) (math-mul (nth 2 x) (calcFunc-cos (nth 1 x)))))) ((and (eq (car x) 'intv) (math-intv-constp x)) (calcFunc-cos (math-sub x (math-quarter-circle nil)))) ((equal x '(var nan var-nan)) x) (t (calc-record-why 'scalarp x) (list 'calcFunc-sin x))) ) (defun calcFunc-cos (x) ; [N N] [Public] (cond ((and (integerp x) (if (eq calc-angle-mode 'deg) (= (% x 90) 0) (= x 0))) (aref [1 0 -1 0] (math-mod (/ x 90) 4))) ((Math-scalarp x) (math-with-extra-prec 2 (math-cos-raw (math-to-radians (math-float x))))) ((eq (car x) 'sdev) (if (math-constp x) (math-with-extra-prec 2 (let* ((xx (math-to-radians (math-float (nth 1 x)))) (xs (math-to-radians (math-float (nth 2 x)))) (sc (math-sin-cos-raw xx))) (math-make-sdev (cdr sc) (math-mul xs (car sc))))) (math-make-sdev (calcFunc-cos (nth 1 x)) (math-mul (nth 2 x) (calcFunc-sin (nth 1 x)))))) ((and (eq (car x) 'intv) (math-intv-constp x)) (math-with-extra-prec 2 (let* ((xx (math-to-radians (math-float x))) (na (math-floor (math-div (nth 2 xx) (math-pi)))) (nb (math-floor (math-div (nth 3 xx) (math-pi)))) (span (math-sub nb na))) (if (memq span '(0 1)) (let ((int (math-sort-intv (nth 1 x) (math-cos-raw (nth 2 xx)) (math-cos-raw (nth 3 xx))))) (if (eq span 1) (if (math-evenp na) (math-make-intv (logior (nth 1 x) 2) -1 (nth 3 int)) (math-make-intv (logior (nth 1 x) 1) (nth 2 int) 1)) int)) (list 'intv 3 -1 1))))) ((equal x '(var nan var-nan)) x) (t (calc-record-why 'scalarp x) (list 'calcFunc-cos x))) ) (defun calcFunc-sincos (x) ; [V N] [Public] (if (Math-scalarp x) (math-with-extra-prec 2 (let ((sc (math-sin-cos-raw (math-to-radians (math-float x))))) (list 'vec (cdr sc) (car sc)))) ; the vector [cos, sin] (list 'vec (calcFunc-sin x) (calcFunc-cos x))) ) (defun calcFunc-tan (x) ; [N N] [Public] (cond ((and (integerp x) (if (eq calc-angle-mode 'deg) (= (% x 180) 0) (= x 0))) 0) ((Math-scalarp x) (math-with-extra-prec 2 (math-tan-raw (math-to-radians (math-float x))))) ((eq (car x) 'sdev) (if (math-constp x) (math-with-extra-prec 2 (let* ((xx (math-to-radians (math-float (nth 1 x)))) (xs (math-to-radians (math-float (nth 2 x)))) (sc (math-sin-cos-raw xx))) (if (and (math-zerop (cdr sc)) (not calc-infinite-mode)) (progn (calc-record-why "*Division by zero") (list 'calcFunc-tan x)) (math-make-sdev (math-div-float (car sc) (cdr sc)) (math-div-float xs (math-sqr (cdr sc))))))) (math-make-sdev (calcFunc-tan (nth 1 x)) (math-div (nth 2 x) (math-sqr (calcFunc-cos (nth 1 x))))))) ((and (eq (car x) 'intv) (math-intv-constp x)) (or (math-with-extra-prec 2 (let* ((xx (math-to-radians (math-float x))) (na (math-floor (math-div (math-sub (nth 2 xx) (math-pi-over-2)) (math-pi)))) (nb (math-floor (math-div (math-sub (nth 3 xx) (math-pi-over-2)) (math-pi))))) (and (equal na nb) (math-sort-intv (nth 1 x) (math-tan-raw (nth 2 xx)) (math-tan-raw (nth 3 xx)))))) '(intv 3 (neg (var inf var-inf)) (var inf var-inf)))) ((equal x '(var nan var-nan)) x) (t (calc-record-why 'scalarp x) (list 'calcFunc-tan x))) ) (defun math-sin-raw (x) ; [N N] (cond ((eq (car x) 'cplx) (let* ((expx (math-exp-raw (nth 2 x))) (expmx (math-div-float '(float 1 0) expx)) (sc (math-sin-cos-raw (nth 1 x)))) (list 'cplx (math-mul-float (car sc) (math-mul-float (math-add-float expx expmx) '(float 5 -1))) (math-mul-float (cdr sc) (math-mul-float (math-sub-float expx expmx) '(float 5 -1)))))) ((eq (car x) 'polar) (math-polar (math-sin-raw (math-complex x)))) ((Math-integer-negp (nth 1 x)) (math-neg-float (math-sin-raw (math-neg-float x)))) ((math-lessp-float '(float 7 0) x) ; avoid inf loops due to roundoff (math-sin-raw (math-mod x (math-two-pi)))) (t (math-sin-raw-2 x x))) ) (defun math-cos-raw (x) ; [N N] (if (eq (car-safe x) 'polar) (math-polar (math-cos-raw (math-complex x))) (math-sin-raw (math-sub (math-pi-over-2) x))) ) ;;; This could use a smarter method: Reduce x as in math-sin-raw, then ;;; compute either sin(x) or cos(x), whichever is smaller, and compute ;;; the other using the identity sin(x)^2 + cos(x)^2 = 1. (defun math-sin-cos-raw (x) ; [F.F F] (result is (sin x . cos x)) (cons (math-sin-raw x) (math-cos-raw x)) ) (defun math-tan-raw (x) ; [N N] (cond ((eq (car x) 'cplx) (let* ((x (math-mul x '(float 2 0))) (expx (math-exp-raw (nth 2 x))) (expmx (math-div-float '(float 1 0) expx)) (sc (math-sin-cos-raw (nth 1 x))) (d (math-add-float (cdr sc) (math-mul-float (math-add-float expx expmx) '(float 5 -1))))) (and (not (eq (nth 1 d) 0)) (list 'cplx (math-div-float (car sc) d) (math-div-float (math-mul-float (math-sub-float expx expmx) '(float 5 -1)) d))))) ((eq (car x) 'polar) (math-polar (math-tan-raw (math-complex x)))) (t (let ((sc (math-sin-cos-raw x))) (if (eq (nth 1 (cdr sc)) 0) (math-div (car sc) 0) (math-div-float (car sc) (cdr sc)))))) ) (defun math-sin-raw-2 (x orgx) ; This avoids poss of inf recursion. [F F] (let ((xmpo2 (math-sub-float (math-pi-over-2) x))) (cond ((Math-integer-negp (nth 1 xmpo2)) (math-neg-float (math-sin-raw-2 (math-sub-float x (math-pi)) orgx))) ((math-lessp-float (math-pi-over-4) x) (math-cos-raw-2 xmpo2 orgx)) ((math-lessp-float x (math-neg (math-pi-over-4))) (math-neg (math-cos-raw-2 (math-add (math-pi-over-2) x) orgx))) ((math-nearly-zerop-float x orgx) '(float 0 0)) (calc-symbolic-mode (signal 'inexact-result nil)) (t (math-sin-series x 6 4 x (math-neg-float (math-sqr-float x)))))) ) (defun math-cos-raw-2 (x orgx) ; [F F] (cond ((math-nearly-zerop-float x orgx) '(float 1 0)) (calc-symbolic-mode (signal 'inexact-result nil)) (t (let ((xnegsqr (math-neg-float (math-sqr-float x)))) (math-sin-series (math-add-float '(float 1 0) (math-mul-float xnegsqr '(float 5 -1))) 24 5 xnegsqr xnegsqr)))) ) (defun math-sin-series (sum nfac n x xnegsqr) (math-working "sin" sum) (let* ((nextx (math-mul-float x xnegsqr)) (nextsum (math-add-float sum (math-div-float nextx (math-float nfac))))) (if (math-nearly-equal-float sum nextsum) sum (math-sin-series nextsum (math-mul nfac (* n (1+ n))) (+ n 2) nextx xnegsqr))) ) ;;; Inverse sine, cosine, tangent. (defun calcFunc-arcsin (x) ; [N N] [Public] (cond ((eq x 0) 0) ((and (eq x 1) (eq calc-angle-mode 'deg)) 90) ((and (eq x -1) (eq calc-angle-mode 'deg)) -90) (calc-symbolic-mode (signal 'inexact-result nil)) ((Math-numberp x) (math-with-extra-prec 2 (math-from-radians (math-arcsin-raw (math-float x))))) ((eq (car x) 'sdev) (math-make-sdev (calcFunc-arcsin (nth 1 x)) (math-from-radians (math-div (nth 2 x) (math-sqrt (math-sub 1 (math-sqr (nth 1 x)))))))) ((eq (car x) 'intv) (math-sort-intv (nth 1 x) (calcFunc-arcsin (nth 2 x)) (calcFunc-arcsin (nth 3 x)))) ((equal x '(var nan var-nan)) x) (t (calc-record-why 'numberp x) (list 'calcFunc-arcsin x))) ) (defun calcFunc-arccos (x) ; [N N] [Public] (cond ((eq x 1) 0) ((and (eq x 0) (eq calc-angle-mode 'deg)) 90) ((and (eq x -1) (eq calc-angle-mode 'deg)) 180) (calc-symbolic-mode (signal 'inexact-result nil)) ((Math-numberp x) (math-with-extra-prec 2 (math-from-radians (math-arccos-raw (math-float x))))) ((eq (car x) 'sdev) (math-make-sdev (calcFunc-arccos (nth 1 x)) (math-from-radians (math-div (nth 2 x) (math-sqrt (math-sub 1 (math-sqr (nth 1 x)))))))) ((eq (car x) 'intv) (math-sort-intv (nth 1 x) (calcFunc-arccos (nth 2 x)) (calcFunc-arccos (nth 3 x)))) ((equal x '(var nan var-nan)) x) (t (calc-record-why 'numberp x) (list 'calcFunc-arccos x))) ) (defun calcFunc-arctan (x) ; [N N] [Public] (cond ((eq x 0) 0) ((and (eq x 1) (eq calc-angle-mode 'deg)) 45) ((and (eq x -1) (eq calc-angle-mode 'deg)) -45) ((Math-numberp x) (math-with-extra-prec 2 (math-from-radians (math-arctan-raw (math-float x))))) ((eq (car x) 'sdev) (math-make-sdev (calcFunc-arctan (nth 1 x)) (math-from-radians (math-div (nth 2 x) (math-add 1 (math-sqr (nth 1 x))))))) ((eq (car x) 'intv) (math-sort-intv (nth 1 x) (calcFunc-arctan (nth 2 x)) (calcFunc-arctan (nth 3 x)))) ((equal x '(var inf var-inf)) (math-quarter-circle t)) ((equal x '(neg (var inf var-inf))) (math-neg (math-quarter-circle t))) ((equal x '(var nan var-nan)) x) (t (calc-record-why 'numberp x) (list 'calcFunc-arctan x))) ) (defun math-arcsin-raw (x) ; [N N] (let ((a (math-sqrt-raw (math-sub '(float 1 0) (math-sqr x))))) (if (or (memq (car x) '(cplx polar)) (memq (car a) '(cplx polar))) (math-with-extra-prec 2 ; use extra precision for difficult case (math-mul '(cplx 0 -1) (math-ln-raw (math-add (math-mul '(cplx 0 1) x) a)))) (math-arctan2-raw x a))) ) (defun math-arccos-raw (x) ; [N N] (math-sub (math-pi-over-2) (math-arcsin-raw x)) ) (defun math-arctan-raw (x) ; [N N] (cond ((memq (car x) '(cplx polar)) (math-with-extra-prec 2 ; extra-extra (math-div (math-sub (math-ln-raw (math-add 1 (math-mul '(cplx 0 1) x))) (math-ln-raw (math-add 1 (math-mul '(cplx 0 -1) x)))) '(cplx 0 2)))) ((Math-integer-negp (nth 1 x)) (math-neg-float (math-arctan-raw (math-neg-float x)))) ((math-zerop x) x) (calc-symbolic-mode (signal 'inexact-result nil)) ((math-equal-int x 1) (math-pi-over-4)) ((math-equal-int x -1) (math-neg (math-pi-over-4))) ((math-lessp-float '(float 414214 -6) x) ; if x > sqrt(2) - 1, reduce (if (math-lessp-float '(float 1 0) x) (math-sub-float (math-mul-float (math-pi) '(float 5 -1)) (math-arctan-raw (math-div-float '(float 1 0) x))) (math-sub-float (math-mul-float (math-pi) '(float 25 -2)) (math-arctan-raw (math-div-float (math-sub-float '(float 1 0) x) (math-add-float '(float 1 0) x)))))) (t (math-arctan-series x 3 x (math-neg-float (math-sqr-float x))))) ) (defun math-arctan-series (sum n x xnegsqr) (math-working "arctan" sum) (let* ((nextx (math-mul-float x xnegsqr)) (nextsum (math-add-float sum (math-div-float nextx (math-float n))))) (if (math-nearly-equal-float sum nextsum) sum (math-arctan-series nextsum (+ n 2) nextx xnegsqr))) ) (defun calcFunc-arctan2 (y x) ; [F R R] [Public] (if (Math-anglep y) (if (Math-anglep x) (math-with-extra-prec 2 (math-from-radians (math-arctan2-raw (math-float y) (math-float x)))) (calc-record-why 'anglep x) (list 'calcFunc-arctan2 y x)) (if (and (or (math-infinitep x) (math-anglep x)) (or (math-infinitep y) (math-anglep y))) (progn (if (math-posp x) (setq x 1) (if (math-negp x) (setq x -1) (or (math-zerop x) (setq x nil)))) (if (math-posp y) (setq y 1) (if (math-negp y) (setq y -1) (or (math-zerop y) (setq y nil)))) (if (and y x) (calcFunc-arctan2 y x) '(var nan var-nan))) (calc-record-why 'anglep y) (list 'calcFunc-arctan2 y x))) ) (defun math-arctan2-raw (y x) ; [F R R] (cond ((math-zerop y) (if (math-negp x) (math-pi) (if (or (math-floatp x) (math-floatp y)) '(float 0 0) 0))) ((math-zerop x) (if (math-posp y) (math-pi-over-2) (math-neg (math-pi-over-2)))) ((math-posp x) (math-arctan-raw (math-div-float y x))) ((math-posp y) (math-add-float (math-arctan-raw (math-div-float y x)) (math-pi))) (t (math-sub-float (math-arctan-raw (math-div-float y x)) (math-pi)))) ) (defun calcFunc-arcsincos (x) ; [V N] [Public] (if (and (Math-vectorp x) (= (length x) 3)) (calcFunc-arctan2 (nth 2 x) (nth 1 x)) (math-reject-arg x "*Two-element vector expected")) ) ;;; Exponential function. (defun calcFunc-exp (x) ; [N N] [Public] (cond ((eq x 0) 1) ((and (memq x '(1 -1)) calc-symbolic-mode) (if (eq x 1) '(var e var-e) (math-div 1 '(var e var-e)))) ((Math-numberp x) (math-with-extra-prec 2 (math-exp-raw (math-float x)))) ((eq (car-safe x) 'sdev) (let ((ex (calcFunc-exp (nth 1 x)))) (math-make-sdev ex (math-mul (nth 2 x) ex)))) ((eq (car-safe x) 'intv) (math-make-intv (nth 1 x) (calcFunc-exp (nth 2 x)) (calcFunc-exp (nth 3 x)))) ((equal x '(var inf var-inf)) x) ((equal x '(neg (var inf var-inf))) 0) ((equal x '(var nan var-nan)) x) (t (calc-record-why 'numberp x) (list 'calcFunc-exp x))) ) (defun calcFunc-expm1 (x) ; [N N] [Public] (cond ((eq x 0) 0) ((math-zerop x) '(float 0 0)) (calc-symbolic-mode (signal 'inexact-result nil)) ((Math-numberp x) (math-with-extra-prec 2 (let ((x (math-float x))) (if (and (eq (car x) 'float) (math-lessp-float x '(float 1 0)) (math-lessp-float '(float -1 0) x)) (math-exp-minus-1-raw x) (math-add (math-exp-raw x) -1))))) ((eq (car-safe x) 'sdev) (if (math-constp x) (let ((ex (calcFunc-expm1 (nth 1 x)))) (math-make-sdev ex (math-mul (nth 2 x) (math-add ex 1)))) (math-make-sdev (calcFunc-expm1 (nth 1 x)) (math-mul (nth 2 x) (calcFunc-exp (nth 1 x)))))) ((eq (car-safe x) 'intv) (math-make-intv (nth 1 x) (calcFunc-expm1 (nth 2 x)) (calcFunc-expm1 (nth 3 x)))) ((equal x '(var inf var-inf)) x) ((equal x '(neg (var inf var-inf))) -1) ((equal x '(var nan var-nan)) x) (t (calc-record-why 'numberp x) (list 'calcFunc-expm1 x))) ) (defun calcFunc-exp10 (x) ; [N N] [Public] (if (eq x 0) 1 (math-pow '(float 1 1) x)) ) (defun math-exp-raw (x) ; [N N] (cond ((math-zerop x) '(float 1 0)) (calc-symbolic-mode (signal 'inexact-result nil)) ((eq (car x) 'cplx) (let ((expx (math-exp-raw (nth 1 x))) (sc (math-sin-cos-raw (nth 2 x)))) (list 'cplx (math-mul-float expx (cdr sc)) (math-mul-float expx (car sc))))) ((eq (car x) 'polar) (let ((xc (math-complex x))) (list 'polar (math-exp-raw (nth 1 xc)) (math-from-radians (nth 2 xc))))) ((or (math-lessp-float '(float 5 -1) x) (math-lessp-float x '(float -5 -1))) (if (math-lessp-float '(float 921035 1) x) (math-overflow) (if (math-lessp-float x '(float -921035 1)) (math-underflow))) (let* ((two-x (math-mul-float x '(float 2 0))) (hint (math-scale-int (nth 1 two-x) (nth 2 two-x))) (hfrac (math-sub-float x (math-mul-float (math-float hint) '(float 5 -1))))) (math-mul-float (math-ipow (math-sqrt-e) hint) (math-add-float '(float 1 0) (math-exp-minus-1-raw hfrac))))) (t (math-add-float '(float 1 0) (math-exp-minus-1-raw x)))) ) (defun math-exp-minus-1-raw (x) ; [F F] (math-exp-series x 2 3 x x) ) (defun math-exp-series (sum nfac n xpow x) (math-working "exp" sum) (let* ((nextx (math-mul-float xpow x)) (nextsum (math-add-float sum (math-div-float nextx (math-float nfac))))) (if (math-nearly-equal-float sum nextsum) sum (math-exp-series nextsum (math-mul nfac n) (1+ n) nextx x))) ) ;;; Logarithms. (defun calcFunc-ln (x) ; [N N] [Public] (cond ((math-zerop x) (if calc-infinite-mode '(neg (var inf var-inf)) (math-reject-arg x "*Logarithm of zero"))) ((eq x 1) 0) ((Math-numberp x) (math-with-extra-prec 2 (math-ln-raw (math-float x)))) ((eq (car-safe x) 'sdev) (math-make-sdev (calcFunc-ln (nth 1 x)) (math-div (nth 2 x) (nth 1 x)))) ((and (eq (car-safe x) 'intv) (or (Math-posp (nth 2 x)) (Math-zerop (nth 2 x)) (not (math-intv-constp x)))) (let ((calc-infinite-mode t)) (math-make-intv (nth 1 x) (calcFunc-ln (nth 2 x)) (calcFunc-ln (nth 3 x))))) ((equal x '(var e var-e)) 1) ((and (eq (car-safe x) '^) (equal (nth 1 x) '(var e var-e)) (math-known-realp (nth 2 x))) (nth 2 x)) ((math-infinitep x) (if (equal x '(var nan var-nan)) x '(var inf var-inf))) (t (calc-record-why 'numberp x) (list 'calcFunc-ln x))) ) (defun calcFunc-log10 (x) ; [N N] [Public] (cond ((math-equal-int x 1) (if (math-floatp x) '(float 0 0) 0)) ((and (Math-integerp x) (math-posp x) (let ((res (math-integer-log x 10))) (and (car res) (setq x (cdr res))))) x) ((and (eq (car-safe x) 'frac) (eq (nth 1 x) 1) (let ((res (math-integer-log (nth 2 x) 10))) (and (car res) (setq x (- (cdr res)))))) x) ((math-zerop x) (if calc-infinite-mode '(neg (var inf var-inf)) (math-reject-arg x "*Logarithm of zero"))) (calc-symbolic-mode (signal 'inexact-result nil)) ((Math-numberp x) (math-with-extra-prec 2 (let ((xf (math-float x))) (if (eq (nth 1 xf) 0) (math-reject-arg x "*Logarithm of zero")) (if (Math-integer-posp (nth 1 xf)) (if (eq (nth 1 xf) 1) ; log10(1*10^n) = n (math-float (nth 2 xf)) (let ((xdigs (1- (math-numdigs (nth 1 xf))))) (math-add-float (math-div-float (math-ln-raw-2 (list 'float (nth 1 xf) (- xdigs))) (math-ln-10)) (math-float (+ (nth 2 xf) xdigs))))) (math-div (calcFunc-ln xf) (math-ln-10)))))) ((eq (car-safe x) 'sdev) (math-make-sdev (calcFunc-log10 (nth 1 x)) (math-div (nth 2 x) (math-mul (nth 1 x) (math-ln-10))))) ((and (eq (car-safe x) 'intv) (or (Math-posp (nth 2 x)) (not (math-intv-constp x)))) (math-make-intv (nth 1 x) (calcFunc-log10 (nth 2 x)) (calcFunc-log10 (nth 3 x)))) ((math-infinitep x) (if (equal x '(var nan var-nan)) x '(var inf var-inf))) (t (calc-record-why 'numberp x) (list 'calcFunc-log10 x))) ) (defun calcFunc-log (x &optional b) ; [N N N] [Public] (cond ((or (null b) (equal b '(var e var-e))) (math-normalize (list 'calcFunc-ln x))) ((or (eq b 10) (equal b '(float 1 1))) (math-normalize (list 'calcFunc-log10 x))) ((math-zerop x) (if calc-infinite-mode (math-div (calcFunc-ln x) (calcFunc-ln b)) (math-reject-arg x "*Logarithm of zero"))) ((math-zerop b) (if calc-infinite-mode (math-div (calcFunc-ln x) (calcFunc-ln b)) (math-reject-arg b "*Logarithm of zero"))) ((math-equal-int b 1) (if calc-infinite-mode (math-div (calcFunc-ln x) 0) (math-reject-arg b "*Logarithm base one"))) ((math-equal-int x 1) (if (or (math-floatp a) (math-floatp b)) '(float 0 0) 0)) ((and (Math-ratp x) (Math-ratp b) (math-posp x) (math-posp b) (let* ((sign 1) (inv nil) (xx (if (Math-lessp 1 x) x (setq sign -1) (math-div 1 x))) (bb (if (Math-lessp 1 b) b (setq sign (- sign)) (math-div 1 b))) (res (if (Math-lessp xx bb) (setq inv (math-integer-log bb xx)) (math-integer-log xx bb)))) (and (car res) (setq x (if inv (math-div 1 (* sign (cdr res))) (* sign (cdr res))))))) x) (calc-symbolic-mode (signal 'inexact-result nil)) ((and (Math-numberp x) (Math-numberp b)) (math-with-extra-prec 2 (math-div (math-ln-raw (math-float x)) (math-log-base-raw b)))) ((and (eq (car-safe x) 'sdev) (Math-numberp b)) (math-make-sdev (calcFunc-log (nth 1 x) b) (math-div (nth 2 x) (math-mul (nth 1 x) (math-log-base-raw b))))) ((and (eq (car-safe x) 'intv) (or (Math-posp (nth 2 x)) (not (math-intv-constp x))) (math-realp b)) (math-make-intv (nth 1 x) (calcFunc-log (nth 2 x) b) (calcFunc-log (nth 3 x) b))) ((or (eq (car-safe x) 'intv) (eq (car-safe b) 'intv)) (math-div (calcFunc-ln x) (calcFunc-ln b))) ((or (math-infinitep x) (math-infinitep b)) (math-div (calcFunc-ln x) (calcFunc-ln b))) (t (if (Math-numberp b) (calc-record-why 'numberp x) (calc-record-why 'numberp b)) (list 'calcFunc-log x b))) ) (defun calcFunc-alog (x &optional b) (cond ((or (null b) (equal b '(var e var-e))) (math-normalize (list 'calcFunc-exp x))) (t (math-pow b x))) ) (defun calcFunc-ilog (x b) (if (and (math-natnump x) (not (eq x 0)) (math-natnump b) (not (eq b 0))) (if (eq b 1) (math-reject-arg x "*Logarithm base one") (if (Math-natnum-lessp x b) 0 (cdr (math-integer-log x b)))) (math-floor (calcFunc-log x b))) ) (defun math-integer-log (x b) (let ((pows (list b)) (pow (math-sqr b)) next sum n) (while (not (Math-lessp x pow)) (setq pows (cons pow pows) pow (math-sqr pow))) (setq n (lsh 1 (1- (length pows))) sum n pow (car pows)) (while (and (setq pows (cdr pows)) (Math-lessp pow x)) (setq n (/ n 2) next (math-mul pow (car pows))) (or (Math-lessp x next) (setq pow next sum (+ sum n)))) (cons (equal pow x) sum)) ) (defun math-log-base-raw (b) ; [N N] (if (not (and (equal (car math-log-base-cache) b) (eq (nth 1 math-log-base-cache) calc-internal-prec))) (setq math-log-base-cache (list b calc-internal-prec (math-ln-raw (math-float b))))) (nth 2 math-log-base-cache) ) (setq math-log-base-cache nil) (defun calcFunc-lnp1 (x) ; [N N] [Public] (cond ((Math-equal-int x -1) (if calc-infinite-mode '(neg (var inf var-inf)) (math-reject-arg x "*Logarithm of zero"))) ((eq x 0) 0) ((math-zerop x) '(float 0 0)) (calc-symbolic-mode (signal 'inexact-result nil)) ((Math-numberp x) (math-with-extra-prec 2 (let ((x (math-float x))) (if (and (eq (car x) 'float) (math-lessp-float x '(float 5 -1)) (math-lessp-float '(float -5 -1) x)) (math-ln-plus-1-raw x) (math-ln-raw (math-add-float x '(float 1 0))))))) ((eq (car-safe x) 'sdev) (math-make-sdev (calcFunc-lnp1 (nth 1 x)) (math-div (nth 2 x) (math-add (nth 1 x) 1)))) ((and (eq (car-safe x) 'intv) (or (Math-posp (nth 2 x)) (not (math-intv-constp x)))) (math-make-intv (nth 1 x) (calcFunc-lnp1 (nth 2 x)) (calcFunc-lnp1 (nth 3 x)))) ((math-infinitep x) (if (equal x '(var nan var-nan)) x '(var inf var-inf))) (t (calc-record-why 'numberp x) (list 'calcFunc-lnp1 x))) ) (defun math-ln-raw (x) ; [N N] --- must be float format! (cond ((eq (car-safe x) 'cplx) (list 'cplx (math-mul-float (math-ln-raw (math-add-float (math-sqr-float (nth 1 x)) (math-sqr-float (nth 2 x)))) '(float 5 -1)) (math-arctan2-raw (nth 2 x) (nth 1 x)))) ((eq (car x) 'polar) (math-polar (list 'cplx (math-ln-raw (nth 1 x)) (math-to-radians (nth 2 x))))) ((Math-equal-int x 1) '(float 0 0)) (calc-symbolic-mode (signal 'inexact-result nil)) ((math-posp (nth 1 x)) ; positive and real (let ((xdigs (1- (math-numdigs (nth 1 x))))) (math-add-float (math-ln-raw-2 (list 'float (nth 1 x) (- xdigs))) (math-mul-float (math-float (+ (nth 2 x) xdigs)) (math-ln-10))))) ((math-zerop x) (math-reject-arg x "*Logarithm of zero")) ((eq calc-complex-mode 'polar) ; negative and real (math-polar (list 'cplx ; negative and real (math-ln-raw (math-neg-float x)) (math-pi)))) (t (list 'cplx ; negative and real (math-ln-raw (math-neg-float x)) (math-pi)))) ) (defun math-ln-raw-2 (x) ; [F F] (cond ((math-lessp-float '(float 14 -1) x) (math-add-float (math-ln-raw-2 (math-mul-float x '(float 5 -1))) (math-ln-2))) (t ; now .7 < x <= 1.4 (math-ln-raw-3 (math-div-float (math-sub-float x '(float 1 0)) (math-add-float x '(float 1 0)))))) ) (defun math-ln-raw-3 (x) ; [F F] (math-mul-float (math-ln-raw-series x 3 x (math-sqr-float x)) '(float 2 0)) ) ;;; Compute ln((1+x)/(1-x)) (defun math-ln-raw-series (sum n x xsqr) (math-working "log" sum) (let* ((nextx (math-mul-float x xsqr)) (nextsum (math-add-float sum (math-div-float nextx (math-float n))))) (if (math-nearly-equal-float sum nextsum) sum (math-ln-raw-series nextsum (+ n 2) nextx xsqr))) ) (defun math-ln-plus-1-raw (x) (math-lnp1-series x 2 x (math-neg x)) ) (defun math-lnp1-series (sum n xpow x) (math-working "lnp1" sum) (let* ((nextx (math-mul-float xpow x)) (nextsum (math-add-float sum (math-div-float nextx (math-float n))))) (if (math-nearly-equal-float sum nextsum) sum (math-lnp1-series nextsum (1+ n) nextx x))) ) (math-defcache math-ln-10 (float (bigpos 018 684 045 994 092 585 302 2) -21) (math-ln-raw-2 '(float 1 1))) (math-defcache math-ln-2 (float (bigpos 417 309 945 559 180 147 693) -21) (math-ln-raw-3 (math-float '(frac 1 3)))) ;;; Hyperbolic functions. (defun calcFunc-sinh (x) ; [N N] [Public] (cond ((eq x 0) 0) (math-expand-formulas (math-normalize (list '/ (list '- (list 'calcFunc-exp x) (list 'calcFunc-exp (list 'neg x))) 2))) ((Math-numberp x) (if calc-symbolic-mode (signal 'inexact-result nil)) (math-with-extra-prec 2 (let ((expx (math-exp-raw (math-float x)))) (math-mul (math-add expx (math-div -1 expx)) '(float 5 -1))))) ((eq (car-safe x) 'sdev) (math-make-sdev (calcFunc-sinh (nth 1 x)) (math-mul (nth 2 x) (calcFunc-cosh (nth 1 x))))) ((eq (car x) 'intv) (math-sort-intv (nth 1 x) (calcFunc-sinh (nth 2 x)) (calcFunc-sinh (nth 3 x)))) ((or (equal x '(var inf var-inf)) (equal x '(neg (var inf var-inf))) (equal x '(var nan var-nan))) x) (t (calc-record-why 'numberp x) (list 'calcFunc-sinh x))) ) (put 'calcFunc-sinh 'math-expandable t) (defun calcFunc-cosh (x) ; [N N] [Public] (cond ((eq x 0) 1) (math-expand-formulas (math-normalize (list '/ (list '+ (list 'calcFunc-exp x) (list 'calcFunc-exp (list 'neg x))) 2))) ((Math-numberp x) (if calc-symbolic-mode (signal 'inexact-result nil)) (math-with-extra-prec 2 (let ((expx (math-exp-raw (math-float x)))) (math-mul (math-add expx (math-div 1 expx)) '(float 5 -1))))) ((eq (car-safe x) 'sdev) (math-make-sdev (calcFunc-cosh (nth 1 x)) (math-mul (nth 2 x) (calcFunc-sinh (nth 1 x))))) ((and (eq (car x) 'intv) (math-intv-constp x)) (setq x (math-abs x)) (math-sort-intv (nth 1 x) (calcFunc-cosh (nth 2 x)) (calcFunc-cosh (nth 3 x)))) ((or (equal x '(var inf var-inf)) (equal x '(neg (var inf var-inf))) (equal x '(var nan var-nan))) (math-abs x)) (t (calc-record-why 'numberp x) (list 'calcFunc-cosh x))) ) (put 'calcFunc-cosh 'math-expandable t) (defun calcFunc-tanh (x) ; [N N] [Public] (cond ((eq x 0) 0) (math-expand-formulas (math-normalize (let ((expx (list 'calcFunc-exp x)) (expmx (list 'calcFunc-exp (list 'neg x)))) (math-normalize (list '/ (list '- expx expmx) (list '+ expx expmx)))))) ((Math-numberp x) (if calc-symbolic-mode (signal 'inexact-result nil)) (math-with-extra-prec 2 (let* ((expx (calcFunc-exp (math-float x))) (expmx (math-div 1 expx))) (math-div (math-sub expx expmx) (math-add expx expmx))))) ((eq (car-safe x) 'sdev) (math-make-sdev (calcFunc-tanh (nth 1 x)) (math-div (nth 2 x) (math-sqr (calcFunc-cosh (nth 1 x)))))) ((eq (car x) 'intv) (math-sort-intv (nth 1 x) (calcFunc-tanh (nth 2 x)) (calcFunc-tanh (nth 3 x)))) ((equal x '(var inf var-inf)) 1) ((equal x '(neg (var inf var-inf))) -1) ((equal x '(var nan var-nan)) x) (t (calc-record-why 'numberp x) (list 'calcFunc-tanh x))) ) (put 'calcFunc-tanh 'math-expandable t) (defun calcFunc-arcsinh (x) ; [N N] [Public] (cond ((eq x 0) 0) (math-expand-formulas (math-normalize (list 'calcFunc-ln (list '+ x (list 'calcFunc-sqrt (list '+ (list '^ x 2) 1)))))) ((Math-numberp x) (if calc-symbolic-mode (signal 'inexact-result nil)) (math-with-extra-prec 2 (math-ln-raw (math-add x (math-sqrt-raw (math-add (math-sqr x) '(float 1 0))))))) ((eq (car-safe x) 'sdev) (math-make-sdev (calcFunc-arcsinh (nth 1 x)) (math-div (nth 2 x) (math-sqrt (math-add (math-sqr (nth 1 x)) 1))))) ((eq (car x) 'intv) (math-sort-intv (nth 1 x) (calcFunc-arcsinh (nth 2 x)) (calcFunc-arcsinh (nth 3 x)))) ((or (equal x '(var inf var-inf)) (equal x '(neg (var inf var-inf))) (equal x '(var nan var-nan))) x) (t (calc-record-why 'numberp x) (list 'calcFunc-arcsinh x))) ) (put 'calcFunc-arcsinh 'math-expandable t) (defun calcFunc-arccosh (x) ; [N N] [Public] (cond ((eq x 1) 0) ((and (eq x -1) calc-symbolic-mode) '(var pi var-pi)) ((and (eq x 0) calc-symbolic-mode) (math-div (math-mul '(var pi var-pi) '(var i var-i)) 2)) (math-expand-formulas (math-normalize (list 'calcFunc-ln (list '+ x (list 'calcFunc-sqrt (list '- (list '^ x 2) 1)))))) ((Math-numberp x) (if calc-symbolic-mode (signal 'inexact-result nil)) (if (Math-equal-int x -1) (math-imaginary (math-pi)) (math-with-extra-prec 2 (if (or t ; need to do this even in the real case! (memq (car-safe x) '(cplx polar))) (let ((xp1 (math-add 1 x))) ; this gets the branch cuts right (math-ln-raw (math-add x (math-mul xp1 (math-sqrt-raw (math-div (math-sub x '(float 1 0)) xp1)))))) (math-ln-raw (math-add x (math-sqrt-raw (math-add (math-sqr x) '(float -1 0))))))))) ((eq (car-safe x) 'sdev) (math-make-sdev (calcFunc-arccosh (nth 1 x)) (math-div (nth 2 x) (math-sqrt (math-add (math-sqr (nth 1 x)) -1))))) ((eq (car x) 'intv) (math-sort-intv (nth 1 x) (calcFunc-arccosh (nth 2 x)) (calcFunc-arccosh (nth 3 x)))) ((or (equal x '(var inf var-inf)) (equal x '(neg (var inf var-inf))) (equal x '(var nan var-nan))) x) (t (calc-record-why 'numberp x) (list 'calcFunc-arccosh x))) ) (put 'calcFunc-arccosh 'math-expandable t) (defun calcFunc-arctanh (x) ; [N N] [Public] (cond ((eq x 0) 0) ((and (Math-equal-int x 1) calc-infinite-mode) '(var inf var-inf)) ((and (Math-equal-int x -1) calc-infinite-mode) '(neg (var inf var-inf))) (math-expand-formulas (list '/ (list '- (list 'calcFunc-ln (list '+ 1 x)) (list 'calcFunc-ln (list '- 1 x))) 2)) ((Math-numberp x) (if calc-symbolic-mode (signal 'inexact-result nil)) (math-with-extra-prec 2 (if (or (memq (car-safe x) '(cplx polar)) (Math-lessp 1 x)) (math-mul (math-sub (math-ln-raw (math-add '(float 1 0) x)) (math-ln-raw (math-sub '(float 1 0) x))) '(float 5 -1)) (if (and (math-equal-int x 1) calc-infinite-mode) '(var inf var-inf) (if (and (math-equal-int x -1) calc-infinite-mode) '(neg (var inf var-inf)) (math-mul (math-ln-raw (math-div (math-add '(float 1 0) x) (math-sub 1 x))) '(float 5 -1))))))) ((eq (car-safe x) 'sdev) (math-make-sdev (calcFunc-arctanh (nth 1 x)) (math-div (nth 2 x) (math-sub 1 (math-sqr (nth 1 x)))))) ((eq (car x) 'intv) (math-sort-intv (nth 1 x) (calcFunc-arctanh (nth 2 x)) (calcFunc-arctanh (nth 3 x)))) ((equal x '(var nan var-nan)) x) (t (calc-record-why 'numberp x) (list 'calcFunc-arctanh x))) ) (put 'calcFunc-arctanh 'math-expandable t) ;;; Convert A from HMS or degrees to radians. (defun calcFunc-rad (a) ; [R R] [Public] (cond ((or (Math-numberp a) (eq (car a) 'intv)) (math-with-extra-prec 2 (math-mul a (math-pi-over-180)))) ((eq (car a) 'hms) (math-from-hms a 'rad)) ((eq (car a) 'sdev) (math-make-sdev (calcFunc-rad (nth 1 a)) (calcFunc-rad (nth 2 a)))) (math-expand-formulas (math-div (math-mul a '(var pi var-pi)) 180)) ((math-infinitep a) a) (t (list 'calcFunc-rad a))) ) (put 'calcFunc-rad 'math-expandable t) ;;; Convert A from HMS or radians to degrees. (defun calcFunc-deg (a) ; [R R] [Public] (cond ((or (Math-numberp a) (eq (car a) 'intv)) (math-with-extra-prec 2 (math-div a (math-pi-over-180)))) ((eq (car a) 'hms) (math-from-hms a 'deg)) ((eq (car a) 'sdev) (math-make-sdev (calcFunc-deg (nth 1 a)) (calcFunc-deg (nth 2 a)))) (math-expand-formulas (math-div (math-mul 180 a) '(var pi var-pi))) ((math-infinitep a) a) (t (list 'calcFunc-deg a))) ) (put 'calcFunc-deg 'math-expandable t) calc-2.02c/calc-frac.el100644 22403 13 14245 5402630604 13200 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-frac.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-frac () nil) (defun calc-fdiv (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op ":" 'calcFunc-fdiv arg 1)) ) (defun calc-fraction (arg) (interactive "P") (calc-slow-wrapper (let ((func (if (calc-is-hyperbolic) 'calcFunc-frac 'calcFunc-pfrac))) (if (eq arg 0) (calc-enter-result 2 "frac" (list func (calc-top-n 2) (calc-top-n 1))) (calc-enter-result 1 "frac" (list func (calc-top-n 1) (prefix-numeric-value (or arg 0))))))) ) (defun calc-over-notation (fmt) (interactive "sFraction separator (:, ::, /, //, :/): ") (calc-wrapper (if (string-match "\\`\\([^ 0-9][^ 0-9]?\\)[0-9]*\\'" fmt) (let ((n nil)) (if (/= (match-end 0) (match-end 1)) (setq n (string-to-int (substring fmt (match-end 1))) fmt (math-match-substring fmt 1))) (if (eq n 0) (error "Bad denominator")) (calc-change-mode 'calc-frac-format (list fmt n) t)) (error "Bad fraction separator format."))) ) (defun calc-slash-notation (n) (interactive "P") (calc-wrapper (calc-change-mode 'calc-frac-format (if n '("//" nil) '("/" nil)) t)) ) (defun calc-frac-mode (n) (interactive "P") (calc-wrapper (calc-change-mode 'calc-prefer-frac n nil t) (message (if calc-prefer-frac "Integer division will now generate fractions." "Integer division will now generate floating-point results."))) ) ;;;; Fractions. ;;; Build a normalized fraction. [R I I] ;;; (This could probably be implemented more efficiently than using ;;; the plain gcd algorithm.) (defun math-make-frac (num den) (if (Math-integer-negp den) (setq num (math-neg num) den (math-neg den))) (let ((gcd (math-gcd num den))) (if (eq gcd 1) (if (eq den 1) num (list 'frac num den)) (if (equal gcd den) (math-quotient num gcd) (list 'frac (math-quotient num gcd) (math-quotient den gcd))))) ) (defun calc-add-fractions (a b) (if (eq (car-safe a) 'frac) (if (eq (car-safe b) 'frac) (math-make-frac (math-add (math-mul (nth 1 a) (nth 2 b)) (math-mul (nth 2 a) (nth 1 b))) (math-mul (nth 2 a) (nth 2 b))) (math-make-frac (math-add (nth 1 a) (math-mul (nth 2 a) b)) (nth 2 a))) (math-make-frac (math-add (math-mul a (nth 2 b)) (nth 1 b)) (nth 2 b))) ) (defun calc-mul-fractions (a b) (if (eq (car-safe a) 'frac) (if (eq (car-safe b) 'frac) (math-make-frac (math-mul (nth 1 a) (nth 1 b)) (math-mul (nth 2 a) (nth 2 b))) (math-make-frac (math-mul (nth 1 a) b) (nth 2 a))) (math-make-frac (math-mul a (nth 1 b)) (nth 2 b))) ) (defun calc-div-fractions (a b) (if (eq (car-safe a) 'frac) (if (eq (car-safe b) 'frac) (math-make-frac (math-mul (nth 1 a) (nth 2 b)) (math-mul (nth 2 a) (nth 1 b))) (math-make-frac (nth 1 a) (math-mul (nth 2 a) b))) (math-make-frac (math-mul a (nth 2 b)) (nth 1 b))) ) ;;; Convert a real value to fractional form. [T R I; T R F] [Public] (defun calcFunc-frac (a &optional tol) (or tol (setq tol 0)) (cond ((Math-ratp a) a) ((memq (car a) '(cplx polar vec hms date sdev intv mod)) (cons (car a) (mapcar (function (lambda (x) (calcFunc-frac x tol))) (cdr a)))) ((Math-messy-integerp a) (math-trunc a)) ((Math-negp a) (math-neg (calcFunc-frac (math-neg a) tol))) ((not (eq (car a) 'float)) (if (math-infinitep a) a (if (math-provably-integerp a) a (math-reject-arg a 'numberp)))) ((integerp tol) (if (<= tol 0) (setq tol (+ tol calc-internal-prec))) (calcFunc-frac a (list 'float 5 (- (+ (math-numdigs (nth 1 a)) (nth 2 a)) (1+ tol))))) ((not (eq (car tol) 'float)) (if (Math-realp tol) (calcFunc-frac a (math-float tol)) (math-reject-arg tol 'realp))) ((Math-negp tol) (calcFunc-frac a (math-neg tol))) ((Math-zerop tol) (calcFunc-frac a 0)) ((not (math-lessp-float tol '(float 1 0))) (math-trunc a)) ((Math-zerop a) 0) (t (let ((cfrac (math-continued-fraction a tol)) (calc-prefer-frac t)) (math-eval-continued-fraction cfrac)))) ) (defun math-continued-fraction (a tol) (let ((calc-internal-prec (+ calc-internal-prec 2))) (let ((cfrac nil) (aa a) (calc-prefer-frac nil) int) (while (or (null cfrac) (and (not (Math-zerop aa)) (not (math-lessp-float (math-abs (math-sub a (let ((f (math-eval-continued-fraction cfrac))) (math-working "Fractionalize" f) f))) tol)))) (setq int (math-trunc aa) aa (math-sub aa int) cfrac (cons int cfrac)) (or (Math-zerop aa) (setq aa (math-div 1 aa)))) cfrac)) ) (defun math-eval-continued-fraction (cf) (let ((n (car cf)) (d 1) temp) (while (setq cf (cdr cf)) (setq temp (math-add (math-mul (car cf) n) d) d n n temp)) (math-div n d)) ) (defun calcFunc-fdiv (a b) ; [R I I] [Public] (if (Math-num-integerp a) (if (Math-num-integerp b) (if (Math-zerop b) (math-reject-arg a "*Division by zero") (math-make-frac (math-trunc a) (math-trunc b))) (math-reject-arg b 'integerp)) (math-reject-arg a 'integerp)) ) calc-2.02c/calc-cplx.el100644 22403 13 23717 5402630551 13240 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-cplx.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-cplx () nil) (defun calc-argument (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "arg" 'calcFunc-arg arg)) ) (defun calc-re (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "re" 'calcFunc-re arg)) ) (defun calc-im (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "im" 'calcFunc-im arg)) ) (defun calc-polar () (interactive) (calc-slow-wrapper (let ((arg (calc-top-n 1))) (if (or (calc-is-inverse) (eq (car-safe arg) 'polar)) (calc-enter-result 1 "p-r" (list 'calcFunc-rect arg)) (calc-enter-result 1 "r-p" (list 'calcFunc-polar arg))))) ) (defun calc-complex-notation () (interactive) (calc-wrapper (calc-change-mode 'calc-complex-format nil t) (message "Displaying complex numbers in (X,Y) format.")) ) (defun calc-i-notation () (interactive) (calc-wrapper (calc-change-mode 'calc-complex-format 'i t) (message "Displaying complex numbers in X+Yi format.")) ) (defun calc-j-notation () (interactive) (calc-wrapper (calc-change-mode 'calc-complex-format 'j t) (message "Displaying complex numbers in X+Yj format.")) ) (defun calc-polar-mode (n) (interactive "P") (calc-wrapper (if (if n (> (prefix-numeric-value n) 0) (eq calc-complex-mode 'cplx)) (progn (calc-change-mode 'calc-complex-mode 'polar) (message "Preferred complex form is polar.")) (calc-change-mode 'calc-complex-mode 'cplx) (message "Preferred complex form is rectangular."))) ) ;;;; Complex numbers. (defun math-normalize-polar (a) (let ((r (math-normalize (nth 1 a))) (th (math-normalize (nth 2 a)))) (cond ((math-zerop r) '(polar 0 0)) ((or (math-zerop th)) r) ((and (not (eq calc-angle-mode 'rad)) (or (equal th '(float 18 1)) (equal th 180))) (math-neg r)) ((math-negp r) (math-neg (list 'polar (math-neg r) th))) (t (list 'polar r th)))) ) ;;; Coerce A to be complex (rectangular form). [c N] (defun math-complex (a) (cond ((eq (car-safe a) 'cplx) a) ((eq (car-safe a) 'polar) (if (math-zerop (nth 1 a)) (nth 1 a) (let ((sc (calcFunc-sincos (nth 2 a)))) (list 'cplx (math-mul (nth 1 a) (nth 1 sc)) (math-mul (nth 1 a) (nth 2 sc)))))) (t (list 'cplx a 0))) ) ;;; Coerce A to be complex (polar form). [c N] (defun math-polar (a) (cond ((eq (car-safe a) 'polar) a) ((math-zerop a) '(polar 0 0)) (t (list 'polar (math-abs a) (calcFunc-arg a)))) ) ;;; Multiply A by the imaginary constant i. [N N] [Public] (defun math-imaginary (a) (if (and (or (Math-objvecp a) (math-infinitep a)) (not calc-symbolic-mode)) (math-mul a (if (or (eq (car-safe a) 'polar) (and (not (eq (car-safe a) 'cplx)) (eq calc-complex-mode 'polar))) (list 'polar 1 (math-quarter-circle nil)) '(cplx 0 1))) (math-mul a '(var i var-i))) ) (defun math-want-polar (a b) (cond ((eq (car-safe a) 'polar) (if (eq (car-safe b) 'cplx) (eq calc-complex-mode 'polar) t)) ((eq (car-safe a) 'cplx) (if (eq (car-safe b) 'polar) (eq calc-complex-mode 'polar) nil)) ((eq (car-safe b) 'polar) t) ((eq (car-safe b) 'cplx) nil) (t (eq calc-complex-mode 'polar))) ) ;;; Force A to be in the (-pi,pi] or (-180,180] range. (defun math-fix-circular (a &optional dir) ; [R R] (cond ((eq (car-safe a) 'hms) (cond ((and (Math-lessp 180 (nth 1 a)) (not (eq dir 1))) (math-fix-circular (math-add a '(float -36 1)) -1)) ((or (Math-lessp -180 (nth 1 a)) (eq dir -1)) a) (t (math-fix-circular (math-add a '(float 36 1)) 1)))) ((eq calc-angle-mode 'rad) (cond ((and (Math-lessp (math-pi) a) (not (eq dir 1))) (math-fix-circular (math-sub a (math-two-pi)) -1)) ((or (Math-lessp (math-neg (math-pi)) a) (eq dir -1)) a) (t (math-fix-circular (math-add a (math-two-pi)) 1)))) (t (cond ((and (Math-lessp '(float 18 1) a) (not (eq dir 1))) (math-fix-circular (math-add a '(float -36 1)) -1)) ((or (Math-lessp '(float -18 1) a) (eq dir -1)) a) (t (math-fix-circular (math-add a '(float 36 1)) 1))))) ) ;;;; Complex numbers. (defun calcFunc-polar (a) ; [C N] [Public] (cond ((Math-vectorp a) (math-map-vec 'calcFunc-polar a)) ((Math-realp a) a) ((Math-numberp a) (math-normalize (math-polar a))) (t (list 'calcFunc-polar a))) ) (defun calcFunc-rect (a) ; [N N] [Public] (cond ((Math-vectorp a) (math-map-vec 'calcFunc-rect a)) ((Math-realp a) a) ((Math-numberp a) (math-normalize (math-complex a))) (t (list 'calcFunc-rect a))) ) ;;; Compute the complex conjugate of A. [O O] [Public] (defun calcFunc-conj (a) (let (aa bb) (cond ((Math-realp a) a) ((eq (car a) 'cplx) (list 'cplx (nth 1 a) (math-neg (nth 2 a)))) ((eq (car a) 'polar) (list 'polar (nth 1 a) (math-neg (nth 2 a)))) ((eq (car a) 'vec) (math-map-vec 'calcFunc-conj a)) ((eq (car a) 'calcFunc-conj) (nth 1 a)) ((math-known-realp a) a) ((and (equal a '(var i var-i)) (math-imaginary-i)) (math-neg a)) ((and (memq (car a) '(+ - * /)) (progn (setq aa (calcFunc-conj (nth 1 a)) bb (calcFunc-conj (nth 2 a))) (or (not (eq (car-safe aa) 'calcFunc-conj)) (not (eq (car-safe bb) 'calcFunc-conj))))) (if (eq (car a) '+) (math-add aa bb) (if (eq (car a) '-) (math-sub aa bb) (if (eq (car a) '*) (math-mul aa bb) (math-div aa bb))))) ((eq (car a) 'neg) (math-neg (calcFunc-conj (nth 1 a)))) ((let ((inf (math-infinitep a))) (and inf (math-mul (calcFunc-conj (math-infinite-dir a inf)) inf)))) (t (calc-record-why 'numberp a) (list 'calcFunc-conj a)))) ) ;;; Compute the complex argument of A. [F N] [Public] (defun calcFunc-arg (a) (cond ((Math-anglep a) (if (math-negp a) (math-half-circle nil) 0)) ((eq (car-safe a) 'cplx) (calcFunc-arctan2 (nth 2 a) (nth 1 a))) ((eq (car-safe a) 'polar) (nth 2 a)) ((eq (car a) 'vec) (math-map-vec 'calcFunc-arg a)) ((and (equal a '(var i var-i)) (math-imaginary-i)) (math-quarter-circle t)) ((and (equal a '(neg (var i var-i))) (math-imaginary-i)) (math-neg (math-quarter-circle t))) ((let ((signs (math-possible-signs a))) (or (and (memq signs '(2 4 6)) 0) (and (eq signs 1) (math-half-circle nil))))) ((math-infinitep a) (if (or (equal a '(var uinf var-uinf)) (equal a '(var nan var-nan))) '(var nan var-nan) (calcFunc-arg (math-infinite-dir a)))) (t (calc-record-why 'numvecp a) (list 'calcFunc-arg a))) ) (defun math-imaginary-i () (let ((val (calc-var-value 'var-i))) (or (eq (car-safe val) 'special-const) (equal val '(cplx 0 1)) (and (eq (car-safe val) 'polar) (eq (nth 1 val) 0) (Math-equal (nth 1 val) (math-quarter-circle nil))))) ) ;;; Extract the real or complex part of a complex number. [R N] [Public] ;;; Also extracts the real part of a modulo form. (defun calcFunc-re (a) (let (aa bb) (cond ((Math-realp a) a) ((memq (car a) '(mod cplx)) (nth 1 a)) ((eq (car a) 'polar) (math-mul (nth 1 a) (calcFunc-cos (nth 2 a)))) ((eq (car a) 'vec) (math-map-vec 'calcFunc-re a)) ((math-known-realp a) a) ((eq (car a) 'calcFunc-conj) (calcFunc-re (nth 1 a))) ((and (equal a '(var i var-i)) (math-imaginary-i)) 0) ((and (memq (car a) '(+ - *)) (progn (setq aa (calcFunc-re (nth 1 a)) bb (calcFunc-re (nth 2 a))) (or (not (eq (car-safe aa) 'calcFunc-re)) (not (eq (car-safe bb) 'calcFunc-re))))) (if (eq (car a) '+) (math-add aa bb) (if (eq (car a) '-) (math-sub aa bb) (math-sub (math-mul aa bb) (math-mul (calcFunc-im (nth 1 a)) (calcFunc-im (nth 2 a))))))) ((and (eq (car a) '/) (math-known-realp (nth 2 a))) (math-div (calcFunc-re (nth 1 a)) (nth 2 a))) ((eq (car a) 'neg) (math-neg (calcFunc-re (nth 1 a)))) (t (calc-record-why 'numberp a) (list 'calcFunc-re a)))) ) (defun calcFunc-im (a) (let (aa bb) (cond ((Math-realp a) (if (math-floatp a) '(float 0 0) 0)) ((eq (car a) 'cplx) (nth 2 a)) ((eq (car a) 'polar) (math-mul (nth 1 a) (calcFunc-sin (nth 2 a)))) ((eq (car a) 'vec) (math-map-vec 'calcFunc-im a)) ((math-known-realp a) 0) ((eq (car a) 'calcFunc-conj) (math-neg (calcFunc-im (nth 1 a)))) ((and (equal a '(var i var-i)) (math-imaginary-i)) 1) ((and (memq (car a) '(+ - *)) (progn (setq aa (calcFunc-im (nth 1 a)) bb (calcFunc-im (nth 2 a))) (or (not (eq (car-safe aa) 'calcFunc-im)) (not (eq (car-safe bb) 'calcFunc-im))))) (if (eq (car a) '+) (math-add aa bb) (if (eq (car a) '-) (math-sub aa bb) (math-add (math-mul (calcFunc-re (nth 1 a)) bb) (math-mul aa (calcFunc-re (nth 2 a))))))) ((and (eq (car a) '/) (math-known-realp (nth 2 a))) (math-div (calcFunc-im (nth 1 a)) (nth 2 a))) ((eq (car a) 'neg) (math-neg (calcFunc-im (nth 1 a)))) (t (calc-record-why 'numberp a) (list 'calcFunc-im a)))) ) calc-2.02c/calc-funcs.el100644 22403 13 73331 5402630613 13404 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-funcs.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-funcs () nil) (defun calc-inc-gamma (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-inverse) (if (calc-is-hyperbolic) (calc-binary-op "gamG" 'calcFunc-gammaG arg) (calc-binary-op "gamQ" 'calcFunc-gammaQ arg)) (if (calc-is-hyperbolic) (calc-binary-op "gamg" 'calcFunc-gammag arg) (calc-binary-op "gamP" 'calcFunc-gammaP arg)))) ) (defun calc-erf (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-inverse) (calc-unary-op "erfc" 'calcFunc-erfc arg) (calc-unary-op "erf" 'calcFunc-erf arg))) ) (defun calc-erfc (arg) (interactive "P") (calc-invert-func) (calc-erf arg) ) (defun calc-beta (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "beta" 'calcFunc-beta arg)) ) (defun calc-inc-beta () (interactive) (calc-slow-wrapper (if (calc-is-hyperbolic) (calc-enter-result 3 "betB" (cons 'calcFunc-betaB (calc-top-list-n 3))) (calc-enter-result 3 "betI" (cons 'calcFunc-betaI (calc-top-list-n 3))))) ) (defun calc-bessel-J (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "besJ" 'calcFunc-besJ arg)) ) (defun calc-bessel-Y (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "besY" 'calcFunc-besY arg)) ) (defun calc-bernoulli-number (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-hyperbolic) (calc-binary-op "bern" 'calcFunc-bern arg) (calc-unary-op "bern" 'calcFunc-bern arg))) ) (defun calc-euler-number (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-hyperbolic) (calc-binary-op "eulr" 'calcFunc-euler arg) (calc-unary-op "eulr" 'calcFunc-euler arg))) ) (defun calc-stirling-number (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-hyperbolic) (calc-binary-op "str2" 'calcFunc-stir2 arg) (calc-binary-op "str1" 'calcFunc-stir1 arg))) ) (defun calc-utpb () (interactive) (calc-prob-dist "b" 3) ) (defun calc-utpc () (interactive) (calc-prob-dist "c" 2) ) (defun calc-utpf () (interactive) (calc-prob-dist "f" 3) ) (defun calc-utpn () (interactive) (calc-prob-dist "n" 3) ) (defun calc-utpp () (interactive) (calc-prob-dist "p" 2) ) (defun calc-utpt () (interactive) (calc-prob-dist "t" 2) ) (defun calc-prob-dist (letter nargs) (calc-slow-wrapper (if (calc-is-inverse) (calc-enter-result nargs (concat "ltp" letter) (append (list (intern (concat "calcFunc-ltp" letter)) (calc-top-n 1)) (calc-top-list-n (1- nargs) 2))) (calc-enter-result nargs (concat "utp" letter) (append (list (intern (concat "calcFunc-utp" letter)) (calc-top-n 1)) (calc-top-list-n (1- nargs) 2))))) ) ;;; Sources: Numerical Recipes, Press et al; ;;; Handbook of Mathematical Functions, Abramowitz & Stegun. ;;; Gamma function. (defun calcFunc-gamma (x) (or (math-numberp x) (math-reject-arg x 'numberp)) (calcFunc-fact (math-add x -1)) ) (defun math-gammap1-raw (x &optional fprec nfprec) ; compute gamma(1 + x) (or fprec (setq fprec (math-float calc-internal-prec) nfprec (math-float (- calc-internal-prec)))) (cond ((math-lessp-float (calcFunc-re x) fprec) (if (math-lessp-float (calcFunc-re x) nfprec) (math-neg (math-div (math-pi) (math-mul (math-gammap1-raw (math-add (math-neg x) '(float -1 0)) fprec nfprec) (math-sin-raw (math-mul (math-pi) x))))) (let ((xplus1 (math-add x '(float 1 0)))) (math-div (math-gammap1-raw xplus1 fprec nfprec) xplus1)))) ((and (math-realp x) (math-lessp-float '(float 736276 0) x)) (math-overflow)) (t ; re(x) now >= 10.0 (let ((xinv (math-div 1 x)) (lnx (math-ln-raw x))) (math-mul (math-sqrt-two-pi) (math-exp-raw (math-gamma-series (math-sub (math-mul (math-add x '(float 5 -1)) lnx) x) xinv (math-sqr xinv) '(float 0 0) 2)))))) ) (defun math-gamma-series (sum x xinvsqr oterm n) (math-working "gamma" sum) (let* ((bn (math-bernoulli-number n)) (term (math-mul (math-div-float (math-float (nth 1 bn)) (math-float (* (nth 2 bn) (* n (1- n))))) x)) (next (math-add sum term))) (if (math-nearly-equal sum next) next (if (> n (* 2 calc-internal-prec)) (progn ;; Need this because series eventually diverges for large enough n. (calc-record-why "*Gamma computation stopped early, not all digits may be valid") next) (math-gamma-series next (math-mul x xinvsqr) xinvsqr term (+ n 2))))) ) ;;; Incomplete gamma function. (defun calcFunc-gammaP (a x) (if (equal x '(var inf var-inf)) '(float 1 0) (math-inexact-result) (or (Math-numberp a) (math-reject-arg a 'numberp)) (or (math-numberp x) (math-reject-arg x 'numberp)) (if (and (math-num-integerp a) (integerp (setq a (math-trunc a))) (> a 0) (< a 20)) (math-sub 1 (calcFunc-gammaQ a x)) (let ((math-current-gamma-value (calcFunc-gamma a))) (math-div (calcFunc-gammag a x) math-current-gamma-value)))) ) (defun calcFunc-gammaQ (a x) (if (equal x '(var inf var-inf)) '(float 0 0) (math-inexact-result) (or (Math-numberp a) (math-reject-arg a 'numberp)) (or (math-numberp x) (math-reject-arg x 'numberp)) (if (and (math-num-integerp a) (integerp (setq a (math-trunc a))) (> a 0) (< a 20)) (let ((n 0) (sum '(float 1 0)) (term '(float 1 0))) (math-with-extra-prec 1 (while (< (setq n (1+ n)) a) (setq term (math-div (math-mul term x) n) sum (math-add sum term)) (math-working "gamma" sum)) (math-mul sum (calcFunc-exp (math-neg x))))) (let ((math-current-gamma-value (calcFunc-gamma a))) (math-div (calcFunc-gammaG a x) math-current-gamma-value)))) ) (defun calcFunc-gammag (a x) (if (equal x '(var inf var-inf)) (calcFunc-gamma a) (math-inexact-result) (or (Math-numberp a) (math-reject-arg a 'numberp)) (or (Math-numberp x) (math-reject-arg x 'numberp)) (math-with-extra-prec 2 (setq a (math-float a)) (setq x (math-float x)) (if (or (math-negp (calcFunc-re a)) (math-lessp-float (calcFunc-re x) (math-add-float (calcFunc-re a) '(float 1 0)))) (math-inc-gamma-series a x) (math-sub (or math-current-gamma-value (calcFunc-gamma a)) (math-inc-gamma-cfrac a x))))) ) (setq math-current-gamma-value nil) (defun calcFunc-gammaG (a x) (if (equal x '(var inf var-inf)) '(float 0 0) (math-inexact-result) (or (Math-numberp a) (math-reject-arg a 'numberp)) (or (Math-numberp x) (math-reject-arg x 'numberp)) (math-with-extra-prec 2 (setq a (math-float a)) (setq x (math-float x)) (if (or (math-negp (calcFunc-re a)) (math-lessp-float (calcFunc-re x) (math-add-float (math-abs-approx a) '(float 1 0)))) (math-sub (or math-current-gamma-value (calcFunc-gamma a)) (math-inc-gamma-series a x)) (math-inc-gamma-cfrac a x)))) ) (defun math-inc-gamma-series (a x) (if (Math-zerop x) '(float 0 0) (math-mul (math-exp-raw (math-sub (math-mul a (math-ln-raw x)) x)) (math-with-extra-prec 2 (let ((start (math-div '(float 1 0) a))) (math-inc-gamma-series-step start start a x))))) ) (defun math-inc-gamma-series-step (sum term a x) (math-working "gamma" sum) (setq a (math-add a '(float 1 0)) term (math-div (math-mul term x) a)) (let ((next (math-add sum term))) (if (math-nearly-equal sum next) next (math-inc-gamma-series-step next term a x))) ) (defun math-inc-gamma-cfrac (a x) (if (Math-zerop x) (or math-current-gamma-value (calcFunc-gamma a)) (math-mul (math-exp-raw (math-sub (math-mul a (math-ln-raw x)) x)) (math-inc-gamma-cfrac-step '(float 1 0) x '(float 0 0) '(float 1 0) '(float 1 0) '(float 1 0) '(float 0 0) a x))) ) (defun math-inc-gamma-cfrac-step (a0 a1 b0 b1 n fac g a x) (let ((ana (math-sub n a)) (anf (math-mul n fac))) (setq n (math-add n '(float 1 0)) a0 (math-mul (math-add a1 (math-mul a0 ana)) fac) b0 (math-mul (math-add b1 (math-mul b0 ana)) fac) a1 (math-add (math-mul x a0) (math-mul anf a1)) b1 (math-add (math-mul x b0) (math-mul anf b1))) (if (math-zerop a1) (math-inc-gamma-cfrac-step a0 a1 b0 b1 n fac g a x) (setq fac (math-div '(float 1 0) a1)) (let ((next (math-mul b1 fac))) (math-working "gamma" next) (if (math-nearly-equal next g) next (math-inc-gamma-cfrac-step a0 a1 b0 b1 n fac next a x))))) ) ;;; Error function. (defun calcFunc-erf (x) (if (equal x '(var inf var-inf)) '(float 1 0) (if (equal x '(neg (var inf var-inf))) '(float -1 0) (if (Math-zerop x) x (let ((math-current-gamma-value (math-sqrt-pi))) (math-to-same-complex-quad (math-div (calcFunc-gammag '(float 5 -1) (math-sqr (math-to-complex-quad-one x))) math-current-gamma-value) x))))) ) (defun calcFunc-erfc (x) (if (equal x '(var inf var-inf)) '(float 0 0) (if (math-posp x) (let ((math-current-gamma-value (math-sqrt-pi))) (math-div (calcFunc-gammaG '(float 5 -1) (math-sqr x)) math-current-gamma-value)) (math-sub 1 (calcFunc-erf x)))) ) (defun math-to-complex-quad-one (x) (if (eq (car-safe x) 'polar) (setq x (math-complex x))) (if (eq (car-safe x) 'cplx) (list 'cplx (math-abs (nth 1 x)) (math-abs (nth 2 x))) x) ) (defun math-to-same-complex-quad (x y) (if (eq (car-safe y) 'cplx) (if (eq (car-safe x) 'cplx) (list 'cplx (if (math-negp (nth 1 y)) (math-neg (nth 1 x)) (nth 1 x)) (if (math-negp (nth 2 y)) (math-neg (nth 2 x)) (nth 2 x))) (if (math-negp (nth 1 y)) (math-neg x) x)) (if (math-negp y) (if (eq (car-safe x) 'cplx) (list 'cplx (math-neg (nth 1 x)) (nth 2 x)) (math-neg x)) x)) ) ;;; Beta function. (defun calcFunc-beta (a b) (if (math-num-integerp a) (let ((am (math-add a -1))) (or (math-numberp b) (math-reject-arg b 'numberp)) (math-div 1 (math-mul b (calcFunc-choose (math-add b am) am)))) (if (math-num-integerp b) (calcFunc-beta b a) (math-div (math-mul (calcFunc-gamma a) (calcFunc-gamma b)) (calcFunc-gamma (math-add a b))))) ) ;;; Incomplete beta function. (defun calcFunc-betaI (x a b) (cond ((math-zerop x) '(float 0 0)) ((math-equal-int x 1) '(float 1 0)) ((or (math-zerop a) (and (math-num-integerp a) (math-negp a))) (if (or (math-zerop b) (and (math-num-integerp b) (math-negp b))) (math-reject-arg b 'range) '(float 1 0))) ((or (math-zerop b) (and (math-num-integerp b) (math-negp b))) '(float 0 0)) ((not (math-numberp a)) (math-reject-arg a 'numberp)) ((not (math-numberp b)) (math-reject-arg b 'numberp)) ((math-inexact-result)) (t (let ((math-current-beta-value (calcFunc-beta a b))) (math-div (calcFunc-betaB x a b) math-current-beta-value)))) ) (defun calcFunc-betaB (x a b) (cond ((math-zerop x) '(float 0 0)) ((math-equal-int x 1) (calcFunc-beta a b)) ((not (math-numberp x)) (math-reject-arg x 'numberp)) ((not (math-numberp a)) (math-reject-arg a 'numberp)) ((not (math-numberp b)) (math-reject-arg b 'numberp)) ((math-zerop a) (math-reject-arg a 'nonzerop)) ((math-zerop b) (math-reject-arg b 'nonzerop)) ((and (math-num-integerp b) (if (math-negp b) (math-reject-arg b 'range) (Math-natnum-lessp (setq b (math-trunc b)) 20))) (and calc-symbolic-mode (or (math-floatp a) (math-floatp b)) (math-inexact-result)) (math-mul (math-with-extra-prec 2 (let* ((i 0) (term 1) (sum (math-div term a))) (while (< (setq i (1+ i)) b) (setq term (math-mul (math-div (math-mul term (- i b)) i) x) sum (math-add sum (math-div term (math-add a i)))) (math-working "beta" sum)) sum)) (math-pow x a))) ((and (math-num-integerp a) (if (math-negp a) (math-reject-arg a 'range) (Math-natnum-lessp (setq a (math-trunc a)) 20))) (math-sub (or math-current-beta-value (calcFunc-beta a b)) (calcFunc-betaB (math-sub 1 x) b a))) (t (math-inexact-result) (math-with-extra-prec 2 (setq x (math-float x)) (setq a (math-float a)) (setq b (math-float b)) (let ((bt (math-exp-raw (math-add (math-mul a (math-ln-raw x)) (math-mul b (math-ln-raw (math-sub '(float 1 0) x))))))) (if (Math-lessp x (math-div (math-add a '(float 1 0)) (math-add (math-add a b) '(float 2 0)))) (math-div (math-mul bt (math-beta-cfrac a b x)) a) (math-sub (or math-current-beta-value (calcFunc-beta a b)) (math-div (math-mul bt (math-beta-cfrac b a (math-sub 1 x))) b))))))) ) (setq math-current-beta-value nil) (defun math-beta-cfrac (a b x) (let ((qab (math-add a b)) (qap (math-add a '(float 1 0))) (qam (math-add a '(float -1 0)))) (math-beta-cfrac-step '(float 1 0) (math-sub '(float 1 0) (math-div (math-mul qab x) qap)) '(float 1 0) '(float 1 0) '(float 1 0) qab qap qam a b x)) ) (defun math-beta-cfrac-step (az bz am bm m qab qap qam a b x) (let* ((two-m (math-mul m '(float 2 0))) (d (math-div (math-mul (math-mul (math-sub b m) m) x) (math-mul (math-add qam two-m) (math-add a two-m)))) (ap (math-add az (math-mul d am))) (bp (math-add bz (math-mul d bm))) (d2 (math-neg (math-div (math-mul (math-mul (math-add a m) (math-add qab m)) x) (math-mul (math-add qap two-m) (math-add a two-m))))) (app (math-add ap (math-mul d2 az))) (bpp (math-add bp (math-mul d2 bz))) (next (math-div app bpp))) (math-working "beta" next) (if (math-nearly-equal next az) next (math-beta-cfrac-step next '(float 1 0) (math-div ap bpp) (math-div bp bpp) (math-add m '(float 1 0)) qab qap qam a b x))) ) ;;; Bessel functions. ;;; Should generalize this to handle arbitrary precision! (defun calcFunc-besJ (v x) (or (math-numberp v) (math-reject-arg v 'numberp)) (or (math-numberp x) (math-reject-arg x 'numberp)) (let ((calc-internal-prec (min 8 calc-internal-prec))) (math-with-extra-prec 3 (setq x (math-float (math-normalize x))) (setq v (math-float (math-normalize v))) (cond ((math-zerop x) (if (math-zerop v) '(float 1 0) '(float 0 0))) ((math-inexact-result)) ((not (math-num-integerp v)) (let ((start (math-div 1 (calcFunc-fact v)))) (math-mul (math-besJ-series start start 0 (math-mul '(float -25 -2) (math-sqr x)) v) (math-pow (math-div x 2) v)))) ((math-negp (setq v (math-trunc v))) (if (math-oddp v) (math-neg (calcFunc-besJ (math-neg v) x)) (calcFunc-besJ (math-neg v) x))) ((eq v 0) (math-besJ0 x)) ((eq v 1) (math-besJ1 x)) ((Math-lessp v (math-abs-approx x)) (let ((j 0) (bjm (math-besJ0 x)) (bj (math-besJ1 x)) (two-over-x (math-div 2 x)) bjp) (while (< (setq j (1+ j)) v) (setq bjp (math-sub (math-mul (math-mul j two-over-x) bj) bjm) bjm bj bj bjp)) bj)) (t (if (Math-lessp 100 v) (math-reject-arg v 'range)) (let* ((j (logior (+ v (math-isqrt-small (* 40 v))) 1)) (two-over-x (math-div 2 x)) (jsum nil) (bjp '(float 0 0)) (sum '(float 0 0)) (bj '(float 1 0)) bjm ans) (while (> (setq j (1- j)) 0) (setq bjm (math-sub (math-mul (math-mul j two-over-x) bj) bjp) bjp bj bj bjm) (if (> (nth 2 (math-abs-approx bj)) 10) (setq bj (math-mul bj '(float 1 -10)) bjp (math-mul bjp '(float 1 -10)) ans (and ans (math-mul ans '(float 1 -10))) sum (math-mul sum '(float 1 -10)))) (or (setq jsum (not jsum)) (setq sum (math-add sum bj))) (if (= j v) (setq ans bjp))) (math-div ans (math-sub (math-mul 2 sum) bj))))))) ) (defun math-besJ-series (sum term k zz vk) (math-working "besJ" sum) (setq k (1+ k) vk (math-add 1 vk) term (math-div (math-mul term zz) (math-mul k vk))) (let ((next (math-add sum term))) (if (math-nearly-equal next sum) next (math-besJ-series next term k zz vk))) ) (defun math-besJ0 (x &optional yflag) (cond ((and (not yflag) (math-negp (calcFunc-re x))) (math-besJ0 (math-neg x))) ((Math-lessp '(float 8 0) (math-abs-approx x)) (let* ((z (math-div '(float 8 0) x)) (y (math-sqr z)) (xx (math-add x '(float (bigneg 164 398 785) -9))) (a1 (math-poly-eval y '((float (bigpos 211 887 093 2) -16) (float (bigneg 639 370 073 2) -15) (float (bigpos 407 510 734 2) -14) (float (bigneg 627 628 098 1) -12) (float 1 0)))) (a2 (math-poly-eval y '((float (bigneg 152 935 934) -16) (float (bigpos 161 095 621 7) -16) (float (bigneg 651 147 911 6) -15) (float (bigpos 765 488 430 1) -13) (float (bigneg 995 499 562 1) -11)))) (sc (math-sin-cos-raw xx))) (if yflag (setq sc (cons (math-neg (cdr sc)) (car sc)))) (math-mul (math-sqrt (math-div '(float (bigpos 722 619 636) -9) x)) (math-sub (math-mul (cdr sc) a1) (math-mul (car sc) (math-mul z a2)))))) (t (let ((y (math-sqr x))) (math-div (math-poly-eval y '((float (bigneg 456 052 849 1) -7) (float (bigpos 017 233 739 7) -5) (float (bigneg 418 442 121 1) -2) (float (bigpos 407 196 516 6) -1) (float (bigneg 354 590 362 13) 0) (float (bigpos 574 490 568 57) 0))) (math-poly-eval y '((float 1 0) (float (bigpos 712 532 678 2) -7) (float (bigpos 853 264 927 5) -5) (float (bigpos 718 680 494 9) -3) (float (bigpos 985 532 029 1) 0) (float (bigpos 411 490 568 57) 0))))))) ) (defun math-besJ1 (x &optional yflag) (cond ((and (math-negp (calcFunc-re x)) (not yflag)) (math-neg (math-besJ1 (math-neg x)))) ((Math-lessp '(float 8 0) (math-abs-approx x)) (let* ((z (math-div '(float 8 0) x)) (y (math-sqr z)) (xx (math-add x '(float (bigneg 491 194 356 2) -9))) (a1 (math-poly-eval y '((float (bigneg 019 337 240) -15) (float (bigpos 174 520 457 2) -15) (float (bigneg 496 396 516 3) -14) (float 183105 -8) (float 1 0)))) (a2 (math-poly-eval y '((float (bigpos 412 787 105) -15) (float (bigneg 987 228 88) -14) (float (bigpos 096 199 449 8) -15) (float (bigneg 873 690 002 2) -13) (float (bigpos 995 499 687 4) -11)))) (sc (math-sin-cos-raw xx))) (if yflag (setq sc (cons (math-neg (cdr sc)) (car sc))) (if (math-negp x) (setq sc (cons (math-neg (car sc)) (math-neg (cdr sc)))))) (math-mul (math-sqrt (math-div '(float (bigpos 722 619 636) -9) x)) (math-sub (math-mul (cdr sc) a1) (math-mul (car sc) (math-mul z a2)))))) (t (let ((y (math-sqr x))) (math-mul x (math-div (math-poly-eval y '((float (bigneg 606 036 016 3) -8) (float (bigpos 826 044 157) -4) (float (bigneg 439 611 972 2) -3) (float (bigpos 531 968 423 2) -1) (float (bigneg 235 059 895 7) 0) (float (bigpos 232 614 362 72) 0))) (math-poly-eval y '((float 1 0) (float (bigpos 397 991 769 3) -7) (float (bigpos 394 743 944 9) -5) (float (bigpos 474 330 858 1) -2) (float (bigpos 178 535 300 2) 0) (float (bigpos 442 228 725 144) 0)))))))) ) (defun calcFunc-besY (v x) (math-inexact-result) (or (math-numberp v) (math-reject-arg v 'numberp)) (or (math-numberp x) (math-reject-arg x 'numberp)) (let ((calc-internal-prec (min 8 calc-internal-prec))) (math-with-extra-prec 3 (setq x (math-float (math-normalize x))) (setq v (math-float (math-normalize v))) (cond ((not (math-num-integerp v)) (let ((sc (math-sin-cos-raw (math-mul v (math-pi))))) (math-div (math-sub (math-mul (calcFunc-besJ v x) (cdr sc)) (calcFunc-besJ (math-neg v) x)) (car sc)))) ((math-negp (setq v (math-trunc v))) (if (math-oddp v) (math-neg (calcFunc-besY (math-neg v) x)) (calcFunc-besY (math-neg v) x))) ((eq v 0) (math-besY0 x)) ((eq v 1) (math-besY1 x)) (t (let ((j 0) (bym (math-besY0 x)) (by (math-besY1 x)) (two-over-x (math-div 2 x)) byp) (while (< (setq j (1+ j)) v) (setq byp (math-sub (math-mul (math-mul j two-over-x) by) bym) bym by by byp)) by))))) ) (defun math-besY0 (x) (cond ((Math-lessp (math-abs-approx x) '(float 8 0)) (let ((y (math-sqr x))) (math-add (math-div (math-poly-eval y '((float (bigpos 733 622 284 2) -7) (float (bigneg 757 792 632 8) -5) (float (bigpos 129 988 087 1) -2) (float (bigneg 036 598 123 5) -1) (float (bigpos 065 834 062 7) 0) (float (bigneg 389 821 957 2) 0))) (math-poly-eval y '((float 1 0) (float (bigpos 244 030 261 2) -7) (float (bigpos 647 472 474) -4) (float (bigpos 438 466 189 7) -3) (float (bigpos 648 499 452 7) -1) (float (bigpos 269 544 076 40) 0)))) (math-mul '(float (bigpos 772 619 636) -9) (math-mul (math-besJ0 x) (math-ln-raw x)))))) ((math-negp (calcFunc-re x)) (math-add (math-besJ0 (math-neg x) t) (math-mul '(cplx 0 2) (math-besJ0 (math-neg x))))) (t (math-besJ0 x t))) ) (defun math-besY1 (x) (cond ((Math-lessp (math-abs-approx x) '(float 8 0)) (let ((y (math-sqr x))) (math-add (math-mul x (math-div (math-poly-eval y '((float (bigpos 935 937 511 8) -6) (float (bigneg 726 922 237 4) -3) (float (bigpos 551 264 349 7) -1) (float (bigneg 139 438 153 5) 1) (float (bigpos 439 527 127) 4) (float (bigneg 943 604 900 4) 3))) (math-poly-eval y '((float 1 0) (float (bigpos 885 632 549 3) -7) (float (bigpos 605 042 102) -3) (float (bigpos 002 904 245 2) -2) (float (bigpos 367 650 733 3) 0) (float (bigpos 664 419 244 4) 2) (float (bigpos 057 958 249) 5))))) (math-mul '(float (bigpos 772 619 636) -9) (math-sub (math-mul (math-besJ1 x) (math-ln-raw x)) (math-div 1 x)))))) ((math-negp (calcFunc-re x)) (math-neg (math-add (math-besJ1 (math-neg x) t) (math-mul '(cplx 0 2) (math-besJ1 (math-neg x)))))) (t (math-besJ1 x t))) ) (defun math-poly-eval (x coefs) (let ((accum (car coefs))) (while (setq coefs (cdr coefs)) (setq accum (math-add (car coefs) (math-mul accum x)))) accum) ) ;;;; Bernoulli and Euler polynomials and numbers. (defun calcFunc-bern (n &optional x) (if (and x (not (math-zerop x))) (if (and calc-symbolic-mode (math-floatp x)) (math-inexact-result) (math-build-polynomial-expr (math-bernoulli-coefs n) x)) (or (math-num-natnump n) (math-reject-arg n 'natnump)) (if (consp n) (progn (math-inexact-result) (math-float (math-bernoulli-number (math-trunc n)))) (math-bernoulli-number n))) ) (defun calcFunc-euler (n &optional x) (or (math-num-natnump n) (math-reject-arg n 'natnump)) (if x (let* ((n1 (math-add n 1)) (coefs (math-bernoulli-coefs n1)) (fac (math-div (math-pow 2 n1) n1)) (k -1) (x1 (math-div (math-add x 1) 2)) (x2 (math-div x 2))) (if (math-numberp x) (if (and calc-symbolic-mode (math-floatp x)) (math-inexact-result) (math-mul fac (math-sub (math-build-polynomial-expr coefs x1) (math-build-polynomial-expr coefs x2)))) (calcFunc-collect (math-reduce-vec 'math-add (cons 'vec (mapcar (function (lambda (c) (setq k (1+ k)) (math-mul (math-mul fac c) (math-sub (math-pow x1 k) (math-pow x2 k))))) coefs))) x))) (math-mul (math-pow 2 n) (if (consp n) (progn (math-inexact-result) (calcFunc-euler n '(float 5 -1))) (calcFunc-euler n '(frac 1 2))))) ) (defun math-bernoulli-coefs (n) (let* ((coefs (list (calcFunc-bern n))) (nn (math-trunc n)) (k nn) (term nn) coef (calc-prefer-frac (or (integerp n) calc-prefer-frac))) (while (>= (setq k (1- k)) 0) (setq term (math-div term (- nn k)) coef (math-mul term (math-bernoulli-number k)) coefs (cons (if (consp n) (math-float coef) coef) coefs) term (math-mul term k))) (nreverse coefs)) ) (defun math-bernoulli-number (n) (if (= (% n 2) 1) (if (= n 1) '(frac -1 2) 0) (setq n (/ n 2)) (while (>= n math-bernoulli-cache-size) (let* ((sum 0) (nk 1) ; nk = n-k+1 (fact 1) ; fact = (n-k+1)! ofact (p math-bernoulli-b-cache) (calc-prefer-frac t)) (math-working "bernoulli B" (* 2 math-bernoulli-cache-size)) (while p (setq nk (+ nk 2) ofact fact fact (math-mul fact (* nk (1- nk))) sum (math-add sum (math-div (car p) fact)) p (cdr p))) (setq ofact (math-mul ofact (1- nk)) sum (math-sub (math-div '(frac 1 2) ofact) sum) math-bernoulli-b-cache (cons sum math-bernoulli-b-cache) math-bernoulli-B-cache (cons (math-mul sum ofact) math-bernoulli-B-cache) math-bernoulli-cache-size (1+ math-bernoulli-cache-size)))) (nth (- math-bernoulli-cache-size n 1) math-bernoulli-B-cache)) ) ;;; Bn = n! bn ;;; bn = - sum_k=0^n-1 bk / (n-k+1)! ;;; A faster method would be to use "tangent numbers", c.f., Concrete ;;; Mathematics pg. 273. (setq math-bernoulli-b-cache '( (frac -174611 (bigpos 0 200 291 698 662 857 802)) (frac 43867 (bigpos 0 944 170 217 94 109 5)) (frac -3617 (bigpos 0 880 842 622 670 10)) (frac 1 (bigpos 600 249 724 74)) (frac -691 (bigpos 0 368 674 307 1)) (frac 1 (bigpos 160 900 47)) (frac -1 (bigpos 600 209 1)) (frac 1 30240) (frac -1 720) (frac 1 12) 1 )) (setq math-bernoulli-B-cache '( (frac -174611 330) (frac 43867 798) (frac -3617 510) (frac 7 6) (frac -691 2730) (frac 5 66) (frac -1 30) (frac 1 42) (frac -1 30) (frac 1 6) 1 )) (setq math-bernoulli-cache-size 11) ;;; Probability distributions. ;;; Binomial. (defun calcFunc-utpb (x n p) (if math-expand-formulas (math-normalize (list 'calcFunc-betaI p x (list '+ (list '- n x) 1))) (calcFunc-betaI p x (math-add (math-sub n x) 1))) ) (put 'calcFunc-utpb 'math-expandable t) (defun calcFunc-ltpb (x n p) (math-sub 1 (calcFunc-utpb x n p)) ) (put 'calcFunc-ltpb 'math-expandable t) ;;; Chi-square. (defun calcFunc-utpc (chisq v) (if math-expand-formulas (math-normalize (list 'calcFunc-gammaQ (list '/ v 2) (list '/ chisq 2))) (calcFunc-gammaQ (math-div v 2) (math-div chisq 2))) ) (put 'calcFunc-utpc 'math-expandable t) (defun calcFunc-ltpc (chisq v) (if math-expand-formulas (math-normalize (list 'calcFunc-gammaP (list '/ v 2) (list '/ chisq 2))) (calcFunc-gammaP (math-div v 2) (math-div chisq 2))) ) (put 'calcFunc-ltpc 'math-expandable t) ;;; F-distribution. (defun calcFunc-utpf (f v1 v2) (if math-expand-formulas (math-normalize (list 'calcFunc-betaI (list '/ v2 (list '+ v2 (list '* v1 f))) (list '/ v2 2) (list '/ v1 2))) (calcFunc-betaI (math-div v2 (math-add v2 (math-mul v1 f))) (math-div v2 2) (math-div v1 2))) ) (put 'calcFunc-utpf 'math-expandable t) (defun calcFunc-ltpf (f v1 v2) (math-sub 1 (calcFunc-utpf f v1 v2)) ) (put 'calcFunc-ltpf 'math-expandable t) ;;; Normal. (defun calcFunc-utpn (x mean sdev) (if math-expand-formulas (math-normalize (list '/ (list '+ 1 (list 'calcFunc-erf (list '/ (list '- mean x) (list '* sdev (list 'calcFunc-sqrt 2))))) 2)) (math-mul (math-add '(float 1 0) (calcFunc-erf (math-div (math-sub mean x) (math-mul sdev (math-sqrt-2))))) '(float 5 -1))) ) (put 'calcFunc-utpn 'math-expandable t) (defun calcFunc-ltpn (x mean sdev) (if math-expand-formulas (math-normalize (list '/ (list '+ 1 (list 'calcFunc-erf (list '/ (list '- x mean) (list '* sdev (list 'calcFunc-sqrt 2))))) 2)) (math-mul (math-add '(float 1 0) (calcFunc-erf (math-div (math-sub x mean) (math-mul sdev (math-sqrt-2))))) '(float 5 -1))) ) (put 'calcFunc-ltpn 'math-expandable t) ;;; Poisson. (defun calcFunc-utpp (n x) (if math-expand-formulas (math-normalize (list 'calcFunc-gammaP x n)) (calcFunc-gammaP x n)) ) (put 'calcFunc-utpp 'math-expandable t) (defun calcFunc-ltpp (n x) (if math-expand-formulas (math-normalize (list 'calcFunc-gammaQ x n)) (calcFunc-gammaQ x n)) ) (put 'calcFunc-ltpp 'math-expandable t) ;;; Student's t. (As defined in Abramowitz & Stegun and Numerical Recipes.) (defun calcFunc-utpt (tt v) (if math-expand-formulas (math-normalize (list 'calcFunc-betaI (list '/ v (list '+ v (list '^ tt 2))) (list '/ v 2) '(float 5 -1))) (calcFunc-betaI (math-div v (math-add v (math-sqr tt))) (math-div v 2) '(float 5 -1))) ) (put 'calcFunc-utpt 'math-expandable t) (defun calcFunc-ltpt (tt v) (math-sub 1 (calcFunc-utpt tt v)) ) (put 'calcFunc-ltpt 'math-expandable t) calc-2.02c/calc-sel.el100644 22403 13 61664 5402630743 13063 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-sel.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-sel () nil) ;;; Selection commands. (defun calc-select-here (num &optional once keep) (interactive "P") (calc-wrapper (calc-prepare-selection) (let ((found (calc-find-selected-part)) (entry calc-selection-cache-entry)) (or (and keep (nth 2 entry)) (progn (if once (progn (setq calc-keep-selection nil) (message "(Selection will apply to next command only)"))) (calc-change-current-selection (if found (if (and num (> (setq num (prefix-numeric-value num)) 0)) (progn (while (and (>= (setq num (1- num)) 0) (not (eq found (car entry)))) (setq found (calc-find-assoc-parent-formula (car entry) found))) found) (calc-grow-assoc-formula (car entry) found)) (car entry))))))) ) (defun calc-select-once (num) (interactive "P") (calc-select-here num t) ) (defun calc-select-here-maybe (num) (interactive "P") (calc-select-here num nil t) ) (defun calc-select-once-maybe (num) (interactive "P") (calc-select-here num t t) ) (defun calc-select-additional () (interactive) (calc-wrapper (let (calc-keep-selection) (calc-prepare-selection)) (let ((found (calc-find-selected-part)) (entry calc-selection-cache-entry)) (calc-change-current-selection (if found (let ((sel (nth 2 entry))) (if sel (progn (while (not (or (eq sel (car entry)) (calc-find-sub-formula sel found))) (setq sel (calc-find-assoc-parent-formula (car entry) sel))) sel) (calc-grow-assoc-formula (car entry) found))) (car entry))))) ) (defun calc-select-more (num) (interactive "P") (calc-wrapper (calc-prepare-selection) (let ((entry calc-selection-cache-entry)) (if (nth 2 entry) (let ((sel (nth 2 entry))) (while (and (not (eq sel (car entry))) (>= (setq num (1- (prefix-numeric-value num))) 0)) (setq sel (calc-find-assoc-parent-formula (car entry) sel))) (calc-change-current-selection sel)) (calc-select-here num)))) ) (defun calc-select-less (num) (interactive "p") (calc-wrapper (calc-prepare-selection) (let ((found (calc-find-selected-part)) (entry calc-selection-cache-entry)) (calc-change-current-selection (and found (let ((sel (nth 2 entry)) old index op) (while (and sel (not (eq sel found)) (>= (setq num (1- num)) 0)) (setq old sel index (calc-find-sub-formula sel found)) (and (setq sel (and index (nth index old))) calc-assoc-selections (setq op (assq (car-safe sel) calc-assoc-ops)) (memq (car old) (nth index op)) (setq num (1+ num)))) sel))))) ) (defun calc-select-part (num) (interactive "P") (or num (setq num (- last-command-char ?0))) (calc-wrapper (calc-prepare-selection) (let ((sel (calc-find-nth-part (or (nth 2 calc-selection-cache-entry) (car calc-selection-cache-entry)) num))) (if sel (calc-change-current-selection sel) (error "%d is not a valid sub-formula index" num)))) ) (defun calc-find-nth-part (expr num) (if (and calc-assoc-selections (assq (car-safe expr) calc-assoc-ops)) (let (op) (calc-find-nth-part-rec expr)) (if (eq (car-safe expr) 'intv) (and (>= num 1) (<= num 2) (nth (1+ num) expr)) (and (not (Math-primp expr)) (>= num 1) (< num (length expr)) (nth num expr)))) ) (defun calc-find-nth-part-rec (expr) ; uses num, op (or (if (and (setq op (assq (car-safe (nth 1 expr)) calc-assoc-ops)) (memq (car expr) (nth 1 op))) (calc-find-nth-part-rec (nth 1 expr)) (and (= (setq num (1- num)) 0) (nth 1 expr))) (if (and (setq op (assq (car-safe (nth 2 expr)) calc-assoc-ops)) (memq (car expr) (nth 2 op))) (calc-find-nth-part-rec (nth 2 expr)) (and (= (setq num (1- num)) 0) (nth 2 expr)))) ) (defun calc-select-next (num) (interactive "p") (if (< num 0) (calc-select-previous (- num)) (calc-wrapper (calc-prepare-selection) (let* ((entry calc-selection-cache-entry) (sel (nth 2 entry))) (if sel (progn (while (>= (setq num (1- num)) 0) (let* ((parent (calc-find-parent-formula (car entry) sel)) (p parent) op) (and (eq p t) (setq p nil)) (while (and (setq p (cdr p)) (not (eq (car p) sel)))) (if (cdr p) (setq sel (or (and calc-assoc-selections (setq op (assq (car-safe (nth 1 p)) calc-assoc-ops)) (memq (car parent) (nth 2 op)) (nth 1 (nth 1 p))) (nth 1 p))) (if (and calc-assoc-selections (setq op (assq (car-safe parent) calc-assoc-ops)) (consp (setq p (calc-find-parent-formula (car entry) parent))) (eq (nth 1 p) parent) (memq (car p) (nth 1 op))) (setq sel (nth 2 p)) (error "No \"next\" sub-formula"))))) (calc-change-current-selection sel)) (if (Math-primp (car entry)) (calc-change-current-selection (car entry)) (calc-select-part num)))))) ) (defun calc-select-previous (num) (interactive "p") (if (< num 0) (calc-select-next (- num)) (calc-wrapper (calc-prepare-selection) (let* ((entry calc-selection-cache-entry) (sel (nth 2 entry))) (if sel (progn (while (>= (setq num (1- num)) 0) (let* ((parent (calc-find-parent-formula (car entry) sel)) (p (cdr-safe parent)) (prev nil) op) (if (eq (car-safe parent) 'intv) (setq p (cdr p))) (while (and (not (eq (car p) sel)) (setq prev (car p) p (cdr p)))) (if prev (setq sel (or (and calc-assoc-selections (setq op (assq (car-safe prev) calc-assoc-ops)) (memq (car parent) (nth 1 op)) (nth 2 prev)) prev)) (if (and calc-assoc-selections (setq op (assq (car-safe parent) calc-assoc-ops)) (consp (setq p (calc-find-parent-formula (car entry) parent))) (eq (nth 2 p) parent) (memq (car p) (nth 2 op))) (setq sel (nth 1 p)) (error "No \"previous\" sub-formula"))))) (calc-change-current-selection sel)) (if (Math-primp (car entry)) (calc-change-current-selection (car entry)) (let ((len (if (and calc-assoc-selections (assq (car (car entry)) calc-assoc-ops)) (let (op (num 0)) (calc-find-nth-part-rec (car entry)) (- 1 num)) (length (car entry))))) (calc-select-part (- len num)))))))) ) (defun calc-find-parent-formula (expr part) (cond ((eq expr part) t) ((Math-primp expr) nil) (t (let ((p expr) res) (while (and (setq p (cdr p)) (not (setq res (calc-find-parent-formula (car p) part))))) (and p (if (eq res t) expr res))))) ) (defun calc-find-assoc-parent-formula (expr part) (calc-grow-assoc-formula expr (calc-find-parent-formula expr part)) ) (defun calc-grow-assoc-formula (expr part) (if calc-assoc-selections (let ((op (assq (car-safe part) calc-assoc-ops))) (if op (let (new) (while (and (consp (setq new (calc-find-parent-formula expr part))) (memq (car new) (nth (calc-find-sub-formula new part) op))) (setq part new)))) part) part) ) (defun calc-find-sub-formula (expr part) (cond ((eq expr part) t) ((Math-primp expr) nil) (t (let ((num 1)) (while (and (setq expr (cdr expr)) (not (calc-find-sub-formula (car expr) part))) (setq num (1+ num))) (and expr num)))) ) (defun calc-unselect (num) (interactive "P") (calc-wrapper (calc-prepare-selection num) (calc-change-current-selection nil)) ) (defun calc-clear-selections () (interactive) (calc-wrapper (let ((limit (calc-stack-size)) (n 1)) (while (<= n limit) (if (calc-top n 'sel) (progn (calc-prepare-selection n) (calc-change-current-selection nil))) (setq n (1+ n)))) (calc-clear-command-flag 'position-point)) ) (defun calc-show-selections (arg) (interactive "P") (calc-wrapper (calc-preserve-point) (setq calc-show-selections (if arg (> (prefix-numeric-value arg) 0) (not calc-show-selections))) (let ((p calc-stack)) (while (and p (or (null (nth 2 (car p))) (equal (car p) calc-selection-cache-entry))) (setq p (cdr p))) (or (and p (let ((calc-selection-cache-default-entry calc-selection-cache-entry)) (calc-do-refresh))) (and calc-selection-cache-entry (let ((sel (nth 2 calc-selection-cache-entry))) (setcar (nthcdr 2 calc-selection-cache-entry) nil) (calc-change-current-selection sel))))) (message (if calc-show-selections "Displaying only selected part of formulas" "Displaying all but selected part of formulas"))) ) (defun calc-preserve-point () (or (looking-at "\\.\n+\\'") (progn (setq calc-final-point-line (+ (count-lines (point-min) (point)) (if (bolp) 1 0)) calc-final-point-column (current-column)) (calc-set-command-flag 'position-point))) ) (defun calc-enable-selections (arg) (interactive "P") (calc-wrapper (calc-preserve-point) (setq calc-use-selections (if arg (> (prefix-numeric-value arg) 0) (not calc-use-selections))) (calc-set-command-flag 'renum-stack) (message (if calc-use-selections "Commands operate only on selected sub-formulas" "Selections of sub-formulas have no effect"))) ) (defun calc-break-selections (arg) (interactive "P") (calc-wrapper (calc-preserve-point) (setq calc-assoc-selections (if arg (<= (prefix-numeric-value arg) 0) (not calc-assoc-selections))) (message (if calc-assoc-selections "Selection treats a+b+c as a sum of three terms" "Selection treats a+b+c as (a+b)+c"))) ) (defun calc-prepare-selection (&optional num) (or num (setq num (calc-locate-cursor-element (point)))) (setq calc-selection-true-num num calc-keep-selection t) (or (> num 0) (setq num 1)) ;; (if (or (< num 1) (> num (calc-stack-size))) ;; (error "Cursor must be positioned on a stack element")) (let* ((entry (calc-top num 'entry)) ww w) (or (equal entry calc-selection-cache-entry) (progn (setcar entry (calc-encase-atoms (car entry))) (setq calc-selection-cache-entry entry calc-selection-cache-num num calc-selection-cache-comp (let ((math-comp-tagged t)) (math-compose-expr (car entry) 0)) calc-selection-cache-offset (+ (car (math-stack-value-offset calc-selection-cache-comp)) (length calc-left-label) (if calc-line-numbering 4 0)))))) (calc-preserve-point) ) (setq calc-selection-cache-entry nil) ;;; The following ensures that no two subformulas will be "eq" to each other! (defun calc-encase-atoms (x) (if (or (not (consp x)) (equal x '(float 0 0))) (list 'cplx x 0) (calc-encase-atoms-rec x) x) ) (defun calc-encase-atoms-rec (x) (or (Math-primp x) (progn (if (eq (car x) 'intv) (setq x (cdr x))) (while (setq x (cdr x)) (if (or (not (consp (car x))) (equal (car x) '(float 0 0))) (setcar x (list 'cplx (car x) 0)) (calc-encase-atoms-rec (car x)))))) ) (defun calc-find-selected-part () (let* ((math-comp-sel-hpos (- (current-column) calc-selection-cache-offset)) toppt (lcount 0) (spaces 0) (math-comp-sel-vpos (save-excursion (beginning-of-line) (let ((line (point))) (calc-cursor-stack-index calc-selection-cache-num) (setq toppt (point)) (while (< (point) line) (forward-line 1) (setq spaces (+ spaces (current-indentation)) lcount (1+ lcount))) (- lcount (math-comp-ascent calc-selection-cache-comp) -1)))) (math-comp-sel-cpos (- (point) toppt calc-selection-cache-offset spaces lcount)) (math-comp-sel-tag nil)) (and (>= math-comp-sel-hpos 0) (> calc-selection-true-num 0) (math-composition-to-string calc-selection-cache-comp 1000000)) (nth 1 math-comp-sel-tag)) ) (defun calc-change-current-selection (sub-expr) (or (eq sub-expr (nth 2 calc-selection-cache-entry)) (let ((calc-prepared-composition calc-selection-cache-comp) (buffer-read-only nil) top) (calc-set-command-flag 'renum-stack) (setcar (nthcdr 2 calc-selection-cache-entry) sub-expr) (calc-cursor-stack-index calc-selection-cache-num) (setq top (point)) (calc-cursor-stack-index (1- calc-selection-cache-num)) (delete-region top (point)) (let ((calc-selection-cache-default-entry calc-selection-cache-entry)) (insert (math-format-stack-value calc-selection-cache-entry) "\n")))) ) (defun calc-top-selected (&optional n m) (and calc-any-selections calc-use-selections (progn (or n (setq n 1)) (or m (setq m 1)) (calc-check-stack (+ n m -1)) (let ((top (nthcdr (+ m calc-stack-top -1) calc-stack)) (sel nil)) (while (>= (setq n (1- n)) 0) (if (nth 2 (car top)) (setq sel (if sel t (nth 2 (car top))))) (setq top (cdr top))) sel))) ) (defun calc-replace-sub-formula (expr old new) (setq new (calc-encase-atoms new)) (calc-replace-sub-formula-rec expr) ) (defun calc-replace-sub-formula-rec (expr) (cond ((eq expr old) new) ((Math-primp expr) expr) (t (cons (car expr) (mapcar 'calc-replace-sub-formula-rec (cdr expr))))) ) (defun calc-sel-error () (error "Illegal operation on sub-formulas") ) (defun calc-replace-selections (n vals m) (if (calc-top-selected n m) (let ((num (length vals))) (calc-preserve-point) (cond ((= n num) (let* ((old (calc-top-list n m 'entry)) (new nil) (sel nil) val) (while old (if (nth 2 (car old)) (setq val (calc-encase-atoms (car vals)) new (cons (calc-replace-sub-formula (car (car old)) (nth 2 (car old)) val) new) sel (cons val sel)) (setq new (cons (car vals) new) sel (cons nil sel))) (setq vals (cdr vals) old (cdr old))) (calc-pop-stack n m t) (calc-push-list (nreverse new) m (and calc-keep-selection (nreverse sel))))) ((= num 1) (let* ((old (calc-top-list n m 'entry)) more) (while (and old (not (nth 2 (car old)))) (setq old (cdr old))) (setq more old) (while (and (setq more (cdr more)) (not (nth 2 (car more))))) (and more (calc-sel-error)) (calc-pop-stack n m t) (if old (let ((val (calc-encase-atoms (car vals)))) (calc-push-list (list (calc-replace-sub-formula (car (car old)) (nth 2 (car old)) val)) m (and calc-keep-selection (list val)))) (calc-push-list vals)))) (t (calc-sel-error)))) (calc-pop-stack n m t) (calc-push-list vals m)) ) (setq calc-keep-selection t) (defun calc-delete-selection (n) (let ((entry (calc-top n 'entry))) (if (nth 2 entry) (if (eq (nth 2 entry) (car entry)) (progn (calc-pop-stack 1 n t) (calc-push-list '(0) n)) (let ((parent (calc-find-parent-formula (car entry) (nth 2 entry))) (repl nil)) (calc-preserve-point) (calc-pop-stack 1 n t) (cond ((or (memq (car parent) '(* / %)) (and (eq (car parent) '^) (eq (nth 2 parent) (nth 2 entry)))) (setq repl 1)) ((memq (car parent) '(vec calcFunc-min calcFunc-max))) ((and (assq (car parent) calc-tweak-eqn-table) (= (length parent) 3)) (setq repl 'del)) (t (setq repl 0))) (cond ((eq repl 'del) (calc-push-list (list (calc-normalize (calc-replace-sub-formula (car entry) parent (if (eq (nth 2 entry) (nth 1 parent)) (nth 2 parent) (nth 1 parent))))) n)) (repl (calc-push-list (list (calc-normalize (calc-replace-sub-formula (car entry) (nth 2 entry) repl))) n)) (t (calc-push-list (list (calc-normalize (calc-replace-sub-formula (car entry) parent (delq (nth 2 entry) (copy-sequence parent))))) n))))) (calc-pop-stack 1 n t))) ) (defun calc-roll-down-with-selections (n m) (let ((vals (append (calc-top-list m 1) (calc-top-list (- n m) (1+ m)))) (sels (append (calc-top-list m 1 'sel) (calc-top-list (- n m) (1+ m) 'sel)))) (calc-pop-push-list n vals 1 sels)) ) (defun calc-roll-up-with-selections (n m) (let ((vals (append (calc-top-list (- n m) 1) (calc-top-list m (- n m -1)))) (sels (append (calc-top-list (- n m) 1 'sel) (calc-top-list m (- n m -1) 'sel)))) (calc-pop-push-list n vals 1 sels)) ) (defun calc-auto-selection (entry) (or (nth 2 entry) (progn (and (boundp 'reselect) (setq reselect nil)) (calc-prepare-selection) (calc-grow-assoc-formula (car entry) (calc-find-selected-part)))) ) (defun calc-copy-selection () (interactive) (calc-wrapper (calc-preserve-point) (let* ((num (max 1 (calc-locate-cursor-element (point)))) (entry (calc-top num 'entry))) (calc-push (or (calc-auto-selection entry) (car entry))))) ) (defun calc-del-selection () (interactive) (calc-wrapper (calc-preserve-point) (let* ((num (max 1 (calc-locate-cursor-element (point)))) (entry (calc-top num 'entry)) (sel (calc-auto-selection entry))) (setcar (nthcdr 2 entry) (and (not (eq sel (car entry))) sel)) (calc-delete-selection num))) ) (defun calc-enter-selection () (interactive) (calc-wrapper (calc-preserve-point) (let* ((num (max 1 (calc-locate-cursor-element (point)))) (reselect calc-keep-selection) (entry (calc-top num 'entry)) (expr (car entry)) (sel (or (calc-auto-selection entry) expr)) alg) (let ((calc-dollar-values (list sel)) (calc-dollar-used 0)) (setq alg (calc-do-alg-entry "" "Replace selection with: ")) (and alg (progn (setq alg (calc-encase-atoms (car alg))) (calc-pop-push-record-list 1 "repl" (list (calc-replace-sub-formula expr sel alg)) num (list (and reselect alg)))))) (calc-handle-whys))) ) (defun calc-edit-selection () (interactive) (calc-wrapper (calc-preserve-point) (let* ((num (max 1 (calc-locate-cursor-element (point)))) (reselect calc-keep-selection) (entry (calc-top num 'entry)) (expr (car entry)) (sel (or (calc-auto-selection entry) expr)) alg) (let ((str (math-showing-full-precision (math-format-nice-expr sel (screen-width))))) (calc-edit-mode (list 'calc-finish-selection-edit num (list 'quote sel) reselect)) (insert str "\n")))) (calc-show-edit-buffer) ) (defun calc-finish-selection-edit (num sel reselect) (let ((buf (current-buffer)) (str (buffer-substring (point) (point-max))) (start (point))) (switch-to-buffer calc-original-buffer) (let ((val (math-read-expr str))) (if (eq (car-safe val) 'error) (progn (switch-to-buffer buf) (goto-char (+ start (nth 1 val))) (error (nth 2 val)))) (calc-wrapper (calc-preserve-point) (if disp-trail (calc-trail-display 1 t)) (setq val (calc-encase-atoms (calc-normalize val))) (let ((expr (calc-top num 'full))) (if (calc-find-sub-formula expr sel) (calc-pop-push-record-list 1 "edit" (list (calc-replace-sub-formula expr sel val)) num (list (and reselect val))) (calc-push val) (error "Original selection has been lost")))))) ) (defun calc-sel-evaluate (arg) (interactive "p") (calc-slow-wrapper (calc-preserve-point) (let* ((num (max 1 (calc-locate-cursor-element (point)))) (reselect calc-keep-selection) (entry (calc-top num 'entry)) (sel (or (calc-auto-selection entry) (car entry)))) (calc-with-default-simplification (let ((math-simplify-only nil)) (calc-modify-simplify-mode arg) (let ((val (calc-encase-atoms (calc-normalize sel)))) (calc-pop-push-record-list 1 "jsmp" (list (calc-replace-sub-formula (car entry) sel val)) num (list (and reselect val)))))) (calc-handle-whys))) ) (defun calc-sel-expand-formula (arg) (interactive "p") (calc-slow-wrapper (calc-preserve-point) (let* ((num (max 1 (calc-locate-cursor-element (point)))) (reselect calc-keep-selection) (entry (calc-top num 'entry)) (sel (or (calc-auto-selection entry) (car entry)))) (calc-with-default-simplification (let ((math-simplify-only nil)) (calc-modify-simplify-mode arg) (let* ((math-expand-formulas (> arg 0)) (val (calc-normalize sel)) top) (and (<= arg 0) (setq top (math-expand-formula val)) (setq val (calc-normalize top))) (setq val (calc-encase-atoms val)) (calc-pop-push-record-list 1 "jexf" (list (calc-replace-sub-formula (car entry) sel val)) num (list (and reselect val)))))) (calc-handle-whys))) ) (defun calc-sel-mult-both-sides (no-simp &optional divide) (interactive "P") (calc-wrapper (calc-preserve-point) (let* ((num (max 1 (calc-locate-cursor-element (point)))) (reselect calc-keep-selection) (entry (calc-top num 'entry)) (expr (car entry)) (sel (or (calc-auto-selection entry) expr)) (func (car-safe sel)) alg lhs rhs) (setq alg (calc-with-default-simplification (car (calc-do-alg-entry "" (if divide "Divide both sides by: " "Multiply both sides by: "))))) (and alg (progn (if (and (or (eq func '/) (assq func calc-tweak-eqn-table)) (= (length sel) 3)) (progn (or (memq func '(/ calcFunc-eq calcFunc-neq)) (if (math-known-nonposp alg) (progn (setq func (nth 1 (assq func calc-tweak-eqn-table))) (or (math-known-negp alg) (message "Assuming this factor is nonzero"))) (or (math-known-posp alg) (if (math-known-nonnegp alg) (message "Assuming this factor is nonzero") (message "Assuming this factor is positive"))))) (setq lhs (list (if divide '/ '*) (nth 1 sel) alg) rhs (list (if divide '/ '*) (nth 2 sel) alg)) (or no-simp (progn (setq lhs (math-simplify lhs) rhs (math-simplify rhs)) (and (eq func '/) (or (Math-equal (nth 1 sel) 1) (Math-equal (nth 1 sel) -1) (and (memq (car-safe (nth 2 sel)) '(+ -)) (memq (car-safe alg) '(+ -)))) (setq rhs (math-expand-term rhs))))) (setq alg (calc-encase-atoms (calc-normalize (list func lhs rhs))))) (setq rhs (list (if divide '* '/) sel alg)) (or no-simp (setq rhs (math-simplify rhs))) (setq alg (calc-encase-atoms (calc-normalize (if divide (list '/ rhs alg) (list '* alg rhs)))))) (calc-pop-push-record-list 1 (if divide "div" "mult") (list (calc-replace-sub-formula expr sel alg)) num (list (and reselect alg))))) (calc-handle-whys))) ) (defun calc-sel-div-both-sides (no-simp) (interactive "P") (calc-sel-mult-both-sides no-simp t) ) (defun calc-sel-add-both-sides (no-simp &optional subtract) (interactive "P") (calc-wrapper (calc-preserve-point) (let* ((num (max 1 (calc-locate-cursor-element (point)))) (reselect calc-keep-selection) (entry (calc-top num 'entry)) (expr (car entry)) (sel (or (calc-auto-selection entry) expr)) (func (car-safe sel)) alg lhs rhs) (setq alg (calc-with-default-simplification (car (calc-do-alg-entry "" (if subtract "Subtract from both sides: " "Add to both sides: "))))) (and alg (progn (if (and (assq func calc-tweak-eqn-table) (= (length sel) 3)) (progn (setq lhs (list (if subtract '- '+) (nth 1 sel) alg) rhs (list (if subtract '- '+) (nth 2 sel) alg)) (or no-simp (setq lhs (math-simplify lhs) rhs (math-simplify rhs))) (setq alg (calc-encase-atoms (calc-normalize (list func lhs rhs))))) (setq rhs (list (if subtract '+ '-) sel alg)) (or no-simp (setq rhs (math-simplify rhs))) (setq alg (calc-encase-atoms (calc-normalize (list (if subtract '- '+) alg rhs))))) (calc-pop-push-record-list 1 (if subtract "sub" "add") (list (calc-replace-sub-formula expr sel alg)) num (list (and reselect alg))))) (calc-handle-whys))) ) (defun calc-sel-sub-both-sides (no-simp) (interactive "P") (calc-sel-add-both-sides no-simp t) ) calc-2.02c/calc-store.el100644 22403 13 45530 5547406515 13436 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-store.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-store () nil) ;;; Memory commands. (defun calc-store (&optional var) (interactive) (let ((calc-store-keep t)) (calc-store-into var)) ) (setq calc-store-keep nil) (defun calc-store-into (&optional var) (interactive) (calc-wrapper (let ((calc-given-value nil) (calc-given-value-flag 1)) (or var (setq var (calc-read-var-name "Store: " t))) (if var (let ((found (assq var '( ( + . calc-store-plus ) ( - . calc-store-minus ) ( * . calc-store-times ) ( / . calc-store-div ) ( ^ . calc-store-power ) ( | . calc-store-concat ) )))) (if found (funcall (cdr found)) (calc-store-value var (or calc-given-value (calc-top 1)) "" calc-given-value-flag) (message "Stored to variable \"%s\"" (calc-var-name var)))) (setq var (calc-is-assignments (calc-top 1))) (if var (while var (calc-store-value (car (car var)) (cdr (car var)) (if (not (cdr var)) "") (if (not (cdr var)) 1)) (setq var (cdr var))))))) ) (defun calc-store-plus (&optional var) (interactive) (calc-store-binary var "+" '+) ) (defun calc-store-minus (&optional var) (interactive) (calc-store-binary var "-" '-) ) (defun calc-store-times (&optional var) (interactive) (calc-store-binary var "*" '*) ) (defun calc-store-div (&optional var) (interactive) (calc-store-binary var "/" '/) ) (defun calc-store-power (&optional var) (interactive) (calc-store-binary var "^" '^) ) (defun calc-store-concat (&optional var) (interactive) (calc-store-binary var "|" '|) ) (defun calc-store-neg (n &optional var) (interactive "p") (calc-store-binary var "n" '/ (- n)) ) (defun calc-store-inv (n &optional var) (interactive "p") (calc-store-binary var "&" '^ (- n)) ) (defun calc-store-incr (n &optional var) (interactive "p") (calc-store-binary var "n" '- (- n)) ) (defun calc-store-decr (n &optional var) (interactive "p") (calc-store-binary var "n" '- n) ) (defun calc-store-value (var value tag &optional pop) (if var (let ((old (calc-var-value var))) (set var value) (if pop (or calc-store-keep (calc-pop-stack pop))) (calc-record-undo (list 'store (symbol-name var) old)) (if tag (let ((calc-full-trail-vectors nil)) (calc-record value (format ">%s%s" tag (calc-var-name var))))) (and (memq var '(var-e var-i var-pi var-phi var-gamma)) (eq (car-safe old) 'special-const) (message "(Note: Built-in definition of %s has been lost)" var)) (and (memq var '(var-inf var-uinf var-nan)) (null old) (message "(Note: %s has built-in meanings which may interfere)" var)) (calc-refresh-evaltos var))) ) (defun calc-var-name (var) (if (symbolp var) (setq var (symbol-name var))) (if (string-match "\\`var-." var) (substring var 4) var) ) (defun calc-store-binary (var tag func &optional val) (calc-wrapper (let ((calc-simplify-mode (if (eq calc-simplify-mode 'none) 'num calc-simplify-mode)) (value (or val (calc-top 1)))) (or var (setq var (calc-read-var-name (format "Store %s: " tag)))) (if var (let ((old (calc-var-value var))) (or old (error "No such variable: \"%s\"" (calc-var-name var))) (if (stringp old) (setq old (math-read-expr old))) (if (eq (car-safe old) 'error) (error "Bad format in variable contents: %s" (nth 2 old))) (calc-store-value var (calc-normalize (if (calc-is-inverse) (list func value old) (list func old value))) tag (and (not val) 1)) (message "Stored to variable \"%s\"" (calc-var-name var)))))) ) (defun calc-read-var-name (prompt &optional calc-store-opers) (setq calc-given-value nil calc-aborted-prefix nil) (let ((var (let ((minibuffer-completion-table obarray) (minibuffer-completion-predicate 'boundp) (minibuffer-completion-confirm t)) (read-from-minibuffer prompt "var-" calc-var-name-map nil)))) (setq calc-aborted-prefix "") (and (not (equal var "")) (not (equal var "var-")) (if (string-match "\\`\\([-a-zA-Z0-9]+\\) *:?=" var) (if (null calc-given-value-flag) (error "Assignment is not allowed in this command") (let ((svar (intern (substring var 0 (match-end 1))))) (setq calc-given-value-flag 0 calc-given-value (math-read-expr (substring var (match-end 0)))) (if (eq (car-safe calc-given-value) 'error) (error "Bad format: %s" (nth 2 calc-given-value))) (setq calc-given-value (math-evaluate-expr calc-given-value)) svar)) (intern var)))) ) (setq calc-given-value-flag nil) (defvar calc-var-name-map nil "Keymap for reading Calc variable names.") (if calc-var-name-map () (setq calc-var-name-map (copy-keymap minibuffer-local-completion-map)) (define-key calc-var-name-map " " 'self-insert-command) (mapcar (function (lambda (x) (define-key calc-var-name-map (char-to-string x) 'calcVar-digit))) "0123456789") (mapcar (function (lambda (x) (define-key calc-var-name-map (char-to-string x) 'calcVar-oper))) "+-*/^|") ) (defun calcVar-digit () (interactive) (if (calc-minibuffer-contains "var-\\'") (if (eq calc-store-opers 0) (beep) (insert "q") (self-insert-and-exit)) (self-insert-command 1)) ) (defun calcVar-oper () (interactive) (if (and (eq calc-store-opers t) (calc-minibuffer-contains "var-\\'")) (progn (erase-buffer) (self-insert-and-exit)) (self-insert-command 1)) ) (defun calc-store-map (&optional oper var) (interactive) (calc-wrapper (let* ((sel-mode nil) (calc-dollar-values (mapcar 'calc-get-stack-element (nthcdr calc-stack-top calc-stack))) (calc-dollar-used 0) (oper (or oper (calc-get-operator "Store Mapping"))) (nargs (car oper))) (or var (setq var (calc-read-var-name (format "Store Mapping %s: " (nth 2 oper))))) (if var (let ((old (or (calc-var-value var) (error "No such variable: \"%s\"" (calc-var-name var)))) (calc-simplify-mode (if (eq calc-simplify-mode 'none) 'num calc-simplify-mode)) (values (and (> nargs 1) (calc-top-list (1- nargs) (1+ calc-dollar-used))))) (message "Working...") (calc-set-command-flag 'clear-message) (if (stringp old) (setq old (math-read-expr old))) (if (eq (car-safe old) 'error) (error "Bad format in variable contents: %s" (nth 2 old))) (setq values (if (calc-is-inverse) (append values (list old)) (append (list old) values))) (calc-store-value var (calc-normalize (cons (nth 1 oper) values)) (nth 2 oper) (+ calc-dollar-used (1- nargs))))))) ) (defun calc-store-exchange (&optional var) (interactive) (calc-wrapper (let ((calc-given-value nil) (calc-given-value-flag 1) top) (or var (setq var (calc-read-var-name "Exchange with: "))) (if var (let ((value (calc-var-value var))) (or value (error "No such variable: \"%s\"" (calc-var-name var))) (if (eq (car-safe value) 'special-const) (error "%s is a special constant" var)) (setq top (or calc-given-value (calc-top 1))) (calc-store-value var top nil) (calc-pop-push-record calc-given-value-flag (concat "<>" (calc-var-name var)) value))))) ) (defun calc-unstore (&optional var) (interactive) (calc-wrapper (or var (setq var (calc-read-var-name "Unstore: "))) (if var (progn (and (memq var '(var-e var-i var-pi var-phi var-gamma)) (eq (car-safe (calc-var-value var)) 'special-const) (message "(Note: Built-in definition of %s has been lost)" var)) (if (and (boundp var) (symbol-value var)) (message "Unstored variable \"%s\"" (calc-var-name var)) (message "Variable \"%s\" remains unstored" (calc-var-name var))) (makunbound var) (calc-refresh-evaltos var)))) ) (defun calc-let (&optional var) (interactive) (calc-wrapper (let* ((calc-given-value nil) (calc-given-value-flag 1) thing value) (or var (setq var (calc-read-var-name "Let variable: "))) (if calc-given-value (setq value calc-given-value thing (calc-top 1)) (setq value (calc-top 1) thing (calc-top 2))) (setq var (if var (list (cons var value)) (calc-is-assignments value))) (if var (calc-pop-push-record (1+ calc-given-value-flag) (concat "=" (calc-var-name (car (car var)))) (let ((saved-val (mapcar (function (lambda (v) (and (boundp (car v)) (symbol-value (car v))))) var))) (unwind-protect (let ((vv var)) (while vv (set (car (car vv)) (calc-normalize (cdr (car vv)))) (calc-refresh-evaltos (car (car vv))) (setq vv (cdr vv))) (math-evaluate-expr thing)) (while saved-val (if (car saved-val) (set (car (car var)) (car saved-val)) (makunbound (car (car var)))) (setq saved-val (cdr saved-val) var (cdr var))) (calc-handle-whys))))))) ) (defun calc-is-assignments (value) (if (memq (car-safe value) '(calcFunc-eq calcFunc-assign)) (and (eq (car-safe (nth 1 value)) 'var) (list (cons (nth 2 (nth 1 value)) (nth 2 value)))) (if (eq (car-safe value) 'vec) (let ((vv nil)) (while (and (setq value (cdr value)) (memq (car-safe (car value)) '(calcFunc-eq calcFunc-assign)) (eq (car-safe (nth 1 (car value))) 'var)) (setq vv (cons (cons (nth 2 (nth 1 (car value))) (nth 2 (car value))) vv))) (and (not value) vv)))) ) (defun calc-recall (&optional var) (interactive) (calc-wrapper (or var (setq var (calc-read-var-name "Recall: "))) (if var (let ((value (calc-var-value var))) (or value (error "No such variable: \"%s\"" (calc-var-name var))) (if (stringp value) (setq value (math-read-expr value))) (if (eq (car-safe value) 'error) (error "Bad format in variable contents: %s" (nth 2 value))) (setq value (calc-normalize value)) (let ((calc-full-trail-vectors nil)) (calc-record value (concat "<" (calc-var-name var)))) (calc-push value)))) ) (defun calc-store-quick () (interactive) (calc-store (intern (format "var-q%c" last-command-char))) ) (defun calc-store-into-quick () (interactive) (calc-store-into (intern (format "var-q%c" last-command-char))) ) (defun calc-recall-quick () (interactive) (calc-recall (intern (format "var-q%c" last-command-char))) ) (defun calc-copy-variable (&optional var1 var2) (interactive) (calc-wrapper (or var1 (setq var1 (calc-read-var-name "Copy variable: "))) (if var1 (let ((value (calc-var-value var1))) (or value (error "No such variable: \"%s\"" (calc-var-name var))) (or var2 (setq var2 (calc-read-var-name (format "Copy variable: %s, to: " var1)))) (if var2 (calc-store-value var2 value ""))))) ) (defun calc-edit-variable (&optional var) (interactive) (calc-wrapper (or var (setq var (calc-read-var-name (if calc-last-edited-variable (format "Edit: (default %s) " (calc-var-name calc-last-edited-variable)) "Edit: ")))) (or var (setq var calc-last-edited-variable)) (if var (let* ((value (calc-var-value var))) (if (eq (car-safe value) 'special-const) (error "%s is a special constant" var)) (setq calc-last-edited-variable var) (calc-edit-mode (list 'calc-finish-stack-edit (list 'quote var)) t (concat "Editing " (calc-var-name var))) (and value (insert (math-format-nice-expr value (screen-width)) "\n"))))) (calc-show-edit-buffer) ) (setq calc-last-edited-variable nil) (defun calc-edit-Decls () (interactive) (calc-edit-variable 'var-Decls) ) (defun calc-edit-EvalRules () (interactive) (calc-edit-variable 'var-EvalRules) ) (defun calc-edit-FitRules () (interactive) (calc-edit-variable 'var-FitRules) ) (defun calc-edit-GenCount () (interactive) (calc-edit-variable 'var-GenCount) ) (defun calc-edit-Holidays () (interactive) (calc-edit-variable 'var-Holidays) ) (defun calc-edit-IntegLimit () (interactive) (calc-edit-variable 'var-IntegLimit) ) (defun calc-edit-LineStyles () (interactive) (calc-edit-variable 'var-LineStyles) ) (defun calc-edit-PointStyles () (interactive) (calc-edit-variable 'var-PointStyles) ) (defun calc-edit-PlotRejects () (interactive) (calc-edit-variable 'var-PlotRejects) ) (defun calc-edit-AlgSimpRules () (interactive) (calc-edit-variable 'var-AlgSimpRules) ) (defun calc-edit-TimeZone () (interactive) (calc-edit-variable 'var-TimeZone) ) (defun calc-edit-Units () (interactive) (calc-edit-variable 'var-Units) ) (defun calc-edit-ExtSimpRules () (interactive) (calc-edit-variable 'var-ExtSimpRules) ) (defun calc-declare-variable (&optional var) (interactive) (calc-wrapper (or var (setq var (calc-read-var-name "Declare: " 0))) (or var (setq var 'var-All)) (let* (dp decl def row rp) (or (and (calc-var-value 'var-Decls) (eq (car-safe var-Decls) 'vec)) (setq var-Decls (list 'vec))) (setq dp var-Decls) (while (and (setq dp (cdr dp)) (or (not (eq (car-safe (car dp)) 'vec)) (/= (length (car dp)) 3) (progn (setq row (nth 1 (car dp)) rp row) (if (eq (car-safe row) 'vec) (progn (while (and (setq rp (cdr rp)) (or (not (eq (car-safe (car rp)) 'var)) (not (eq (nth 2 (car rp)) var))))) (setq rp (car rp))) (if (or (not (eq (car-safe row) 'var)) (not (eq (nth 2 row) var))) (setq rp nil))) (not rp))))) (calc-unread-command ?\C-a) (setq decl (read-string (format "Declare: %s to be: " var) (and rp (math-format-flat-expr (nth 2 (car dp)) 0)))) (setq decl (and (string-match "[^ \t]" decl) (math-read-exprs decl))) (if (eq (car-safe decl) 'error) (error "Bad format in declaration: %s" (nth 2 decl))) (if (cdr decl) (setq decl (cons 'vec decl)) (setq decl (car decl))) (and (eq (car-safe decl) 'vec) (= (length decl) 2) (setq decl (nth 1 decl))) (calc-record (append '(vec) (list (math-build-var-name var)) (and decl (list decl))) "decl") (setq var-Decls (copy-sequence var-Decls)) (if (eq (car-safe row) 'vec) (progn (setcdr row (delq rp (cdr row))) (or (cdr row) (setq var-Decls (delq (car dp) var-Decls)))) (setq var-Decls (delq (car dp) var-Decls))) (if decl (progn (setq dp (and (not (eq var 'var-All)) var-Decls)) (while (and (setq dp (cdr dp)) (or (not (eq (car-safe (car dp)) 'vec)) (/= (length (car dp)) 3) (not (equal (nth 2 (car dp)) decl))))) (if dp (setcar (cdr (car dp)) (append (if (eq (car-safe (nth 1 (car dp))) 'vec) (nth 1 (car dp)) (list 'vec (nth 1 (car dp)))) (list (math-build-var-name var)))) (setq var-Decls (append var-Decls (list (list 'vec (math-build-var-name var) decl))))))) (calc-refresh-evaltos 'var-Decls))) ) (defun calc-permanent-variable (&optional var) (interactive) (calc-wrapper (or var (setq var (calc-read-var-name "Save variable (default=all): "))) (let (pos) (and var (or (and (boundp var) (symbol-value var)) (error "No such variable"))) (set-buffer (find-file-noselect (substitute-in-file-name calc-settings-file))) (if var (calc-insert-permanent-variable var) (mapatoms (function (lambda (x) (and (string-match "\\`var-" (symbol-name x)) (not (memq x calc-dont-insert-variables)) (calc-var-value x) (not (eq (car-safe (symbol-value x)) 'special-const)) (calc-insert-permanent-variable x)))))) (save-buffer))) ) (defvar calc-dont-insert-variables '(var-FitRules var-FactorRules var-CommuteRules var-JumpRules var-DistribRules var-MergeRules var-NegateRules var-InvertRules var-IntegAfterRules var-TimeZone var-PlotRejects var-PlotData1 var-PlotData2 var-PlotData3 var-PlotData4 var-PlotData5 var-PlotData6 var-DUMMY )) (defun calc-insert-permanent-variable (var) (goto-char (point-min)) (if (search-forward (concat "(setq " (symbol-name var) " '") nil t) (progn (setq pos (point-marker)) (forward-line -1) (if (looking-at ";;; Variable .* stored by Calc on ") (progn (delete-region (match-end 0) (progn (end-of-line) (point))) (insert (current-time-string)))) (goto-char (- pos 8 (length (symbol-name var)))) (forward-sexp 1) (backward-char 1) (delete-region pos (point))) (goto-char (point-max)) (insert "\n;;; Variable \"" (symbol-name var) "\" stored by Calc on " (current-time-string) "\n(setq " (symbol-name var) " ')\n") (backward-char 2)) (insert (prin1-to-string (calc-var-value var))) (forward-line 1) ) (defun calc-insert-variables (buf) (interactive "bBuffer in which to save variable values: ") (save-excursion (set-buffer buf) (mapatoms (function (lambda (x) (and (string-match "\\`var-" (symbol-name x)) (not (memq x calc-dont-insert-variables)) (calc-var-value x) (not (eq (car-safe (symbol-value x)) 'special-const)) (or (not (eq x 'var-Decls)) (not (equal var-Decls '(vec)))) (or (not (eq x 'var-Holidays)) (not (equal var-Holidays '(vec (var sat var-sat) (var sun var-sun))))) (insert "(setq " (symbol-name x) " " (prin1-to-string (let ((calc-language (if (memq calc-language '(nil big)) 'flat calc-language))) (math-format-value (symbol-value x) 100000))) ")\n")))))) ) (defun calc-assign (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op ":=" 'calcFunc-assign arg)) ) (defun calc-evalto (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "=>" 'calcFunc-evalto arg)) ) (defun calc-subscript (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "sub" 'calcFunc-subscr arg)) ) calc-2.02c/calc-yank.el100644 22403 13 42641 5402631022 13223 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-yank.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-yank () nil) ;;; Kill ring commands. (defun calc-kill (nn &optional no-delete) (interactive "P") (if (eq major-mode 'calc-mode) (calc-wrapper (calc-force-refresh) (calc-set-command-flag 'no-align) (let ((num (max (calc-locate-cursor-element (point)) 1)) (n (prefix-numeric-value nn))) (if (< n 0) (progn (if (eobp) (setq num (1- num))) (setq num (- num n) n (- n)))) (let ((stuff (calc-top-list n (- num n -1)))) (calc-cursor-stack-index num) (let ((first (point))) (calc-cursor-stack-index (- num n)) (if (null nn) (backward-char 1)) ; don't include newline for raw C-k (copy-region-as-kill first (point)) (if (not no-delete) (calc-pop-stack n (- num n -1)))) (setq calc-last-kill (cons (car kill-ring) stuff))))) (kill-line nn)) ) (defun calc-force-refresh () (if (or calc-executing-macro calc-display-dirty) (let ((calc-executing-macro nil)) (calc-refresh))) ) (defun calc-locate-cursor-element (pt) (save-excursion (goto-char (point-max)) (calc-locate-cursor-scan (- calc-stack-top) calc-stack pt)) ) (defun calc-locate-cursor-scan (n stack pt) (if (or (<= (point) pt) (null stack)) n (forward-line (- (nth 1 (car stack)))) (calc-locate-cursor-scan (1+ n) (cdr stack) pt)) ) (defun calc-kill-region (top bot &optional no-delete) (interactive "r") (if (eq major-mode 'calc-mode) (calc-wrapper (calc-force-refresh) (calc-set-command-flag 'no-align) (let* ((top-num (calc-locate-cursor-element top)) (bot-num (calc-locate-cursor-element (1- bot))) (num (- top-num bot-num -1))) (copy-region-as-kill top bot) (setq calc-last-kill (cons (car kill-ring) (calc-top-list num bot-num))) (if (not no-delete) (calc-pop-stack num bot-num)))) (if no-delete (copy-region-as-kill top bot) (kill-region top bot))) ) (defun calc-copy-as-kill (n) (interactive "P") (calc-kill n t) ) (defun calc-copy-region-as-kill (top bot) (interactive "r") (calc-kill-region top bot t) ) ;;; This function uses calc-last-kill if possible to get an exact result, ;;; otherwise it just parses the yanked string. (defun calc-yank () (interactive) (calc-wrapper (calc-pop-push-record-list 0 "yank" (if (eq (car-safe calc-last-kill) (car kill-ring-yank-pointer)) (cdr calc-last-kill) (if (stringp (car kill-ring-yank-pointer)) (let ((val (math-read-exprs (calc-clean-newlines (car kill-ring-yank-pointer))))) (if (eq (car-safe val) 'error) (progn (setq val (math-read-exprs (car kill-ring-yank-pointer))) (if (eq (car-safe val) 'error) (error "Bad format in yanked data") val)) val)))))) ) (defun calc-clean-newlines (s) (cond ;; Omit leading/trailing whitespace ((or (string-match "\\`[ \n\r]+\\([^\001]*\\)\\'" s) (string-match "\\`\\([^\001]*\\)[ \n\r]+\\'" s)) (calc-clean-newlines (math-match-substring s 1))) ;; Convert newlines to commas ((string-match "\\`\\(.*\\)[\n\r]+\\([^\001]*\\)\\'" s) (calc-clean-newlines (concat (math-match-substring s 1) "," (math-match-substring s 2)))) (t s)) ) (defun calc-do-grab-region (top bot arg) (and (memq major-mode '(calc-mode calc-trail-mode)) (error "This command works only in a regular text buffer.")) (let* ((from-buffer (current-buffer)) (calc-was-started (get-buffer-window "*Calculator*")) (single nil) data vals pos) (if arg (if (consp arg) (setq single t) (setq arg (prefix-numeric-value arg)) (if (= arg 0) (save-excursion (beginning-of-line) (setq top (point)) (end-of-line) (setq bot (point))) (save-excursion (setq top (point)) (forward-line arg) (if (> arg 0) (setq bot (point)) (setq bot top top (point))))))) (setq data (buffer-substring top bot)) (calc) (if single (setq vals (math-read-expr data)) (setq vals (math-read-expr (concat "[" data "]"))) (and (eq (car-safe vals) 'vec) (= (length vals) 2) (eq (car-safe (nth 1 vals)) 'vec) (setq vals (nth 1 vals)))) (if (eq (car-safe vals) 'error) (progn (if calc-was-started (pop-to-buffer from-buffer) (calc-quit t) (switch-to-buffer from-buffer)) (goto-char top) (forward-char (+ (nth 1 vals) (if single 0 1))) (error (nth 2 vals)))) (calc-slow-wrapper (calc-enter-result 0 "grab" vals))) ) (defun calc-do-grab-rectangle (top bot arg &optional reduce) (and (memq major-mode '(calc-mode calc-trail-mode)) (error "This command works only in a regular text buffer.")) (let* ((col1 (save-excursion (goto-char top) (current-column))) (col2 (save-excursion (goto-char bot) (current-column))) (from-buffer (current-buffer)) (calc-was-started (get-buffer-window "*Calculator*")) data mat vals lnum pt pos) (if (= col1 col2) (save-excursion (or (= col1 0) (error "Point and mark must be at beginning of line, or define a rectangle")) (goto-char top) (while (< (point) bot) (setq pt (point)) (forward-line 1) (setq data (cons (buffer-substring pt (1- (point))) data))) (setq data (nreverse data))) (setq data (extract-rectangle top bot))) (calc) (setq mat (list 'vec) lnum 0) (and arg (setq arg (if (consp arg) 0 (prefix-numeric-value arg)))) (while data (if (natnump arg) (progn (if (= arg 0) (setq arg 1000000)) (setq pos 0 vals (list 'vec)) (let ((w (length (car data))) j v) (while (< pos w) (setq j (+ pos arg) v (if (>= j w) (math-read-expr (substring (car data) pos)) (math-read-expr (substring (car data) pos j)))) (if (eq (car-safe v) 'error) (setq vals v w 0) (setq vals (nconc vals (list v)) pos j))))) (if (string-match "\\` *-?[0-9][0-9]?[0-9]?[0-9]?[0-9]?[0-9]? *\\'" (car data)) (setq vals (list 'vec (string-to-int (car data)))) (if (and (null arg) (string-match "[[{][^][{}]*[]}]" (car data))) (setq pos (match-beginning 0) vals (math-read-expr (math-match-substring (car data) 0))) (let ((s (if (string-match "\\`\\([0-9]+:[ \t]\\)?\\(.*[^, \t]\\)[, \t]*\\'" (car data)) (math-match-substring (car data) 2) (car data)))) (setq pos -1 vals (math-read-expr (concat "[" s "]"))) (if (eq (car-safe vals) 'error) (let ((v2 (math-read-expr s))) (or (eq (car-safe v2) 'error) (setq vals (list 'vec v2))))))))) (if (eq (car-safe vals) 'error) (progn (if calc-was-started (pop-to-buffer from-buffer) (calc-quit t) (switch-to-buffer from-buffer)) (goto-char top) (forward-line lnum) (forward-char (+ (nth 1 vals) (min col1 col2) pos)) (error (nth 2 vals)))) (or (equal vals '(vec)) (setq mat (cons vals mat))) (setq data (cdr data) lnum (1+ lnum))) (calc-slow-wrapper (if reduce (calc-enter-result 0 "grb+" (list reduce '(var add var-add) (nreverse mat))) (calc-enter-result 0 "grab" (nreverse mat))))) ) (defun calc-copy-to-buffer (nn) "Copy the top of stack into an editing buffer." (interactive "P") (let ((thebuf (and (not (memq major-mode '(calc-mode calc-trail-mode))) (current-buffer))) (movept nil) oldbuf newbuf) (calc-wrapper (save-excursion (calc-force-refresh) (let ((n (prefix-numeric-value nn)) (eat-lnums calc-line-numbering) (big-offset (if (eq calc-language 'big) 1 0)) top bot) (setq oldbuf (current-buffer) newbuf (or thebuf (calc-find-writable-buffer (buffer-list) 0) (calc-find-writable-buffer (buffer-list) 1) (error "No other buffer"))) (cond ((and (or (null nn) (consp nn)) (= (calc-substack-height 0) (- (1- (calc-substack-height 1)) big-offset))) (calc-cursor-stack-index 1) (if (looking-at (if calc-line-numbering "[0-9]+: *[^ \n]" " *[^ \n]")) (goto-char (1- (match-end 0)))) (setq eat-lnums nil top (point)) (calc-cursor-stack-index 0) (setq bot (- (1- (point)) big-offset))) ((> n 0) (calc-cursor-stack-index n) (setq top (point)) (calc-cursor-stack-index 0) (setq bot (- (point) big-offset))) ((< n 0) (calc-cursor-stack-index (- n)) (setq top (point)) (calc-cursor-stack-index (1- (- n))) (setq bot (point))) (t (goto-char (point-min)) (forward-line 1) (setq top (point)) (calc-cursor-stack-index 0) (setq bot (point)))) (save-excursion (set-buffer newbuf) (if (consp nn) (kill-region (region-beginning) (region-end))) (push-mark (point) t) (if (and overwrite-mode (not (consp nn))) (calc-overwrite-string (save-excursion (set-buffer oldbuf) (buffer-substring top bot)) eat-lnums) (or (bolp) (setq eat-lnums nil)) (insert-buffer-substring oldbuf top bot) (and eat-lnums (let ((n 1)) (while (and (> (point) (mark)) (progn (forward-line -1) (>= (point) (mark)))) (delete-char 4) (setq n (1+ n))) (forward-line n)))) (if thebuf (setq movept (point))) (if (get-buffer-window (current-buffer)) (set-window-point (get-buffer-window (current-buffer)) (point))))))) (if movept (goto-char movept)) (and (consp nn) (not thebuf) (progn (calc-quit t) (switch-to-buffer newbuf)))) ) (defun calc-overwrite-string (str eat-lnums) (if (string-match "\n\\'" str) (setq str (substring str 0 -1))) (if eat-lnums (setq str (substring str 4))) (if (and (string-match "\\`[-+]?[0-9.]+\\(e-?[0-9]+\\)?\\'" str) (looking-at "[-+]?[0-9.]+\\(e-?[0-9]+\\)?")) (progn (delete-region (point) (match-end 0)) (insert str)) (let ((i 0)) (while (< i (length str)) (if (= (setq last-command-char (aref str i)) ?\n) (or (= i (1- (length str))) (let ((pt (point))) (end-of-line) (delete-region pt (point)) (if (eobp) (insert "\n") (forward-char 1)) (if eat-lnums (setq i (+ i 4))))) (self-insert-command 1)) (setq i (1+ i))))) ) ;;; First, require that buffer is visible and does not begin with "*" ;;; Second, require only that it not begin with "*Calc" (defun calc-find-writable-buffer (buf mode) (and buf (if (or (string-match "\\`\\( .*\\|\\*Calc.*\\)" (buffer-name (car buf))) (and (= mode 0) (or (string-match "\\`\\*.*" (buffer-name (car buf))) (not (get-buffer-window (car buf)))))) (calc-find-writable-buffer (cdr buf) mode) (car buf))) ) (defun calc-edit (n) (interactive "p") (calc-slow-wrapper (if (eq n 0) (setq n (calc-stack-size))) (let* ((flag nil) (allow-ret (> n 1)) (list (math-showing-full-precision (mapcar (if (> n 1) (function (lambda (x) (math-format-flat-expr x 0))) (function (lambda (x) (if (math-vectorp x) (setq allow-ret t)) (math-format-nice-expr x (screen-width))))) (if (> n 0) (calc-top-list n) (calc-top-list 1 (- n))))))) (calc-edit-mode (list 'calc-finish-stack-edit (or flag n)) allow-ret) (while list (insert (car list) "\n") (setq list (cdr list))))) (calc-show-edit-buffer) ) (defun calc-alg-edit (str) (calc-edit-mode '(calc-finish-stack-edit 0)) (calc-show-edit-buffer) (insert str "\n") (backward-char 1) (calc-set-command-flag 'do-edit) ) (defvar calc-edit-mode-map nil "Keymap for use by the calc-edit command.") (if calc-edit-mode-map () (setq calc-edit-mode-map (make-sparse-keymap)) (define-key calc-edit-mode-map "\n" 'calc-edit-finish) (define-key calc-edit-mode-map "\r" 'calc-edit-return) (define-key calc-edit-mode-map "\C-c\C-c" 'calc-edit-finish) ) (defun calc-edit-mode (&optional handler allow-ret title) "Calculator editing mode. Press RET, LFD, or C-c C-c to finish. To cancel the edit, simply kill the *Calc Edit* buffer." (interactive) (or handler (error "This command can be used only indirectly through calc-edit.")) (let ((oldbuf (current-buffer)) (buf (get-buffer-create "*Calc Edit*"))) (set-buffer buf) (kill-all-local-variables) (use-local-map calc-edit-mode-map) (setq buffer-read-only nil) (setq truncate-lines nil) (setq major-mode 'calc-edit-mode) (setq mode-name "Calc Edit") (run-hooks 'calc-edit-mode-hook) (make-local-variable 'calc-original-buffer) (setq calc-original-buffer oldbuf) (make-local-variable 'calc-return-buffer) (setq calc-return-buffer oldbuf) (make-local-variable 'calc-one-window) (setq calc-one-window (and (one-window-p t) pop-up-windows)) (make-local-variable 'calc-edit-handler) (setq calc-edit-handler handler) (make-local-variable 'calc-restore-trail) (setq calc-restore-trail (get-buffer-window (calc-trail-buffer))) (make-local-variable 'calc-allow-ret) (setq calc-allow-ret allow-ret) (erase-buffer) (insert (or title title "Calc Edit Mode") ". Press " (if (eq (lookup-key (current-global-map) "\e#") 'calc-dispatch) "M-# M-# or C-c C-c" (if allow-ret "C-c C-c" "RET")) " to finish, " (if (eq (lookup-key (current-global-map) "\e#") 'calc-dispatch) "M-# x" "C-x k RET") " to cancel.\n")) ) (put 'calc-edit-mode 'mode-class 'special) (defun calc-show-edit-buffer () (let ((buf (current-buffer))) (if (and (one-window-p t) pop-up-windows) (pop-to-buffer (get-buffer-create "*Calc Edit*")) (and calc-embedded-info (get-buffer-window (aref calc-embedded-info 1)) (select-window (get-buffer-window (aref calc-embedded-info 1)))) (switch-to-buffer (get-buffer-create "*Calc Edit*"))) (setq calc-return-buffer buf) (if (and (< (window-width) (screen-width)) calc-display-trail) (let ((win (get-buffer-window (calc-trail-buffer)))) (if win (delete-window win)))) (set-buffer-modified-p nil) (goto-char (point-min)) (forward-line 1)) ) (defun calc-edit-return () (interactive) (if (and (boundp 'calc-allow-ret) calc-allow-ret) (newline) (calc-edit-finish)) ) (defun calc-edit-finish (&optional keep) "Finish calc-edit mode. Parse buffer contents and push them on the stack." (interactive "P") (message "Working...") (or (and (boundp 'calc-original-buffer) (boundp 'calc-return-buffer) (boundp 'calc-one-window) (boundp 'calc-edit-handler) (boundp 'calc-restore-trail) (eq major-mode 'calc-edit-mode)) (error "This command is valid only in buffers created by calc-edit.")) (let ((buf (current-buffer)) (original calc-original-buffer) (return calc-return-buffer) (one-window calc-one-window) (disp-trail calc-restore-trail)) (save-excursion (if (or (null (buffer-name original)) (progn (set-buffer original) (not (eq major-mode 'calc-mode)))) (error "Original calculator buffer has been corrupted."))) (goto-char (point-min)) (if (looking-at "Calc Edit\\|Editing ") (forward-line 1)) (if (buffer-modified-p) (eval calc-edit-handler)) (if one-window (delete-window)) (if (get-buffer-window return) (select-window (get-buffer-window return)) (switch-to-buffer return)) (if keep (bury-buffer buf) (kill-buffer buf)) (if disp-trail (calc-wrapper (calc-trail-display 1 t))) (message "")) ) (defun calc-edit-cancel () "Cancel calc-edit mode. Ignore the Calc Edit buffer and don't change stack." (interactive) (let ((calc-edit-handler nil)) (calc-edit-finish)) (message "(Cancelled)") ) (defun calc-finish-stack-edit (num) (let ((buf (current-buffer)) (str (buffer-substring (point) (point-max))) (start (point)) pos) (if (and (integerp num) (> num 1)) (while (setq pos (string-match "\n." str)) (aset str pos ?\,))) (switch-to-buffer calc-original-buffer) (let ((vals (let ((calc-language nil) (math-expr-opers math-standard-opers)) (and (string-match "[^\n\t ]" str) (math-read-exprs str))))) (if (eq (car-safe vals) 'error) (progn (switch-to-buffer buf) (goto-char (+ start (nth 1 vals))) (error (nth 2 vals)))) (calc-wrapper (if (symbolp num) (progn (set num (car vals)) (calc-refresh-evaltos num)) (if disp-trail (calc-trail-display 1 t)) (and vals (let ((calc-simplify-mode (if (eq last-command-char ?\C-j) 'none calc-simplify-mode))) (if (>= num 0) (calc-enter-result num "edit" vals) (calc-enter-result 1 "edit" vals (- num))))))))) ) calc-2.02c/calc-sel-2.el100644 22403 13 21674 5402630735 13220 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-sel-2.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-sel-2 () nil) (defun calc-commute-left (arg) (interactive "p") (if (< arg 0) (calc-commute-right (- arg)) (calc-wrapper (calc-preserve-point) (let ((num (max 1 (calc-locate-cursor-element (point)))) (reselect calc-keep-selection)) (if (= arg 0) (setq arg nil)) (while (or (null arg) (>= (setq arg (1- arg)) 0)) (let* ((entry (calc-top num 'entry)) (expr (car entry)) (sel (calc-auto-selection entry)) parent new) (or (and sel (consp (setq parent (calc-find-assoc-parent-formula expr sel)))) (error "No term is selected")) (if (and calc-assoc-selections (assq (car parent) calc-assoc-ops)) (let ((outer (calc-find-parent-formula parent sel))) (if (eq sel (nth 2 outer)) (setq new (calc-replace-sub-formula parent outer (cond ((memq (car outer) (nth 1 (assq (car-safe (nth 1 outer)) calc-assoc-ops))) (let* ((other (nth 2 (nth 1 outer))) (new (calc-build-assoc-term (car (nth 1 outer)) (calc-build-assoc-term (car outer) (nth 1 (nth 1 outer)) sel) other))) (setq sel (nth 2 (nth 1 new))) new)) ((eq (car outer) '-) (calc-build-assoc-term '+ (setq sel (math-neg sel)) (nth 1 outer))) ((eq (car outer) '/) (calc-build-assoc-term '* (setq sel (calcFunc-div 1 sel)) (nth 1 outer))) (t (calc-build-assoc-term (car outer) sel (nth 1 outer)))))) (let ((next (calc-find-parent-formula parent outer))) (if (not (and (consp next) (eq outer (nth 2 next)) (eq (car next) (car outer)))) (setq new nil) (setq new (calc-build-assoc-term (car next) sel (calc-build-assoc-term (car next) (nth 1 next) (nth 2 outer))) sel (nth 1 new) new (calc-replace-sub-formula parent next new)))))) (if (eq (nth 1 parent) sel) (setq new nil) (let ((p (nthcdr (1- (calc-find-sub-formula parent sel)) (setq new (copy-sequence parent))))) (setcar (cdr p) (car p)) (setcar p sel)))) (if (null new) (if arg (error "Term is already leftmost") (or reselect (calc-pop-push-list 1 (list expr) num '(nil))) (setq arg 0)) (calc-pop-push-record-list 1 "left" (list (calc-replace-sub-formula expr parent new)) num (list (and (or (not (eq arg 0)) reselect) sel))))))))) ) (defun calc-commute-right (arg) (interactive "p") (if (< arg 0) (calc-commute-left (- arg)) (calc-wrapper (calc-preserve-point) (let ((num (max 1 (calc-locate-cursor-element (point)))) (reselect calc-keep-selection)) (if (= arg 0) (setq arg nil)) (while (or (null arg) (>= (setq arg (1- arg)) 0)) (let* ((entry (calc-top num 'entry)) (expr (car entry)) (sel (calc-auto-selection entry)) parent new) (or (and sel (consp (setq parent (calc-find-assoc-parent-formula expr sel)))) (error "No term is selected")) (if (and calc-assoc-selections (assq (car parent) calc-assoc-ops)) (let ((outer (calc-find-parent-formula parent sel))) (if (eq sel (nth 1 outer)) (setq new (calc-replace-sub-formula parent outer (if (memq (car outer) (nth 2 (assq (car-safe (nth 2 outer)) calc-assoc-ops))) (let ((other (nth 1 (nth 2 outer)))) (calc-build-assoc-term (car outer) other (calc-build-assoc-term (car (nth 2 outer)) sel (nth 2 (nth 2 outer))))) (let ((new (cond ((eq (car outer) '-) (calc-build-assoc-term '+ (math-neg (nth 2 outer)) sel)) ((eq (car outer) '/) (calc-build-assoc-term '* (calcFunc-div 1 (nth 2 outer)) sel)) (t (calc-build-assoc-term (car outer) (nth 2 outer) sel))))) (setq sel (nth 2 new)) new)))) (let ((next (calc-find-parent-formula parent outer))) (if (not (and (consp next) (eq outer (nth 1 next)))) (setq new nil) (setq new (calc-build-assoc-term (car outer) (calc-build-assoc-term (car next) (nth 1 outer) (nth 2 next)) sel) sel (nth 2 new) new (calc-replace-sub-formula parent next new)))))) (if (eq (nth (1- (length parent)) parent) sel) (setq new nil) (let ((p (nthcdr (calc-find-sub-formula parent sel) (setq new (copy-sequence parent))))) (setcar p (nth 1 p)) (setcar (cdr p) sel)))) (if (null new) (if arg (error "Term is already rightmost") (or reselect (calc-pop-push-list 1 (list expr) num '(nil))) (setq arg 0)) (calc-pop-push-record-list 1 "rght" (list (calc-replace-sub-formula expr parent new)) num (list (and (or (not (eq arg 0)) reselect) sel))))))))) ) (defun calc-build-assoc-term (op lhs rhs) (cond ((and (eq op '+) (or (math-looks-negp rhs) (and (eq (car-safe rhs) 'cplx) (math-negp (nth 1 rhs)) (eq (nth 2 rhs) 0)))) (list '- lhs (math-neg rhs))) ((and (eq op '-) (or (math-looks-negp rhs) (and (eq (car-safe rhs) 'cplx) (math-negp (nth 1 rhs)) (eq (nth 2 rhs) 0)))) (list '+ lhs (math-neg rhs))) ((and (eq op '*) (and (eq (car-safe rhs) '/) (or (math-equal-int (nth 1 rhs) 1) (equal (nth 1 rhs) '(cplx 1 0))))) (list '/ lhs (nth 2 rhs))) ((and (eq op '/) (and (eq (car-safe rhs) '/) (or (math-equal-int (nth 1 rhs) 1) (equal (nth 1 rhs) '(cplx 1 0))))) (list '/ lhs (nth 2 rhs))) (t (list op lhs rhs))) ) (defun calc-sel-unpack () (interactive) (calc-wrapper (calc-preserve-point) (let* ((num (max 1 (calc-locate-cursor-element (point)))) (reselect calc-keep-selection) (entry (calc-top num 'entry)) (expr (car entry)) (sel (or (calc-auto-selection entry) expr))) (or (and (not (math-primp sel)) (= (length sel) 2)) (error "Selection must be a function of one argument")) (calc-pop-push-record-list 1 "unpk" (list (calc-replace-sub-formula expr sel (nth 1 sel))) num (list (and reselect (nth 1 sel)))))) ) (defun calc-sel-isolate () (interactive) (calc-slow-wrapper (calc-preserve-point) (let* ((num (max 1 (calc-locate-cursor-element (point)))) (reselect calc-keep-selection) (entry (calc-top num 'entry)) (expr (car entry)) (sel (or (calc-auto-selection entry) (error "No selection"))) (eqn sel) soln) (while (and (or (consp (setq eqn (calc-find-parent-formula expr eqn))) (error "Selection must be a member of an equation")) (not (assq (car eqn) calc-tweak-eqn-table)))) (setq soln (math-solve-eqn eqn sel calc-hyperbolic-flag)) (or soln (error "No solution found")) (setq soln (calc-encase-atoms (if (eq (not (calc-find-sub-formula (nth 2 eqn) sel)) (eq (nth 1 soln) sel)) soln (list (nth 1 (assq (car soln) calc-tweak-eqn-table)) (nth 2 soln) (nth 1 soln))))) (calc-pop-push-record-list 1 "isol" (list (calc-replace-sub-formula expr eqn soln)) num (list (and reselect sel))) (calc-handle-whys))) ) (defun calc-sel-commute (many) (interactive "P") (let ((calc-assoc-selections nil)) (calc-rewrite-selection "CommuteRules" many "cmut")) (calc-set-mode-line) ) (defun calc-sel-jump-equals (many) (interactive "P") (calc-rewrite-selection "JumpRules" many "jump") ) (defun calc-sel-distribute (many) (interactive "P") (calc-rewrite-selection "DistribRules" many "dist") ) (defun calc-sel-merge (many) (interactive "P") (calc-rewrite-selection "MergeRules" many "merg") ) (defun calc-sel-negate (many) (interactive "P") (calc-rewrite-selection "NegateRules" many "jneg") ) (defun calc-sel-invert (many) (interactive "P") (calc-rewrite-selection "InvertRules" many "jinv") ) calc-2.02c/calc-rules.el100644 22403 13 42026 5402630731 13416 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-rules.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-rules () nil) (defun calc-compile-rule-set (name rules) (prog2 (message "Preparing rule set %s..." name) (math-read-plain-expr rules t) (message "Preparing rule set %s...done" name)) ) (defun calc-CommuteRules () "CommuteRules" (calc-compile-rule-set "CommuteRules" "[ iterations(1), select(plain(a + b)) := select(plain(b + a)), select(plain(a - b)) := select(plain((-b) + a)), select(plain((1/a) * b)) := select(b / a), select(plain(a * b)) := select(b * a), select((1/a) / b) := select((1/b) / a), select(a / b) := select((1/b) * a), select((a^b) ^ c) := select((a^c) ^ b), select(log(a, b)) := select(1 / log(b, a)), select(plain(a && b)) := select(b && a), select(plain(a || b)) := select(b || a), select(plain(a = b)) := select(b = a), select(plain(a != b)) := select(b != a), select(a < b) := select(b > a), select(a > b) := select(b < a), select(a <= b) := select(b >= a), select(a >= b) := select(b <= a) ]") ) (defun calc-JumpRules () "JumpRules" (calc-compile-rule-set "JumpRules" "[ iterations(1), plain(select(x) = y) := 0 = select(-x) + y, plain(a + select(x) = y) := a = select(-x) + y, plain(a - select(x) = y) := a = select(x) + y, plain(select(x) + a = y) := a = select(-x) + y, plain(a * select(x) = y) := a = y / select(x), plain(a / select(x) = y) := a = select(x) * y, plain(select(x) / a = y) := 1/a = y / select(x), plain(a ^ select(2) = y) := a = select(sqrt(y)), plain(a ^ select(x) = y) := a = y ^ select(1/x), plain(select(x) ^ a = y) := a = log(y, select(x)), plain(log(a, select(x)) = y) := a = select(x) ^ y, plain(log(select(x), a) = y) := a = select(x) ^ (1/y), plain(y = select(x)) := y - select(x) = 0, plain(y = a + select(x)) := y - select(x) = a, plain(y = a - select(x)) := y + select(x) = a, plain(y = select(x) + a) := y - select(x) = a, plain(y = a * select(x)) := y / select(x) = a, plain(y = a / select(x)) := y * select(x) = a, plain(y = select(x) / a) := y / select(x) = 1/a, plain(y = a ^ select(2)) := select(sqrt(y)) = a, plain(y = a ^ select(x)) := y ^ select(1/x) = a, plain(y = select(x) ^ a) := log(y, select(x)) = a, plain(y = log(a, select(x))) := select(x) ^ y = a, plain(y = log(select(x), a)) := select(x) ^ (1/y) = a ]") ) (defun calc-DistribRules () "DistribRules" (calc-compile-rule-set "DistribRules" "[ iterations(1), x * select(a + b) := x*select(a) + x*b, x * select(sum(a,b,c,d)) := sum(x*select(a),b,c,d), x / select(a + b) := 1 / (select(a)/x + b/x), select(a + b) / x := select(a)/x + b/x, sum(select(a),b,c,d) / x := sum(select(a)/x,b,c,d), x ^ select(a + b) := x^select(a) * x^b, x ^ select(sum(a,b,c,d)) := prod(x^select(a),b,c,d), x ^ select(a * b) := (x^a)^select(b), x ^ select(a / b) := (x^a)^select(1/b), select(a + b) ^ n := select(x) :: integer(n) :: n >= 2 :: let(x, expandpow(a+b,n)) :: quote(matches(x,y+z)), select(a + b) ^ x := a*select(a+b)^(x-1) + b*select(a+b)^(x-1), select(a * b) ^ x := a^x * select(b)^x, select(prod(a,b,c,d)) ^ x := prod(select(a)^x,b,c,d), select(a / b) ^ x := select(a)^x / b^x, select(- a) ^ x := (-1)^x * select(a)^x, plain(-select(a + b)) := select(-a) - b, plain(-select(sum(a,b,c,d))) := sum(select(-a),b,c,d), plain(-select(a * b)) := select(-a) * b, plain(-select(a / b)) := select(-a) / b, sqrt(select(a * b)) := sqrt(select(a)) * sqrt(b), sqrt(select(prod(a,b,c,d))) := prod(sqrt(select(a)),b,c,d), sqrt(select(a / b)) := sqrt(select(a)) / sqrt(b), sqrt(select(- a)) := sqrt(-1) sqrt(select(a)), exp(select(a + b)) := exp(select(a)) / exp(-b) :: negative(b), exp(select(a + b)) := exp(select(a)) * exp(b), exp(select(sum(a,b,c,d))) := prod(exp(select(a)),b,c,d), exp(select(a * b)) := exp(select(a)) ^ b :: constant(b), exp(select(a * b)) := exp(select(a)) ^ b, exp(select(a / b)) := exp(select(a)) ^ (1/b), ln(select(a * b)) := ln(select(a)) + ln(b), ln(select(prod(a,b,c,d))) := sum(ln(select(a)),b,c,d), ln(select(a / b)) := ln(select(a)) - ln(b), ln(select(a ^ b)) := ln(select(a)) * b, log10(select(a * b)) := log10(select(a)) + log10(b), log10(select(prod(a,b,c,d))) := sum(log10(select(a)),b,c,d), log10(select(a / b)) := log10(select(a)) - log10(b), log10(select(a ^ b)) := log10(select(a)) * b, log(select(a * b), x) := log(select(a), x) + log(b,x), log(select(prod(a,b,c,d)),x) := sum(log(select(a),x),b,c,d), log(select(a / b), x) := log(select(a), x) - log(b,x), log(select(a ^ b), x) := log(select(a), x) * b, log(a, select(b)) := ln(a) / select(ln(b)), sin(select(a + b)) := sin(select(a)) cos(b) + cos(a) sin(b), sin(select(2 a)) := 2 sin(select(a)) cos(a), sin(select(n a)) := 2sin((n-1) select(a)) cos(a) - sin((n-2) a) :: integer(n) :: n > 2, cos(select(a + b)) := cos(select(a)) cos(b) - sin(a) sin(b), cos(select(2 a)) := 2 cos(select(a))^2 - 1, cos(select(n a)) := 2cos((n-1) select(a)) cos(a) - cos((n-2) a) :: integer(n) :: n > 2, tan(select(a + b)) := (tan(select(a)) + tan(b)) / (1 - tan(a) tan(b)), tan(select(2 a)) := 2 tan(select(a)) / (1 - tan(a)^2), tan(select(n a)) := (tan((n-1) select(a)) + tan(a)) / (1 - tan((n-1) a) tan(a)) :: integer(n) :: n > 2, sinh(select(a + b)) := sinh(select(a)) cosh(b) + cosh(a) sinh(b), cosh(select(a + b)) := cosh(select(a)) cosh(b) + sinh(a) sinh(b), tanh(select(a + b)) := (tanh(select(a)) + tanh(b)) / (1 + tanh(a) tanh(b)), x && select(a || b) := (x && select(a)) || (x && b), select(a || b) && x := (select(a) && x) || (b && x), ! select(a && b) := (!a) || (!b), ! select(a || b) := (!a) && (!b) ]") ) (defun calc-MergeRules () "MergeRules" (calc-compile-rule-set "MergeRules" "[ iterations(1), (x*opt(a)) + select(x*b) := x * (a + select(b)), (x*opt(a)) - select(x*b) := x * (a - select(b)), sum(select(x)*a,b,c,d) := x * sum(select(a),b,c,d), (a/x) + select(b/x) := (a + select(b)) / x, (a/x) - select(b/x) := (a - select(b)) / x, sum(a/select(x),b,c,d) := sum(select(a),b,c,d) / x, (a/opt(b)) + select(c/d) := ((select(a)*d) + (b*c)) / (b*d), (a/opt(b)) - select(c/d) := ((select(a)*d) - (b*c)) / (b*d), (x^opt(a)) * select(x^b) := x ^ (a + select(b)), (x^opt(a)) / select(x^b) := x ^ (a - select(b)), select(x^a) / (x^opt(b)) := x ^ (select(a) - b), prod(select(x)^a,b,c,d) := x ^ sum(select(a),b,c,d), select(x^a) / (x^opt(b)) := x ^ (select(a) - b), (a^x) * select(b^x) := select((a * b) ^x), (a^x) / select(b^x) := select((b / b) ^ x), select(a^x) / (b^x) := select((a / b) ^ x), prod(a^select(x),b,c,d) := select(prod(a,b,c,d) ^ x), (a^x) * select(b^y) := select((a * b^(y-x)) ^x), (a^x) / select(b^y) := select((b / b^(y-x)) ^ x), select(a^x) / (b^y) := select((a / b^(y-x)) ^ x), select(x^a) ^ b := x ^ select(a * b), (x^a) ^ select(b) := x ^ select(a * b), select(sqrt(a)) ^ b := select(a ^ (b / 2)), sqrt(a) ^ select(b) := select(a ^ (b / 2)), sqrt(select(a) ^ b) := select(a ^ (b / 2)), sqrt(a ^ select(b)) := select(a ^ (b / 2)), sqrt(a) * select(sqrt(b)) := select(sqrt(a * b)), sqrt(a) / select(sqrt(b)) := select(sqrt(a / b)), select(sqrt(a)) / sqrt(b) := select(sqrt(a / b)), prod(select(sqrt(a)),b,c,d) := select(sqrt(prod(a,b,c,d))), exp(a) * select(exp(b)) := select(exp(a + b)), exp(a) / select(exp(b)) := select(exp(a - b)), select(exp(a)) / exp(b) := select(exp(a - b)), prod(select(exp(a)),b,c,d) := select(exp(sum(a,b,c,d))), select(exp(a)) ^ b := select(exp(a * b)), exp(a) ^ select(b) := select(exp(a * b)), ln(a) + select(ln(b)) := select(ln(a * b)), ln(a) - select(ln(b)) := select(ln(a / b)), select(ln(a)) - ln(b) := select(ln(a / b)), sum(select(ln(a)),b,c,d) := select(ln(prod(a,b,c,d))), b * select(ln(a)) := select(ln(a ^ b)), select(b) * ln(a) := select(ln(a ^ b)), select(ln(a)) / ln(b) := select(log(a, b)), ln(a) / select(ln(b)) := select(log(a, b)), select(ln(a)) / b := select(ln(a ^ (1/b))), ln(a) / select(b) := select(ln(a ^ (1/b))), log10(a) + select(log10(b)) := select(log10(a * b)), log10(a) - select(log10(b)) := select(log10(a / b)), select(log10(a)) - log10(b) := select(log10(a / b)), sum(select(log10(a)),b,c,d) := select(log10(prod(a,b,c,d))), b * select(log10(a)) := select(log10(a ^ b)), select(b) * log10(a) := select(log10(a ^ b)), select(log10(a)) / log10(b) := select(log(a, b)), log10(a) / select(log10(b)) := select(log(a, b)), select(log10(a)) / b := select(log10(a ^ (1/b))), log10(a) / select(b) := select(log10(a ^ (1/b))), log(a,x) + select(log(b,x)) := select(log(a * b,x)), log(a,x) - select(log(b,x)) := select(log(a / b,x)), select(log(a,x)) - log(b,x) := select(log(a / b,x)), sum(select(log(a,x)),b,c,d) := select(log(prod(a,b,c,d),x)), b * select(log(a,x)) := select(log(a ^ b,x)), select(b) * log(a,x) := select(log(a ^ b,x)), select(log(a,x)) / log(b,x) := select(log(a, b)), log(a,x) / select(log(b,x)) := select(log(a, b)), select(log(a,x)) / b := select(log(a ^ (1/b),x)), log(a,x) / select(b) := select(log(a ^ (1/b),x)), select(x && a) || (x && opt(b)) := x && (select(a) || b) ]") ) (defun calc-NegateRules () "NegateRules" (calc-compile-rule-set "NegateRules" "[ iterations(1), a + select(x) := a - select(-x), a - select(x) := a + select(-x), sum(select(x),b,c,d) := -sum(select(-x),b,c,d), a * select(x) := -a * select(-x), a / select(x) := -a / select(-x), select(x) / a := -select(-x) / a, prod(select(x),b,c,d) := (-1)^(d-c+1) * prod(select(-x),b,c,d), select(x) ^ n := select(-x) ^ a :: integer(n) :: n%2 = 0, select(x) ^ n := -(select(-x) ^ a) :: integer(n) :: n%2 = 1, select(x) ^ a := (-select(-x)) ^ a, a ^ select(x) := (1 / a)^select(-x), abs(select(x)) := abs(select(-x)), i sqrt(select(x)) := -sqrt(select(-x)), sqrt(select(x)) := i sqrt(select(-x)), re(select(x)) := -re(select(-x)), im(select(x)) := -im(select(-x)), conj(select(x)) := -conj(select(-x)), trunc(select(x)) := -trunc(select(-x)), round(select(x)) := -round(select(-x)), floor(select(x)) := -ceil(select(-x)), ceil(select(x)) := -floor(select(-x)), ftrunc(select(x)) := -ftrunc(select(-x)), fround(select(x)) := -fround(select(-x)), ffloor(select(x)) := -fceil(select(-x)), fceil(select(x)) := -ffloor(select(-x)), exp(select(x)) := 1 / exp(select(-x)), sin(select(x)) := -sin(select(-x)), cos(select(x)) := cos(select(-x)), tan(select(x)) := -tan(select(-x)), arcsin(select(x)) := -arcsin(select(-x)), arccos(select(x)) := 4 arctan(1) - arccos(select(-x)), arctan(select(x)) := -arctan(select(-x)), sinh(select(x)) := -sinh(select(-x)), cosh(select(x)) := cosh(select(-x)), tanh(select(x)) := -tanh(select(-x)), arcsinh(select(x)) := -arcsinh(select(-x)), arctanh(select(x)) := -arctanh(select(-x)), select(x) = a := select(-x) = -a, select(x) != a := select(-x) != -a, select(x) < a := select(-x) > -a, select(x) > a := select(-x) < -a, select(x) <= a := select(-x) >= -a, select(x) >= a := select(-x) <= -a, a < select(x) := -a > select(-x), a > select(x) := -a < select(-x), a <= select(x) := -a >= select(-x), a >= select(x) := -a <= select(-x), select(x) := -select(-x) ]") ) (defun calc-InvertRules () "InvertRules" (calc-compile-rule-set "InvertRules" "[ iterations(1), a * select(x) := a / select(1/x), a / select(x) := a * select(1/x), select(x) / a := 1 / (select(1/x) a), prod(select(x),b,c,d) := 1 / prod(select(1/x),b,c,d), abs(select(x)) := 1 / abs(select(1/x)), sqrt(select(x)) := 1 / sqrt(select(1/x)), ln(select(x)) := -ln(select(1/x)), log10(select(x)) := -log10(select(1/x)), log(select(x), a) := -log(select(1/x), a), log(a, select(x)) := -log(a, select(1/x)), arctan(select(x)) := simplify(2 arctan(1))-arctan(select(1/x)), select(x) = a := select(1/x) = 1/a, select(x) != a := select(1/x) != 1/a, select(x) < a := select(1/x) > 1/a, select(x) > a := select(1/x) < 1/a, select(x) <= a := select(1/x) >= 1/a, select(x) >= a := select(1/x) <= 1/a, a < select(x) := 1/a > select(1/x), a > select(x) := 1/a < select(1/x), a <= select(x) := 1/a >= select(1/x), a >= select(x) := 1/a <= select(1/x), select(x) := 1 / select(1/x) ]") ) (defun calc-FactorRules () "FactorRules" (calc-compile-rule-set "FactorRules" "[ thecoefs(x, [z, a+b, c]) := thefactors(x, [d x + d a/c, (c/d) x + (b/d)]) :: z = a b/c :: let(d := pgcd(pcont(c), pcont(b))), thecoefs(x, [z, a, c]) := thefactors(x, [(r x + a/(2 r))^2]) :: z = (a/2)^2/c :: let(r := esimplify(sqrt(c))) :: !matches(r, sqrt(rr)), thecoefs(x, [z, 0, c]) := thefactors(x, [rc x + rz, rc x - rz]) :: negative(z) :: let(rz := esimplify(sqrt(-z))) :: !matches(rz, sqrt(rzz)) :: let(rc := esimplify(sqrt(c))) :: !matches(rc, sqrt(rcc)), thecoefs(x, [z, 0, c]) := thefactors(x, [rz + rc x, rz - rc x]) :: negative(c) :: let(rz := esimplify(sqrt(z))) :: !matches(rz, sqrt(rzz)) :: let(rc := esimplify(sqrt(-c))) :: !matches(rc, sqrt(rcc)) ]") ) ;;(setq var-FactorRules 'calc-FactorRules) (defun calc-IntegAfterRules () "IntegAfterRules" (calc-compile-rule-set "IntegAfterRules" "[ opt(a) ln(x) + opt(b) ln(y) := 2 a esimplify(arctanh(x-1)) :: a + b = 0 :: nrat(x + y) = 2 || nrat(x - y) = 2, a * (b + c) := a b + a c :: constant(a) ]") ) ;;(setq var-IntegAfterRules 'calc-IntegAfterRules) (defun calc-FitRules () "FitRules" (calc-compile-rule-set "FitRules" "[ schedule(1,2,3,4), iterations(inf), phase(1), e^x := exp(x), x^y := exp(y ln(x)) :: !istrue(constant(y)), x/y := x fitinv(y), fitinv(x y) := fitinv(x) fitinv(y), exp(a) exp(b) := exp(a + b), a exp(b) := exp(ln(a) + b) :: !hasfitvars(a), fitinv(exp(a)) := exp(-a), ln(a b) := ln(a) + ln(b), ln(fitinv(a)) := -ln(a), log10(a b) := log10(a) + log10(b), log10(fitinv(a)) := -log10(a), log(a,b) := ln(a)/ln(b), ln(exp(a)) := a, a*(b+c) := a*b + a*c, (a+b)^n := x :: integer(n) :: n >= 2 :: let(x, expandpow(a+b,n)) :: quote(matches(x,y+z)), phase(1,2), fitmodel(y = x) := fitmodel(0, y - x), fitmodel(y, x+c) := fitmodel(y-c, x) :: !hasfitparams(c), fitmodel(y, x c) := fitmodel(y/c, x) :: !hasfitparams(c), fitmodel(y, x/(c opt(d))) := fitmodel(y c, x/d) :: !hasfitparams(c), fitmodel(y, apply(f,[x])) := fitmodel(yy, x) :: hasfitparams(x) :: let(FTemp() = yy, solve(apply(f,[FTemp()]) = y, FTemp())), fitmodel(y, apply(f,[x,c])) := fitmodel(yy, x) :: !hasfitparams(c) :: let(FTemp() = yy, solve(apply(f,[FTemp(),c]) = y, FTemp())), fitmodel(y, apply(f,[c,x])) := fitmodel(yy, x) :: !hasfitparams(c) :: let(FTemp() = yy, solve(apply(f,[c,FTemp()]) = y, FTemp())), phase(2,3), fitmodel(y, x) := fitsystem(y, [], [], fitpart(1,1,x)), fitpart(a,b,plain(x + y)) := fitpart(a,b,x) + fitpart(a,b,y), fitpart(a,b,plain(x - y)) := fitpart(a,b,x) + fitpart(-a,b,y), fitpart(a,b,plain(-x)) := fitpart(-a,b,x), fitpart(a,b,x opt(c)) := fitpart(a,x b,c) :: !hasfitvars(x), fitpart(a,x opt(b),c) := fitpart(x a,b,c) :: !hasfitparams(x), fitpart(a,x y + x opt(z),c) := fitpart(a,x*(y+z),c), fitpart(a,b,c) := fitpart2(a,b,c), phase(3), fitpart2(a1,b1,x) + fitpart2(a2,b2,x) := fitpart(1, a1 b1 + a2 b2, x), fitpart2(a1,x,c1) + fitpart2(a2,x,c2) := fitpart2(1, x, a1 c1 + a2 c2), phase(4), fitinv(x) := 1 / x, exp(x + ln(y)) := y exp(x), exp(x ln(y)) := y^x, ln(x) + ln(y) := ln(x y), ln(x) - ln(y) := ln(x/y), x*y + x*z := x*(y+z), fitsystem(y, xv, pv, fitpart2(a,fitparam(b),c) + opt(d)) := fitsystem(y, rcons(xv, a c), rcons(pv, fitdummy(b) = fitparam(b)), d) :: b = vlen(pv)+1, fitsystem(y, xv, pv, fitpart2(a,b,c) + opt(d)) := fitsystem(y, rcons(xv, a c), rcons(pv, fitdummy(vlen(pv)+1) = b), d), fitsystem(y, xv, pv, 0) := fitsystem(y, xv, cons(fvh,fvt)) :: !hasfitparams(xv) :: let(cons(fvh,fvt), solve(pv, table(fitparam(j), j, 1, hasfitparams(pv)))), fitparam(n) = x := x ]") ) calc-2.02c/calc-rewr.el100644 22403 13 210167 5402630725 13271 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-rewr.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-rewr () nil) (defun calc-rewrite-selection (rules-str &optional many prefix) (interactive "sRewrite rule(s): \np") (calc-slow-wrapper (calc-preserve-point) (let* ((num (max 1 (calc-locate-cursor-element (point)))) (reselect t) (pop-rules nil) (entry (calc-top num 'entry)) (expr (car entry)) (sel (calc-auto-selection entry)) (math-rewrite-selections t) (math-rewrite-default-iters 1)) (if (or (null rules-str) (equal rules-str "") (equal rules-str "$")) (if (= num 1) (error "Can't use same stack entry for formula and rules.") (setq rules (calc-top-n 1 t) pop-rules t)) (setq rules (if (stringp rules-str) (math-read-exprs rules-str) rules-str)) (if (eq (car-safe rules) 'error) (error "Bad format in expression: %s" (nth 1 rules))) (if (= (length rules) 1) (setq rules (car rules)) (setq rules (cons 'vec rules))) (or (memq (car-safe rules) '(vec var calcFunc-assign calcFunc-condition)) (let ((rhs (math-read-expr (read-string (concat "Rewrite from: " rules-str " to: "))))) (if (eq (car-safe rhs) 'error) (error "Bad format in expression: %s" (nth 1 rhs))) (setq rules (list 'calcFunc-assign rules rhs)))) (or (eq (car-safe rules) 'var) (calc-record rules "rule"))) (if (eq many 0) (setq many '(var inf var-inf)) (if many (setq many (prefix-numeric-value many)))) (if sel (setq expr (calc-replace-sub-formula (car entry) sel (list 'calcFunc-select sel))) (setq expr (car entry) reselect nil math-rewrite-selections nil)) (setq expr (calc-encase-atoms (calc-normalize (math-rewrite (calc-normalize expr) rules many))) sel nil expr (calc-locate-select-marker expr)) (or (consp sel) (setq sel nil)) (if pop-rules (calc-pop-stack 1)) (calc-pop-push-record-list 1 (or prefix "rwrt") (list expr) (- num (if pop-rules 1 0)) (list (and reselect sel)))) (calc-handle-whys)) ) (defun calc-locate-select-marker (expr) ; changes "sel" (if (Math-primp expr) expr (if (and (eq (car expr) 'calcFunc-select) (= (length expr) 2)) (progn (setq sel (if sel t (nth 1 expr))) (nth 1 expr)) (cons (car expr) (mapcar 'calc-locate-select-marker (cdr expr))))) ) (defun calc-rewrite (rules-str many) (interactive "sRewrite rule(s): \nP") (calc-slow-wrapper (let (n rules expr) (if (or (null rules-str) (equal rules-str "") (equal rules-str "$")) (setq expr (calc-top-n 2) rules (calc-top-n 1 t) n 2) (setq rules (if (stringp rules-str) (math-read-exprs rules-str) rules-str)) (if (eq (car-safe rules) 'error) (error "Bad format in expression: %s" (nth 1 rules))) (if (= (length rules) 1) (setq rules (car rules)) (setq rules (cons 'vec rules))) (or (memq (car-safe rules) '(vec var calcFunc-assign calcFunc-condition)) (let ((rhs (math-read-expr (read-string (concat "Rewrite from: " rules-str " to: "))))) (if (eq (car-safe rhs) 'error) (error "Bad format in expression: %s" (nth 1 rhs))) (setq rules (list 'calcFunc-assign rules rhs)))) (or (eq (car-safe rules) 'var) (calc-record rules "rule")) (setq expr (calc-top-n 1) n 1)) (if (eq many 0) (setq many '(var inf var-inf)) (if many (setq many (prefix-numeric-value many)))) (setq expr (calc-normalize (math-rewrite expr rules many))) (let (sel) (setq expr (calc-locate-select-marker expr))) (calc-pop-push-record-list n "rwrt" (list expr))) (calc-handle-whys)) ) (defun calc-match (pat) (interactive "sPattern: \n") (calc-slow-wrapper (let (n expr) (if (or (null pat) (equal pat "") (equal pat "$")) (setq expr (calc-top-n 2) pat (calc-top-n 1) n 2) (if (interactive-p) (setq calc-previous-alg-entry pat)) (setq pat (if (stringp pat) (math-read-expr pat) pat)) (if (eq (car-safe pat) 'error) (error "Bad format in expression: %s" (nth 1 pat))) (if (not (eq (car-safe pat) 'var)) (calc-record pat "pat")) (setq expr (calc-top-n 1) n 1)) (or (math-vectorp expr) (error "Argument must be a vector")) (if (calc-is-inverse) (calc-enter-result n "mtcn" (math-match-patterns pat expr t)) (calc-enter-result n "mtch" (math-match-patterns pat expr nil))))) ) (defun math-rewrite (whole-expr rules &optional mmt-many) (let ((crules (math-compile-rewrites rules)) (heads (math-rewrite-heads whole-expr)) (trace-buffer (get-buffer "*Trace*")) (calc-display-just 'center) (calc-display-origin 39) (calc-line-breaking 78) (calc-line-numbering nil) (calc-show-selections t) (calc-why nil) (mmt-func (function (lambda (x) (let ((result (math-apply-rewrites x (cdr crules) heads crules))) (if result (progn (if trace-buffer (let ((fmt (math-format-stack-value (list result nil nil)))) (save-excursion (set-buffer trace-buffer) (insert "\nrewrite to\n" fmt "\n")))) (setq heads (math-rewrite-heads result heads t)))) result))))) (if trace-buffer (let ((fmt (math-format-stack-value (list whole-expr nil nil)))) (save-excursion (set-buffer trace-buffer) (setq truncate-lines t) (goto-char (point-max)) (insert "\n\nBegin rewriting\n" fmt "\n")))) (or mmt-many (setq mmt-many (or (nth 1 (car crules)) math-rewrite-default-iters))) (if (equal mmt-many '(var inf var-inf)) (setq mmt-many 1000000)) (if (equal mmt-many '(neg (var inf var-inf))) (setq mmt-many -1000000)) (math-rewrite-phase (nth 3 (car crules))) (if trace-buffer (let ((fmt (math-format-stack-value (list whole-expr nil nil)))) (save-excursion (set-buffer trace-buffer) (insert "\nDone rewriting" (if (= mmt-many 0) " (reached iteration limit)" "") ":\n" fmt "\n")))) whole-expr) ) (setq math-rewrite-default-iters 100) (defun math-rewrite-phase (sched) (while (and sched (/= mmt-many 0)) (if (listp (car sched)) (while (let ((save-expr whole-expr)) (math-rewrite-phase (car sched)) (not (equal whole-expr save-expr)))) (if (symbolp (car sched)) (progn (setq whole-expr (math-normalize (list (car sched) whole-expr))) (if trace-buffer (let ((fmt (math-format-stack-value (list whole-expr nil nil)))) (save-excursion (set-buffer trace-buffer) (insert "\ncall " (substring (symbol-name (car sched)) 9) ":\n" fmt "\n"))))) (let ((math-rewrite-phase (car sched))) (if trace-buffer (save-excursion (set-buffer trace-buffer) (insert (format "\n(Phase %d)\n" math-rewrite-phase)))) (while (let ((save-expr whole-expr)) (setq whole-expr (math-normalize (math-map-tree-rec whole-expr))) (not (equal whole-expr save-expr))))))) (setq sched (cdr sched))) ) (defun calcFunc-rewrite (expr rules &optional many) (or (null many) (integerp many) (equal many '(var inf var-inf)) (equal many '(neg (var inf var-inf))) (math-reject-arg many 'fixnump)) (condition-case err (math-rewrite expr rules (or many 1)) (error (math-reject-arg rules (nth 1 err)))) ) (defun calcFunc-match (pat vec) (or (math-vectorp vec) (math-reject-arg vec 'vectorp)) (condition-case err (math-match-patterns pat vec nil) (error (math-reject-arg pat (nth 1 err)))) ) (defun calcFunc-matchnot (pat vec) (or (math-vectorp vec) (math-reject-arg vec 'vectorp)) (condition-case err (math-match-patterns pat vec t) (error (math-reject-arg pat (nth 1 err)))) ) (defun math-match-patterns (pat vec &optional not-flag) (let ((newvec nil) (crules (math-compile-patterns pat))) (while (setq vec (cdr vec)) (if (eq (not (math-apply-rewrites (car vec) crules)) not-flag) (setq newvec (cons (car vec) newvec)))) (cons 'vec (nreverse newvec))) ) (defun calcFunc-matches (expr pat) (condition-case err (if (math-apply-rewrites expr (math-compile-patterns pat)) 1 0) (error (math-reject-arg pat (nth 1 err)))) ) (defun calcFunc-vmatches (expr pat) (condition-case err (or (math-apply-rewrites expr (math-compile-patterns pat)) 0) (error (math-reject-arg pat (nth 1 err)))) ) ;;; A compiled rule set is an a-list of entries whose cars are functors, ;;; and whose cdrs are lists of rules. If there are rules with no ;;; well-defined head functor, they are included on all lists and also ;;; on an extra list whose car is nil. ;;; ;;; The first entry in the a-list is of the form (schedule A B C ...). ;;; ;;; Rule list entries take the form (regs prog head phases), where: ;;; ;;; regs is a vector of match registers. ;;; ;;; prog is a match program (see below). ;;; ;;; head is a rare function name appearing in the rule body (but not the ;;; head of the whole rule), or nil if none. ;;; ;;; phases is a list of phase numbers for which the rule is enabled. ;;; ;;; A match program is a list of match instructions. ;;; ;;; In the following, "part" is a register number that contains the ;;; subexpression to be operated on. ;;; ;;; Register 0 is the whole expression being matched. The others are ;;; meta-variables in the pattern, temporaries used for matching and ;;; backtracking, and constant expressions. ;;; ;;; (same part reg) ;;; The selected part must be math-equal to the contents of "reg". ;;; ;;; (same-neg part reg) ;;; The selected part must be math-equal to the negative of "reg". ;;; ;;; (copy part reg) ;;; The selected part is copied into "reg". (Rarely used.) ;;; ;;; (copy-neg part reg) ;;; The negative of the selected part is copied into "reg". ;;; ;;; (integer part) ;;; The selected part must be an integer. ;;; ;;; (real part) ;;; The selected part must be a real. ;;; ;;; (constant part) ;;; The selected part must be a constant. ;;; ;;; (negative part) ;;; The selected part must "look" negative. ;;; ;;; (rel part op reg) ;;; The selected part must satisfy "part op reg", where "op" ;;; is one of the 6 relational ops, and "reg" is a register. ;;; ;;; (mod part modulo value) ;;; The selected part must satisfy "part % modulo = value", where ;;; "modulo" and "value" are constants. ;;; ;;; (func part head reg1 reg2 ... regn) ;;; The selected part must be an n-ary call to function "head". ;;; The arguments are stored in "reg1" through "regn". ;;; ;;; (func-def part head defs reg1 reg2 ... regn) ;;; The selected part must be an n-ary call to function "head". ;;; "Defs" is a list of value/register number pairs for default args. ;;; If a match, assign default values to registers and then skip ;;; immediately over any following "func-def" instructions and ;;; the following "func" instruction. If wrong number of arguments, ;;; proceed to the following "func-def" or "func" instruction. ;;; ;;; (func-opt part head defs reg1) ;;; Like func-def with "n=1", except that if the selected part is ;;; not a call to "head", then the part itself successfully matches ;;; "reg1" (and the defaults are assigned). ;;; ;;; (try part heads mark reg1 [def]) ;;; The selected part must be a function of the correct type which is ;;; associative and/or commutative. "Heads" is a list of acceptable ;;; types. An initial assignment of arguments to "reg1" is tried. ;;; If the program later fails, it backtracks to this instruction ;;; and tries other assignments of arguments to "reg1". ;;; If "def" exists and normal matching fails, backtrack and assign ;;; "part" to "reg1", and "def" to "reg2" in the following "try2". ;;; The "mark" is a vector of size 5; only "mark[3-4]" are initialized. ;;; "mark[0]" points to the argument list; "mark[1]" points to the ;;; current argument; "mark[2]" is 0 if there are two arguments, ;;; 1 if reg1 is matching single arguments, 2 if reg2 is matching ;;; single arguments (a+b+c+d is never split as (a+b)+(c+d)), or ;;; 3 if reg2 is matching "def"; "mark[3]" is 0 if the function must ;;; have two arguments, 1 if phase-2 can be skipped, 2 if full ;;; backtracking is necessary; "mark[4]" is t if the arguments have ;;; been switched from the order given in the original pattern. ;;; ;;; (try2 try reg2) ;;; Every "try" will be followed by a "try2" whose "try" field is ;;; a pointer to the corresponding "try". The arguments which were ;;; not stored in "reg1" by that "try" are now stored in "reg2". ;;; ;;; (alt instr nil mark) ;;; Basic backtracking. Execute the instruction sequence "instr". ;;; If this fails, back up and execute following the "alt" instruction. ;;; The "mark" must be the vector "[nil nil 4]". The "instr" sequence ;;; should execute "end-alt" at the end. ;;; ;;; (end-alt ptr) ;;; Register success of the first alternative of a previous "alt". ;;; "Ptr" is a pointer to the next instruction following that "alt". ;;; ;;; (apply part reg1 reg2) ;;; The selected part must be a function call. The functor ;;; (as a variable name) is stored in "reg1"; the arguments ;;; (as a vector) are stored in "reg2". ;;; ;;; (cons part reg1 reg2) ;;; The selected part must be a nonempty vector. The first element ;;; of the vector is stored in "reg1"; the rest of the vector ;;; (as another vector) is stored in "reg2". ;;; ;;; (rcons part reg1 reg2) ;;; The selected part must be a nonempty vector. The last element ;;; of the vector is stored in "reg2"; the rest of the vector ;;; (as another vector) is stored in "reg1". ;;; ;;; (select part reg) ;;; If the selected part is a unary call to function "select", its ;;; argument is stored in "reg"; otherwise (provided this is an `a r' ;;; and not a `g r' command) the selected part is stored in "reg". ;;; ;;; (cond expr) ;;; The "expr", with registers substituted, must simplify to ;;; a non-zero value. ;;; ;;; (let reg expr) ;;; Evaluate "expr" and store the result in "reg". Always succeeds. ;;; ;;; (done rhs remember) ;;; Rewrite the expression to "rhs", with register substituted. ;;; Normalize; if the result is different from the original ;;; expression, the match has succeeded. This is the last ;;; instruction of every program. If "remember" is non-nil, ;;; record the result of the match as a new literal rule. ;;; Pseudo-functions related to rewrites: ;;; ;;; In patterns: quote, plain, condition, opt, apply, cons, select ;;; ;;; In righthand sides: quote, plain, eval, evalsimp, evalextsimp, ;;; apply, cons, select ;;; ;;; In conditions: let + same as for righthand sides ;;; Some optimizations that would be nice to have: ;;; ;;; * Merge registers with disjoint lifetimes. ;;; * Merge constant registers with equivalent values. ;;; ;;; * If an argument of a commutative op math-depends neither on the ;;; rest of the pattern nor on any of the conditions, then no backtracking ;;; should be done for that argument. (This won't apply to very many ;;; cases.) ;;; ;;; * If top functor is "select", and its argument is a unique function, ;;; add the rule to the lists for both "select" and that function. ;;; (Currently rules like this go on the "nil" list.) ;;; Same for "func-opt" functions. (Though not urgent for these.) ;;; ;;; * Shouldn't evaluate a "let" condition until the end, or until it ;;; would enable another condition to be evaluated. ;;; ;;; Some additional features to add / things to think about: ;;; ;;; * Figure out what happens to "a +/- b" and "a +/- opt(b)". ;;; ;;; * Same for interval forms. ;;; ;;; * Have a name(v,pat) pattern which matches pat, and gives the ;;; whole match the name v. Beware of circular structures! ;;; (defun math-compile-patterns (pats) (if (and (eq (car-safe pats) 'var) (calc-var-value (nth 2 pats))) (let ((prop (get (nth 2 pats) 'math-pattern-cache))) (or prop (put (nth 2 pats) 'math-pattern-cache (setq prop (list nil)))) (or (eq (car prop) (symbol-value (nth 2 pats))) (progn (setcdr prop (math-compile-patterns (symbol-value (nth 2 pats)))) (setcar prop (symbol-value (nth 2 pats))))) (cdr prop)) (let ((math-rewrite-whole t)) (cdr (math-compile-rewrites (cons 'vec (mapcar (function (lambda (x) (list 'vec x t))) (if (eq (car-safe pats) 'vec) (cdr pats) (list pats)))))))) ) (setq math-rewrite-whole nil) (setq math-make-import-list nil) (defun math-compile-rewrites (rules &optional name) (if (eq (car-safe rules) 'var) (let ((prop (get (nth 2 rules) 'math-rewrite-cache)) (math-import-list nil) (math-make-import-list t) p) (or (calc-var-value (nth 2 rules)) (error "Rules variable %s has no stored value" (nth 1 rules))) (or prop (put (nth 2 rules) 'math-rewrite-cache (setq prop (list (list (cons (nth 2 rules) nil)))))) (setq p (car prop)) (while (and p (eq (symbol-value (car (car p))) (cdr (car p)))) (setq p (cdr p))) (or (null p) (progn (message "Compiling rule set %s..." (nth 1 rules)) (setcdr prop (math-compile-rewrites (symbol-value (nth 2 rules)) (nth 2 rules))) (message "Compiling rule set %s...done" (nth 1 rules)) (setcar prop (cons (cons (nth 2 rules) (symbol-value (nth 2 rules))) math-import-list)))) (cdr prop)) (if (or (not (eq (car-safe rules) 'vec)) (and (memq (length rules) '(3 4)) (let ((p rules)) (while (and (setq p (cdr p)) (memq (car-safe (car p)) '(vec calcFunc-assign calcFunc-condition calcFunc-import calcFunc-phase calcFunc-schedule calcFunc-iterations)))) p))) (setq rules (list rules)) (setq rules (cdr rules))) (if (assq 'calcFunc-import rules) (let ((pp (setq rules (copy-sequence rules))) p part) (while (setq p (car (cdr pp))) (if (eq (car-safe p) 'calcFunc-import) (progn (setcdr pp (cdr (cdr pp))) (or (and (eq (car-safe (nth 1 p)) 'var) (setq part (calc-var-value (nth 2 (nth 1 p)))) (memq (car-safe part) '(vec calcFunc-assign calcFunc-condition))) (error "Argument of import() must be a rules variable")) (if math-make-import-list (setq math-import-list (cons (cons (nth 2 (nth 1 p)) (symbol-value (nth 2 (nth 1 p)))) math-import-list))) (while (setq p (cdr (cdr p))) (or (cdr p) (error "import() must have odd number of arguments")) (setq part (math-rwcomp-substitute part (car p) (nth 1 p)))) (if (eq (car-safe part) 'vec) (setq part (cdr part)) (setq part (list part))) (setcdr pp (append part (cdr pp)))) (setq pp (cdr pp)))))) (let ((rule-set nil) (all-heads nil) (nil-rules nil) (rule-count 0) (math-schedule nil) (math-iterations nil) (math-phases nil) (math-all-phases nil) (math-remembering nil) math-pattern math-rhs math-conds) (while rules (cond ((and (eq (car-safe (car rules)) 'calcFunc-iterations) (= (length (car rules)) 2)) (or (integerp (nth 1 (car rules))) (equal (nth 1 (car rules)) '(var inf var-inf)) (equal (nth 1 (car rules)) '(neg (var inf var-inf))) (error "Invalid argument for iterations(n)")) (or math-iterations (setq math-iterations (nth 1 (car rules))))) ((eq (car-safe (car rules)) 'calcFunc-schedule) (or math-schedule (setq math-schedule (math-parse-schedule (cdr (car rules)))))) ((eq (car-safe (car rules)) 'calcFunc-phase) (setq math-phases (cdr (car rules))) (if (equal math-phases '((var all var-all))) (setq math-phases nil)) (let ((p math-phases)) (while p (or (integerp (car p)) (error "Phase numbers must be small integers")) (or (memq (car p) math-all-phases) (setq math-all-phases (cons (car p) math-all-phases))) (setq p (cdr p))))) ((or (and (eq (car-safe (car rules)) 'vec) (cdr (cdr (car rules))) (not (nthcdr 4 (car rules))) (setq math-conds (nth 3 (car rules)) math-rhs (nth 2 (car rules)) math-pattern (nth 1 (car rules)))) (progn (setq math-conds nil math-pattern (car rules)) (while (and (eq (car-safe math-pattern) 'calcFunc-condition) (= (length math-pattern) 3)) (let ((cond (nth 2 math-pattern))) (setq math-conds (if math-conds (list 'calcFunc-land math-conds cond) cond) math-pattern (nth 1 math-pattern)))) (and (eq (car-safe math-pattern) 'calcFunc-assign) (= (length math-pattern) 3) (setq math-rhs (nth 2 math-pattern) math-pattern (nth 1 math-pattern))))) (let* ((math-prog (list nil)) (math-prog-last math-prog) (math-num-regs 1) (math-regs (list (list nil 0 nil nil))) (math-bound-vars nil) (math-aliased-vars nil) (math-copy-neg nil)) (setq math-conds (and math-conds (math-flatten-lands math-conds))) (math-rwcomp-pattern math-pattern 0) (while math-conds (let ((expr (car math-conds))) (setq math-conds (cdr math-conds)) (math-rwcomp-cond-instr expr))) (math-rwcomp-instr 'done (if (eq math-rhs t) (cons 'vec (delq nil (nreverse (mapcar (function (lambda (v) (and (car v) (list 'calcFunc-assign (math-build-var-name (car v)) (math-rwcomp-register-expr (nth 1 v)))))) math-regs)))) (math-rwcomp-match-vars math-rhs)) math-remembering) (setq math-prog (cdr math-prog)) (let* ((heads (math-rewrite-heads math-pattern)) (rule (list (vconcat (nreverse (mapcar (function (lambda (x) (nth 3 x))) math-regs))) math-prog heads math-phases)) (head (and (not (Math-primp math-pattern)) (not (and (eq (car (car math-prog)) 'try) (nth 5 (car math-prog)))) (not (memq (car (car math-prog)) '(func-opt apply select alt))) (if (memq (car (car math-prog)) '(func func-def)) (nth 2 (car math-prog)) (if (eq (car math-pattern) 'calcFunc-quote) (car-safe (nth 1 math-pattern)) (car math-pattern)))))) (let (found) (while heads (if (setq found (assq (car heads) all-heads)) (setcdr found (1+ (cdr found))) (setq all-heads (cons (cons (car heads) 1) all-heads))) (setq heads (cdr heads)))) (if (eq head '-) (setq head '+)) (if (memq head '(calcFunc-cons calcFunc-rcons)) (setq head 'vec)) (if head (progn (nconc (or (assq head rule-set) (car (setq rule-set (cons (cons head (copy-sequence nil-rules)) rule-set)))) (list rule)) (if (eq head '*) (nconc (or (assq '/ rule-set) (car (setq rule-set (cons (cons '/ (copy-sequence nil-rules)) rule-set)))) (list rule)))) (setq nil-rules (nconc nil-rules (list rule))) (let ((ptr rule-set)) (while ptr (nconc (car ptr) (list rule)) (setq ptr (cdr ptr)))))))) (t (error "Rewrite rule set must be a vector of A := B rules"))) (setq rules (cdr rules))) (if nil-rules (setq rule-set (cons (cons nil nil-rules) rule-set))) (setq all-heads (mapcar 'car (sort all-heads (function (lambda (x y) (< (cdr x) (cdr y))))))) (let ((set rule-set) rule heads ptr) (while set (setq rule (cdr (car set))) (while rule (if (consp (setq heads (nth 2 (car rule)))) (progn (setq heads (delq (car (car set)) heads) ptr all-heads) (while (and ptr (not (memq (car ptr) heads))) (setq ptr (cdr ptr))) (setcar (nthcdr 2 (car rule)) (car ptr)))) (setq rule (cdr rule))) (setq set (cdr set)))) (let ((plus (assq '+ rule-set))) (if plus (setq rule-set (cons (cons '- (cdr plus)) rule-set)))) (cons (list 'schedule math-iterations name (or math-schedule (sort math-all-phases '<) (list 1))) rule-set))) ) (defun math-flatten-lands (expr) (if (eq (car-safe expr) 'calcFunc-land) (append (math-flatten-lands (nth 1 expr)) (math-flatten-lands (nth 2 expr))) (list expr)) ) (defun math-rewrite-heads (expr &optional more all) (let ((heads more) (skips (and (not all) '(calcFunc-apply calcFunc-condition calcFunc-opt calcFunc-por calcFunc-pnot))) (blanks (and (not all) '(calcFunc-quote calcFunc-plain calcFunc-select calcFunc-cons calcFunc-rcons calcFunc-pand)))) (or (Math-primp expr) (math-rewrite-heads-rec expr)) heads) ) (defun math-rewrite-heads-rec (expr) (or (memq (car expr) skips) (progn (or (memq (car expr) heads) (memq (car expr) blanks) (memq 'algebraic (get (car expr) 'math-rewrite-props)) (setq heads (cons (car expr) heads))) (while (setq expr (cdr expr)) (or (Math-primp (car expr)) (math-rewrite-heads-rec (car expr)))))) ) (defun math-parse-schedule (sched) (mapcar (function (lambda (s) (if (integerp s) s (if (math-vectorp s) (math-parse-schedule (cdr s)) (if (eq (car-safe s) 'var) (math-var-to-calcFunc s) (error "Improper component in rewrite schedule")))))) sched) ) (defun math-rwcomp-match-vars (expr) (if (Math-primp expr) (if (eq (car-safe expr) 'var) (let ((entry (assq (nth 2 expr) math-regs))) (if entry (math-rwcomp-register-expr (nth 1 entry)) expr)) expr) (if (and (eq (car expr) 'calcFunc-quote) (= (length expr) 2)) (math-rwcomp-match-vars (nth 1 expr)) (if (and (eq (car expr) 'calcFunc-plain) (= (length expr) 2) (not (Math-primp (nth 1 expr)))) (list (car expr) (cons (car (nth 1 expr)) (mapcar 'math-rwcomp-match-vars (cdr (nth 1 expr))))) (cons (car expr) (mapcar 'math-rwcomp-match-vars (cdr expr)))))) ) (defun math-rwcomp-register-expr (num) (let ((entry (nth (1- (- math-num-regs num)) math-regs))) (if (nth 2 entry) (list 'neg (list 'calcFunc-register (nth 1 entry))) (list 'calcFunc-register (nth 1 entry)))) ) (defun math-rwcomp-substitute (expr old new) (if (and (eq (car-safe old) 'var) (memq (car-safe new) '(var calcFunc-lambda))) (let ((old-func (math-var-to-calcFunc old)) (new-func (math-var-to-calcFunc new))) (math-rwcomp-subst-rec expr)) (let ((old-func nil)) (math-rwcomp-subst-rec expr))) ) (defun math-rwcomp-subst-rec (expr) (cond ((equal expr old) new) ((Math-primp expr) expr) (t (if (eq (car expr) old-func) (math-build-call new-func (mapcar 'math-rwcomp-subst-rec (cdr expr))) (cons (car expr) (mapcar 'math-rwcomp-subst-rec (cdr expr)))))) ) (setq math-rwcomp-tracing nil) (defun math-rwcomp-trace (instr) (if math-rwcomp-tracing (progn (terpri) (princ instr))) instr ) (defun math-rwcomp-instr (&rest instr) (setcdr math-prog-last (setq math-prog-last (list (math-rwcomp-trace instr)))) ) (defun math-rwcomp-multi-instr (tail &rest instr) (setcdr math-prog-last (setq math-prog-last (list (math-rwcomp-trace (append instr tail))))) ) (defun math-rwcomp-bind-var (reg var) (setcar (math-rwcomp-reg-entry reg) (nth 2 var)) (setq math-bound-vars (cons (nth 2 var) math-bound-vars)) (math-rwcomp-do-conditions) ) (defun math-rwcomp-unbind-vars (mark) (while (not (eq math-bound-vars mark)) (setcar (assq (car math-bound-vars) math-regs) nil) (setq math-bound-vars (cdr math-bound-vars))) ) (defun math-rwcomp-do-conditions () (let ((cond math-conds)) (while cond (if (math-rwcomp-all-regs-done (car cond)) (let ((expr (car cond))) (setq math-conds (delq (car cond) math-conds)) (setcar cond 1) (math-rwcomp-cond-instr expr))) (setq cond (cdr cond)))) ) (defun math-rwcomp-cond-instr (expr) (let (op arg) (cond ((and (eq (car-safe expr) 'calcFunc-matches) (= (length expr) 3) (eq (car-safe (setq arg (math-rwcomp-match-vars (nth 1 expr)))) 'calcFunc-register)) (math-rwcomp-pattern (nth 2 expr) (nth 1 arg))) ((math-numberp (setq expr (math-rwcomp-match-vars expr))) (if (Math-zerop expr) (math-rwcomp-instr 'backtrack))) ((and (eq (car expr) 'calcFunc-let) (= (length expr) 3)) (let ((reg (math-rwcomp-reg))) (math-rwcomp-instr 'let reg (nth 2 expr)) (math-rwcomp-pattern (nth 1 expr) reg))) ((and (eq (car expr) 'calcFunc-let) (= (length expr) 2) (eq (car-safe (nth 1 expr)) 'calcFunc-assign) (= (length (nth 1 expr)) 3)) (let ((reg (math-rwcomp-reg))) (math-rwcomp-instr 'let reg (nth 2 (nth 1 expr))) (math-rwcomp-pattern (nth 1 (nth 1 expr)) reg))) ((and (setq op (cdr (assq (car-safe expr) '( (calcFunc-integer . integer) (calcFunc-real . real) (calcFunc-constant . constant) (calcFunc-negative . negative) )))) (= (length expr) 2) (or (and (eq (car-safe (nth 1 expr)) 'neg) (memq op '(integer real constant)) (setq arg (nth 1 (nth 1 expr)))) (setq arg (nth 1 expr))) (eq (car-safe (setq arg (nth 1 expr))) 'calcFunc-register)) (math-rwcomp-instr op (nth 1 arg))) ((and (assq (car-safe expr) calc-tweak-eqn-table) (= (length expr) 3) (eq (car-safe (nth 1 expr)) 'calcFunc-register)) (if (math-constp (nth 2 expr)) (let ((reg (math-rwcomp-reg))) (setcar (nthcdr 3 (car math-regs)) (nth 2 expr)) (math-rwcomp-instr 'rel (nth 1 (nth 1 expr)) (car expr) reg)) (if (eq (car (nth 2 expr)) 'calcFunc-register) (math-rwcomp-instr 'rel (nth 1 (nth 1 expr)) (car expr) (nth 1 (nth 2 expr))) (math-rwcomp-instr 'cond expr)))) ((and (eq (car-safe expr) 'calcFunc-eq) (= (length expr) 3) (eq (car-safe (nth 1 expr)) '%) (eq (car-safe (nth 1 (nth 1 expr))) 'calcFunc-register) (math-constp (nth 2 (nth 1 expr))) (math-constp (nth 2 expr))) (math-rwcomp-instr 'mod (nth 1 (nth 1 (nth 1 expr))) (nth 2 (nth 1 expr)) (nth 2 expr))) ((equal expr '(var remember var-remember)) (setq math-remembering 1)) ((and (eq (car-safe expr) 'calcFunc-remember) (= (length expr) 2)) (setq math-remembering (if math-remembering (list 'calcFunc-lor math-remembering (nth 1 expr)) (nth 1 expr)))) (t (math-rwcomp-instr 'cond expr)))) ) (defun math-rwcomp-same-instr (reg1 reg2 neg) (math-rwcomp-instr (if (eq (eq (nth 2 (math-rwcomp-reg-entry reg1)) (nth 2 (math-rwcomp-reg-entry reg2))) neg) 'same-neg 'same) reg1 reg2) ) (defun math-rwcomp-copy-instr (reg1 reg2 neg) (if (eq (eq (nth 2 (math-rwcomp-reg-entry reg1)) (nth 2 (math-rwcomp-reg-entry reg2))) neg) (math-rwcomp-instr 'copy-neg reg1 reg2) (or (eq reg1 reg2) (math-rwcomp-instr 'copy reg1 reg2))) ) (defun math-rwcomp-reg () (prog1 math-num-regs (setq math-regs (cons (list nil math-num-regs nil 0) math-regs) math-num-regs (1+ math-num-regs))) ) (defun math-rwcomp-reg-entry (num) (nth (1- (- math-num-regs num)) math-regs) ) (defun math-rwcomp-pattern (expr part &optional not-direct) (cond ((or (math-rwcomp-no-vars expr) (and (eq (car expr) 'calcFunc-quote) (= (length expr) 2) (setq expr (nth 1 expr)))) (if (eq (car-safe expr) 'calcFunc-register) (math-rwcomp-same-instr part (nth 1 expr) nil) (let ((reg (math-rwcomp-reg))) (setcar (nthcdr 3 (car math-regs)) expr) (math-rwcomp-same-instr part reg nil)))) ((eq (car expr) 'var) (let ((entry (assq (nth 2 expr) math-regs))) (if entry (math-rwcomp-same-instr part (nth 1 entry) nil) (if not-direct (let ((reg (math-rwcomp-reg))) (math-rwcomp-pattern expr reg) (math-rwcomp-copy-instr part reg nil)) (if (setq entry (assq (nth 2 expr) math-aliased-vars)) (progn (setcar (math-rwcomp-reg-entry (nth 1 entry)) (nth 2 expr)) (setcar entry nil) (math-rwcomp-copy-instr part (nth 1 entry) nil)) (math-rwcomp-bind-var part expr)))))) ((and (eq (car expr) 'calcFunc-select) (= (length expr) 2)) (let ((reg (math-rwcomp-reg))) (math-rwcomp-instr 'select part reg) (math-rwcomp-pattern (nth 1 expr) reg))) ((and (eq (car expr) 'calcFunc-opt) (memq (length expr) '(2 3))) (error "opt( ) occurs in context where it is not allowed")) ((eq (car expr) 'neg) (if (eq (car (nth 1 expr)) 'var) (let ((entry (assq (nth 2 (nth 1 expr)) math-regs))) (if entry (math-rwcomp-same-instr part (nth 1 entry) t) (if math-copy-neg (let ((reg (math-rwcomp-best-reg (nth 1 expr)))) (math-rwcomp-copy-instr part reg t) (math-rwcomp-pattern (nth 1 expr) reg)) (setcar (cdr (cdr (math-rwcomp-reg-entry part))) t) (math-rwcomp-pattern (nth 1 expr) part)))) (if (math-rwcomp-is-algebraic (nth 1 expr)) (math-rwcomp-cond-instr (list 'calcFunc-eq (math-rwcomp-register-expr part) expr)) (let ((reg (math-rwcomp-reg))) (math-rwcomp-instr 'func part 'neg reg) (math-rwcomp-pattern (nth 1 expr) reg))))) ((and (eq (car expr) 'calcFunc-apply) (= (length expr) 3)) (let ((reg1 (math-rwcomp-reg)) (reg2 (math-rwcomp-reg))) (math-rwcomp-instr 'apply part reg1 reg2) (math-rwcomp-pattern (nth 1 expr) reg1) (math-rwcomp-pattern (nth 2 expr) reg2))) ((and (eq (car expr) 'calcFunc-cons) (= (length expr) 3)) (let ((reg1 (math-rwcomp-reg)) (reg2 (math-rwcomp-reg))) (math-rwcomp-instr 'cons part reg1 reg2) (math-rwcomp-pattern (nth 1 expr) reg1) (math-rwcomp-pattern (nth 2 expr) reg2))) ((and (eq (car expr) 'calcFunc-rcons) (= (length expr) 3)) (let ((reg1 (math-rwcomp-reg)) (reg2 (math-rwcomp-reg))) (math-rwcomp-instr 'rcons part reg1 reg2) (math-rwcomp-pattern (nth 1 expr) reg1) (math-rwcomp-pattern (nth 2 expr) reg2))) ((and (eq (car expr) 'calcFunc-condition) (>= (length expr) 3)) (math-rwcomp-pattern (nth 1 expr) part) (setq expr (cdr expr)) (while (setq expr (cdr expr)) (let ((cond (math-flatten-lands (car expr)))) (while cond (if (math-rwcomp-all-regs-done (car cond)) (math-rwcomp-cond-instr (car cond)) (setq math-conds (cons (car cond) math-conds))) (setq cond (cdr cond)))))) ((and (eq (car expr) 'calcFunc-pand) (= (length expr) 3)) (math-rwcomp-pattern (nth 1 expr) part) (math-rwcomp-pattern (nth 2 expr) part)) ((and (eq (car expr) 'calcFunc-por) (= (length expr) 3)) (math-rwcomp-instr 'alt nil nil [nil nil 4]) (let ((math-conds nil) (head math-prog-last) (mark math-bound-vars) (math-copy-neg t)) (math-rwcomp-pattern (nth 1 expr) part t) (let ((amark math-aliased-vars) (math-aliased-vars math-aliased-vars) (tail math-prog-last) (p math-bound-vars) entry) (while (not (eq p mark)) (setq entry (assq (car p) math-regs) math-aliased-vars (cons (list (car p) (nth 1 entry) nil) math-aliased-vars) p (cdr p)) (setcar (math-rwcomp-reg-entry (nth 1 entry)) nil)) (setcar (cdr (car head)) (cdr head)) (setcdr head nil) (setq math-prog-last head) (math-rwcomp-pattern (nth 2 expr) part) (math-rwcomp-instr 'same 0 0) (setcdr tail math-prog-last) (setq p math-aliased-vars) (while (not (eq p amark)) (if (car (car p)) (setcar (math-rwcomp-reg-entry (nth 1 (car p))) (car (car p)))) (setq p (cdr p))))) (math-rwcomp-do-conditions)) ((and (eq (car expr) 'calcFunc-pnot) (= (length expr) 2)) (math-rwcomp-instr 'alt nil nil [nil nil 4]) (let ((head math-prog-last) (mark math-bound-vars)) (math-rwcomp-pattern (nth 1 expr) part) (math-rwcomp-unbind-vars mark) (math-rwcomp-instr 'end-alt head) (math-rwcomp-instr 'backtrack) (setcar (cdr (car head)) (cdr head)) (setcdr head nil) (setq math-prog-last head))) (t (let ((props (get (car expr) 'math-rewrite-props))) (if (and (eq (car expr) 'calcFunc-plain) (= (length expr) 2) (not (math-primp (nth 1 expr)))) (setq expr (nth 1 expr))) ; but "props" is still nil (if (and (memq 'algebraic props) (math-rwcomp-is-algebraic expr)) (math-rwcomp-cond-instr (list 'calcFunc-eq (math-rwcomp-register-expr part) expr)) (if (and (memq 'commut props) (= (length expr) 3)) (let ((arg1 (nth 1 expr)) (arg2 (nth 2 expr)) try1 def code head (flip nil)) (if (eq (car expr) '-) (setq arg2 (math-rwcomp-neg arg2))) (setq arg1 (cons arg1 (math-rwcomp-best-reg arg1)) arg2 (cons arg2 (math-rwcomp-best-reg arg2))) (or (math-rwcomp-order arg1 arg2) (setq def arg1 arg1 arg2 arg2 def flip t)) (if (math-rwcomp-optional-arg (car expr) arg1) (error "Too many opt( ) arguments in this context")) (setq def (math-rwcomp-optional-arg (car expr) arg2) head (if (memq (car expr) '(+ -)) '(+ -) (if (eq (car expr) '*) '(* /) (list (car expr)))) code (if (math-rwcomp-is-constrained (car arg1) head) (if (math-rwcomp-is-constrained (car arg2) head) 0 1) 2)) (math-rwcomp-multi-instr (and def (list def)) 'try part head (vector nil nil nil code flip) (cdr arg1)) (setq try1 (car math-prog-last)) (math-rwcomp-pattern (car arg1) (cdr arg1)) (math-rwcomp-instr 'try2 try1 (cdr arg2)) (if (and (= part 0) (not def) (not math-rewrite-whole) (not (eq math-rhs t)) (setq def (get (car expr) 'math-rewrite-default))) (let ((reg1 (math-rwcomp-reg)) (reg2 (math-rwcomp-reg))) (if (= (aref (nth 3 try1) 3) 0) (aset (nth 3 try1) 3 1)) (math-rwcomp-instr 'try (cdr arg2) (if (equal head '(* /)) '(*) head) (vector nil nil nil (if (= code 0) 1 2) nil) reg1 def) (setq try1 (car math-prog-last)) (math-rwcomp-pattern (car arg2) reg1) (math-rwcomp-instr 'try2 try1 reg2) (setq math-rhs (list (if (eq (car expr) '-) '+ (car expr)) math-rhs (list 'calcFunc-register reg2)))) (math-rwcomp-pattern (car arg2) (cdr arg2)))) (let* ((args (mapcar (function (lambda (x) (cons x (math-rwcomp-best-reg x)))) (cdr expr))) (args2 (copy-sequence args)) (argp (reverse args2)) (defs nil) (num 1)) (while argp (let ((def (math-rwcomp-optional-arg (car expr) (car argp)))) (if def (progn (setq args2 (delq (car argp) args2) defs (cons (cons def (cdr (car argp))) defs)) (math-rwcomp-multi-instr (mapcar 'cdr args2) (if (or (and (memq 'unary1 props) (= (length args2) 1) (eq (car args2) (car args))) (and (memq 'unary2 props) (= (length args) 2) (eq (car args2) (nth 1 args)))) 'func-opt 'func-def) part (car expr) defs)))) (setq argp (cdr argp))) (math-rwcomp-multi-instr (mapcar 'cdr args) 'func part (car expr)) (setq args (sort args 'math-rwcomp-order)) (while args (math-rwcomp-pattern (car (car args)) (cdr (car args))) (setq num (1+ num) args (cdr args))))))))) ) (defun math-rwcomp-best-reg (x) (or (and (eq (car-safe x) 'var) (let ((entry (assq (nth 2 x) math-aliased-vars))) (and entry (not (nth 2 entry)) (not (nth 2 (math-rwcomp-reg-entry (nth 1 entry)))) (progn (setcar (cdr (cdr entry)) t) (nth 1 entry))))) (math-rwcomp-reg)) ) (defun math-rwcomp-all-regs-done (expr) (if (Math-primp expr) (or (not (eq (car-safe expr) 'var)) (assq (nth 2 expr) math-regs) (eq (nth 2 expr) 'var-remember) (math-const-var expr)) (if (and (eq (car expr) 'calcFunc-let) (= (length expr) 3)) (math-rwcomp-all-regs-done (nth 2 expr)) (if (and (eq (car expr) 'calcFunc-let) (= (length expr) 2) (eq (car-safe (nth 1 expr)) 'calcFunc-assign) (= (length (nth 1 expr)) 3)) (math-rwcomp-all-regs-done (nth 2 (nth 1 expr))) (while (and (setq expr (cdr expr)) (math-rwcomp-all-regs-done (car expr)))) (null expr)))) ) (defun math-rwcomp-no-vars (expr) (if (Math-primp expr) (or (not (eq (car-safe expr) 'var)) (math-const-var expr)) (and (not (memq (car expr) '(calcFunc-condition calcFunc-select calcFunc-quote calcFunc-plain calcFunc-opt calcFunc-por calcFunc-pand calcFunc-pnot calcFunc-apply calcFunc-cons calcFunc-rcons))) (progn (while (and (setq expr (cdr expr)) (math-rwcomp-no-vars (car expr)))) (null expr)))) ) (defun math-rwcomp-is-algebraic (expr) (if (Math-primp expr) (or (not (eq (car-safe expr) 'var)) (math-const-var expr) (assq (nth 2 expr) math-regs)) (and (memq 'algebraic (get (car expr) 'math-rewrite-props)) (progn (while (and (setq expr (cdr expr)) (math-rwcomp-is-algebraic (car expr)))) (null expr)))) ) (defun math-rwcomp-is-constrained (expr not-these) (if (Math-primp expr) (not (eq (car-safe expr) 'var)) (if (eq (car expr) 'calcFunc-plain) (math-rwcomp-is-constrained (nth 1 expr) not-these) (not (or (memq (car expr) '(neg calcFunc-select)) (memq (car expr) not-these) (and (memq 'commut (get (car expr) 'math-rewrite-props)) (or (eq (car-safe (nth 1 expr)) 'calcFunc-opt) (eq (car-safe (nth 2 expr)) 'calcFunc-opt))))))) ) (defun math-rwcomp-optional-arg (head argp) (let ((arg (car argp))) (if (eq (car-safe arg) 'calcFunc-opt) (and (memq (length arg) '(2 3)) (progn (or (eq (car-safe (nth 1 arg)) 'var) (error "First argument of opt( ) must be a variable")) (setcar argp (nth 1 arg)) (if (= (length arg) 2) (or (get head 'math-rewrite-default) (error "opt( ) must include a default in this context")) (nth 2 arg)))) (and (eq (car-safe arg) 'neg) (let* ((part (list (nth 1 arg))) (partp (math-rwcomp-optional-arg head part))) (and partp (setcar argp (math-rwcomp-neg (car part))) (math-neg partp)))))) ) (defun math-rwcomp-neg (expr) (if (memq (car-safe expr) '(* /)) (if (eq (car-safe (nth 1 expr)) 'var) (list (car expr) (list 'neg (nth 1 expr)) (nth 2 expr)) (if (eq (car-safe (nth 2 expr)) 'var) (list (car expr) (nth 1 expr) (list 'neg (nth 2 expr))) (math-neg expr))) (math-neg expr)) ) (defun math-rwcomp-assoc-args (expr) (if (and (eq (car-safe (nth 1 expr)) (car expr)) (= (length (nth 1 expr)) 3)) (math-rwcomp-assoc-args (nth 1 expr)) (setq math-args (cons (nth 1 expr) math-args))) (if (and (eq (car-safe (nth 2 expr)) (car expr)) (= (length (nth 2 expr)) 3)) (math-rwcomp-assoc-args (nth 2 expr)) (setq math-args (cons (nth 2 expr) math-args))) ) (defun math-rwcomp-addsub-args (expr) (if (memq (car-safe (nth 1 expr)) '(+ -)) (math-rwcomp-addsub-args (nth 1 expr)) (setq math-args (cons (nth 1 expr) math-args))) (if (eq (car expr) '-) (setq math-args (cons (math-rwcomp-neg (nth 2 expr)) math-args)) (if (eq (car-safe (nth 2 expr)) '+) (math-rwcomp-addsub-args (nth 2 expr)) (setq math-args (cons (nth 2 expr) math-args)))) ) (defun math-rwcomp-order (a b) (< (math-rwcomp-priority (car a)) (math-rwcomp-priority (car b))) ) ;;; Order of priority: 0 Constants and other exact matches (first) ;;; 10 Functions (except below) ;;; 20 Meta-variables which occur more than once ;;; 30 Algebraic functions ;;; 40 Commutative/associative functions ;;; 50 Meta-variables which occur only once ;;; +100 for every "!!!" (pnot) in the pattern ;;; 10000 Optional arguments (last) (defun math-rwcomp-priority (expr) (+ (math-rwcomp-count-pnots expr) (cond ((eq (car-safe expr) 'calcFunc-opt) 10000) ((math-rwcomp-no-vars expr) 0) ((eq (car expr) 'calcFunc-quote) 0) ((eq (car expr) 'var) (if (assq (nth 2 expr) math-regs) 0 (if (= (math-rwcomp-count-refs expr) 1) 50 20))) (t (let ((props (get (car expr) 'math-rewrite-props))) (if (or (memq 'commut props) (memq 'assoc props)) 40 (if (memq 'algebraic props) 30 10)))))) ) (defun math-rwcomp-count-refs (var) (let ((count (or (math-expr-contains-count math-pattern var) 0)) (p math-conds)) (while p (if (eq (car-safe (car p)) 'calcFunc-let) (if (= (length (car p)) 3) (setq count (+ count (or (math-expr-contains-count (nth 2 (car p)) var) 0))) (if (and (= (length (car p)) 2) (eq (car-safe (nth 1 (car p))) 'calcFunc-assign) (= (length (nth 1 (car p))) 3)) (setq count (+ count (or (math-expr-contains-count (nth 2 (nth 1 (car p))) var) 0)))))) (setq p (cdr p))) count) ) (defun math-rwcomp-count-pnots (expr) (if (Math-primp expr) 0 (if (eq (car expr) 'calcFunc-pnot) 100 (let ((count 0)) (while (setq expr (cdr expr)) (setq count (+ count (math-rwcomp-count-pnots (car expr))))) count))) ) ;;; In the current implementation, all associative functions must ;;; also be commutative. (put '+ 'math-rewrite-props '(algebraic assoc commut)) (put '- 'math-rewrite-props '(algebraic assoc commut)) ; see below (put '* 'math-rewrite-props '(algebraic assoc commut)) ; see below (put '/ 'math-rewrite-props '(algebraic unary1)) (put '^ 'math-rewrite-props '(algebraic unary1)) (put '% 'math-rewrite-props '(algebraic)) (put 'neg 'math-rewrite-props '(algebraic)) (put 'calcFunc-idiv 'math-rewrite-props '(algebraic)) (put 'calcFunc-abs 'math-rewrite-props '(algebraic)) (put 'calcFunc-sign 'math-rewrite-props '(algebraic)) (put 'calcFunc-round 'math-rewrite-props '(algebraic)) (put 'calcFunc-rounde 'math-rewrite-props '(algebraic)) (put 'calcFunc-roundu 'math-rewrite-props '(algebraic)) (put 'calcFunc-trunc 'math-rewrite-props '(algebraic)) (put 'calcFunc-floor 'math-rewrite-props '(algebraic)) (put 'calcFunc-ceil 'math-rewrite-props '(algebraic)) (put 'calcFunc-re 'math-rewrite-props '(algebraic)) (put 'calcFunc-im 'math-rewrite-props '(algebraic)) (put 'calcFunc-conj 'math-rewrite-props '(algebraic)) (put 'calcFunc-arg 'math-rewrite-props '(algebraic)) (put 'calcFunc-and 'math-rewrite-props '(assoc commut)) (put 'calcFunc-or 'math-rewrite-props '(assoc commut)) (put 'calcFunc-xor 'math-rewrite-props '(assoc commut)) (put 'calcFunc-eq 'math-rewrite-props '(commut)) (put 'calcFunc-neq 'math-rewrite-props '(commut)) (put 'calcFunc-land 'math-rewrite-props '(assoc commut)) (put 'calcFunc-lor 'math-rewrite-props '(assoc commut)) (put 'calcFunc-beta 'math-rewrite-props '(commut)) (put 'calcFunc-gcd 'math-rewrite-props '(assoc commut)) (put 'calcFunc-lcm 'math-rewrite-props '(assoc commut)) (put 'calcFunc-max 'math-rewrite-props '(algebraic assoc commut)) (put 'calcFunc-min 'math-rewrite-props '(algebraic assoc commut)) (put 'calcFunc-vunion 'math-rewrite-props '(assoc commut)) (put 'calcFunc-vint 'math-rewrite-props '(assoc commut)) (put 'calcFunc-vxor 'math-rewrite-props '(assoc commut)) ;;; Note: "*" is not commutative for matrix args, but we pretend it is. ;;; Also, "-" is not commutative but the code tweaks things so that it is. (put '+ 'math-rewrite-default 0) (put '- 'math-rewrite-default 0) (put '* 'math-rewrite-default 1) (put '/ 'math-rewrite-default 1) (put '^ 'math-rewrite-default 1) (put 'calcFunc-land 'math-rewrite-default 1) (put 'calcFunc-lor 'math-rewrite-default 0) (put 'calcFunc-vunion 'math-rewrite-default '(vec)) (put 'calcFunc-vint 'math-rewrite-default '(vec)) (put 'calcFunc-vdiff 'math-rewrite-default '(vec)) (put 'calcFunc-vxor 'math-rewrite-default '(vec)) (defmacro math-rwfail (&optional back) (list 'setq 'pc (list 'and (if back '(setq btrack (cdr btrack)) 'btrack) ''((backtrack)))) ) ;;; This monstrosity is necessary because the use of static vectors of ;;; registers makes rewrite rules non-reentrant. Yucko! (defmacro math-rweval (form) (list 'let '((orig (car rules))) '(setcar rules (quote (nil nil nil no-phase))) (list 'unwind-protect form '(setcar rules orig))) ) (setq math-rewrite-phase 1) (defun math-apply-rewrites (expr rules &optional heads ruleset) (and (setq rules (cdr (or (assq (car-safe expr) rules) (assq nil rules)))) (let ((result nil) op regs inst part pc mark btrack (tracing math-rwcomp-tracing) (phase math-rewrite-phase)) (while rules (or (and (setq part (nth 2 (car rules))) heads (not (memq part heads))) (and (setq part (nth 3 (car rules))) (not (memq phase part))) (progn (setq regs (car (car rules)) pc (nth 1 (car rules)) btrack nil) (aset regs 0 expr) (while pc (and tracing (progn (terpri) (princ (car pc)) (if (and (natnump (nth 1 (car pc))) (< (nth 1 (car pc)) (length regs))) (princ (format "\n part = %s" (aref regs (nth 1 (car pc)))))))) (cond ((eq (setq op (car (setq inst (car pc)))) 'func) (if (and (consp (setq part (aref regs (car (cdr inst))))) (eq (car part) (car (setq inst (cdr (cdr inst))))) (progn (while (and (setq inst (cdr inst) part (cdr part)) inst) (aset regs (car inst) (car part))) (not (or inst part)))) (setq pc (cdr pc)) (math-rwfail))) ((eq op 'same) (if (or (equal (setq part (aref regs (nth 1 inst))) (setq mark (aref regs (nth 2 inst)))) (Math-equal part mark)) (setq pc (cdr pc)) (math-rwfail))) ((and (eq op 'try) calc-matrix-mode (not (eq calc-matrix-mode 'scalar)) (eq (car (nth 2 inst)) '*) (consp (setq part (aref regs (car (cdr inst))))) (eq (car part) '*) (not (math-known-scalarp part))) (setq mark (nth 3 inst) pc (cdr pc)) (if (aref mark 4) (progn (aset regs (nth 4 inst) (nth 2 part)) (aset mark 1 (cdr (cdr part)))) (aset regs (nth 4 inst) (nth 1 part)) (aset mark 1 (cdr part))) (aset mark 0 (cdr part)) (aset mark 2 0)) ((eq op 'try) (if (and (consp (setq part (aref regs (car (cdr inst))))) (memq (car part) (nth 2 inst)) (= (length part) 3) (or (not (eq (car part) '/)) (Math-objectp (nth 2 part)))) (progn (setq op nil mark (car (cdr (setq inst (cdr (cdr inst)))))) (and (memq 'assoc (get (car part) 'math-rewrite-props)) (not (= (aref mark 3) 0)) (while (if (and (consp (nth 1 part)) (memq (car (nth 1 part)) (car inst))) (setq op (cons (if (eq (car part) '-) (math-rwapply-neg (nth 2 part)) (nth 2 part)) op) part (nth 1 part)) (if (and (consp (nth 2 part)) (memq (car (nth 2 part)) (car inst)) (not (eq (car (nth 2 part)) '-))) (setq op (cons (nth 1 part) op) part (nth 2 part)))))) (setq op (cons (nth 1 part) (cons (if (eq (car part) '-) (math-rwapply-neg (nth 2 part)) (if (eq (car part) '/) (math-rwapply-inv (nth 2 part)) (nth 2 part))) op)) btrack (cons pc btrack) pc (cdr pc)) (aset regs (nth 2 inst) (car op)) (aset mark 0 op) (aset mark 1 op) (aset mark 2 (if (cdr (cdr op)) 1 0))) (if (nth 5 inst) (if (and (consp part) (eq (car part) 'neg) (eq (car (nth 2 inst)) '*) (eq (nth 5 inst) 1)) (progn (setq mark (nth 3 inst) pc (cdr pc)) (aset regs (nth 4 inst) (nth 1 part)) (aset mark 1 -1) (aset mark 2 4)) (setq mark (nth 3 inst) pc (cdr pc)) (aset regs (nth 4 inst) part) (aset mark 2 3)) (math-rwfail)))) ((eq op 'try2) (setq part (nth 1 inst) ; try instr mark (nth 3 part) op (aref mark 2) pc (cdr pc)) (aset regs (nth 2 inst) (cond ((eq op 0) (if (eq (aref mark 0) (aref mark 1)) (nth 1 (aref mark 0)) (car (aref mark 0)))) ((eq op 1) (setq mark (delq (car (aref mark 1)) (copy-sequence (aref mark 0))) op (car (nth 2 part))) (if (eq op '*) (progn (setq mark (nreverse mark) part (list '* (nth 1 mark) (car mark)) mark (cdr mark)) (while (setq mark (cdr mark)) (setq part (list '* (car mark) part)))) (setq part (car mark) mark (cdr mark) part (if (and (eq op '+) (consp (car mark)) (eq (car (car mark)) 'neg)) (list '- part (nth 1 (car mark))) (list op part (car mark)))) (while (setq mark (cdr mark)) (setq part (if (and (eq op '+) (consp (car mark)) (eq (car (car mark)) 'neg)) (list '- part (nth 1 (car mark))) (list op part (car mark)))))) part) ((eq op 2) (car (aref mark 1))) ((eq op 3) (nth 5 part)) (t (aref mark 1))))) ((eq op 'select) (setq pc (cdr pc)) (if (and (consp (setq part (aref regs (nth 1 inst)))) (eq (car part) 'calcFunc-select)) (aset regs (nth 2 inst) (nth 1 part)) (if math-rewrite-selections (math-rwfail) (aset regs (nth 2 inst) part)))) ((eq op 'same-neg) (if (or (equal (setq part (aref regs (nth 1 inst))) (setq mark (math-neg (aref regs (nth 2 inst))))) (Math-equal part mark)) (setq pc (cdr pc)) (math-rwfail))) ((eq op 'backtrack) (setq inst (car (car btrack)) ; "try" or "alt" instr pc (cdr (car btrack)) mark (or (nth 3 inst) [nil nil 4]) op (aref mark 2)) (cond ((eq op 0) (if (setq op (cdr (aref mark 1))) (aset regs (nth 4 inst) (car (aset mark 1 op))) (if (nth 5 inst) (progn (aset mark 2 3) (aset regs (nth 4 inst) (aref regs (nth 1 inst)))) (math-rwfail t)))) ((eq op 1) (if (setq op (cdr (aref mark 1))) (aset regs (nth 4 inst) (car (aset mark 1 op))) (if (= (aref mark 3) 1) (if (nth 5 inst) (progn (aset mark 2 3) (aset regs (nth 4 inst) (aref regs (nth 1 inst)))) (math-rwfail t)) (aset mark 2 2) (aset mark 1 (cons nil (aref mark 0))) (math-rwfail)))) ((eq op 2) (if (setq op (cdr (aref mark 1))) (progn (setq mark (delq (car (aset mark 1 op)) (copy-sequence (aref mark 0))) op (car (nth 2 inst))) (if (eq op '*) (progn (setq mark (nreverse mark) part (list '* (nth 1 mark) (car mark)) mark (cdr mark)) (while (setq mark (cdr mark)) (setq part (list '* (car mark) part)))) (setq part (car mark) mark (cdr mark) part (if (and (eq op '+) (consp (car mark)) (eq (car (car mark)) 'neg)) (list '- part (nth 1 (car mark))) (list op part (car mark)))) (while (setq mark (cdr mark)) (setq part (if (and (eq op '+) (consp (car mark)) (eq (car (car mark)) 'neg)) (list '- part (nth 1 (car mark))) (list op part (car mark)))))) (aset regs (nth 4 inst) part)) (if (nth 5 inst) (progn (aset mark 2 3) (aset regs (nth 4 inst) (aref regs (nth 1 inst)))) (math-rwfail t)))) ((eq op 4) (setq btrack (cdr btrack))) (t (math-rwfail t)))) ((eq op 'integer) (if (Math-integerp (setq part (aref regs (nth 1 inst)))) (setq pc (cdr pc)) (if (Math-primp part) (math-rwfail) (setq part (math-rweval (math-simplify part))) (if (Math-integerp part) (setq pc (cdr pc)) (math-rwfail))))) ((eq op 'real) (if (Math-realp (setq part (aref regs (nth 1 inst)))) (setq pc (cdr pc)) (if (Math-primp part) (math-rwfail) (setq part (math-rweval (math-simplify part))) (if (Math-realp part) (setq pc (cdr pc)) (math-rwfail))))) ((eq op 'constant) (if (math-constp (setq part (aref regs (nth 1 inst)))) (setq pc (cdr pc)) (if (Math-primp part) (math-rwfail) (setq part (math-rweval (math-simplify part))) (if (math-constp part) (setq pc (cdr pc)) (math-rwfail))))) ((eq op 'negative) (if (math-looks-negp (setq part (aref regs (nth 1 inst)))) (setq pc (cdr pc)) (if (Math-primp part) (math-rwfail) (setq part (math-rweval (math-simplify part))) (if (math-looks-negp part) (setq pc (cdr pc)) (math-rwfail))))) ((eq op 'rel) (setq part (math-compare (aref regs (nth 1 inst)) (aref regs (nth 3 inst))) op (nth 2 inst)) (if (= part 2) (setq part (math-rweval (math-simplify (calcFunc-sign (math-sub (aref regs (nth 1 inst)) (aref regs (nth 3 inst)))))))) (if (cond ((eq op 'calcFunc-eq) (eq part 0)) ((eq op 'calcFunc-neq) (memq part '(-1 1))) ((eq op 'calcFunc-lt) (eq part -1)) ((eq op 'calcFunc-leq) (memq part '(-1 0))) ((eq op 'calcFunc-gt) (eq part 1)) ((eq op 'calcFunc-geq) (memq part '(0 1)))) (setq pc (cdr pc)) (math-rwfail))) ((eq op 'func-def) (if (and (consp (setq part (aref regs (car (cdr inst))))) (eq (car part) (car (setq inst (cdr (cdr inst)))))) (progn (setq inst (cdr inst) mark (car inst)) (while (and (setq inst (cdr inst) part (cdr part)) inst) (aset regs (car inst) (car part))) (if (or inst part) (setq pc (cdr pc)) (while (eq (car (car (setq pc (cdr pc)))) 'func-def)) (setq pc (cdr pc)) ; skip over "func" (while mark (aset regs (cdr (car mark)) (car (car mark))) (setq mark (cdr mark))))) (math-rwfail))) ((eq op 'func-opt) (if (or (not (and (consp (setq part (aref regs (car (cdr inst))))) (eq (car part) (nth 2 inst)))) (and (= (length part) 2) (setq part (nth 1 part)))) (progn (setq mark (nth 3 inst)) (aset regs (nth 4 inst) part) (while (eq (car (car (setq pc (cdr pc)))) 'func-def)) (setq pc (cdr pc)) ; skip over "func" (while mark (aset regs (cdr (car mark)) (car (car mark))) (setq mark (cdr mark)))) (setq pc (cdr pc)))) ((eq op 'mod) (if (if (Math-zerop (setq part (aref regs (nth 1 inst)))) (Math-zerop (nth 3 inst)) (and (not (Math-zerop (nth 2 inst))) (progn (setq part (math-mod part (nth 2 inst))) (or (Math-numberp part) (setq part (math-rweval (math-simplify part)))) (Math-equal part (nth 3 inst))))) (setq pc (cdr pc)) (math-rwfail))) ((eq op 'apply) (if (and (consp (setq part (aref regs (car (cdr inst))))) (not (Math-objvecp part)) (not (eq (car part) 'var))) (progn (aset regs (nth 2 inst) (math-calcFunc-to-var (car part))) (aset regs (nth 3 inst) (cons 'vec (cdr part))) (setq pc (cdr pc))) (math-rwfail))) ((eq op 'cons) (if (and (consp (setq part (aref regs (car (cdr inst))))) (eq (car part) 'vec) (cdr part)) (progn (aset regs (nth 2 inst) (nth 1 part)) (aset regs (nth 3 inst) (cons 'vec (cdr (cdr part)))) (setq pc (cdr pc))) (math-rwfail))) ((eq op 'rcons) (if (and (consp (setq part (aref regs (car (cdr inst))))) (eq (car part) 'vec) (cdr part)) (progn (aset regs (nth 2 inst) (calcFunc-rhead part)) (aset regs (nth 3 inst) (calcFunc-rtail part)) (setq pc (cdr pc))) (math-rwfail))) ((eq op 'cond) (if (math-is-true (math-rweval (math-simplify (math-rwapply-replace-regs (nth 1 inst))))) (setq pc (cdr pc)) (math-rwfail))) ((eq op 'let) (aset regs (nth 1 inst) (math-rweval (math-normalize (math-rwapply-replace-regs (nth 2 inst))))) (setq pc (cdr pc))) ((eq op 'copy) (aset regs (nth 2 inst) (aref regs (nth 1 inst))) (setq pc (cdr pc))) ((eq op 'copy-neg) (aset regs (nth 2 inst) (math-rwapply-neg (aref regs (nth 1 inst)))) (setq pc (cdr pc))) ((eq op 'alt) (setq btrack (cons pc btrack) pc (nth 1 inst))) ((eq op 'end-alt) (while (and btrack (not (eq (car btrack) (nth 1 inst)))) (setq btrack (cdr btrack))) (setq btrack (cdr btrack) pc (cdr pc))) ((eq op 'done) (setq result (math-rwapply-replace-regs (nth 1 inst))) (if (or (and (eq (car-safe result) '+) (eq (nth 2 result) 0)) (and (eq (car-safe result) '*) (eq (nth 2 result) 1))) (setq result (nth 1 result))) (setq part (and (nth 2 inst) (math-is-true (math-rweval (math-simplify (math-rwapply-replace-regs (nth 2 inst))))))) (if (or (equal result expr) (equal (setq result (math-normalize result)) expr)) (setq result nil) (if part (math-rwapply-remember expr result)) (setq rules nil)) (setq pc nil)) (t (error "%s is not a valid rewrite opcode" op)))))) (setq rules (cdr rules))) result)) ) (defun math-rwapply-neg (expr) (if (and (consp expr) (memq (car expr) '(* /))) (if (Math-objectp (nth 2 expr)) (list (car expr) (nth 1 expr) (math-neg (nth 2 expr))) (list (car expr) (if (Math-objectp (nth 1 expr)) (math-neg (nth 1 expr)) (list '* -1 (nth 1 expr))) (nth 2 expr))) (math-neg expr)) ) (defun math-rwapply-inv (expr) (if (and (Math-integerp expr) calc-prefer-frac) (math-make-frac 1 expr) (list '/ 1 expr)) ) (defun math-rwapply-replace-regs (expr) (cond ((Math-primp expr) expr) ((eq (car expr) 'calcFunc-register) (setq expr (aref regs (nth 1 expr))) (if (eq (car-safe expr) '*) (if (eq (nth 1 expr) -1) (math-neg (nth 2 expr)) (if (eq (nth 1 expr) 1) (nth 2 expr) expr)) expr)) ((and (eq (car expr) 'calcFunc-eval) (= (length expr) 2)) (calc-with-default-simplification (math-normalize (math-rwapply-replace-regs (nth 1 expr))))) ((and (eq (car expr) 'calcFunc-evalsimp) (= (length expr) 2)) (math-simplify (math-rwapply-replace-regs (nth 1 expr)))) ((and (eq (car expr) 'calcFunc-evalextsimp) (= (length expr) 2)) (math-simplify-extended (math-rwapply-replace-regs (nth 1 expr)))) ((and (eq (car expr) 'calcFunc-apply) (= (length expr) 3)) (let ((func (math-rwapply-replace-regs (nth 1 expr))) (args (math-rwapply-replace-regs (nth 2 expr))) call) (if (and (math-vectorp args) (not (eq (car-safe (setq call (math-build-call (math-var-to-calcFunc func) (cdr args)))) 'calcFunc-call))) call (list 'calcFunc-apply func args)))) ((and (eq (car expr) 'calcFunc-cons) (= (length expr) 3)) (let ((head (math-rwapply-replace-regs (nth 1 expr))) (tail (math-rwapply-replace-regs (nth 2 expr)))) (if (math-vectorp tail) (cons 'vec (cons head (cdr tail))) (list 'calcFunc-cons head tail)))) ((and (eq (car expr) 'calcFunc-rcons) (= (length expr) 3)) (let ((head (math-rwapply-replace-regs (nth 1 expr))) (tail (math-rwapply-replace-regs (nth 2 expr)))) (if (math-vectorp head) (append head (list tail)) (list 'calcFunc-rcons head tail)))) ((and (eq (car expr) 'neg) (math-rwapply-reg-looks-negp (nth 1 expr))) (math-rwapply-reg-neg (nth 1 expr))) ((and (eq (car expr) 'neg) (eq (car-safe (nth 1 expr)) 'calcFunc-register) (math-scalarp (aref regs (nth 1 (nth 1 expr))))) (math-neg (math-rwapply-replace-regs (nth 1 expr)))) ((and (eq (car expr) '+) (math-rwapply-reg-looks-negp (nth 1 expr))) (list '- (math-rwapply-replace-regs (nth 2 expr)) (math-rwapply-reg-neg (nth 1 expr)))) ((and (eq (car expr) '+) (math-rwapply-reg-looks-negp (nth 2 expr))) (list '- (math-rwapply-replace-regs (nth 1 expr)) (math-rwapply-reg-neg (nth 2 expr)))) ((and (eq (car expr) '-) (math-rwapply-reg-looks-negp (nth 2 expr))) (list '+ (math-rwapply-replace-regs (nth 1 expr)) (math-rwapply-reg-neg (nth 2 expr)))) ((eq (car expr) '*) (cond ((eq (nth 1 expr) -1) (if (math-rwapply-reg-looks-negp (nth 2 expr)) (math-rwapply-reg-neg (nth 2 expr)) (math-neg (math-rwapply-replace-regs (nth 2 expr))))) ((eq (nth 1 expr) 1) (math-rwapply-replace-regs (nth 2 expr))) ((eq (nth 2 expr) -1) (if (math-rwapply-reg-looks-negp (nth 1 expr)) (math-rwapply-reg-neg (nth 1 expr)) (math-neg (math-rwapply-replace-regs (nth 1 expr))))) ((eq (nth 2 expr) 1) (math-rwapply-replace-regs (nth 1 expr))) (t (let ((arg1 (math-rwapply-replace-regs (nth 1 expr))) (arg2 (math-rwapply-replace-regs (nth 2 expr)))) (cond ((and (eq (car-safe arg1) '/) (eq (nth 1 arg1) 1)) (list '/ arg2 (nth 2 arg1))) ((and (eq (car-safe arg2) '/) (eq (nth 1 arg2) 1)) (list '/ arg1 (nth 2 arg2))) (t (list '* arg1 arg2))))))) ((eq (car expr) '/) (let ((arg1 (math-rwapply-replace-regs (nth 1 expr))) (arg2 (math-rwapply-replace-regs (nth 2 expr)))) (if (eq (car-safe arg2) '/) (list '/ (list '* arg1 (nth 2 arg2)) (nth 1 arg2)) (list '/ arg1 arg2)))) ((and (eq (car expr) 'calcFunc-plain) (= (length expr) 2)) (if (Math-primp (nth 1 expr)) (nth 1 expr) (if (eq (car (nth 1 expr)) 'calcFunc-register) (aref regs (nth 1 (nth 1 expr))) (cons (car (nth 1 expr)) (mapcar 'math-rwapply-replace-regs (cdr (nth 1 expr))))))) (t (cons (car expr) (mapcar 'math-rwapply-replace-regs (cdr expr))))) ) (defun math-rwapply-reg-looks-negp (expr) (if (eq (car-safe expr) 'calcFunc-register) (math-looks-negp (aref regs (nth 1 expr))) (if (memq (car-safe expr) '(* /)) (or (math-rwapply-reg-looks-negp (nth 1 expr)) (math-rwapply-reg-looks-negp (nth 2 expr))))) ) (defun math-rwapply-reg-neg (expr) ; expr must satisfy rwapply-reg-looks-negp (if (eq (car expr) 'calcFunc-register) (math-neg (math-rwapply-replace-regs expr)) (if (math-rwapply-reg-looks-negp (nth 1 expr)) (math-rwapply-replace-regs (list (car expr) (math-rwapply-reg-neg (nth 1 expr)) (nth 2 expr))) (math-rwapply-replace-regs (list (car expr) (nth 1 expr) (math-rwapply-reg-neg (nth 2 expr)))))) ) (defun math-rwapply-remember (old new) (let ((varval (symbol-value (nth 2 (car ruleset)))) (rules (assq (car-safe old) ruleset))) (if (and (eq (car-safe varval) 'vec) (not (memq (car-safe old) '(nil schedule + -))) rules) (progn (setcdr varval (cons (list 'calcFunc-assign (if (math-rwcomp-no-vars old) old (list 'calcFunc-quote old)) new) (cdr varval))) (setcdr rules (cons (list (vector nil old) (list (list 'same 0 1) (list 'done new nil)) nil nil) (cdr rules)))))) ) calc-2.02c/calc-alg.el100644 22403 13 152003 5547406465 13063 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-alg.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-alg () nil) ;;; Algebra commands. (defun calc-alg-evaluate (arg) (interactive "p") (calc-slow-wrapper (calc-with-default-simplification (let ((math-simplify-only nil)) (calc-modify-simplify-mode arg) (calc-enter-result 1 "dsmp" (calc-top 1))))) ) (defun calc-modify-simplify-mode (arg) (if (= (math-abs arg) 2) (setq calc-simplify-mode 'alg) (if (>= (math-abs arg) 3) (setq calc-simplify-mode 'ext))) (if (< arg 0) (setq calc-simplify-mode (list calc-simplify-mode))) ) (defun calc-simplify () (interactive) (calc-slow-wrapper (calc-with-default-simplification (calc-enter-result 1 "simp" (math-simplify (calc-top-n 1))))) ) (defun calc-simplify-extended () (interactive) (calc-slow-wrapper (calc-with-default-simplification (calc-enter-result 1 "esmp" (math-simplify-extended (calc-top-n 1))))) ) (defun calc-expand-formula (arg) (interactive "p") (calc-slow-wrapper (calc-with-default-simplification (let ((math-simplify-only nil)) (calc-modify-simplify-mode arg) (calc-enter-result 1 "expf" (if (> arg 0) (let ((math-expand-formulas t)) (calc-top-n 1)) (let ((top (calc-top-n 1))) (or (math-expand-formula top) top))))))) ) (defun calc-factor (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "fctr" (if (calc-is-hyperbolic) 'calcFunc-factors 'calcFunc-factor) arg)) ) (defun calc-expand (n) (interactive "P") (calc-slow-wrapper (calc-enter-result 1 "expa" (append (list 'calcFunc-expand (calc-top-n 1)) (and n (list (prefix-numeric-value n)))))) ) (defun calc-collect (&optional var) (interactive "sCollect terms involving: ") (calc-slow-wrapper (if (or (equal var "") (equal var "$") (null var)) (calc-enter-result 2 "clct" (cons 'calcFunc-collect (calc-top-list-n 2))) (let ((var (math-read-expr var))) (if (eq (car-safe var) 'error) (error "Bad format in expression: %s" (nth 1 var))) (calc-enter-result 1 "clct" (list 'calcFunc-collect (calc-top-n 1) var))))) ) (defun calc-apart (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "aprt" 'calcFunc-apart arg)) ) (defun calc-normalize-rat (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "nrat" 'calcFunc-nrat arg)) ) (defun calc-poly-gcd (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "pgcd" 'calcFunc-pgcd arg)) ) (defun calc-poly-div (arg) (interactive "P") (calc-slow-wrapper (setq calc-poly-div-remainder nil) (calc-binary-op "pdiv" 'calcFunc-pdiv arg) (if (and calc-poly-div-remainder (null arg)) (progn (calc-clear-command-flag 'clear-message) (calc-record calc-poly-div-remainder "prem") (if (not (Math-zerop calc-poly-div-remainder)) (message "(Remainder was %s)" (math-format-flat-expr calc-poly-div-remainder 0)) (message "(No remainder)"))))) ) (defun calc-poly-rem (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "prem" 'calcFunc-prem arg)) ) (defun calc-poly-div-rem (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-hyperbolic) (calc-binary-op "pdvr" 'calcFunc-pdivide arg) (calc-binary-op "pdvr" 'calcFunc-pdivrem arg))) ) (defun calc-substitute (&optional oldname newname) (interactive "sSubstitute old: ") (calc-slow-wrapper (let (old new (num 1) expr) (if (or (equal oldname "") (equal oldname "$") (null oldname)) (setq new (calc-top-n 1) old (calc-top-n 2) expr (calc-top-n 3) num 3) (or newname (progn (calc-unread-command ?\C-a) (setq newname (read-string (concat "Substitute old: " oldname ", new: ") oldname)))) (if (or (equal newname "") (equal newname "$") (null newname)) (setq new (calc-top-n 1) expr (calc-top-n 2) num 2) (setq new (if (stringp newname) (math-read-expr newname) newname)) (if (eq (car-safe new) 'error) (error "Bad format in expression: %s" (nth 1 new))) (setq expr (calc-top-n 1))) (setq old (if (stringp oldname) (math-read-expr oldname) oldname)) (if (eq (car-safe old) 'error) (error "Bad format in expression: %s" (nth 1 old))) (or (math-expr-contains expr old) (error "No occurrences found."))) (calc-enter-result num "sbst" (math-expr-subst expr old new)))) ) (defun calc-has-rules (name) (setq name (calc-var-value name)) (and (consp name) (memq (car name) '(vec calcFunc-assign calcFunc-condition)) name) ) (defun math-recompile-eval-rules () (setq math-eval-rules-cache (and (calc-has-rules 'var-EvalRules) (math-compile-rewrites '(var EvalRules var-EvalRules))) math-eval-rules-cache-other (assq nil math-eval-rules-cache) math-eval-rules-cache-tag (calc-var-value 'var-EvalRules)) ) ;;; Try to expand a formula according to its definition. (defun math-expand-formula (expr) (and (consp expr) (symbolp (car expr)) (or (get (car expr) 'calc-user-defn) (get (car expr) 'math-expandable)) (let ((res (let ((math-expand-formulas t)) (apply (car expr) (cdr expr))))) (and (not (eq (car-safe res) (car expr))) res))) ) ;;; True if A comes before B in a canonical ordering of expressions. [P X X] (defun math-beforep (a b) ; [Public] (cond ((and (Math-realp a) (Math-realp b)) (let ((comp (math-compare a b))) (or (eq comp -1) (and (eq comp 0) (not (equal a b)) (> (length (memq (car-safe a) '(bigneg nil bigpos frac float))) (length (memq (car-safe b) '(bigneg nil bigpos frac float)))))))) ((equal b '(neg (var inf var-inf))) nil) ((equal a '(neg (var inf var-inf))) t) ((equal a '(var inf var-inf)) nil) ((equal b '(var inf var-inf)) t) ((Math-realp a) (if (and (eq (car-safe b) 'intv) (math-intv-constp b)) (if (or (math-beforep a (nth 2 b)) (Math-equal a (nth 2 b))) t nil) t)) ((Math-realp b) (if (and (eq (car-safe a) 'intv) (math-intv-constp a)) (if (math-beforep (nth 2 a) b) t nil) nil)) ((and (eq (car a) 'intv) (eq (car b) 'intv) (math-intv-constp a) (math-intv-constp b)) (let ((comp (math-compare (nth 2 a) (nth 2 b)))) (cond ((eq comp -1) t) ((eq comp 1) nil) ((and (memq (nth 1 a) '(2 3)) (memq (nth 1 b) '(0 1))) t) ((and (memq (nth 1 a) '(0 1)) (memq (nth 1 b) '(2 3))) nil) ((eq (setq comp (math-compare (nth 3 a) (nth 3 b))) -1) t) ((eq comp 1) nil) ((and (memq (nth 1 a) '(0 2)) (memq (nth 1 b) '(1 3))) t) (t nil)))) ((not (eq (not (Math-objectp a)) (not (Math-objectp b)))) (Math-objectp a)) ((eq (car a) 'var) (if (eq (car b) 'var) (string-lessp (symbol-name (nth 1 a)) (symbol-name (nth 1 b))) (not (Math-numberp b)))) ((eq (car b) 'var) (Math-numberp a)) ((eq (car a) (car b)) (while (and (setq a (cdr a) b (cdr b)) a (equal (car a) (car b)))) (and b (or (null a) (math-beforep (car a) (car b))))) (t (string-lessp (symbol-name (car a)) (symbol-name (car b))))) ) (defun math-simplify-extended (a) (let ((math-living-dangerously t)) (math-simplify a)) ) (fset 'calcFunc-esimplify (symbol-function 'math-simplify-extended)) (defun math-simplify (top-expr) (let ((math-simplifying t) (top-only (consp calc-simplify-mode)) (simp-rules (append (and (calc-has-rules 'var-AlgSimpRules) '((var AlgSimpRules var-AlgSimpRules))) (and math-living-dangerously (calc-has-rules 'var-ExtSimpRules) '((var ExtSimpRules var-ExtSimpRules))) (and math-simplifying-units (calc-has-rules 'var-UnitSimpRules) '((var UnitSimpRules var-UnitSimpRules))) (and math-integrating (calc-has-rules 'var-IntegSimpRules) '((var IntegSimpRules var-IntegSimpRules))))) res) (if top-only (let ((r simp-rules)) (setq res (math-simplify-step (math-normalize top-expr)) calc-simplify-mode '(nil) top-expr (math-normalize res)) (while r (setq top-expr (math-rewrite top-expr (car r) '(neg (var inf var-inf))) r (cdr r)))) (calc-with-default-simplification (while (let ((r simp-rules)) (setq res (math-normalize top-expr)) (while r (setq res (math-rewrite res (car r)) r (cdr r))) (not (equal top-expr (setq res (math-simplify-step res))))) (setq top-expr res))))) top-expr ) (fset 'calcFunc-simplify (symbol-function 'math-simplify)) ;;; The following has a "bug" in that if any recursive simplifications ;;; occur only the first handler will be tried; this doesn't really ;;; matter, since math-simplify-step is iterated to a fixed point anyway. (defun math-simplify-step (a) (if (Math-primp a) a (let ((aa (if (or top-only (memq (car a) '(calcFunc-quote calcFunc-condition calcFunc-evalto))) a (cons (car a) (mapcar 'math-simplify-step (cdr a)))))) (and (symbolp (car aa)) (let ((handler (get (car aa) 'math-simplify))) (and handler (while (and handler (equal (setq aa (or (funcall (car handler) aa) aa)) a)) (setq handler (cdr handler)))))) aa)) ) (defun math-need-std-simps () ;; Placeholder, to synchronize autoloading. ) (math-defsimplify (+ -) (math-simplify-plus)) (defun math-simplify-plus () (cond ((and (memq (car-safe (nth 1 expr)) '(+ -)) (Math-numberp (nth 2 (nth 1 expr))) (not (Math-numberp (nth 2 expr)))) (let ((x (nth 2 expr)) (op (car expr))) (setcar (cdr (cdr expr)) (nth 2 (nth 1 expr))) (setcar expr (car (nth 1 expr))) (setcar (cdr (cdr (nth 1 expr))) x) (setcar (nth 1 expr) op))) ((and (eq (car expr) '+) (Math-numberp (nth 1 expr)) (not (Math-numberp (nth 2 expr)))) (let ((x (nth 2 expr))) (setcar (cdr (cdr expr)) (nth 1 expr)) (setcar (cdr expr) x)))) (let ((aa expr) aaa temp) (while (memq (car-safe (setq aaa (nth 1 aa))) '(+ -)) (if (setq temp (math-combine-sum (nth 2 aaa) (nth 2 expr) (eq (car aaa) '-) (eq (car expr) '-) t)) (progn (setcar (cdr (cdr expr)) temp) (setcar expr '+) (setcar (cdr (cdr aaa)) 0))) (setq aa (nth 1 aa))) (if (setq temp (math-combine-sum aaa (nth 2 expr) nil (eq (car expr) '-) t)) (progn (setcar (cdr (cdr expr)) temp) (setcar expr '+) (setcar (cdr aa) 0))) expr) ) (math-defsimplify * (math-simplify-times)) (defun math-simplify-times () (if (eq (car-safe (nth 2 expr)) '*) (and (math-beforep (nth 1 (nth 2 expr)) (nth 1 expr)) (or (math-known-scalarp (nth 1 expr) t) (math-known-scalarp (nth 1 (nth 2 expr)) t)) (let ((x (nth 1 expr))) (setcar (cdr expr) (nth 1 (nth 2 expr))) (setcar (cdr (nth 2 expr)) x))) (and (math-beforep (nth 2 expr) (nth 1 expr)) (or (math-known-scalarp (nth 1 expr) t) (math-known-scalarp (nth 2 expr) t)) (let ((x (nth 2 expr))) (setcar (cdr (cdr expr)) (nth 1 expr)) (setcar (cdr expr) x)))) (let ((aa expr) aaa temp (safe t) (scalar (math-known-scalarp (nth 1 expr)))) (if (and (Math-ratp (nth 1 expr)) (setq temp (math-common-constant-factor (nth 2 expr)))) (progn (setcar (cdr (cdr expr)) (math-cancel-common-factor (nth 2 expr) temp)) (setcar (cdr expr) (math-mul (nth 1 expr) temp)))) (while (and (eq (car-safe (setq aaa (nth 2 aa))) '*) safe) (if (setq temp (math-combine-prod (nth 1 expr) (nth 1 aaa) nil nil t)) (progn (setcar (cdr expr) temp) (setcar (cdr aaa) 1))) (setq safe (or scalar (math-known-scalarp (nth 1 aaa) t)) aa (nth 2 aa))) (if (and (setq temp (math-combine-prod aaa (nth 1 expr) nil nil t)) safe) (progn (setcar (cdr expr) temp) (setcar (cdr (cdr aa)) 1))) (if (and (eq (car-safe (nth 1 expr)) 'frac) (memq (nth 1 (nth 1 expr)) '(1 -1))) (math-div (math-mul (nth 2 expr) (nth 1 (nth 1 expr))) (nth 2 (nth 1 expr))) expr)) ) (math-defsimplify / (math-simplify-divide)) (defun math-simplify-divide () (let ((np (cdr expr)) (nover nil) (nn (and (or (eq (car expr) '/) (not (Math-realp (nth 2 expr)))) (math-common-constant-factor (nth 2 expr)))) n op) (if nn (progn (setq n (and (or (eq (car expr) '/) (not (Math-realp (nth 1 expr)))) (math-common-constant-factor (nth 1 expr)))) (if (and (eq (car-safe nn) 'frac) (eq (nth 1 nn) 1) (not n)) (progn (setcar (cdr expr) (math-mul (nth 2 nn) (nth 1 expr))) (setcar (cdr (cdr expr)) (math-cancel-common-factor (nth 2 expr) nn)) (if (and (math-negp nn) (setq op (assq (car expr) calc-tweak-eqn-table))) (setcar expr (nth 1 op)))) (if (and n (not (eq (setq n (math-frac-gcd n nn)) 1))) (progn (setcar (cdr expr) (math-cancel-common-factor (nth 1 expr) n)) (setcar (cdr (cdr expr)) (math-cancel-common-factor (nth 2 expr) n)) (if (and (math-negp n) (setq op (assq (car expr) calc-tweak-eqn-table))) (setcar expr (nth 1 op)))))))) (if (and (eq (car-safe (car np)) '/) (math-known-scalarp (nth 2 expr) t)) (progn (setq np (cdr (nth 1 expr))) (while (eq (car-safe (setq n (car np))) '*) (and (math-known-scalarp (nth 2 n) t) (math-simplify-divisor (cdr n) (cdr (cdr expr)) nil t)) (setq np (cdr (cdr n)))) (math-simplify-divisor np (cdr (cdr expr)) nil t) (setq nover t np (cdr (cdr (nth 1 expr)))))) (while (eq (car-safe (setq n (car np))) '*) (and (math-known-scalarp (nth 2 n) t) (math-simplify-divisor (cdr n) (cdr (cdr expr)) nover t)) (setq np (cdr (cdr n)))) (math-simplify-divisor np (cdr (cdr expr)) nover t) expr) ) (defun math-simplify-divisor (np dp nover dover) (cond ((eq (car-safe (car dp)) '/) (math-simplify-divisor np (cdr (car dp)) nover dover) (and (math-known-scalarp (nth 1 (car dp)) t) (math-simplify-divisor np (cdr (cdr (car dp))) nover (not dover)))) ((or (or (eq (car expr) '/) (let ((signs (math-possible-signs (car np)))) (or (memq signs '(1 4)) (and (memq (car expr) '(calcFunc-eq calcFunc-neq)) (eq signs 5)) math-living-dangerously))) (math-numberp (car np))) (let ((n (car np)) d dd temp op (safe t) (scalar (math-known-scalarp n))) (while (and (eq (car-safe (setq d (car dp))) '*) safe) (math-simplify-one-divisor np (cdr d)) (setq safe (or scalar (math-known-scalarp (nth 1 d) t)) dp (cdr (cdr d)))) (if safe (math-simplify-one-divisor np dp))))) ) (defun math-simplify-one-divisor (np dp) (if (setq temp (math-combine-prod (car np) (car dp) nover dover t)) (progn (and (not (memq (car expr) '(/ calcFunc-eq calcFunc-neq))) (math-known-negp (car dp)) (setq op (assq (car expr) calc-tweak-eqn-table)) (setcar expr (nth 1 op))) (setcar np (if nover (math-div 1 temp) temp)) (setcar dp 1)) (and dover (not nover) (eq (car expr) '/) (eq (car-safe (car dp)) 'calcFunc-sqrt) (Math-integerp (nth 1 (car dp))) (progn (setcar np (math-mul (car np) (list 'calcFunc-sqrt (nth 1 (car dp))))) (setcar dp (nth 1 (car dp)))))) ) (defun math-common-constant-factor (expr) (if (Math-realp expr) (if (Math-ratp expr) (and (not (memq expr '(0 1 -1))) (math-abs expr)) (if (math-ratp (setq expr (math-to-simple-fraction expr))) (math-common-constant-factor expr))) (if (memq (car expr) '(+ - cplx sdev)) (let ((f1 (math-common-constant-factor (nth 1 expr))) (f2 (math-common-constant-factor (nth 2 expr)))) (and f1 f2 (not (eq (setq f1 (math-frac-gcd f1 f2)) 1)) f1)) (if (memq (car expr) '(* polar)) (math-common-constant-factor (nth 1 expr)) (if (eq (car expr) '/) (or (math-common-constant-factor (nth 1 expr)) (and (Math-integerp (nth 2 expr)) (list 'frac 1 (math-abs (nth 2 expr))))))))) ) (defun math-cancel-common-factor (expr val) (if (memq (car-safe expr) '(+ - cplx sdev)) (progn (setcar (cdr expr) (math-cancel-common-factor (nth 1 expr) val)) (setcar (cdr (cdr expr)) (math-cancel-common-factor (nth 2 expr) val)) expr) (if (eq (car-safe expr) '*) (math-mul (math-cancel-common-factor (nth 1 expr) val) (nth 2 expr)) (math-div expr val))) ) (defun math-frac-gcd (a b) (if (Math-zerop a) b (if (Math-zerop b) a (if (and (Math-integerp a) (Math-integerp b)) (math-gcd a b) (and (Math-integerp a) (setq a (list 'frac a 1))) (and (Math-integerp b) (setq b (list 'frac b 1))) (math-make-frac (math-gcd (nth 1 a) (nth 1 b)) (math-gcd (nth 2 a) (nth 2 b)))))) ) (math-defsimplify % (math-simplify-mod)) (defun math-simplify-mod () (and (Math-realp (nth 2 expr)) (Math-posp (nth 2 expr)) (let ((lin (math-is-linear (nth 1 expr))) t1 t2 t3) (or (and lin (or (math-negp (car lin)) (not (Math-lessp (car lin) (nth 2 expr)))) (list '% (list '+ (math-mul (nth 1 lin) (nth 2 lin)) (math-mod (car lin) (nth 2 expr))) (nth 2 expr))) (and lin (not (math-equal-int (nth 1 lin) 1)) (math-num-integerp (nth 1 lin)) (math-num-integerp (nth 2 expr)) (setq t1 (calcFunc-gcd (nth 1 lin) (nth 2 expr))) (not (math-equal-int t1 1)) (list '* t1 (list '% (list '+ (math-mul (math-div (nth 1 lin) t1) (nth 2 lin)) (let ((calc-prefer-frac t)) (math-div (car lin) t1))) (math-div (nth 2 expr) t1)))) (and (math-equal-int (nth 2 expr) 1) (math-known-integerp (if lin (math-mul (nth 1 lin) (nth 2 lin)) (nth 1 expr))) (if lin (math-mod (car lin) 1) 0))))) ) (math-defsimplify (calcFunc-eq calcFunc-neq calcFunc-lt calcFunc-gt calcFunc-leq calcFunc-geq) (if (= (length expr) 3) (math-simplify-ineq))) (defun math-simplify-ineq () (let ((np (cdr expr)) n) (while (memq (car-safe (setq n (car np))) '(+ -)) (math-simplify-add-term (cdr (cdr n)) (cdr (cdr expr)) (eq (car n) '-) nil) (setq np (cdr n))) (math-simplify-add-term np (cdr (cdr expr)) nil (eq np (cdr expr))) (math-simplify-divide) (let ((signs (math-possible-signs (cons '- (cdr expr))))) (or (cond ((eq (car expr) 'calcFunc-eq) (or (and (eq signs 2) 1) (and (memq signs '(1 4 5)) 0))) ((eq (car expr) 'calcFunc-neq) (or (and (eq signs 2) 0) (and (memq signs '(1 4 5)) 1))) ((eq (car expr) 'calcFunc-lt) (or (and (eq signs 1) 1) (and (memq signs '(2 4 6)) 0))) ((eq (car expr) 'calcFunc-gt) (or (and (eq signs 4) 1) (and (memq signs '(1 2 3)) 0))) ((eq (car expr) 'calcFunc-leq) (or (and (eq signs 4) 0) (and (memq signs '(1 2 3)) 1))) ((eq (car expr) 'calcFunc-geq) (or (and (eq signs 1) 0) (and (memq signs '(2 4 6)) 1)))) expr))) ) (defun math-simplify-add-term (np dp minus lplain) (or (math-vectorp (car np)) (let ((rplain t) n d dd temp) (while (memq (car-safe (setq n (car np) d (car dp))) '(+ -)) (setq rplain nil) (if (setq temp (math-combine-sum n (nth 2 d) minus (eq (car d) '+) t)) (if (or lplain (eq (math-looks-negp temp) minus)) (progn (setcar np (setq n (if minus (math-neg temp) temp))) (setcar (cdr (cdr d)) 0)) (progn (setcar np 0) (setcar (cdr (cdr d)) (setq n (if (eq (car d) '+) (math-neg temp) temp)))))) (setq dp (cdr d))) (if (setq temp (math-combine-sum n d minus t t)) (if (or lplain (and (not rplain) (eq (math-looks-negp temp) minus))) (progn (setcar np (setq n (if minus (math-neg temp) temp))) (setcar dp 0)) (progn (setcar np 0) (setcar dp (setq n (math-neg temp)))))))) ) (math-defsimplify calcFunc-sin (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-arcsin) (nth 1 (nth 1 expr))) (and (math-looks-negp (nth 1 expr)) (math-neg (list 'calcFunc-sin (math-neg (nth 1 expr))))) (and (eq calc-angle-mode 'rad) (let ((n (math-linear-in (nth 1 expr) '(var pi var-pi)))) (and n (math-known-sin (car n) (nth 1 n) 120 0)))) (and (eq calc-angle-mode 'deg) (let ((n (math-integer-plus (nth 1 expr)))) (and n (math-known-sin (car n) (nth 1 n) '(frac 2 3) 0)))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-arccos) (list 'calcFunc-sqrt (math-sub 1 (math-sqr (nth 1 (nth 1 expr)))))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-arctan) (math-div (nth 1 (nth 1 expr)) (list 'calcFunc-sqrt (math-add 1 (math-sqr (nth 1 (nth 1 expr))))))) (let ((m (math-should-expand-trig (nth 1 expr)))) (and m (integerp (car m)) (let ((n (car m)) (a (nth 1 m))) (list '+ (list '* (list 'calcFunc-sin (list '* (1- n) a)) (list 'calcFunc-cos a)) (list '* (list 'calcFunc-cos (list '* (1- n) a)) (list 'calcFunc-sin a))))))) ) (math-defsimplify calcFunc-cos (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-arccos) (nth 1 (nth 1 expr))) (and (math-looks-negp (nth 1 expr)) (list 'calcFunc-cos (math-neg (nth 1 expr)))) (and (eq calc-angle-mode 'rad) (let ((n (math-linear-in (nth 1 expr) '(var pi var-pi)))) (and n (math-known-sin (car n) (nth 1 n) 120 300)))) (and (eq calc-angle-mode 'deg) (let ((n (math-integer-plus (nth 1 expr)))) (and n (math-known-sin (car n) (nth 1 n) '(frac 2 3) 300)))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-arcsin) (list 'calcFunc-sqrt (math-sub 1 (math-sqr (nth 1 (nth 1 expr)))))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-arctan) (math-div 1 (list 'calcFunc-sqrt (math-add 1 (math-sqr (nth 1 (nth 1 expr))))))) (let ((m (math-should-expand-trig (nth 1 expr)))) (and m (integerp (car m)) (let ((n (car m)) (a (nth 1 m))) (list '- (list '* (list 'calcFunc-cos (list '* (1- n) a)) (list 'calcFunc-cos a)) (list '* (list 'calcFunc-sin (list '* (1- n) a)) (list 'calcFunc-sin a))))))) ) (defun math-should-expand-trig (x &optional hyperbolic) (let ((m (math-is-multiple x))) (and math-living-dangerously m (or (and (integerp (car m)) (> (car m) 1)) (equal (car m) '(frac 1 2))) (or math-integrating (memq (car-safe (nth 1 m)) (if hyperbolic '(calcFunc-arcsinh calcFunc-arccosh calcFunc-arctanh) '(calcFunc-arcsin calcFunc-arccos calcFunc-arctan))) (and (eq (car-safe (nth 1 m)) 'calcFunc-ln) (eq hyperbolic 'exp))) m)) ) (defun math-known-sin (plus n mul off) (setq n (math-mul n mul)) (and (math-num-integerp n) (setq n (math-mod (math-add (math-trunc n) off) 240)) (if (>= n 120) (and (setq n (math-known-sin plus (- n 120) 1 0)) (math-neg n)) (if (> n 60) (setq n (- 120 n))) (if (math-zerop plus) (and (or calc-symbolic-mode (memq n '(0 20 60))) (cdr (assq n '( (0 . 0) (10 . (/ (calcFunc-sqrt (- 2 (calcFunc-sqrt 3))) 2)) (12 . (/ (- (calcFunc-sqrt 5) 1) 4)) (15 . (/ (calcFunc-sqrt (- 2 (calcFunc-sqrt 2))) 2)) (20 . (/ 1 2)) (24 . (* (^ (/ 1 2) (/ 3 2)) (calcFunc-sqrt (- 5 (calcFunc-sqrt 5))))) (30 . (/ (calcFunc-sqrt 2) 2)) (36 . (/ (+ (calcFunc-sqrt 5) 1) 4)) (40 . (/ (calcFunc-sqrt 3) 2)) (45 . (/ (calcFunc-sqrt (+ 2 (calcFunc-sqrt 2))) 2)) (48 . (* (^ (/ 1 2) (/ 3 2)) (calcFunc-sqrt (+ 5 (calcFunc-sqrt 5))))) (50 . (/ (calcFunc-sqrt (+ 2 (calcFunc-sqrt 3))) 2)) (60 . 1))))) (cond ((eq n 0) (math-normalize (list 'calcFunc-sin plus))) ((eq n 60) (math-normalize (list 'calcFunc-cos plus))) (t nil))))) ) (math-defsimplify calcFunc-tan (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-arctan) (nth 1 (nth 1 expr))) (and (math-looks-negp (nth 1 expr)) (math-neg (list 'calcFunc-tan (math-neg (nth 1 expr))))) (and (eq calc-angle-mode 'rad) (let ((n (math-linear-in (nth 1 expr) '(var pi var-pi)))) (and n (math-known-tan (car n) (nth 1 n) 120)))) (and (eq calc-angle-mode 'deg) (let ((n (math-integer-plus (nth 1 expr)))) (and n (math-known-tan (car n) (nth 1 n) '(frac 2 3))))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-arcsin) (math-div (nth 1 (nth 1 expr)) (list 'calcFunc-sqrt (math-sub 1 (math-sqr (nth 1 (nth 1 expr))))))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-arccos) (math-div (list 'calcFunc-sqrt (math-sub 1 (math-sqr (nth 1 (nth 1 expr))))) (nth 1 (nth 1 expr)))) (let ((m (math-should-expand-trig (nth 1 expr)))) (and m (if (equal (car m) '(frac 1 2)) (math-div (math-sub 1 (list 'calcFunc-cos (nth 1 m))) (list 'calcFunc-sin (nth 1 m))) (math-div (list 'calcFunc-sin (nth 1 expr)) (list 'calcFunc-cos (nth 1 expr))))))) ) (defun math-known-tan (plus n mul) (setq n (math-mul n mul)) (and (math-num-integerp n) (setq n (math-mod (math-trunc n) 120)) (if (> n 60) (and (setq n (math-known-tan plus (- 120 n) 1)) (math-neg n)) (if (math-zerop plus) (and (or calc-symbolic-mode (memq n '(0 30 60))) (cdr (assq n '( (0 . 0) (10 . (- 2 (calcFunc-sqrt 3))) (12 . (calcFunc-sqrt (- 1 (* (/ 2 5) (calcFunc-sqrt 5))))) (15 . (- (calcFunc-sqrt 2) 1)) (20 . (/ (calcFunc-sqrt 3) 3)) (24 . (calcFunc-sqrt (- 5 (* 2 (calcFunc-sqrt 5))))) (30 . 1) (36 . (calcFunc-sqrt (+ 1 (* (/ 2 5) (calcFunc-sqrt 5))))) (40 . (calcFunc-sqrt 3)) (45 . (+ (calcFunc-sqrt 2) 1)) (48 . (calcFunc-sqrt (+ 5 (* 2 (calcFunc-sqrt 5))))) (50 . (+ 2 (calcFunc-sqrt 3))) (60 . (var uinf var-uinf)))))) (cond ((eq n 0) (math-normalize (list 'calcFunc-tan plus))) ((eq n 60) (math-normalize (list '/ -1 (list 'calcFunc-tan plus)))) (t nil))))) ) (math-defsimplify calcFunc-sinh (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-arcsinh) (nth 1 (nth 1 expr))) (and (math-looks-negp (nth 1 expr)) (math-neg (list 'calcFunc-sinh (math-neg (nth 1 expr))))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-arccosh) math-living-dangerously (list 'calcFunc-sqrt (math-sub (math-sqr (nth 1 (nth 1 expr))) 1))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-arctanh) math-living-dangerously (math-div (nth 1 (nth 1 expr)) (list 'calcFunc-sqrt (math-sub 1 (math-sqr (nth 1 (nth 1 expr))))))) (let ((m (math-should-expand-trig (nth 1 expr) t))) (and m (integerp (car m)) (let ((n (car m)) (a (nth 1 m))) (if (> n 1) (list '+ (list '* (list 'calcFunc-sinh (list '* (1- n) a)) (list 'calcFunc-cosh a)) (list '* (list 'calcFunc-cosh (list '* (1- n) a)) (list 'calcFunc-sinh a)))))))) ) (math-defsimplify calcFunc-cosh (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-arccosh) (nth 1 (nth 1 expr))) (and (math-looks-negp (nth 1 expr)) (list 'calcFunc-cosh (math-neg (nth 1 expr)))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-arcsinh) math-living-dangerously (list 'calcFunc-sqrt (math-add (math-sqr (nth 1 (nth 1 expr))) 1))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-arctanh) math-living-dangerously (math-div 1 (list 'calcFunc-sqrt (math-sub 1 (math-sqr (nth 1 (nth 1 expr))))))) (let ((m (math-should-expand-trig (nth 1 expr) t))) (and m (integerp (car m)) (let ((n (car m)) (a (nth 1 m))) (if (> n 1) (list '+ (list '* (list 'calcFunc-cosh (list '* (1- n) a)) (list 'calcFunc-cosh a)) (list '* (list 'calcFunc-sinh (list '* (1- n) a)) (list 'calcFunc-sinh a)))))))) ) (math-defsimplify calcFunc-tanh (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-arctanh) (nth 1 (nth 1 expr))) (and (math-looks-negp (nth 1 expr)) (math-neg (list 'calcFunc-tanh (math-neg (nth 1 expr))))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-arcsinh) math-living-dangerously (math-div (nth 1 (nth 1 expr)) (list 'calcFunc-sqrt (math-add (math-sqr (nth 1 (nth 1 expr))) 1)))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-arccosh) math-living-dangerously (math-div (list 'calcFunc-sqrt (math-sub (math-sqr (nth 1 (nth 1 expr))) 1)) (nth 1 (nth 1 expr)))) (let ((m (math-should-expand-trig (nth 1 expr) t))) (and m (if (equal (car m) '(frac 1 2)) (math-div (math-sub (list 'calcFunc-cosh (nth 1 m)) 1) (list 'calcFunc-sinh (nth 1 m))) (math-div (list 'calcFunc-sinh (nth 1 expr)) (list 'calcFunc-cosh (nth 1 expr))))))) ) (math-defsimplify calcFunc-arcsin (or (and (math-looks-negp (nth 1 expr)) (math-neg (list 'calcFunc-arcsin (math-neg (nth 1 expr))))) (and (eq (nth 1 expr) 1) (math-quarter-circle t)) (and (equal (nth 1 expr) '(frac 1 2)) (math-div (math-half-circle t) 6)) (and math-living-dangerously (eq (car-safe (nth 1 expr)) 'calcFunc-sin) (nth 1 (nth 1 expr))) (and math-living-dangerously (eq (car-safe (nth 1 expr)) 'calcFunc-cos) (math-sub (math-quarter-circle t) (nth 1 (nth 1 expr))))) ) (math-defsimplify calcFunc-arccos (or (and (eq (nth 1 expr) 0) (math-quarter-circle t)) (and (eq (nth 1 expr) -1) (math-half-circle t)) (and (equal (nth 1 expr) '(frac 1 2)) (math-div (math-half-circle t) 3)) (and (equal (nth 1 expr) '(frac -1 2)) (math-div (math-mul (math-half-circle t) 2) 3)) (and math-living-dangerously (eq (car-safe (nth 1 expr)) 'calcFunc-cos) (nth 1 (nth 1 expr))) (and math-living-dangerously (eq (car-safe (nth 1 expr)) 'calcFunc-sin) (math-sub (math-quarter-circle t) (nth 1 (nth 1 expr))))) ) (math-defsimplify calcFunc-arctan (or (and (math-looks-negp (nth 1 expr)) (math-neg (list 'calcFunc-arctan (math-neg (nth 1 expr))))) (and (eq (nth 1 expr) 1) (math-div (math-half-circle t) 4)) (and math-living-dangerously (eq (car-safe (nth 1 expr)) 'calcFunc-tan) (nth 1 (nth 1 expr)))) ) (math-defsimplify calcFunc-arcsinh (or (and (math-looks-negp (nth 1 expr)) (math-neg (list 'calcFunc-arcsinh (math-neg (nth 1 expr))))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-sinh) (or math-living-dangerously (math-known-realp (nth 1 (nth 1 expr)))) (nth 1 (nth 1 expr)))) ) (math-defsimplify calcFunc-arccosh (and (eq (car-safe (nth 1 expr)) 'calcFunc-cosh) (or math-living-dangerously (math-known-realp (nth 1 (nth 1 expr)))) (nth 1 (nth 1 expr))) ) (math-defsimplify calcFunc-arctanh (or (and (math-looks-negp (nth 1 expr)) (math-neg (list 'calcFunc-arctanh (math-neg (nth 1 expr))))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-tanh) (or math-living-dangerously (math-known-realp (nth 1 (nth 1 expr)))) (nth 1 (nth 1 expr)))) ) (math-defsimplify calcFunc-sqrt (math-simplify-sqrt) ) (defun math-simplify-sqrt () (or (and (eq (car-safe (nth 1 expr)) 'frac) (math-div (list 'calcFunc-sqrt (math-mul (nth 1 (nth 1 expr)) (nth 2 (nth 1 expr)))) (nth 2 (nth 1 expr)))) (let ((fac (if (math-objectp (nth 1 expr)) (math-squared-factor (nth 1 expr)) (math-common-constant-factor (nth 1 expr))))) (and fac (not (eq fac 1)) (math-mul (math-normalize (list 'calcFunc-sqrt fac)) (math-normalize (list 'calcFunc-sqrt (math-cancel-common-factor (nth 1 expr) fac)))))) (and math-living-dangerously (or (and (eq (car-safe (nth 1 expr)) '-) (math-equal-int (nth 1 (nth 1 expr)) 1) (eq (car-safe (nth 2 (nth 1 expr))) '^) (math-equal-int (nth 2 (nth 2 (nth 1 expr))) 2) (or (and (eq (car-safe (nth 1 (nth 2 (nth 1 expr)))) 'calcFunc-sin) (list 'calcFunc-cos (nth 1 (nth 1 (nth 2 (nth 1 expr)))))) (and (eq (car-safe (nth 1 (nth 2 (nth 1 expr)))) 'calcFunc-cos) (list 'calcFunc-sin (nth 1 (nth 1 (nth 2 (nth 1 expr)))))))) (and (eq (car-safe (nth 1 expr)) '-) (math-equal-int (nth 2 (nth 1 expr)) 1) (eq (car-safe (nth 1 (nth 1 expr))) '^) (math-equal-int (nth 2 (nth 1 (nth 1 expr))) 2) (and (eq (car-safe (nth 1 (nth 1 (nth 1 expr)))) 'calcFunc-cosh) (list 'calcFunc-sinh (nth 1 (nth 1 (nth 1 (nth 1 expr))))))) (and (eq (car-safe (nth 1 expr)) '+) (let ((a (nth 1 (nth 1 expr))) (b (nth 2 (nth 1 expr)))) (and (or (and (math-equal-int a 1) (setq a b b (nth 1 (nth 1 expr)))) (math-equal-int b 1)) (eq (car-safe a) '^) (math-equal-int (nth 2 a) 2) (or (and (eq (car-safe (nth 1 a)) 'calcFunc-sinh) (list 'calcFunc-cosh (nth 1 (nth 1 a)))) (and (eq (car-safe (nth 1 a)) 'calcFunc-tan) (list '/ 1 (list 'calcFunc-cos (nth 1 (nth 1 a))))))))) (and (eq (car-safe (nth 1 expr)) '^) (list '^ (nth 1 (nth 1 expr)) (math-div (nth 2 (nth 1 expr)) 2))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-sqrt) (list '^ (nth 1 (nth 1 expr)) (math-div 1 4))) (and (memq (car-safe (nth 1 expr)) '(* /)) (list (car (nth 1 expr)) (list 'calcFunc-sqrt (nth 1 (nth 1 expr))) (list 'calcFunc-sqrt (nth 2 (nth 1 expr))))) (and (memq (car-safe (nth 1 expr)) '(+ -)) (not (math-any-floats (nth 1 expr))) (let ((f (calcFunc-factors (calcFunc-expand (nth 1 expr))))) (and (math-vectorp f) (or (> (length f) 2) (> (nth 2 (nth 1 f)) 1)) (let ((out 1) (rest 1) (sums 1) fac pow) (while (setq f (cdr f)) (setq fac (nth 1 (car f)) pow (nth 2 (car f))) (if (> pow 1) (setq out (math-mul out (math-pow fac (/ pow 2))) pow (% pow 2))) (if (> pow 0) (if (memq (car-safe fac) '(+ -)) (setq sums (math-mul-thru sums fac)) (setq rest (math-mul rest fac))))) (and (not (and (eq out 1) (memq rest '(1 -1)))) (math-mul out (list 'calcFunc-sqrt (math-mul sums rest))))))))))) ) ;;; Rather than factoring x into primes, just check for the first ten primes. (defun math-squared-factor (x) (if (Math-integerp x) (let ((prsqr '(4 9 25 49 121 169 289 361 529 841)) (fac 1) res) (while prsqr (if (eq (cdr (setq res (math-idivmod x (car prsqr)))) 0) (setq x (car res) fac (math-mul fac (car prsqr))) (setq prsqr (cdr prsqr)))) fac)) ) (math-defsimplify calcFunc-exp (math-simplify-exp (nth 1 expr)) ) (defun math-simplify-exp (x) (or (and (eq (car-safe x) 'calcFunc-ln) (nth 1 x)) (and math-living-dangerously (or (and (eq (car-safe x) 'calcFunc-arcsinh) (math-add (nth 1 x) (list 'calcFunc-sqrt (math-add (math-sqr (nth 1 x)) 1)))) (and (eq (car-safe x) 'calcFunc-arccosh) (math-add (nth 1 x) (list 'calcFunc-sqrt (math-sub (math-sqr (nth 1 x)) 1)))) (and (eq (car-safe x) 'calcFunc-arctanh) (math-div (list 'calcFunc-sqrt (math-add 1 (nth 1 x))) (list 'calcFunc-sqrt (math-sub 1 (nth 1 x))))) (let ((m (math-should-expand-trig x 'exp))) (and m (integerp (car m)) (list '^ (list 'calcFunc-exp (nth 1 m)) (car m)))))) (and calc-symbolic-mode (math-known-imagp x) (let* ((ip (calcFunc-im x)) (n (math-linear-in ip '(var pi var-pi))) s c) (and n (setq s (math-known-sin (car n) (nth 1 n) 120 0)) (setq c (math-known-sin (car n) (nth 1 n) 120 300)) (list '+ c (list '* s '(var i var-i))))))) ) (math-defsimplify calcFunc-ln (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-exp) (or math-living-dangerously (math-known-realp (nth 1 (nth 1 expr)))) (nth 1 (nth 1 expr))) (and (eq (car-safe (nth 1 expr)) '^) (equal (nth 1 (nth 1 expr)) '(var e var-e)) (or math-living-dangerously (math-known-realp (nth 2 (nth 1 expr)))) (nth 2 (nth 1 expr))) (and calc-symbolic-mode (math-known-negp (nth 1 expr)) (math-add (list 'calcFunc-ln (math-neg (nth 1 expr))) '(var pi var-pi))) (and calc-symbolic-mode (math-known-imagp (nth 1 expr)) (let* ((ip (calcFunc-im (nth 1 expr))) (ips (math-possible-signs ip))) (or (and (memq ips '(4 6)) (math-add (list 'calcFunc-ln ip) '(/ (* (var pi var-pi) (var i var-i)) 2))) (and (memq ips '(1 3)) (math-sub (list 'calcFunc-ln (math-neg ip)) '(/ (* (var pi var-pi) (var i var-i)) 2))))))) ) (math-defsimplify ^ (math-simplify-pow)) (defun math-simplify-pow () (or (and math-living-dangerously (or (and (eq (car-safe (nth 1 expr)) '^) (list '^ (nth 1 (nth 1 expr)) (math-mul (nth 2 expr) (nth 2 (nth 1 expr))))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-sqrt) (list '^ (nth 1 (nth 1 expr)) (math-div (nth 2 expr) 2))) (and (memq (car-safe (nth 1 expr)) '(* /)) (list (car (nth 1 expr)) (list '^ (nth 1 (nth 1 expr)) (nth 2 expr)) (list '^ (nth 2 (nth 1 expr)) (nth 2 expr)))))) (and (math-equal-int (nth 1 expr) 10) (eq (car-safe (nth 2 expr)) 'calcFunc-log10) (nth 1 (nth 2 expr))) (and (equal (nth 1 expr) '(var e var-e)) (math-simplify-exp (nth 2 expr))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-exp) (not math-integrating) (list 'calcFunc-exp (math-mul (nth 1 (nth 1 expr)) (nth 2 expr)))) (and (equal (nth 1 expr) '(var i var-i)) (math-imaginary-i) (math-num-integerp (nth 2 expr)) (let ((x (math-mod (math-trunc (nth 2 expr)) 4))) (cond ((eq x 0) 1) ((eq x 1) (nth 1 expr)) ((eq x 2) -1) ((eq x 3) (math-neg (nth 1 expr)))))) (and math-integrating (integerp (nth 2 expr)) (>= (nth 2 expr) 2) (or (and (eq (car-safe (nth 1 expr)) 'calcFunc-cos) (math-mul (math-pow (nth 1 expr) (- (nth 2 expr) 2)) (math-sub 1 (math-sqr (list 'calcFunc-sin (nth 1 (nth 1 expr))))))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-cosh) (math-mul (math-pow (nth 1 expr) (- (nth 2 expr) 2)) (math-add 1 (math-sqr (list 'calcFunc-sinh (nth 1 (nth 1 expr))))))))) (and (eq (car-safe (nth 2 expr)) 'frac) (Math-ratp (nth 1 expr)) (Math-posp (nth 1 expr)) (if (equal (nth 2 expr) '(frac 1 2)) (list 'calcFunc-sqrt (nth 1 expr)) (let ((flr (math-floor (nth 2 expr)))) (and (not (Math-zerop flr)) (list '* (list '^ (nth 1 expr) flr) (list '^ (nth 1 expr) (math-sub (nth 2 expr) flr))))))) (and (eq (math-quarter-integer (nth 2 expr)) 2) (let ((temp (math-simplify-sqrt))) (and temp (list '^ temp (math-mul (nth 2 expr) 2)))))) ) (math-defsimplify calcFunc-log10 (and (eq (car-safe (nth 1 expr)) '^) (math-equal-int (nth 1 (nth 1 expr)) 10) (or math-living-dangerously (math-known-realp (nth 2 (nth 1 expr)))) (nth 2 (nth 1 expr))) ) (math-defsimplify calcFunc-erf (or (and (math-looks-negp (nth 1 expr)) (math-neg (list 'calcFunc-erf (math-neg (nth 1 expr))))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-conj) (list 'calcFunc-conj (list 'calcFunc-erf (nth 1 (nth 1 expr)))))) ) (math-defsimplify calcFunc-erfc (or (and (math-looks-negp (nth 1 expr)) (math-sub 2 (list 'calcFunc-erfc (math-neg (nth 1 expr))))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-conj) (list 'calcFunc-conj (list 'calcFunc-erfc (nth 1 (nth 1 expr)))))) ) (defun math-linear-in (expr term &optional always) (if (math-expr-contains expr term) (let* ((calc-prefer-frac t) (p (math-is-polynomial expr term 1))) (and (cdr p) p)) (and always (list expr 0))) ) (defun math-multiple-of (expr term) (let ((p (math-linear-in expr term))) (and p (math-zerop (car p)) (nth 1 p))) ) (defun math-integer-plus (expr) (cond ((Math-integerp expr) (list 0 expr)) ((and (memq (car expr) '(+ -)) (Math-integerp (nth 1 expr))) (list (if (eq (car expr) '+) (nth 2 expr) (math-neg (nth 2 expr))) (nth 1 expr))) ((and (memq (car expr) '(+ -)) (Math-integerp (nth 2 expr))) (list (nth 1 expr) (if (eq (car expr) '+) (nth 2 expr) (math-neg (nth 2 expr))))) (t nil)) ; not perfect, but it'll do ) (defun math-is-linear (expr &optional always) (let ((offset nil) (coef nil)) (if (eq (car-safe expr) '+) (if (Math-objectp (nth 1 expr)) (setq offset (nth 1 expr) expr (nth 2 expr)) (if (Math-objectp (nth 2 expr)) (setq offset (nth 2 expr) expr (nth 1 expr)))) (if (eq (car-safe expr) '-) (if (Math-objectp (nth 1 expr)) (setq offset (nth 1 expr) expr (math-neg (nth 2 expr))) (if (Math-objectp (nth 2 expr)) (setq offset (math-neg (nth 2 expr)) expr (nth 1 expr)))))) (setq coef (math-is-multiple expr always)) (if offset (list offset (or (car coef) 1) (or (nth 1 coef) expr)) (if coef (cons 0 coef)))) ) (defun math-is-multiple (expr &optional always) (or (if (eq (car-safe expr) '*) (if (Math-objectp (nth 1 expr)) (list (nth 1 expr) (nth 2 expr))) (if (eq (car-safe expr) '/) (if (and (Math-objectp (nth 1 expr)) (not (math-equal-int (nth 1 expr) 1))) (list (nth 1 expr) (math-div 1 (nth 2 expr))) (if (Math-objectp (nth 2 expr)) (list (math-div 1 (nth 2 expr)) (nth 1 expr)) (let ((res (math-is-multiple (nth 1 expr)))) (if res (list (car res) (math-div (nth 2 (nth 1 expr)) (nth 2 expr))) (setq res (math-is-multiple (nth 2 expr))) (if res (list (math-div 1 (car res)) (math-div (nth 1 expr) (nth 2 (nth 2 expr))))))))) (if (eq (car-safe expr) 'neg) (list -1 (nth 1 expr))))) (if (Math-objvecp expr) (and (eq always 1) (list expr 1)) (and always (list 1 expr)))) ) (defun calcFunc-lin (expr &optional var) (if var (let ((res (math-linear-in expr var t))) (or res (math-reject-arg expr "Linear term expected")) (list 'vec (car res) (nth 1 res) var)) (let ((res (math-is-linear expr t))) (or res (math-reject-arg expr "Linear term expected")) (cons 'vec res))) ) (defun calcFunc-linnt (expr &optional var) (if var (let ((res (math-linear-in expr var))) (or res (math-reject-arg expr "Linear term expected")) (list 'vec (car res) (nth 1 res) var)) (let ((res (math-is-linear expr))) (or res (math-reject-arg expr "Linear term expected")) (cons 'vec res))) ) (defun calcFunc-islin (expr &optional var) (if (and (Math-objvecp expr) (not var)) 0 (calcFunc-lin expr var) 1) ) (defun calcFunc-islinnt (expr &optional var) (if (Math-objvecp expr) 0 (calcFunc-linnt expr var) 1) ) ;;; Simple operations on expressions. ;;; Return number of ocurrences of thing in expr, or nil if none. (defun math-expr-contains-count (expr thing) (cond ((equal expr thing) 1) ((Math-primp expr) nil) (t (let ((num 0)) (while (setq expr (cdr expr)) (setq num (+ num (or (math-expr-contains-count (car expr) thing) 0)))) (and (> num 0) num)))) ) (defun math-expr-contains (expr thing) (cond ((equal expr thing) 1) ((Math-primp expr) nil) (t (while (and (setq expr (cdr expr)) (not (math-expr-contains (car expr) thing)))) expr)) ) ;;; Return non-nil if any variable of thing occurs in expr. (defun math-expr-depends (expr thing) (if (Math-primp thing) (and (eq (car-safe thing) 'var) (math-expr-contains expr thing)) (while (and (setq thing (cdr thing)) (not (math-expr-depends expr (car thing))))) thing) ) ;;; Substitute all occurrences of old for new in expr (non-destructive). (defun math-expr-subst (expr old new) (math-expr-subst-rec expr) ) (fset 'calcFunc-subst (symbol-function 'math-expr-subst)) (defun math-expr-subst-rec (expr) (cond ((equal expr old) new) ((Math-primp expr) expr) ((memq (car expr) '(calcFunc-deriv calcFunc-tderiv)) (if (= (length expr) 2) (if (equal (nth 1 expr) old) (append expr (list new)) expr) (list (car expr) (nth 1 expr) (math-expr-subst-rec (nth 2 expr))))) (t (cons (car expr) (mapcar 'math-expr-subst-rec (cdr expr))))) ) ;;; Various measures of the size of an expression. (defun math-expr-weight (expr) (if (Math-primp expr) 1 (let ((w 1)) (while (setq expr (cdr expr)) (setq w (+ w (math-expr-weight (car expr))))) w)) ) (defun math-expr-height (expr) (if (Math-primp expr) 0 (let ((h 0)) (while (setq expr (cdr expr)) (setq h (max h (math-expr-height (car expr))))) (1+ h))) ) ;;; Polynomial operations (to support the integrator and solve-for). (defun calcFunc-collect (expr base) (let ((p (math-is-polynomial expr base 50 t))) (if (cdr p) (math-normalize ; fix selection bug (math-build-polynomial-expr p base)) expr)) ) ;;; If expr is of the form "a + bx + cx^2 + ...", return the list (a b c ...), ;;; else return nil if not in polynomial form. If "loose", coefficients ;;; may contain x, e.g., sin(x) + cos(x) x^2 is a loose polynomial in x. (defun math-is-polynomial (expr var &optional degree loose) (let* ((math-poly-base-variable (if loose (if (eq loose 'gen) var '(var XXX XXX)) math-poly-base-variable)) (poly (math-is-poly-rec expr math-poly-neg-powers))) (and (or (null degree) (<= (length poly) (1+ degree))) poly)) ) (defun math-is-poly-rec (expr negpow) (math-poly-simplify (or (cond ((or (equal expr var) (eq (car-safe expr) '^)) (let ((pow 1) (expr expr)) (or (equal expr var) (setq pow (nth 2 expr) expr (nth 1 expr))) (or (eq math-poly-mult-powers 1) (setq pow (let ((m (math-is-multiple pow 1))) (and (eq (car-safe (car m)) 'cplx) (Math-zerop (nth 1 (car m))) (setq m (list (nth 2 (car m)) (math-mul (nth 1 m) '(var i var-i))))) (and (if math-poly-mult-powers (equal math-poly-mult-powers (nth 1 m)) (setq math-poly-mult-powers (nth 1 m))) (or (equal expr var) (eq math-poly-mult-powers 1)) (car m))))) (if (consp pow) (progn (setq pow (math-to-simple-fraction pow)) (and (eq (car-safe pow) 'frac) math-poly-frac-powers (equal expr var) (setq math-poly-frac-powers (calcFunc-lcm math-poly-frac-powers (nth 2 pow)))))) (or (memq math-poly-frac-powers '(1 nil)) (setq pow (math-mul pow math-poly-frac-powers))) (if (integerp pow) (if (and (= pow 1) (equal expr var)) (list 0 1) (if (natnump pow) (let ((p1 (if (equal expr var) (list 0 1) (math-is-poly-rec expr nil))) (n pow) (accum (list 1))) (and p1 (or (null degree) (<= (* (1- (length p1)) n) degree)) (progn (while (>= n 1) (setq accum (math-poly-mul accum p1) n (1- n))) accum))) (and negpow (math-is-poly-rec expr nil) (setq math-poly-neg-powers (cons (math-pow expr (- pow)) math-poly-neg-powers)) (list (list '^ expr pow)))))))) ((Math-objectp expr) (list expr)) ((memq (car expr) '(+ -)) (let ((p1 (math-is-poly-rec (nth 1 expr) negpow))) (and p1 (let ((p2 (math-is-poly-rec (nth 2 expr) negpow))) (and p2 (math-poly-mix p1 1 p2 (if (eq (car expr) '+) 1 -1))))))) ((eq (car expr) 'neg) (mapcar 'math-neg (math-is-poly-rec (nth 1 expr) negpow))) ((eq (car expr) '*) (let ((p1 (math-is-poly-rec (nth 1 expr) negpow))) (and p1 (let ((p2 (math-is-poly-rec (nth 2 expr) negpow))) (and p2 (or (null degree) (<= (- (+ (length p1) (length p2)) 2) degree)) (math-poly-mul p1 p2)))))) ((eq (car expr) '/) (and (or (not (math-poly-depends (nth 2 expr) var)) (and negpow (math-is-poly-rec (nth 2 expr) nil) (setq math-poly-neg-powers (cons (nth 2 expr) math-poly-neg-powers)))) (not (Math-zerop (nth 2 expr))) (let ((p1 (math-is-poly-rec (nth 1 expr) negpow))) (mapcar (function (lambda (x) (math-div x (nth 2 expr)))) p1)))) ((and (eq (car expr) 'calcFunc-exp) (equal var '(var e var-e))) (math-is-poly-rec (list '^ var (nth 1 expr)) negpow)) ((and (eq (car expr) 'calcFunc-sqrt) math-poly-frac-powers) (math-is-poly-rec (list '^ (nth 1 expr) '(frac 1 2)) negpow)) (t nil)) (and (or (not (math-poly-depends expr var)) loose) (not (eq (car expr) 'vec)) (list expr)))) ) ;;; Check if expr is a polynomial in var; if so, return its degree. (defun math-polynomial-p (expr var) (cond ((equal expr var) 1) ((Math-primp expr) 0) ((memq (car expr) '(+ -)) (let ((p1 (math-polynomial-p (nth 1 expr) var)) p2) (and p1 (setq p2 (math-polynomial-p (nth 2 expr) var)) (max p1 p2)))) ((eq (car expr) '*) (let ((p1 (math-polynomial-p (nth 1 expr) var)) p2) (and p1 (setq p2 (math-polynomial-p (nth 2 expr) var)) (+ p1 p2)))) ((eq (car expr) 'neg) (math-polynomial-p (nth 1 expr) var)) ((and (eq (car expr) '/) (not (math-poly-depends (nth 2 expr) var))) (math-polynomial-p (nth 1 expr) var)) ((and (eq (car expr) '^) (natnump (nth 2 expr))) (let ((p1 (math-polynomial-p (nth 1 expr) var))) (and p1 (* p1 (nth 2 expr))))) ((math-poly-depends expr var) nil) (t 0)) ) (defun math-poly-depends (expr var) (if math-poly-base-variable (math-expr-contains expr math-poly-base-variable) (math-expr-depends expr var)) ) ;;; Find the variable (or sub-expression) which is the base of polynomial expr. (defun math-polynomial-base (mpb-top-expr &optional mpb-pred) (or mpb-pred (setq mpb-pred (function (lambda (base) (math-polynomial-p mpb-top-expr base))))) (or (let ((const-ok nil)) (math-polynomial-base-rec mpb-top-expr)) (let ((const-ok t)) (math-polynomial-base-rec mpb-top-expr))) ) (defun math-polynomial-base-rec (mpb-expr) (and (not (Math-objvecp mpb-expr)) (or (and (memq (car mpb-expr) '(+ - *)) (or (math-polynomial-base-rec (nth 1 mpb-expr)) (math-polynomial-base-rec (nth 2 mpb-expr)))) (and (memq (car mpb-expr) '(/ neg)) (math-polynomial-base-rec (nth 1 mpb-expr))) (and (eq (car mpb-expr) '^) (math-polynomial-base-rec (nth 1 mpb-expr))) (and (eq (car mpb-expr) 'calcFunc-exp) (math-polynomial-base-rec '(var e var-e))) (and (or const-ok (math-expr-contains-vars mpb-expr)) (funcall mpb-pred mpb-expr) mpb-expr))) ) ;;; Return non-nil if expr refers to any variables. (defun math-expr-contains-vars (expr) (or (eq (car-safe expr) 'var) (and (not (Math-primp expr)) (progn (while (and (setq expr (cdr expr)) (not (math-expr-contains-vars (car expr))))) expr))) ) ;;; Simplify a polynomial in list form by stripping off high-end zeros. ;;; This always leaves the constant part, i.e., nil->nil and nonnil->nonnil. (defun math-poly-simplify (p) (and p (if (Math-zerop (nth (1- (length p)) p)) (let ((pp (copy-sequence p))) (while (and (cdr pp) (Math-zerop (nth (1- (length pp)) pp))) (setcdr (nthcdr (- (length pp) 2) pp) nil)) pp) p)) ) ;;; Compute ac*a + bc*b for polynomials in list form a, b and ;;; coefficients ac, bc. Result may be unsimplified. (defun math-poly-mix (a ac b bc) (and (or a b) (cons (math-add (math-mul (or (car a) 0) ac) (math-mul (or (car b) 0) bc)) (math-poly-mix (cdr a) ac (cdr b) bc))) ) (defun math-poly-zerop (a) (or (null a) (and (null (cdr a)) (Math-zerop (car a)))) ) ;;; Multiply two polynomials in list form. (defun math-poly-mul (a b) (and a b (math-poly-mix b (car a) (math-poly-mul (cdr a) (cons 0 b)) 1)) ) ;;; Build an expression from a polynomial list. (defun math-build-polynomial-expr (p var) (if p (if (Math-numberp var) (math-with-extra-prec 1 (let* ((rp (reverse p)) (accum (car rp))) (while (setq rp (cdr rp)) (setq accum (math-add (car rp) (math-mul accum var)))) accum)) (let* ((rp (reverse p)) (n (1- (length rp))) (accum (math-mul (car rp) (math-pow var n))) term) (while (setq rp (cdr rp)) (setq n (1- n)) (or (math-zerop (car rp)) (setq accum (list (if (math-looks-negp (car rp)) '- '+) accum (math-mul (if (math-looks-negp (car rp)) (math-neg (car rp)) (car rp)) (math-pow var n)))))) accum)) 0) ) (defun math-to-simple-fraction (f) (or (and (eq (car-safe f) 'float) (or (and (>= (nth 2 f) 0) (math-scale-int (nth 1 f) (nth 2 f))) (and (integerp (nth 1 f)) (> (nth 1 f) -1000) (< (nth 1 f) 1000) (math-make-frac (nth 1 f) (math-scale-int 1 (- (nth 2 f))))))) f) ) calc-2.02c/calc-alg-2.el100644 22403 13 331516 5402630465 13217 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-alg-2.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-alg-2 () nil) (defun calc-derivative (var num) (interactive "sDifferentiate with respect to: \np") (calc-slow-wrapper (and (< num 0) (error "Order of derivative must be positive")) (let ((func (if (calc-is-hyperbolic) 'calcFunc-tderiv 'calcFunc-deriv)) n expr) (if (or (equal var "") (equal var "$")) (setq n 2 expr (calc-top-n 2) var (calc-top-n 1)) (setq var (math-read-expr var)) (if (eq (car-safe var) 'error) (error "Bad format in expression: %s" (nth 1 var))) (setq n 1 expr (calc-top-n 1))) (while (>= (setq num (1- num)) 0) (setq expr (list func expr var))) (calc-enter-result n "derv" expr))) ) (defun calc-integral (var) (interactive "sIntegration variable: ") (calc-slow-wrapper (if (or (equal var "") (equal var "$")) (calc-enter-result 2 "intg" (list 'calcFunc-integ (calc-top-n 2) (calc-top-n 1))) (let ((var (math-read-expr var))) (if (eq (car-safe var) 'error) (error "Bad format in expression: %s" (nth 1 var))) (calc-enter-result 1 "intg" (list 'calcFunc-integ (calc-top-n 1) var))))) ) (defun calc-num-integral (&optional varname lowname highname) (interactive "sIntegration variable: ") (calc-tabular-command 'calcFunc-ninteg "Integration" "nint" nil varname lowname highname) ) (defun calc-summation (arg &optional varname lowname highname) (interactive "P\nsSummation variable: ") (calc-tabular-command 'calcFunc-sum "Summation" "sum" arg varname lowname highname) ) (defun calc-alt-summation (arg &optional varname lowname highname) (interactive "P\nsSummation variable: ") (calc-tabular-command 'calcFunc-asum "Summation" "asum" arg varname lowname highname) ) (defun calc-product (arg &optional varname lowname highname) (interactive "P\nsIndex variable: ") (calc-tabular-command 'calcFunc-prod "Index" "prod" arg varname lowname highname) ) (defun calc-tabulate (arg &optional varname lowname highname) (interactive "P\nsIndex variable: ") (calc-tabular-command 'calcFunc-table "Index" "tabl" arg varname lowname highname) ) (defun calc-tabular-command (func prompt prefix arg varname lowname highname) (calc-slow-wrapper (let (var (low nil) (high nil) (step nil) stepname stepnum (num 1) expr) (if (consp arg) (setq stepnum 1) (setq stepnum 0)) (if (or (equal varname "") (equal varname "$") (null varname)) (setq high (calc-top-n (+ stepnum 1)) low (calc-top-n (+ stepnum 2)) var (calc-top-n (+ stepnum 3)) num (+ stepnum 4)) (setq var (if (stringp varname) (math-read-expr varname) varname)) (if (eq (car-safe var) 'error) (error "Bad format in expression: %s" (nth 1 var))) (or lowname (setq lowname (read-string (concat prompt " variable: " varname ", from: ")))) (if (or (equal lowname "") (equal lowname "$")) (setq high (calc-top-n (+ stepnum 1)) low (calc-top-n (+ stepnum 2)) num (+ stepnum 3)) (setq low (if (stringp lowname) (math-read-expr lowname) lowname)) (if (eq (car-safe low) 'error) (error "Bad format in expression: %s" (nth 1 low))) (or highname (setq highname (read-string (concat prompt " variable: " varname ", from: " lowname ", to: ")))) (if (or (equal highname "") (equal highname "$")) (setq high (calc-top-n (+ stepnum 1)) num (+ stepnum 2)) (setq high (if (stringp highname) (math-read-expr highname) highname)) (if (eq (car-safe high) 'error) (error "Bad format in expression: %s" (nth 1 high))) (if (consp arg) (progn (setq stepname (read-string (concat prompt " variable: " varname ", from: " lowname ", to: " highname ", step: "))) (if (or (equal stepname "") (equal stepname "$")) (setq step (calc-top-n 1) num 2) (setq step (math-read-expr stepname)) (if (eq (car-safe step) 'error) (error "Bad format in expression: %s" (nth 1 step))))))))) (or step (if (consp arg) (setq step (calc-top-n 1)) (if arg (setq step (prefix-numeric-value arg))))) (setq expr (calc-top-n num)) (calc-enter-result num prefix (append (list func expr var low high) (and step (list step)))))) ) (defun calc-solve-for (var) (interactive "sVariable to solve for: ") (calc-slow-wrapper (let ((func (if (calc-is-inverse) (if (calc-is-hyperbolic) 'calcFunc-ffinv 'calcFunc-finv) (if (calc-is-hyperbolic) 'calcFunc-fsolve 'calcFunc-solve)))) (if (or (equal var "") (equal var "$")) (calc-enter-result 2 "solv" (list func (calc-top-n 2) (calc-top-n 1))) (let ((var (if (and (string-match ",\\|[^ ] +[^ ]" var) (not (string-match "\\[" var))) (math-read-expr (concat "[" var "]")) (math-read-expr var)))) (if (eq (car-safe var) 'error) (error "Bad format in expression: %s" (nth 1 var))) (calc-enter-result 1 "solv" (list func (calc-top-n 1) var)))))) ) (defun calc-poly-roots (var) (interactive "sVariable to solve for: ") (calc-slow-wrapper (if (or (equal var "") (equal var "$")) (calc-enter-result 2 "prts" (list 'calcFunc-roots (calc-top-n 2) (calc-top-n 1))) (let ((var (if (and (string-match ",\\|[^ ] +[^ ]" var) (not (string-match "\\[" var))) (math-read-expr (concat "[" var "]")) (math-read-expr var)))) (if (eq (car-safe var) 'error) (error "Bad format in expression: %s" (nth 1 var))) (calc-enter-result 1 "prts" (list 'calcFunc-roots (calc-top-n 1) var))))) ) (defun calc-taylor (var nterms) (interactive "sTaylor expansion variable: \nNNumber of terms: ") (calc-slow-wrapper (let ((var (math-read-expr var))) (if (eq (car-safe var) 'error) (error "Bad format in expression: %s" (nth 1 var))) (calc-enter-result 1 "tylr" (list 'calcFunc-taylor (calc-top-n 1) var (prefix-numeric-value nterms))))) ) (defun math-derivative (expr) ; uses global values: deriv-var, deriv-total. (cond ((equal expr deriv-var) 1) ((or (Math-scalarp expr) (eq (car expr) 'sdev) (and (eq (car expr) 'var) (or (not deriv-total) (math-const-var expr) (progn (math-setup-declarations) (memq 'const (nth 1 (or (assq (nth 2 expr) math-decls-cache) math-decls-all))))))) 0) ((eq (car expr) '+) (math-add (math-derivative (nth 1 expr)) (math-derivative (nth 2 expr)))) ((eq (car expr) '-) (math-sub (math-derivative (nth 1 expr)) (math-derivative (nth 2 expr)))) ((memq (car expr) '(calcFunc-eq calcFunc-neq calcFunc-lt calcFunc-gt calcFunc-leq calcFunc-geq)) (list (car expr) (math-derivative (nth 1 expr)) (math-derivative (nth 2 expr)))) ((eq (car expr) 'neg) (math-neg (math-derivative (nth 1 expr)))) ((eq (car expr) '*) (math-add (math-mul (nth 2 expr) (math-derivative (nth 1 expr))) (math-mul (nth 1 expr) (math-derivative (nth 2 expr))))) ((eq (car expr) '/) (math-sub (math-div (math-derivative (nth 1 expr)) (nth 2 expr)) (math-div (math-mul (nth 1 expr) (math-derivative (nth 2 expr))) (math-sqr (nth 2 expr))))) ((eq (car expr) '^) (let ((du (math-derivative (nth 1 expr))) (dv (math-derivative (nth 2 expr)))) (or (Math-zerop du) (setq du (math-mul (nth 2 expr) (math-mul (math-normalize (list '^ (nth 1 expr) (math-add (nth 2 expr) -1))) du)))) (or (Math-zerop dv) (setq dv (math-mul (math-normalize (list 'calcFunc-ln (nth 1 expr))) (math-mul expr dv)))) (math-add du dv))) ((eq (car expr) '%) (math-derivative (nth 1 expr))) ; a reasonable definition ((eq (car expr) 'vec) (math-map-vec 'math-derivative expr)) ((and (memq (car expr) '(calcFunc-conj calcFunc-re calcFunc-im)) (= (length expr) 2)) (list (car expr) (math-derivative (nth 1 expr)))) ((and (memq (car expr) '(calcFunc-subscr calcFunc-mrow calcFunc-mcol)) (= (length expr) 3)) (let ((d (math-derivative (nth 1 expr)))) (if (math-numberp d) 0 ; assume x and x_1 are independent vars (list (car expr) d (nth 2 expr))))) (t (or (and (symbolp (car expr)) (if (= (length expr) 2) (let ((handler (get (car expr) 'math-derivative))) (and handler (let ((deriv (math-derivative (nth 1 expr)))) (if (Math-zerop deriv) deriv (math-mul (funcall handler (nth 1 expr)) deriv))))) (let ((handler (get (car expr) 'math-derivative-n))) (and handler (funcall handler expr))))) (and (not (eq deriv-symb 'pre-expand)) (let ((exp (math-expand-formula expr))) (and exp (or (let ((deriv-symb 'pre-expand)) (catch 'math-deriv (math-derivative expr))) (math-derivative exp))))) (if (or (Math-objvecp expr) (eq (car expr) 'var) (not (symbolp (car expr)))) (if deriv-symb (throw 'math-deriv nil) (list (if deriv-total 'calcFunc-tderiv 'calcFunc-deriv) expr deriv-var)) (let ((accum 0) (arg expr) (n 1) derv) (while (setq arg (cdr arg)) (or (Math-zerop (setq derv (math-derivative (car arg)))) (let ((func (intern (concat (symbol-name (car expr)) "'" (if (> n 1) (int-to-string n) "")))) (prop (cond ((= (length expr) 2) 'math-derivative-1) ((= (length expr) 3) 'math-derivative-2) ((= (length expr) 4) 'math-derivative-3) ((= (length expr) 5) 'math-derivative-4) ((= (length expr) 6) 'math-derivative-5)))) (setq accum (math-add accum (math-mul derv (let ((handler (get func prop))) (or (and prop handler (apply handler (cdr expr))) (if (and deriv-symb (not (get func 'calc-user-defn))) (throw 'math-deriv nil) (cons func (cdr expr)))))))))) (setq n (1+ n))) accum))))) ) (defun calcFunc-deriv (expr deriv-var &optional deriv-value deriv-symb) (let* ((deriv-total nil) (res (catch 'math-deriv (math-derivative expr)))) (or (eq (car-safe res) 'calcFunc-deriv) (null res) (setq res (math-normalize res))) (and res (if deriv-value (math-expr-subst res deriv-var deriv-value) res))) ) (defun calcFunc-tderiv (expr deriv-var &optional deriv-value deriv-symb) (math-setup-declarations) (let* ((deriv-total t) (res (catch 'math-deriv (math-derivative expr)))) (or (eq (car-safe res) 'calcFunc-tderiv) (null res) (setq res (math-normalize res))) (and res (if deriv-value (math-expr-subst res deriv-var deriv-value) res))) ) (put 'calcFunc-inv\' 'math-derivative-1 (function (lambda (u) (math-neg (math-div 1 (math-sqr u)))))) (put 'calcFunc-sqrt\' 'math-derivative-1 (function (lambda (u) (math-div 1 (math-mul 2 (list 'calcFunc-sqrt u)))))) (put 'calcFunc-deg\' 'math-derivative-1 (function (lambda (u) (math-div-float '(float 18 1) (math-pi))))) (put 'calcFunc-rad\' 'math-derivative-1 (function (lambda (u) (math-pi-over-180)))) (put 'calcFunc-ln\' 'math-derivative-1 (function (lambda (u) (math-div 1 u)))) (put 'calcFunc-log10\' 'math-derivative-1 (function (lambda (u) (math-div (math-div 1 (math-normalize '(calcFunc-ln 10))) u)))) (put 'calcFunc-lnp1\' 'math-derivative-1 (function (lambda (u) (math-div 1 (math-add u 1))))) (put 'calcFunc-log\' 'math-derivative-2 (function (lambda (x b) (and (not (Math-zerop b)) (let ((lnv (math-normalize (list 'calcFunc-ln b)))) (math-div 1 (math-mul lnv x))))))) (put 'calcFunc-log\'2 'math-derivative-2 (function (lambda (x b) (let ((lnv (list 'calcFunc-ln b))) (math-neg (math-div (list 'calcFunc-log x b) (math-mul lnv b))))))) (put 'calcFunc-exp\' 'math-derivative-1 (function (lambda (u) (math-normalize (list 'calcFunc-exp u))))) (put 'calcFunc-expm1\' 'math-derivative-1 (function (lambda (u) (math-normalize (list 'calcFunc-expm1 u))))) (put 'calcFunc-sin\' 'math-derivative-1 (function (lambda (u) (math-to-radians-2 (math-normalize (list 'calcFunc-cos u)))))) (put 'calcFunc-cos\' 'math-derivative-1 (function (lambda (u) (math-neg (math-to-radians-2 (math-normalize (list 'calcFunc-sin u))))))) (put 'calcFunc-tan\' 'math-derivative-1 (function (lambda (u) (math-to-radians-2 (math-div 1 (math-sqr (math-normalize (list 'calcFunc-cos u)))))))) (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))))))))) (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))))))))) (put 'calcFunc-arctan\' 'math-derivative-1 (function (lambda (u) (math-from-radians-2 (math-div 1 (math-add 1 (math-sqr u))))))) (put 'calcFunc-sinh\' 'math-derivative-1 (function (lambda (u) (math-normalize (list 'calcFunc-cosh u))))) (put 'calcFunc-cosh\' 'math-derivative-1 (function (lambda (u) (math-normalize (list 'calcFunc-sinh u))))) (put 'calcFunc-tanh\' 'math-derivative-1 (function (lambda (u) (math-div 1 (math-sqr (math-normalize (list 'calcFunc-cosh u))))))) (put 'calcFunc-arcsinh\' 'math-derivative-1 (function (lambda (u) (math-div 1 (math-normalize (list 'calcFunc-sqrt (math-add (math-sqr u) 1))))))) (put 'calcFunc-arccosh\' 'math-derivative-1 (function (lambda (u) (math-div 1 (math-normalize (list 'calcFunc-sqrt (math-add (math-sqr u) -1))))))) (put 'calcFunc-arctanh\' 'math-derivative-1 (function (lambda (u) (math-div 1 (math-sub 1 (math-sqr u)))))) (put 'calcFunc-bern\'2 'math-derivative-2 (function (lambda (n x) (math-mul n (list 'calcFunc-bern (math-add n -1) x))))) (put 'calcFunc-euler\'2 'math-derivative-2 (function (lambda (n x) (math-mul n (list 'calcFunc-euler (math-add n -1) x))))) (put 'calcFunc-gammag\'2 'math-derivative-2 (function (lambda (a x) (math-deriv-gamma a x 1)))) (put 'calcFunc-gammaG\'2 'math-derivative-2 (function (lambda (a x) (math-deriv-gamma a x -1)))) (put 'calcFunc-gammaP\'2 'math-derivative-2 (function (lambda (a x) (math-deriv-gamma a x (math-div 1 (math-normalize (list 'calcFunc-gamma a))))))) (put 'calcFunc-gammaQ\'2 'math-derivative-2 (function (lambda (a x) (math-deriv-gamma a x (math-div -1 (math-normalize (list 'calcFunc-gamma a))))))) (defun math-deriv-gamma (a x scale) (math-mul scale (math-mul (math-pow x (math-add a -1)) (list 'calcFunc-exp (math-neg x)))) ) (put 'calcFunc-betaB\' 'math-derivative-3 (function (lambda (x a b) (math-deriv-beta x a b 1)))) (put 'calcFunc-betaI\' 'math-derivative-3 (function (lambda (x a b) (math-deriv-beta x a b (math-div 1 (list 'calcFunc-beta a b)))))) (defun math-deriv-beta (x a b scale) (math-mul (math-mul (math-pow x (math-add a -1)) (math-pow (math-sub 1 x) (math-add b -1))) scale) ) (put 'calcFunc-erf\' 'math-derivative-1 (function (lambda (x) (math-div 2 (math-mul (list 'calcFunc-exp (math-sqr x)) (if calc-symbolic-mode '(calcFunc-sqrt (var pi var-pi)) (math-sqrt-pi))))))) (put 'calcFunc-erfc\' 'math-derivative-1 (function (lambda (x) (math-div -2 (math-mul (list 'calcFunc-exp (math-sqr x)) (if calc-symbolic-mode '(calcFunc-sqrt (var pi var-pi)) (math-sqrt-pi))))))) (put 'calcFunc-besJ\'2 'math-derivative-2 (function (lambda (v z) (math-div (math-sub (list 'calcFunc-besJ (math-add v -1) z) (list 'calcFunc-besJ (math-add v 1) z)) 2)))) (put 'calcFunc-besY\'2 'math-derivative-2 (function (lambda (v z) (math-div (math-sub (list 'calcFunc-besY (math-add v -1) z) (list 'calcFunc-besY (math-add v 1) z)) 2)))) (put 'calcFunc-sum 'math-derivative-n (function (lambda (expr) (if (math-expr-contains (cons 'vec (cdr (cdr expr))) deriv-var) (throw 'math-deriv nil) (cons 'calcFunc-sum (cons (math-derivative (nth 1 expr)) (cdr (cdr expr)))))))) (put 'calcFunc-prod 'math-derivative-n (function (lambda (expr) (if (math-expr-contains (cons 'vec (cdr (cdr expr))) deriv-var) (throw 'math-deriv nil) (math-mul expr (cons 'calcFunc-sum (cons (math-div (math-derivative (nth 1 expr)) (nth 1 expr)) (cdr (cdr expr))))))))) (put 'calcFunc-integ 'math-derivative-n (function (lambda (expr) (if (= (length expr) 3) (if (equal (nth 2 expr) deriv-var) (nth 1 expr) (math-normalize (list 'calcFunc-integ (math-derivative (nth 1 expr)) (nth 2 expr)))) (if (= (length expr) 5) (let ((lower (math-expr-subst (nth 1 expr) (nth 2 expr) (nth 3 expr))) (upper (math-expr-subst (nth 1 expr) (nth 2 expr) (nth 4 expr)))) (math-add (math-sub (math-mul upper (math-derivative (nth 4 expr))) (math-mul lower (math-derivative (nth 3 expr)))) (if (equal (nth 2 expr) deriv-var) 0 (math-normalize (list 'calcFunc-integ (math-derivative (nth 1 expr)) (nth 2 expr) (nth 3 expr) (nth 4 expr))))))))))) (put 'calcFunc-if 'math-derivative-n (function (lambda (expr) (and (= (length expr) 4) (list 'calcFunc-if (nth 1 expr) (math-derivative (nth 2 expr)) (math-derivative (nth 3 expr))))))) (put 'calcFunc-subscr 'math-derivative-n (function (lambda (expr) (and (= (length expr) 3) (list 'calcFunc-subscr (nth 1 expr) (math-derivative (nth 2 expr))))))) (setq math-integ-var '(var X ---)) (setq math-integ-var-2 '(var Y ---)) (setq math-integ-vars (list 'f math-integ-var math-integ-var-2)) (setq math-integ-var-list (list math-integ-var)) (setq math-integ-var-list-list (list math-integ-var-list)) (defmacro math-tracing-integral (&rest parts) (list 'and 'trace-buffer (list 'save-excursion '(set-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))) ) ;;; The following wrapper caches results and avoids infinite recursion. ;;; Each cache entry is: ( A B ) Integral of A is B; ;;; ( A N ) Integral of A failed at level N; ;;; ( A busy ) Currently working on integral of A; ;;; ( A parts ) Currently working, integ-by-parts; ;;; ( A parts2 ) Currently working, integ-by-parts; ;;; ( A cancelled ) Ignore this cache entry; ;;; ( A [B] ) Same result as for cur-record = B. (defun math-integral (expr &optional simplify same-as-above) (let* ((simp cur-record) (cur-record (assoc expr math-integral-cache)) (math-integ-depth (1+ math-integ-depth)) (val 'cancelled)) (math-tracing-integral "Integrating " (math-format-value expr 1000) "...\n") (and cur-record (progn (math-tracing-integral "Found " (math-format-value (nth 1 cur-record) 1000)) (and (consp (nth 1 cur-record)) (math-replace-integral-parts cur-record)) (math-tracing-integral " => " (math-format-value (nth 1 cur-record) 1000) "\n"))) (or (and cur-record (not (eq (nth 1 cur-record) 'cancelled)) (or (not (integerp (nth 1 cur-record))) (>= (nth 1 cur-record) math-integ-level))) (and (math-integral-contains-parts expr) (progn (setq val nil) t)) (unwind-protect (progn (let (math-integ-msg) (if (eq calc-display-working-message 'lots) (progn (calc-set-command-flag 'clear-message) (setq math-integ-msg (format "Working... Integrating %s" (math-format-flat-expr expr 0))) (message math-integ-msg))) (if cur-record (setcar (cdr cur-record) (if same-as-above (vector simp) 'busy)) (setq cur-record (list expr (if same-as-above (vector simp) 'busy)) math-integral-cache (cons cur-record math-integral-cache))) (if (eq simplify 'yes) (progn (math-tracing-integral "Simplifying...") (setq simp (math-simplify expr)) (setq val (if (equal simp expr) (progn (math-tracing-integral " no change\n") (math-do-integral expr)) (math-tracing-integral " simplified\n") (math-integral simp 'no t)))) (or (setq val (math-do-integral expr)) (eq simplify 'no) (let ((simp (math-simplify expr))) (or (equal simp expr) (progn (math-tracing-integral "Trying again after " "simplification...\n") (setq val (math-integral simp 'no t)))))))) (if (eq calc-display-working-message 'lots) (message math-integ-msg))) (setcar (cdr cur-record) (or val (if (or math-enable-subst (not math-any-substs)) math-integ-level 'cancelled))))) (setq val cur-record) (while (vectorp (nth 1 val)) (setq val (aref (nth 1 val) 0))) (setq val (if (memq (nth 1 val) '(parts parts2)) (progn (setcar (cdr val) 'parts2) (list 'var 'PARTS val)) (and (consp (nth 1 val)) (nth 1 val)))) (math-tracing-integral "Integral of " (math-format-value expr 1000) " is " (math-format-value val 1000) "\n") val) ) (defvar math-integral-cache nil) (defvar math-integral-cache-state nil) (defun math-integral-contains-parts (expr) (if (Math-primp expr) (and (eq (car-safe expr) 'var) (eq (nth 1 expr) 'PARTS) (listp (nth 2 expr))) (while (and (setq expr (cdr expr)) (not (math-integral-contains-parts (car expr))))) expr) ) (defun math-replace-integral-parts (expr) (or (Math-primp expr) (while (setq expr (cdr expr)) (and (consp (car expr)) (if (eq (car (car expr)) 'var) (and (eq (nth 1 (car expr)) 'PARTS) (consp (nth 2 (car expr))) (if (listp (nth 1 (nth 2 (car expr)))) (progn (setcar expr (nth 1 (nth 2 (car expr)))) (math-replace-integral-parts (cons 'foo expr))) (setcar (cdr cur-record) 'cancelled))) (math-replace-integral-parts (car expr)))))) ) (defun math-do-integral (expr) (let (t1 t2) (or (cond ((not (math-expr-contains expr math-integ-var)) (math-mul expr math-integ-var)) ((equal expr math-integ-var) (math-div (math-sqr expr) 2)) ((eq (car expr) '+) (and (setq t1 (math-integral (nth 1 expr))) (setq t2 (math-integral (nth 2 expr))) (math-add t1 t2))) ((eq (car expr) '-) (and (setq t1 (math-integral (nth 1 expr))) (setq t2 (math-integral (nth 2 expr))) (math-sub t1 t2))) ((eq (car expr) 'neg) (and (setq t1 (math-integral (nth 1 expr))) (math-neg t1))) ((eq (car expr) '*) (cond ((not (math-expr-contains (nth 1 expr) math-integ-var)) (and (setq t1 (math-integral (nth 2 expr))) (math-mul (nth 1 expr) t1))) ((not (math-expr-contains (nth 2 expr) math-integ-var)) (and (setq t1 (math-integral (nth 1 expr))) (math-mul t1 (nth 2 expr)))) ((memq (car-safe (nth 1 expr)) '(+ -)) (math-integral (list (car (nth 1 expr)) (math-mul (nth 1 (nth 1 expr)) (nth 2 expr)) (math-mul (nth 2 (nth 1 expr)) (nth 2 expr))) 'yes t)) ((memq (car-safe (nth 2 expr)) '(+ -)) (math-integral (list (car (nth 2 expr)) (math-mul (nth 1 (nth 2 expr)) (nth 1 expr)) (math-mul (nth 2 (nth 2 expr)) (nth 1 expr))) 'yes t)))) ((eq (car expr) '/) (cond ((and (not (math-expr-contains (nth 1 expr) math-integ-var)) (not (math-equal-int (nth 1 expr) 1))) (and (setq t1 (math-integral (math-div 1 (nth 2 expr)))) (math-mul (nth 1 expr) t1))) ((not (math-expr-contains (nth 2 expr) math-integ-var)) (and (setq t1 (math-integral (nth 1 expr))) (math-div t1 (nth 2 expr)))) ((and (eq (car-safe (nth 1 expr)) '*) (not (math-expr-contains (nth 1 (nth 1 expr)) math-integ-var))) (and (setq t1 (math-integral (math-div (nth 2 (nth 1 expr)) (nth 2 expr)))) (math-mul t1 (nth 1 (nth 1 expr))))) ((and (eq (car-safe (nth 1 expr)) '*) (not (math-expr-contains (nth 2 (nth 1 expr)) math-integ-var))) (and (setq t1 (math-integral (math-div (nth 1 (nth 1 expr)) (nth 2 expr)))) (math-mul t1 (nth 2 (nth 1 expr))))) ((and (eq (car-safe (nth 2 expr)) '*) (not (math-expr-contains (nth 1 (nth 2 expr)) math-integ-var))) (and (setq t1 (math-integral (math-div (nth 1 expr) (nth 2 (nth 2 expr))))) (math-div t1 (nth 1 (nth 2 expr))))) ((and (eq (car-safe (nth 2 expr)) '*) (not (math-expr-contains (nth 2 (nth 2 expr)) math-integ-var))) (and (setq t1 (math-integral (math-div (nth 1 expr) (nth 1 (nth 2 expr))))) (math-div t1 (nth 2 (nth 2 expr))))) ((eq (car-safe (nth 2 expr)) 'calcFunc-exp) (math-integral (math-mul (nth 1 expr) (list 'calcFunc-exp (math-neg (nth 1 (nth 2 expr))))))))) ((eq (car expr) '^) (cond ((not (math-expr-contains (nth 1 expr) math-integ-var)) (or (and (setq t1 (math-is-polynomial (nth 2 expr) math-integ-var 1)) (math-div expr (math-mul (nth 1 t1) (math-normalize (list 'calcFunc-ln (nth 1 expr)))))) (math-integral (list 'calcFunc-exp (math-mul (nth 2 expr) (math-normalize (list 'calcFunc-ln (nth 1 expr))))) 'yes t))) ((not (math-expr-contains (nth 2 expr) math-integ-var)) (if (and (integerp (nth 2 expr)) (< (nth 2 expr) 0)) (math-integral (list '/ 1 (math-pow (nth 1 expr) (- (nth 2 expr)))) nil t) (or (and (setq t1 (math-is-polynomial (nth 1 expr) math-integ-var 1)) (setq t2 (math-add (nth 2 expr) 1)) (math-div (math-pow (nth 1 expr) t2) (math-mul t2 (nth 1 t1)))) (and (Math-negp (nth 2 expr)) (math-integral (math-div 1 (math-pow (nth 1 expr) (math-neg (nth 2 expr)))) nil t)) nil)))))) ;; Integral of a polynomial. (and (setq t1 (math-is-polynomial expr math-integ-var 20)) (let ((accum 0) (n 1)) (while t1 (if (setq accum (math-add accum (math-div (math-mul (car t1) (math-pow math-integ-var n)) n)) t1 (cdr t1)) (setq n (1+ n)))) accum)) ;; Try looking it up! (cond ((= (length expr) 2) (and (symbolp (car expr)) (setq t1 (get (car expr) 'math-integral)) (progn (while (and t1 (not (setq t2 (funcall (car t1) (nth 1 expr))))) (setq t1 (cdr t1))) (and t2 (math-normalize t2))))) ((= (length expr) 3) (and (symbolp (car expr)) (setq t1 (get (car expr) 'math-integral-2)) (progn (while (and t1 (not (setq t2 (funcall (car t1) (nth 1 expr) (nth 2 expr))))) (setq t1 (cdr t1))) (and t2 (math-normalize t2)))))) ;; Integral of a rational function. (and (math-ratpoly-p expr math-integ-var) (setq t1 (calcFunc-apart expr math-integ-var)) (not (equal t1 expr)) (math-integral t1)) ;; Try user-defined integration rules. (and has-rules (let ((math-old-integ (symbol-function 'calcFunc-integ)) (input (list 'calcFunc-integtry expr math-integ-var)) res part) (unwind-protect (progn (fset 'calcFunc-integ 'math-sub-integration) (setq res (math-rewrite input '(var IntegRules var-IntegRules) 1)) (fset 'calcFunc-integ math-old-integ) (and (not (equal res input)) (if (setq part (math-expr-calls res '(calcFunc-integsubst))) (and (memq (length part) '(3 4 5)) (let ((parts (mapcar (function (lambda (x) (math-expr-subst x (nth 2 part) math-integ-var))) (cdr part)))) (math-integrate-by-substitution expr (car parts) t (or (nth 2 parts) (list 'calcFunc-integfailed math-integ-var)) (nth 3 parts)))) (if (not (math-expr-calls res '(calcFunc-integtry calcFunc-integfailed))) res)))) (fset 'calcFunc-integ math-old-integ)))) ;; See if the function is a symbolic derivative. (and (string-match "'" (symbol-name (car expr))) (let ((name (symbol-name (car expr))) (p expr) (n 0) (which nil) (bad nil)) (while (setq n (1+ n) p (cdr p)) (if (equal (car p) math-integ-var) (if which (setq bad t) (setq which n)) (if (math-expr-contains (car p) math-integ-var) (setq bad t)))) (and which (not bad) (let ((prime (if (= which 1) "'" (format "'%d" which)))) (and (string-match (concat prime "\\('['0-9]*\\|$\\)") name) (cons (intern (concat (substring name 0 (match-beginning 0)) (substring name (+ (match-beginning 0) (length prime))))) (cdr expr))))))) ;; Try transformation methods (parts, substitutions). (and (> math-integ-level 0) (math-do-integral-methods expr)) ;; Try expanding the function's definition. (let ((res (math-expand-formula expr))) (and res (math-integral res))))) ) (defun math-sub-integration (expr &rest rest) (or (if (or (not rest) (and (< math-integ-level math-integral-limit) (eq (car rest) math-integ-var))) (math-integral expr) (let ((res (apply math-old-integ expr rest))) (and (or (= math-integ-level math-integral-limit) (not (math-expr-calls res 'calcFunc-integ))) res))) (list 'calcFunc-integfailed expr)) ) (defun math-do-integral-methods (expr) (let ((so-far math-integ-var-list-list) rat-in) ;; Integration by substitution, for various likely sub-expressions. ;; (In first pass, we look only for sub-exprs that are linear in X.) (or (if math-enable-subst (math-integ-try-substitutions expr) (math-integ-try-linear-substitutions expr)) ;; If function has sines and cosines, try tan(x/2) substitution. (and (let ((p (setq rat-in (math-expr-rational-in expr)))) (while (and p (memq (car (car p)) '(calcFunc-sin calcFunc-cos calcFunc-tan)) (equal (nth 1 (car p)) math-integ-var)) (setq p (cdr p))) (null p)) (or (and (math-integ-parts-easy expr) (math-integ-try-parts expr t)) (math-integrate-by-good-substitution expr (list 'calcFunc-tan (math-div math-integ-var 2))))) ;; If function has sinh and cosh, try tanh(x/2) substitution. (and (let ((p rat-in)) (while (and p (memq (car (car p)) '(calcFunc-sinh calcFunc-cosh calcFunc-tanh calcFunc-exp)) (equal (nth 1 (car p)) math-integ-var)) (setq p (cdr p))) (null p)) (or (and (math-integ-parts-easy expr) (math-integ-try-parts expr t)) (math-integrate-by-good-substitution expr (list 'calcFunc-tanh (math-div math-integ-var 2))))) ;; If function has square roots, try sin, tan, or sec substitution. (and (let ((p rat-in)) (setq t1 nil) (while (and p (or (equal (car p) math-integ-var) (and (eq (car (car p)) 'calcFunc-sqrt) (setq t1 (math-is-polynomial (nth 1 (setq t2 (car p))) math-integ-var 2))))) (setq p (cdr p))) (and (null p) t1)) (if (cdr (cdr t1)) (if (math-guess-if-neg (nth 2 t1)) (let* ((c (math-sqrt (math-neg (nth 2 t1)))) (d (math-div (nth 1 t1) (math-mul -2 c))) (a (math-sqrt (math-add (car t1) (math-sqr d))))) (math-integrate-by-good-substitution expr (list 'calcFunc-arcsin (math-div-thru (math-add (math-mul c math-integ-var) d) a)))) (let* ((c (math-sqrt (nth 2 t1))) (d (math-div (nth 1 t1) (math-mul 2 c))) (aa (math-sub (car t1) (math-sqr d)))) (if (and nil (not (and (eq d 0) (eq c 1)))) (math-integrate-by-good-substitution expr (math-add (math-mul c math-integ-var) d)) (if (math-guess-if-neg aa) (math-integrate-by-good-substitution expr (list 'calcFunc-arccosh (math-div-thru (math-add (math-mul c math-integ-var) d) (math-sqrt (math-neg aa))))) (math-integrate-by-good-substitution expr (list 'calcFunc-arcsinh (math-div-thru (math-add (math-mul c math-integ-var) d) (math-sqrt aa)))))))) (math-integrate-by-good-substitution expr t2)) ) ;; Try integration by parts. (math-integ-try-parts expr) ;; Give up. nil)) ) (defun math-integ-parts-easy (expr) (cond ((Math-primp expr) t) ((memq (car expr) '(+ - *)) (and (math-integ-parts-easy (nth 1 expr)) (math-integ-parts-easy (nth 2 expr)))) ((eq (car expr) '/) (and (math-integ-parts-easy (nth 1 expr)) (math-atomic-factorp (nth 2 expr)))) ((eq (car expr) '^) (and (natnump (nth 2 expr)) (math-integ-parts-easy (nth 1 expr)))) ((eq (car expr) 'neg) (math-integ-parts-easy (nth 1 expr))) (t t)) ) (defun math-integ-try-parts (expr &optional math-good-parts) ;; Integration by parts: ;; integ(f(x) g(x),x) = f(x) h(x) - integ(h(x) f'(x),x) ;; where h(x) = integ(g(x),x). (or (let ((exp (calcFunc-expand expr))) (and (not (equal exp expr)) (math-integral exp))) (and (eq (car expr) '*) (let ((first-bad (or (math-polynomial-p (nth 1 expr) math-integ-var) (equal (nth 2 expr) math-prev-parts-v)))) (or (and first-bad ; so try this one first (math-integrate-by-parts (nth 1 expr) (nth 2 expr))) (math-integrate-by-parts (nth 2 expr) (nth 1 expr)) (and (not first-bad) (math-integrate-by-parts (nth 1 expr) (nth 2 expr)))))) (and (eq (car expr) '/) (math-expr-contains (nth 1 expr) math-integ-var) (let ((recip (math-div 1 (nth 2 expr)))) (or (math-integrate-by-parts (nth 1 expr) recip) (math-integrate-by-parts recip (nth 1 expr))))) (and (eq (car expr) '^) (math-integrate-by-parts (math-pow (nth 1 expr) (math-sub (nth 2 expr) 1)) (nth 1 expr)))) ) (defun math-integrate-by-parts (u vprime) (let ((math-integ-level (if (or math-good-parts (math-polynomial-p u math-integ-var)) math-integ-level (1- math-integ-level))) (math-doing-parts t) v temp) (and (>= math-integ-level 0) (unwind-protect (progn (setcar (cdr cur-record) 'parts) (math-tracing-integral "Integrating by parts, u = " (math-format-value u 1000) ", v' = " (math-format-value vprime 1000) "\n") (and (setq v (math-integral vprime)) (setq temp (calcFunc-deriv u math-integ-var nil t)) (setq temp (let ((math-prev-parts-v v)) (math-integral (math-mul v temp) 'yes))) (setq temp (math-sub (math-mul u v) temp)) (if (eq (nth 1 cur-record) 'parts) (calcFunc-expand temp) (setq v (list 'var 'PARTS cur-record) var-thing (list 'vec (math-sub v temp) v) temp (let (calc-next-why) (math-solve-for (math-sub v temp) 0 v nil))) (and temp (not (integerp temp)) (math-simplify-extended temp))))) (setcar (cdr cur-record) 'busy)))) ) ;;; This tries two different formulations, hoping the algebraic simplifier ;;; will be strong enough to handle at least one. (defun math-integrate-by-substitution (expr u &optional user uinv uinvprime) (and (> math-integ-level 0) (let ((math-integ-level (max (- math-integ-level 2) 0))) (math-integrate-by-good-substitution expr u user uinv uinvprime))) ) (defun math-integrate-by-good-substitution (expr u &optional user uinv uinvprime) (let ((math-living-dangerously t) deriv temp) (and (setq uinv (if uinv (math-expr-subst uinv math-integ-var math-integ-var-2) (let (calc-next-why) (math-solve-for u math-integ-var-2 math-integ-var nil)))) (progn (math-tracing-integral "Integrating by substitution, u = " (math-format-value u 1000) "\n") (or (and (setq deriv (calcFunc-deriv u math-integ-var nil (not user))) (setq temp (math-integral (math-expr-subst (math-expr-subst (math-expr-subst (math-div expr deriv) u math-integ-var-2) math-integ-var uinv) math-integ-var-2 math-integ-var) 'yes))) (and (setq deriv (or uinvprime (calcFunc-deriv uinv math-integ-var-2 math-integ-var (not user)))) (setq temp (math-integral (math-mul (math-expr-subst (math-expr-subst (math-expr-subst expr u math-integ-var-2) math-integ-var uinv) math-integ-var-2 math-integ-var) deriv) 'yes))))) (math-simplify-extended (math-expr-subst temp math-integ-var u)))) ) ;;; Look for substitutions of the form u = a x + b. (defun math-integ-try-linear-substitutions (sub-expr) (and (not (Math-primp sub-expr)) (or (and (not (memq (car sub-expr) '(+ - * / neg))) (not (and (eq (car sub-expr) '^) (integerp (nth 2 sub-expr)))) (math-expr-contains sub-expr math-integ-var) (let ((res nil)) (while (and (setq sub-expr (cdr sub-expr)) (or (not (math-linear-in (car sub-expr) math-integ-var)) (assoc (car sub-expr) so-far) (progn (setq so-far (cons (list (car sub-expr)) so-far)) (not (setq res (math-integrate-by-substitution expr (car sub-expr)))))))) res)) (let ((res nil)) (while (and (setq sub-expr (cdr sub-expr)) (not (setq res (math-integ-try-linear-substitutions (car sub-expr)))))) res))) ) ;;; Recursively try different substitutions based on various sub-expressions. (defun math-integ-try-substitutions (sub-expr &optional allow-rat) (and (not (Math-primp sub-expr)) (not (assoc sub-expr so-far)) (math-expr-contains sub-expr math-integ-var) (or (and (if (and (not (memq (car sub-expr) '(+ - * / neg))) (not (and (eq (car sub-expr) '^) (integerp (nth 2 sub-expr))))) (setq allow-rat t) (prog1 allow-rat (setq allow-rat nil))) (not (eq sub-expr expr)) (or (math-integrate-by-substitution expr sub-expr) (and (eq (car sub-expr) '^) (integerp (nth 2 sub-expr)) (< (nth 2 sub-expr) 0) (math-integ-try-substitutions (math-pow (nth 1 sub-expr) (- (nth 2 sub-expr))) t)))) (let ((res nil)) (setq so-far (cons (list sub-expr) so-far)) (while (and (setq sub-expr (cdr sub-expr)) (not (setq res (math-integ-try-substitutions (car sub-expr) allow-rat))))) res))) ) (defun math-expr-rational-in (expr) (let ((parts nil)) (math-expr-rational-in-rec expr) (mapcar 'car parts)) ) (defun math-expr-rational-in-rec (expr) (cond ((Math-primp expr) (and (equal expr math-integ-var) (not (assoc expr parts)) (setq parts (cons (list expr) parts)))) ((or (memq (car expr) '(+ - * / neg)) (and (eq (car expr) '^) (integerp (nth 2 expr)))) (math-expr-rational-in-rec (nth 1 expr)) (and (nth 2 expr) (math-expr-rational-in-rec (nth 2 expr)))) ((and (eq (car expr) '^) (eq (math-quarter-integer (nth 2 expr)) 2)) (math-expr-rational-in-rec (list 'calcFunc-sqrt (nth 1 expr)))) (t (and (not (assoc expr parts)) (math-expr-contains expr math-integ-var) (setq parts (cons (list expr) parts))))) ) (defun math-expr-calls (expr funcs &optional arg-contains) (if (consp expr) (if (or (memq (car expr) funcs) (and (eq (car expr) '^) (eq (car funcs) 'calcFunc-sqrt) (eq (math-quarter-integer (nth 2 expr)) 2))) (and (or (not arg-contains) (math-expr-contains expr arg-contains)) expr) (and (not (Math-primp expr)) (let ((res nil)) (while (and (setq expr (cdr expr)) (not (setq res (math-expr-calls (car expr) funcs arg-contains))))) res)))) ) (defun math-fix-const-terms (expr except-vars) (cond ((not (math-expr-depends expr except-vars)) 0) ((Math-primp expr) expr) ((eq (car expr) '+) (math-add (math-fix-const-terms (nth 1 expr) except-vars) (math-fix-const-terms (nth 2 expr) except-vars))) ((eq (car expr) '-) (math-sub (math-fix-const-terms (nth 1 expr) except-vars) (math-fix-const-terms (nth 2 expr) except-vars))) (t expr)) ) ;; Command for debugging the Calculator's symbolic integrator. (defun calc-dump-integral-cache (&optional arg) (interactive "P") (let ((buf (current-buffer))) (unwind-protect (let ((p math-integral-cache) cur-record) (display-buffer (get-buffer-create "*Integral Cache*")) (set-buffer (get-buffer "*Integral Cache*")) (erase-buffer) (while p (setq cur-record (car p)) (or arg (math-replace-integral-parts cur-record)) (insert (math-format-flat-expr (car cur-record) 0) " --> " (if (symbolp (nth 1 cur-record)) (concat "(" (symbol-name (nth 1 cur-record)) ")") (math-format-flat-expr (nth 1 cur-record) 0)) "\n") (setq p (cdr p))) (goto-char (point-min))) (set-buffer buf))) ) (defun math-try-integral (expr) (let ((math-integ-level math-integral-limit) (math-integ-depth 0) (math-integ-msg "Working...done") (cur-record nil) ; a technicality (math-integrating t) (calc-prefer-frac t) (calc-symbolic-mode t) (has-rules (calc-has-rules 'var-IntegRules))) (or (math-integral expr 'yes) (and math-any-substs (setq math-enable-subst t) (math-integral expr 'yes)) (and (> math-max-integral-limit math-integral-limit) (setq math-integral-limit math-max-integral-limit math-integ-level math-integral-limit) (math-integral expr 'yes)))) ) (defun calcFunc-integ (expr var &optional low high) (cond ;; Do these even if the parts turn out not to be integrable. ((eq (car-safe expr) '+) (math-add (calcFunc-integ (nth 1 expr) var low high) (calcFunc-integ (nth 2 expr) var low high))) ((eq (car-safe expr) '-) (math-sub (calcFunc-integ (nth 1 expr) var low high) (calcFunc-integ (nth 2 expr) var low high))) ((eq (car-safe expr) 'neg) (math-neg (calcFunc-integ (nth 1 expr) var low high))) ((and (eq (car-safe expr) '*) (not (math-expr-contains (nth 1 expr) var))) (math-mul (nth 1 expr) (calcFunc-integ (nth 2 expr) var low high))) ((and (eq (car-safe expr) '*) (not (math-expr-contains (nth 2 expr) var))) (math-mul (calcFunc-integ (nth 1 expr) var low high) (nth 2 expr))) ((and (eq (car-safe expr) '/) (not (math-expr-contains (nth 1 expr) var)) (not (math-equal-int (nth 1 expr) 1))) (math-mul (nth 1 expr) (calcFunc-integ (math-div 1 (nth 2 expr)) var low high))) ((and (eq (car-safe expr) '/) (not (math-expr-contains (nth 2 expr) var))) (math-div (calcFunc-integ (nth 1 expr) var low high) (nth 2 expr))) ((and (eq (car-safe expr) '/) (eq (car-safe (nth 1 expr)) '*) (not (math-expr-contains (nth 1 (nth 1 expr)) var))) (math-mul (nth 1 (nth 1 expr)) (calcFunc-integ (math-div (nth 2 (nth 1 expr)) (nth 2 expr)) var low high))) ((and (eq (car-safe expr) '/) (eq (car-safe (nth 1 expr)) '*) (not (math-expr-contains (nth 2 (nth 1 expr)) var))) (math-mul (nth 2 (nth 1 expr)) (calcFunc-integ (math-div (nth 1 (nth 1 expr)) (nth 2 expr)) var low high))) ((and (eq (car-safe expr) '/) (eq (car-safe (nth 2 expr)) '*) (not (math-expr-contains (nth 1 (nth 2 expr)) var))) (math-div (calcFunc-integ (math-div (nth 1 expr) (nth 2 (nth 2 expr))) var low high) (nth 1 (nth 2 expr)))) ((and (eq (car-safe expr) '/) (eq (car-safe (nth 2 expr)) '*) (not (math-expr-contains (nth 2 (nth 2 expr)) var))) (math-div (calcFunc-integ (math-div (nth 1 expr) (nth 1 (nth 2 expr))) var low high) (nth 2 (nth 2 expr)))) ((eq (car-safe expr) 'vec) (cons 'vec (mapcar (function (lambda (x) (calcFunc-integ x var low high))) (cdr expr)))) (t (let ((state (list calc-angle-mode ;;calc-symbolic-mode ;;calc-prefer-frac calc-internal-prec (calc-var-value 'var-IntegRules) (calc-var-value 'var-IntegSimpRules)))) (or (equal state math-integral-cache-state) (setq math-integral-cache-state state math-integral-cache nil))) (let* ((math-max-integral-limit (or (and (boundp 'var-IntegLimit) (natnump var-IntegLimit) var-IntegLimit) 3)) (math-integral-limit 1) (sexpr (math-expr-subst expr var math-integ-var)) (trace-buffer (get-buffer "*Trace*")) (calc-language (if (eq calc-language 'big) nil calc-language)) (math-any-substs t) (math-enable-subst nil) (math-prev-parts-v nil) (math-doing-parts nil) (math-good-parts nil) (res (if trace-buffer (let ((calcbuf (current-buffer)) (calcwin (selected-window))) (unwind-protect (progn (if (get-buffer-window trace-buffer) (select-window (get-buffer-window trace-buffer))) (set-buffer trace-buffer) (goto-char (point-max)) (or (assq 'scroll-stop (buffer-local-variables)) (progn (make-local-variable 'scroll-step) (setq scroll-step 3))) (insert "\n\n\n") (set-buffer calcbuf) (math-try-integral sexpr)) (select-window calcwin) (set-buffer calcbuf))) (math-try-integral sexpr)))) (if res (progn (if (calc-has-rules 'var-IntegAfterRules) (setq res (math-rewrite res '(var IntegAfterRules var-IntegAfterRules)))) (math-simplify (if (and low high) (math-sub (math-expr-subst res math-integ-var high) (math-expr-subst res math-integ-var low)) (setq res (math-fix-const-terms res math-integ-vars)) (if low (math-expr-subst res math-integ-var low) (math-expr-subst res math-integ-var var))))) (append (list 'calcFunc-integ expr var) (and low (list low)) (and high (list high))))))) ) (math-defintegral calcFunc-inv (math-integral (math-div 1 u))) (math-defintegral calcFunc-conj (let ((int (math-integral u))) (and int (list 'calcFunc-conj int)))) (math-defintegral calcFunc-deg (let ((int (math-integral u))) (and int (list 'calcFunc-deg int)))) (math-defintegral calcFunc-rad (let ((int (math-integral u))) (and int (list 'calcFunc-rad int)))) (math-defintegral calcFunc-re (let ((int (math-integral u))) (and int (list 'calcFunc-re int)))) (math-defintegral calcFunc-im (let ((int (math-integral u))) (and int (list 'calcFunc-im int)))) (math-defintegral calcFunc-sqrt (and (equal u math-integ-var) (math-mul '(frac 2 3) (list 'calcFunc-sqrt (math-pow u 3))))) (math-defintegral calcFunc-exp (or (and (equal u math-integ-var) (list 'calcFunc-exp u)) (let ((p (math-is-polynomial u math-integ-var 2))) (and (nth 2 p) (let ((sqa (math-sqrt (math-neg (nth 2 p))))) (math-div (math-mul (math-mul (math-div (list 'calcFunc-sqrt '(var pi var-pi)) sqa) (math-normalize (list 'calcFunc-exp (math-div (math-sub (math-mul (car p) (nth 2 p)) (math-div (math-sqr (nth 1 p)) 4)) (nth 2 p))))) (list 'calcFunc-erf (math-sub (math-mul sqa math-integ-var) (math-div (nth 1 p) (math-mul 2 sqa))))) 2)))))) (math-defintegral calcFunc-ln (or (and (equal u math-integ-var) (math-sub (math-mul u (list 'calcFunc-ln u)) u)) (and (eq (car u) '*) (math-integral (math-add (list 'calcFunc-ln (nth 1 u)) (list 'calcFunc-ln (nth 2 u))))) (and (eq (car u) '/) (math-integral (math-sub (list 'calcFunc-ln (nth 1 u)) (list 'calcFunc-ln (nth 2 u))))) (and (eq (car u) '^) (math-integral (math-mul (nth 2 u) (list 'calcFunc-ln (nth 1 u))))))) (math-defintegral calcFunc-log10 (and (equal u math-integ-var) (math-sub (math-mul u (list 'calcFunc-ln u)) (math-div u (list 'calcFunc-ln 10))))) (math-defintegral-2 calcFunc-log (math-integral (math-div (list 'calcFunc-ln u) (list 'calcFunc-ln v)))) (math-defintegral calcFunc-sin (or (and (equal u math-integ-var) (math-neg (math-from-radians-2 (list 'calcFunc-cos u)))) (and (nth 2 (math-is-polynomial u math-integ-var 2)) (math-integral (math-to-exponentials (list 'calcFunc-sin u)))))) (math-defintegral calcFunc-cos (or (and (equal u math-integ-var) (math-from-radians-2 (list 'calcFunc-sin u))) (and (nth 2 (math-is-polynomial u math-integ-var 2)) (math-integral (math-to-exponentials (list 'calcFunc-cos u)))))) (math-defintegral calcFunc-tan (and (equal u math-integ-var) (math-neg (math-from-radians-2 (list 'calcFunc-ln (list 'calcFunc-cos u)))))) (math-defintegral calcFunc-arcsin (and (equal u math-integ-var) (math-add (math-mul u (list 'calcFunc-arcsin u)) (math-from-radians-2 (list 'calcFunc-sqrt (math-sub 1 (math-sqr u))))))) (math-defintegral calcFunc-arccos (and (equal u math-integ-var) (math-sub (math-mul u (list 'calcFunc-arccos u)) (math-from-radians-2 (list 'calcFunc-sqrt (math-sub 1 (math-sqr u))))))) (math-defintegral calcFunc-arctan (and (equal u math-integ-var) (math-sub (math-mul u (list 'calcFunc-arctan u)) (math-from-radians-2 (math-div (list 'calcFunc-ln (math-add 1 (math-sqr u))) 2))))) (math-defintegral calcFunc-sinh (and (equal u math-integ-var) (list 'calcFunc-cosh u))) (math-defintegral calcFunc-cosh (and (equal u math-integ-var) (list 'calcFunc-sinh u))) (math-defintegral calcFunc-tanh (and (equal u math-integ-var) (list 'calcFunc-ln (list 'calcFunc-cosh u)))) (math-defintegral calcFunc-arcsinh (and (equal u math-integ-var) (math-sub (math-mul u (list 'calcFunc-arcsinh u)) (list 'calcFunc-sqrt (math-add (math-sqr u) 1))))) (math-defintegral calcFunc-arccosh (and (equal u math-integ-var) (math-sub (math-mul u (list 'calcFunc-arccosh u)) (list 'calcFunc-sqrt (math-sub 1 (math-sqr u)))))) (math-defintegral calcFunc-arctanh (and (equal u math-integ-var) (math-sub (math-mul u (list 'calcFunc-arctan u)) (math-div (list 'calcFunc-ln (math-add 1 (math-sqr u))) 2)))) ;;; (Ax + B) / (ax^2 + bx + c)^n forms. (math-defintegral-2 / (math-integral-rational-funcs u v)) (defun math-integral-rational-funcs (u v) (let ((pu (math-is-polynomial u math-integ-var 1)) (vpow 1) pv) (and pu (catch 'int-rat (if (and (eq (car-safe v) '^) (natnump (nth 2 v))) (setq vpow (nth 2 v) v (nth 1 v))) (and (setq pv (math-is-polynomial v math-integ-var 2)) (let ((int (math-mul-thru (car pu) (math-integral-q02 (car pv) (nth 1 pv) (nth 2 pv) v vpow)))) (if (cdr pu) (setq int (math-add int (math-mul-thru (nth 1 pu) (math-integral-q12 (car pv) (nth 1 pv) (nth 2 pv) v vpow))))) int)))))) (defun math-integral-q12 (a b c v vpow) (let (q) (cond ((not c) (cond ((= vpow 1) (math-sub (math-div math-integ-var b) (math-mul (math-div a (math-sqr b)) (list 'calcFunc-ln v)))) ((= vpow 2) (math-div (math-add (list 'calcFunc-ln v) (math-div a v)) (math-sqr b))) (t (let ((nm1 (math-sub vpow 1)) (nm2 (math-sub vpow 2))) (math-div (math-sub (math-div a (math-mul nm1 (math-pow v nm1))) (math-div 1 (math-mul nm2 (math-pow v nm2)))) (math-sqr b)))))) ((math-zerop (setq q (math-sub (math-mul 4 (math-mul a c)) (math-sqr b)))) (let ((part (math-div b (math-mul 2 c)))) (math-mul-thru (math-pow c vpow) (math-integral-q12 part 1 nil (math-add math-integ-var part) (* vpow 2))))) ((= vpow 1) (and (math-ratp q) (math-negp q) (let ((calc-symbolic-mode t)) (math-ratp (math-sqrt (math-neg q)))) (throw 'int-rat nil)) ; should have used calcFunc-apart first (math-sub (math-div (list 'calcFunc-ln v) (math-mul 2 c)) (math-mul-thru (math-div b (math-mul 2 c)) (math-integral-q02 a b c v 1)))) (t (let ((n (1- vpow))) (math-sub (math-neg (math-div (math-add (math-mul b math-integ-var) (math-mul 2 a)) (math-mul n (math-mul q (math-pow v n))))) (math-mul-thru (math-div (math-mul b (1- (* 2 n))) (math-mul n q)) (math-integral-q02 a b c v n))))))) ) (defun math-integral-q02 (a b c v vpow) (let (q rq part) (cond ((not c) (cond ((= vpow 1) (math-div (list 'calcFunc-ln v) b)) (t (math-div (math-pow v (- 1 vpow)) (math-mul (- 1 vpow) b))))) ((math-zerop (setq q (math-sub (math-mul 4 (math-mul a c)) (math-sqr b)))) (let ((part (math-div b (math-mul 2 c)))) (math-mul-thru (math-pow c vpow) (math-integral-q02 part 1 nil (math-add math-integ-var part) (* vpow 2))))) ((progn (setq part (math-add (math-mul 2 (math-mul c math-integ-var)) b)) (> vpow 1)) (let ((n (1- vpow))) (math-add (math-div part (math-mul n (math-mul q (math-pow v n)))) (math-mul-thru (math-div (math-mul (- (* 4 n) 2) c) (math-mul n q)) (math-integral-q02 a b c v n))))) ((math-guess-if-neg q) (setq rq (list 'calcFunc-sqrt (math-neg q))) ;;(math-div-thru (list 'calcFunc-ln ;; (math-div (math-sub part rq) ;; (math-add part rq))) ;; rq) (math-div (math-mul -2 (list 'calcFunc-arctanh (math-div part rq))) rq)) (t (setq rq (list 'calcFunc-sqrt q)) (math-div (math-mul 2 (math-to-radians-2 (list 'calcFunc-arctan (math-div part rq)))) rq)))) ) (math-defintegral calcFunc-erf (and (equal u math-integ-var) (math-add (math-mul u (list 'calcFunc-erf u)) (math-div 1 (math-mul (list 'calcFunc-exp (math-sqr u)) (list 'calcFunc-sqrt '(var pi var-pi))))))) (math-defintegral calcFunc-erfc (and (equal u math-integ-var) (math-sub (math-mul u (list 'calcFunc-erfc u)) (math-div 1 (math-mul (list 'calcFunc-exp (math-sqr u)) (list 'calcFunc-sqrt '(var pi var-pi))))))) (defun calcFunc-table (expr var &optional low high step) (or low (setq low '(neg (var inf var-inf)) high '(var inf var-inf))) (or high (setq high low low 1)) (and (or (math-infinitep low) (math-infinitep high)) (not step) (math-scan-for-limits expr)) (and step (math-zerop step) (math-reject-arg step 'nonzerop)) (let ((known (+ (if (Math-objectp low) 1 0) (if (Math-objectp high) 1 0) (if (or (null step) (Math-objectp step)) 1 0))) (count '(var inf var-inf)) vec) (or (= known 2) ; handy optimization (equal high '(var inf var-inf)) (progn (setq count (math-div (math-sub high low) (or step 1))) (or (Math-objectp count) (setq count (math-simplify count))) (if (Math-messy-integerp count) (setq count (math-trunc count))))) (if (Math-negp count) (setq count -1)) (if (integerp count) (let ((var-DUMMY nil) (vec math-tabulate-initial) (math-working-step-2 (1+ count)) (math-working-step 0)) (setq expr (math-evaluate-expr (math-expr-subst expr var '(var DUMMY var-DUMMY)))) (while (>= count 0) (setq math-working-step (1+ math-working-step) var-DUMMY low vec (cond ((eq math-tabulate-function 'calcFunc-sum) (math-add vec (math-evaluate-expr expr))) ((eq math-tabulate-function 'calcFunc-prod) (math-mul vec (math-evaluate-expr expr))) (t (cons (math-evaluate-expr expr) vec))) low (math-add low (or step 1)) count (1- count))) (if math-tabulate-function vec (cons 'vec (nreverse vec)))) (if (Math-integerp count) (calc-record-why 'fixnump high) (if (Math-num-integerp low) (if (Math-num-integerp high) (calc-record-why 'integerp step) (calc-record-why 'integerp high)) (calc-record-why 'integerp low))) (append (list (or math-tabulate-function 'calcFunc-table) expr var) (and (not (and (equal low '(neg (var inf var-inf))) (equal high '(var inf var-inf)))) (list low high)) (and step (list step))))) ) (setq math-tabulate-initial nil) (setq math-tabulate-function nil) (defun math-scan-for-limits (x) (cond ((Math-primp x)) ((and (eq (car x) 'calcFunc-subscr) (Math-vectorp (nth 1 x)) (math-expr-contains (nth 2 x) var)) (let* ((calc-next-why nil) (low-val (math-solve-for (nth 2 x) 1 var nil)) (high-val (math-solve-for (nth 2 x) (1- (length (nth 1 x))) var nil)) temp) (and low-val (math-realp low-val) high-val (math-realp high-val)) (and (Math-lessp high-val low-val) (setq temp low-val low-val high-val high-val temp)) (setq low (math-max low (math-ceiling low-val)) high (math-min high (math-floor high-val))))) (t (while (setq x (cdr x)) (math-scan-for-limits (car x))))) ) (defun calcFunc-sum (expr var &optional low high step) (if math-disable-sums (math-reject-arg)) (let* ((res (let* ((calc-internal-prec (+ calc-internal-prec 2))) (math-sum-rec expr var low high step))) (math-disable-sums t)) (math-normalize res)) ) (setq math-disable-sums nil) (defun math-sum-rec (expr var &optional low high step) (or low (setq low '(neg (var inf var-inf)) high '(var inf var-inf))) (and low (not high) (setq high low low 1)) (let (t1 t2 val) (setq val (cond ((not (math-expr-contains expr var)) (math-mul expr (math-add (math-div (math-sub high low) (or step 1)) 1))) ((and step (not (math-equal-int step 1))) (if (math-negp step) (math-sum-rec expr var high low (math-neg step)) (let ((lo (math-simplify (math-div low step)))) (if (math-known-num-integerp lo) (math-sum-rec (math-normalize (math-expr-subst expr var (math-mul step var))) var lo (math-simplify (math-div high step))) (math-sum-rec (math-normalize (math-expr-subst expr var (math-add (math-mul step var) low))) var 0 (math-simplify (math-div (math-sub high low) step))))))) ((memq (setq t1 (math-compare low high)) '(0 1)) (if (eq t1 0) (math-expr-subst expr var low) 0)) ((setq t1 (math-is-polynomial expr var 20)) (let ((poly nil) (n 0)) (while t1 (setq poly (math-poly-mix poly 1 (math-sum-integer-power n) (car t1)) n (1+ n) t1 (cdr t1))) (setq n (math-build-polynomial-expr poly high)) (if (memq low '(0 1)) n (math-sub n (math-build-polynomial-expr poly (math-sub low 1)))))) ((and (memq (car expr) '(+ -)) (setq t1 (math-sum-rec (nth 1 expr) var low high) t2 (math-sum-rec (nth 2 expr) var low high)) (not (and (math-expr-calls t1 '(calcFunc-sum)) (math-expr-calls t2 '(calcFunc-sum))))) (list (car expr) t1 t2)) ((and (eq (car expr) '*) (setq t1 (math-sum-const-factors expr var))) (math-mul (car t1) (math-sum-rec (cdr t1) var low high))) ((and (eq (car expr) '*) (memq (car-safe (nth 1 expr)) '(+ -))) (math-sum-rec (math-add-or-sub (math-mul (nth 1 (nth 1 expr)) (nth 2 expr)) (math-mul (nth 2 (nth 1 expr)) (nth 2 expr)) nil (eq (car (nth 1 expr)) '-)) var low high)) ((and (eq (car expr) '*) (memq (car-safe (nth 2 expr)) '(+ -))) (math-sum-rec (math-add-or-sub (math-mul (nth 1 expr) (nth 1 (nth 2 expr))) (math-mul (nth 1 expr) (nth 2 (nth 2 expr))) nil (eq (car (nth 2 expr)) '-)) var low high)) ((and (eq (car expr) '/) (not (math-primp (nth 1 expr))) (setq t1 (math-sum-const-factors (nth 1 expr) var))) (math-mul (car t1) (math-sum-rec (math-div (cdr t1) (nth 2 expr)) var low high))) ((and (eq (car expr) '/) (setq t1 (math-sum-const-factors (nth 2 expr) var))) (math-div (math-sum-rec (math-div (nth 1 expr) (cdr t1)) var low high) (car t1))) ((eq (car expr) 'neg) (math-neg (math-sum-rec (nth 1 expr) var low high))) ((and (eq (car expr) '^) (not (math-expr-contains (nth 1 expr) var)) (setq t1 (math-is-polynomial (nth 2 expr) var 1))) (let ((x (math-pow (nth 1 expr) (nth 1 t1)))) (math-div (math-mul (math-sub (math-pow x (math-add 1 high)) (math-pow x low)) (math-pow (nth 1 expr) (car t1))) (math-sub x 1)))) ((and (setq t1 (math-to-exponentials expr)) (setq t1 (math-sum-rec t1 var low high)) (not (math-expr-calls t1 '(calcFunc-sum)))) (math-to-exps t1)) ((memq (car expr) '(calcFunc-ln calcFunc-log10)) (list (car expr) (calcFunc-prod (nth 1 expr) var low high))) ((and (eq (car expr) 'calcFunc-log) (= (length expr) 3) (not (math-expr-contains (nth 2 expr) var))) (list 'calcFunc-log (calcFunc-prod (nth 1 expr) var low high) (nth 2 expr))))) (if (equal val '(var nan var-nan)) (setq val nil)) (or val (let* ((math-tabulate-initial 0) (math-tabulate-function 'calcFunc-sum)) (calcFunc-table expr var low high)))) ) (defun calcFunc-asum (expr var low &optional high step no-mul-flag) (or high (setq high low low 1)) (if (and step (not (math-equal-int step 1))) (if (math-negp step) (math-mul (math-pow -1 low) (calcFunc-asum expr var high low (math-neg step) t)) (let ((lo (math-simplify (math-div low step)))) (if (math-num-integerp lo) (calcFunc-asum (math-normalize (math-expr-subst expr var (math-mul step var))) var lo (math-simplify (math-div high step))) (calcFunc-asum (math-normalize (math-expr-subst expr var (math-add (math-mul step var) low))) var 0 (math-simplify (math-div (math-sub high low) step)))))) (math-mul (if no-mul-flag 1 (math-pow -1 low)) (calcFunc-sum (math-mul (math-pow -1 var) expr) var low high))) ) (defun math-sum-const-factors (expr var) (let ((const nil) (not-const nil) (p expr)) (while (eq (car-safe p) '*) (if (math-expr-contains (nth 1 p) var) (setq not-const (cons (nth 1 p) not-const)) (setq const (cons (nth 1 p) const))) (setq p (nth 2 p))) (if (math-expr-contains p var) (setq not-const (cons p not-const)) (setq const (cons p const))) (and const (cons (let ((temp (car const))) (while (setq const (cdr const)) (setq temp (list '* (car const) temp))) temp) (let ((temp (or (car not-const) 1))) (while (setq not-const (cdr not-const)) (setq temp (list '* (car not-const) temp))) temp)))) ) ;; Following is from CRC Math Tables, 27th ed, pp. 52-53. (defun math-sum-integer-power (pow) (let ((calc-prefer-frac t) (n (length math-sum-int-pow-cache))) (while (<= n pow) (let* ((new (list 0 0)) (lin new) (pp (cdr (nth (1- n) math-sum-int-pow-cache))) (p 2) (sum 0) q) (while pp (setq q (math-div (car pp) p) new (cons (math-mul q n) new) sum (math-add sum q) p (1+ p) pp (cdr pp))) (setcar lin (math-sub 1 (math-mul n sum))) (setq math-sum-int-pow-cache (nconc math-sum-int-pow-cache (list (nreverse new))) n (1+ n)))) (nth pow math-sum-int-pow-cache)) ) (setq math-sum-int-pow-cache (list '(0 1))) (defun math-to-exponentials (expr) (and (consp expr) (= (length expr) 2) (let ((x (nth 1 expr)) (pi (if calc-symbolic-mode '(var pi var-pi) (math-pi))) (i (if calc-symbolic-mode '(var i var-i) '(cplx 0 1)))) (cond ((eq (car expr) 'calcFunc-exp) (list '^ '(var e var-e) x)) ((eq (car expr) 'calcFunc-sin) (or (eq calc-angle-mode 'rad) (setq x (list '/ (list '* x pi) 180))) (list '/ (list '- (list '^ '(var e var-e) (list '* x i)) (list '^ '(var e var-e) (list 'neg (list '* x i)))) (list '* 2 i))) ((eq (car expr) 'calcFunc-cos) (or (eq calc-angle-mode 'rad) (setq x (list '/ (list '* x pi) 180))) (list '/ (list '+ (list '^ '(var e var-e) (list '* x i)) (list '^ '(var e var-e) (list 'neg (list '* x i)))) 2)) ((eq (car expr) 'calcFunc-sinh) (list '/ (list '- (list '^ '(var e var-e) x) (list '^ '(var e var-e) (list 'neg x))) 2)) ((eq (car expr) 'calcFunc-cosh) (list '/ (list '+ (list '^ '(var e var-e) x) (list '^ '(var e var-e) (list 'neg x))) 2)) (t nil)))) ) (defun math-to-exps (expr) (cond (calc-symbolic-mode expr) ((Math-primp expr) (if (equal expr '(var e var-e)) (math-e) expr)) ((and (eq (car expr) '^) (equal (nth 1 expr) '(var e var-e))) (list 'calcFunc-exp (nth 2 expr))) (t (cons (car expr) (mapcar 'math-to-exps (cdr expr))))) ) (defun calcFunc-prod (expr var &optional low high step) (if math-disable-prods (math-reject-arg)) (let* ((res (let* ((calc-internal-prec (+ calc-internal-prec 2))) (math-prod-rec expr var low high step))) (math-disable-prods t)) (math-normalize res)) ) (setq math-disable-prods nil) (defun math-prod-rec (expr var &optional low high step) (or low (setq low '(neg (var inf var-inf)) high '(var inf var-inf))) (and low (not high) (setq high '(var inf var-inf))) (let (t1 t2 t3 val) (setq val (cond ((not (math-expr-contains expr var)) (math-pow expr (math-add (math-div (math-sub high low) (or step 1)) 1))) ((and step (not (math-equal-int step 1))) (if (math-negp step) (math-prod-rec expr var high low (math-neg step)) (let ((lo (math-simplify (math-div low step)))) (if (math-known-num-integerp lo) (math-prod-rec (math-normalize (math-expr-subst expr var (math-mul step var))) var lo (math-simplify (math-div high step))) (math-prod-rec (math-normalize (math-expr-subst expr var (math-add (math-mul step var) low))) var 0 (math-simplify (math-div (math-sub high low) step))))))) ((and (memq (car expr) '(* /)) (setq t1 (math-prod-rec (nth 1 expr) var low high) t2 (math-prod-rec (nth 2 expr) var low high)) (not (and (math-expr-calls t1 '(calcFunc-prod)) (math-expr-calls t2 '(calcFunc-prod))))) (list (car expr) t1 t2)) ((and (eq (car expr) '^) (not (math-expr-contains (nth 2 expr) var))) (math-pow (math-prod-rec (nth 1 expr) var low high) (nth 2 expr))) ((and (eq (car expr) '^) (not (math-expr-contains (nth 1 expr) var))) (math-pow (nth 1 expr) (calcFunc-sum (nth 2 expr) var low high))) ((eq (car expr) 'sqrt) (math-normalize (list 'calcFunc-sqrt (list 'calcFunc-prod (nth 1 expr) var low high)))) ((eq (car expr) 'neg) (math-mul (math-pow -1 (math-add (math-sub high low) 1)) (math-prod-rec (nth 1 expr) var low high))) ((eq (car expr) 'calcFunc-exp) (list 'calcFunc-exp (calcFunc-sum (nth 1 expr) var low high))) ((and (setq t1 (math-is-polynomial expr var 1)) (setq t2 (cond ((or (and (math-equal-int (nth 1 t1) 1) (setq low (math-simplify (math-add low (car t1))) high (math-simplify (math-add high (car t1))))) (and (math-equal-int (nth 1 t1) -1) (setq t2 low low (math-simplify (math-sub (car t1) high)) high (math-simplify (math-sub (car t1) t2))))) (if (or (math-zerop low) (math-zerop high)) 0 (if (and (or (math-negp low) (math-negp high)) (or (math-num-integerp low) (math-num-integerp high))) (if (math-posp high) 0 (math-mul (math-pow -1 (math-add (math-add low high) 1)) (list '/ (list 'calcFunc-fact (math-neg low)) (list 'calcFunc-fact (math-sub -1 high))))) (list '/ (list 'calcFunc-fact high) (list 'calcFunc-fact (math-sub low 1)))))) ((and (or (and (math-equal-int (nth 1 t1) 2) (setq t2 (math-simplify (math-add (math-mul low 2) (car t1))) t3 (math-simplify (math-add (math-mul high 2) (car t1))))) (and (math-equal-int (nth 1 t1) -2) (setq t2 (math-simplify (math-sub (car t1) (math-mul high 2))) t3 (math-simplify (math-sub (car t1) (math-mul low 2)))))) (or (math-integerp t2) (and (math-messy-integerp t2) (setq t2 (math-trunc t2))) (math-integerp t3) (and (math-messy-integerp t3) (setq t3 (math-trunc t3))))) (if (or (math-zerop t2) (math-zerop t3)) 0 (if (or (math-evenp t2) (math-evenp t3)) (if (or (math-negp t2) (math-negp t3)) (if (math-posp high) 0 (list '/ (list 'calcFunc-dfact (math-neg t2)) (list 'calcFunc-dfact (math-sub -2 t3)))) (list '/ (list 'calcFunc-dfact t3) (list 'calcFunc-dfact (math-sub t2 2)))) (if (math-negp t3) (list '* (list '^ -1 (list '/ (list '- (list '- t2 t3) 2) 2)) (list '/ (list 'calcFunc-dfact (math-neg t2)) (list 'calcFunc-dfact (math-sub -2 t3)))) (if (math-posp t2) (list '/ (list 'calcFunc-dfact t3) (list 'calcFunc-dfact (math-sub t2 2))) nil)))))))) t2))) (if (equal val '(var nan var-nan)) (setq val nil)) (or val (let* ((math-tabulate-initial 1) (math-tabulate-function 'calcFunc-prod)) (calcFunc-table expr var low high)))) ) ;;; Attempt to reduce lhs = rhs to solve-var = rhs', where solve-var appears ;;; in lhs but not in rhs or rhs'; return rhs'. ;;; Uses global values: solve-*. (defun math-try-solve-for (lhs rhs &optional sign no-poly) (let (t1 t2 t3) (cond ((equal lhs solve-var) (setq math-solve-sign sign) (if (eq solve-full 'all) (let ((vec (list 'vec (math-evaluate-expr rhs))) newvec var p) (while math-solve-ranges (setq p (car math-solve-ranges) var (car p) newvec (list 'vec)) (while (setq p (cdr p)) (setq newvec (nconc newvec (cdr (math-expr-subst vec var (car p)))))) (setq vec newvec math-solve-ranges (cdr math-solve-ranges))) (math-normalize vec)) rhs)) ((Math-primp lhs) nil) ((and (eq (car lhs) '-) (eq (car-safe (nth 1 lhs)) (car-safe (nth 2 lhs))) (Math-zerop rhs) (= (length (nth 1 lhs)) 2) (= (length (nth 2 lhs)) 2) (setq t1 (get (car (nth 1 lhs)) 'math-inverse)) (setq t2 (funcall t1 '(var SOLVEDUM SOLVEDUM))) (eq (math-expr-contains-count t2 '(var SOLVEDUM SOLVEDUM)) 1) (setq t3 (math-solve-above-dummy t2)) (setq t1 (math-try-solve-for (math-sub (nth 1 (nth 1 lhs)) (math-expr-subst t2 t3 (nth 1 (nth 2 lhs)))) 0))) t1) ((eq (car lhs) 'neg) (math-try-solve-for (nth 1 lhs) (math-neg rhs) (and sign (- sign)))) ((and (not (eq solve-full 't)) (math-try-solve-prod))) ((and (not no-poly) (setq t2 (math-decompose-poly lhs solve-var 15 rhs))) (setq t1 (cdr (nth 1 t2)) t1 (let ((math-solve-ranges math-solve-ranges)) (cond ((= (length t1) 5) (apply 'math-solve-quartic (car t2) t1)) ((= (length t1) 4) (apply 'math-solve-cubic (car t2) t1)) ((= (length t1) 3) (apply 'math-solve-quadratic (car t2) t1)) ((= (length t1) 2) (apply 'math-solve-linear (car t2) sign t1)) (solve-full (math-poly-all-roots (car t2) t1)) (calc-symbolic-mode nil) (t (math-try-solve-for (car t2) (math-poly-any-root (reverse t1) 0 t) nil t))))) (if t1 (if (eq (nth 2 t2) 1) t1 (math-solve-prod t1 (math-try-solve-for (nth 2 t2) 0 nil t))) (calc-record-why "*Unable to find a symbolic solution") nil)) ((and (math-solve-find-root-term lhs nil) (eq (math-expr-contains-count lhs t1) 1)) ; just in case (math-try-solve-for (math-simplify (math-sub (if (or t3 (math-evenp t2)) (math-pow t1 t2) (math-neg (math-pow t1 t2))) (math-expand-power (math-sub (math-normalize (math-expr-subst lhs t1 0)) rhs) t2 solve-var))) 0)) ((eq (car lhs) '+) (cond ((not (math-expr-contains (nth 1 lhs) solve-var)) (math-try-solve-for (nth 2 lhs) (math-sub rhs (nth 1 lhs)) sign)) ((not (math-expr-contains (nth 2 lhs) solve-var)) (math-try-solve-for (nth 1 lhs) (math-sub rhs (nth 2 lhs)) sign)))) ((eq (car lhs) 'calcFunc-eq) (math-try-solve-for (math-sub (nth 1 lhs) (nth 2 lhs)) rhs sign no-poly)) ((eq (car lhs) '-) (cond ((or (and (eq (car-safe (nth 1 lhs)) 'calcFunc-sin) (eq (car-safe (nth 2 lhs)) 'calcFunc-cos)) (and (eq (car-safe (nth 1 lhs)) 'calcFunc-cos) (eq (car-safe (nth 2 lhs)) 'calcFunc-sin))) (math-try-solve-for (math-sub (nth 1 lhs) (list (car (nth 1 lhs)) (math-sub (math-quarter-circle t) (nth 1 (nth 2 lhs))))) rhs)) ((not (math-expr-contains (nth 1 lhs) solve-var)) (math-try-solve-for (nth 2 lhs) (math-sub (nth 1 lhs) rhs) (and sign (- sign)))) ((not (math-expr-contains (nth 2 lhs) solve-var)) (math-try-solve-for (nth 1 lhs) (math-add rhs (nth 2 lhs)) sign)))) ((and (eq solve-full 't) (math-try-solve-prod))) ((and (eq (car lhs) '%) (not (math-expr-contains (nth 2 lhs) solve-var))) (math-try-solve-for (nth 1 lhs) (math-add rhs (math-solve-get-int (nth 2 lhs))))) ((eq (car lhs) 'calcFunc-log) (cond ((not (math-expr-contains (nth 2 lhs) solve-var)) (math-try-solve-for (nth 1 lhs) (math-pow (nth 2 lhs) rhs))) ((not (math-expr-contains (nth 1 lhs) solve-var)) (math-try-solve-for (nth 2 lhs) (math-pow (nth 1 lhs) (math-div 1 rhs)))))) ((and (= (length lhs) 2) (symbolp (car lhs)) (setq t1 (get (car lhs) 'math-inverse)) (setq t2 (funcall t1 rhs))) (setq t1 (get (car lhs) 'math-inverse-sign)) (math-try-solve-for (nth 1 lhs) (math-normalize t2) (and sign t1 (if (integerp t1) (* t1 sign) (funcall t1 lhs sign))))) ((and (symbolp (car lhs)) (setq t1 (get (car lhs) 'math-inverse-n)) (setq t2 (funcall t1 lhs rhs))) t2) ((setq t1 (math-expand-formula lhs)) (math-try-solve-for t1 rhs sign)) (t (calc-record-why "*No inverse known" lhs) nil))) ) (setq math-solve-ranges nil) (defun math-try-solve-prod () (cond ((eq (car lhs) '*) (cond ((not (math-expr-contains (nth 1 lhs) solve-var)) (math-try-solve-for (nth 2 lhs) (math-div rhs (nth 1 lhs)) (math-solve-sign sign (nth 1 lhs)))) ((not (math-expr-contains (nth 2 lhs) solve-var)) (math-try-solve-for (nth 1 lhs) (math-div rhs (nth 2 lhs)) (math-solve-sign sign (nth 2 lhs)))) ((Math-zerop rhs) (math-solve-prod (let ((math-solve-ranges math-solve-ranges)) (math-try-solve-for (nth 2 lhs) 0)) (math-try-solve-for (nth 1 lhs) 0))))) ((eq (car lhs) '/) (cond ((not (math-expr-contains (nth 1 lhs) solve-var)) (math-try-solve-for (nth 2 lhs) (math-div (nth 1 lhs) rhs) (math-solve-sign sign (nth 1 lhs)))) ((not (math-expr-contains (nth 2 lhs) solve-var)) (math-try-solve-for (nth 1 lhs) (math-mul rhs (nth 2 lhs)) (math-solve-sign sign (nth 2 lhs)))) ((setq t1 (math-try-solve-for (math-sub (nth 1 lhs) (math-mul (nth 2 lhs) rhs)) 0)) t1))) ((eq (car lhs) '^) (cond ((not (math-expr-contains (nth 1 lhs) solve-var)) (math-try-solve-for (nth 2 lhs) (math-add (math-normalize (list 'calcFunc-log rhs (nth 1 lhs))) (math-div (math-mul 2 (math-mul '(var pi var-pi) (math-solve-get-int '(var i var-i)))) (math-normalize (list 'calcFunc-ln (nth 1 lhs))))))) ((not (math-expr-contains (nth 2 lhs) solve-var)) (cond ((and (integerp (nth 2 lhs)) (>= (nth 2 lhs) 2) (setq t1 (math-integer-log2 (nth 2 lhs)))) (setq t2 rhs) (if (and (eq solve-full t) (math-known-realp (nth 1 lhs))) (progn (while (>= (setq t1 (1- t1)) 0) (setq t2 (list 'calcFunc-sqrt t2))) (setq t2 (math-solve-get-sign t2))) (while (>= (setq t1 (1- t1)) 0) (setq t2 (math-solve-get-sign (math-normalize (list 'calcFunc-sqrt t2)))))) (math-try-solve-for (nth 1 lhs) (math-normalize t2))) ((math-looks-negp (nth 2 lhs)) (math-try-solve-for (list '^ (nth 1 lhs) (math-neg (nth 2 lhs))) (math-div 1 rhs))) ((and (eq solve-full t) (Math-integerp (nth 2 lhs)) (math-known-realp (nth 1 lhs))) (setq t1 (math-normalize (list 'calcFunc-nroot rhs (nth 2 lhs)))) (if (math-evenp (nth 2 lhs)) (setq t1 (math-solve-get-sign t1))) (math-try-solve-for (nth 1 lhs) t1 (and sign (math-oddp (nth 2 lhs)) (math-solve-sign sign (nth 2 lhs))))) (t (math-try-solve-for (nth 1 lhs) (math-mul (math-normalize (list 'calcFunc-exp (if (Math-realp (nth 2 lhs)) (math-div (math-mul '(var pi var-pi) (math-solve-get-int '(var i var-i) (and (integerp (nth 2 lhs)) (math-abs (nth 2 lhs))))) (math-div (nth 2 lhs) 2)) (math-div (math-mul 2 (math-mul '(var pi var-pi) (math-solve-get-int '(var i var-i) (and (integerp (nth 2 lhs)) (math-abs (nth 2 lhs)))))) (nth 2 lhs))))) (math-normalize (list 'calcFunc-nroot rhs (nth 2 lhs)))) (and sign (math-oddp (nth 2 lhs)) (math-solve-sign sign (nth 2 lhs))))))))) (t nil)) ) (defun math-solve-prod (lsoln rsoln) (cond ((null lsoln) rsoln) ((null rsoln) lsoln) ((eq solve-full 'all) (cons 'vec (append (cdr lsoln) (cdr rsoln)))) (solve-full (list 'calcFunc-if (list 'calcFunc-gt (math-solve-get-sign 1) 0) lsoln rsoln)) (t lsoln)) ) ;;; This deals with negative, fractional, and symbolic powers of "x". (defun math-solve-poly-funny-powers (sub-rhs) ; uses "t1", "t2" (setq t1 lhs) (let ((pp math-poly-neg-powers) fac) (while pp (setq fac (math-pow (car pp) (or math-poly-mult-powers 1)) t1 (math-mul t1 fac) rhs (math-mul rhs fac) pp (cdr pp)))) (if sub-rhs (setq t1 (math-sub t1 rhs))) (let ((math-poly-neg-powers nil)) (setq t2 (math-mul (or math-poly-mult-powers 1) (let ((calc-prefer-frac t)) (math-div 1 math-poly-frac-powers))) t1 (math-is-polynomial (math-simplify (calcFunc-expand t1)) b 50))) ) ;;; This converts "a x^8 + b x^5 + c x^2" to "(a (x^3)^2 + b (x^3) + c) * x^2". (defun math-solve-crunch-poly (max-degree) ; uses "t1", "t3" (let ((count 0)) (while (and t1 (Math-zerop (car t1))) (setq t1 (cdr t1) count (1+ count))) (and t1 (let* ((degree (1- (length t1))) (scale degree)) (while (and (> scale 1) (= (car t3) 1)) (and (= (% degree scale) 0) (let ((p t1) (n 0) (new-t1 nil) (okay t)) (while (and p okay) (if (= (% n scale) 0) (setq new-t1 (nconc new-t1 (list (car p)))) (or (Math-zerop (car p)) (setq okay nil))) (setq p (cdr p) n (1+ n))) (if okay (setq t3 (cons scale (cdr t3)) t1 new-t1)))) (setq scale (1- scale))) (setq t3 (list (math-mul (car t3) t2) (math-mul count t2))) (<= (1- (length t1)) max-degree)))) ) (defun calcFunc-poly (expr var &optional degree) (if degree (or (natnump degree) (math-reject-arg degree 'fixnatnump)) (setq degree 50)) (let ((p (math-is-polynomial expr var degree 'gen))) (if p (if (equal p '(0)) (list 'vec) (cons 'vec p)) (math-reject-arg expr "Expected a polynomial"))) ) (defun calcFunc-gpoly (expr var &optional degree) (if degree (or (natnump degree) (math-reject-arg degree 'fixnatnump)) (setq degree 50)) (let* ((math-poly-base-variable var) (d (math-decompose-poly expr var degree nil))) (if d (cons 'vec d) (math-reject-arg expr "Expected a polynomial"))) ) (defun math-decompose-poly (lhs solve-var degree sub-rhs) (let ((rhs (or sub-rhs 1)) t1 t2 t3) (setq t2 (math-polynomial-base lhs (function (lambda (b) (let ((math-poly-neg-powers '(1)) (math-poly-mult-powers nil) (math-poly-frac-powers 1) (math-poly-exp-base t)) (and (not (equal b lhs)) (or (not (memq (car-safe b) '(+ -))) sub-rhs) (setq t3 '(1 0) t2 1 t1 (math-is-polynomial lhs b 50)) (if (and (equal math-poly-neg-powers '(1)) (memq math-poly-mult-powers '(nil 1)) (eq math-poly-frac-powers 1) sub-rhs) (setq t1 (cons (math-sub (car t1) rhs) (cdr t1))) (math-solve-poly-funny-powers sub-rhs)) (math-solve-crunch-poly degree) (or (math-expr-contains b solve-var) (math-expr-contains (car t3) solve-var)))))))) (if t2 (list (math-pow t2 (car t3)) (cons 'vec t1) (if sub-rhs (math-pow t2 (nth 1 t3)) (math-div (math-pow t2 (nth 1 t3)) rhs))))) ) (defun math-solve-linear (var sign b a) (math-try-solve-for var (math-div (math-neg b) a) (math-solve-sign sign a) t) ) (defun math-solve-quadratic (var c b a) (math-try-solve-for var (if (math-looks-evenp b) (let ((halfb (math-div b 2))) (math-div (math-add (math-neg halfb) (math-solve-get-sign (math-normalize (list 'calcFunc-sqrt (math-add (math-sqr halfb) (math-mul (math-neg c) a)))))) a)) (math-div (math-add (math-neg b) (math-solve-get-sign (math-normalize (list 'calcFunc-sqrt (math-add (math-sqr b) (math-mul 4 (math-mul (math-neg c) a))))))) (math-mul 2 a))) nil t) ) (defun math-solve-cubic (var d c b a) (let* ((p (math-div b a)) (q (math-div c a)) (r (math-div d a)) (psqr (math-sqr p)) (aa (math-sub q (math-div psqr 3))) (bb (math-add r (math-div (math-sub (math-mul 2 (math-mul psqr p)) (math-mul 9 (math-mul p q))) 27))) m) (if (Math-zerop aa) (math-try-solve-for (math-pow (math-add var (math-div p 3)) 3) (math-neg bb) nil t) (if (Math-zerop bb) (math-try-solve-for (math-mul (math-add var (math-div p 3)) (math-add (math-sqr (math-add var (math-div p 3))) aa)) 0 nil t) (setq m (math-mul 2 (list 'calcFunc-sqrt (math-div aa -3)))) (math-try-solve-for var (math-sub (math-normalize (math-mul m (list 'calcFunc-cos (math-div (math-sub (list 'calcFunc-arccos (math-div (math-mul 3 bb) (math-mul aa m))) (math-mul 2 (math-mul (math-add 1 (math-solve-get-int 1 3)) (math-half-circle calc-symbolic-mode)))) 3)))) (math-div p 3)) nil t)))) ) (defun math-solve-quartic (var d c b a aa) (setq a (math-div a aa)) (setq b (math-div b aa)) (setq c (math-div c aa)) (setq d (math-div d aa)) (math-try-solve-for var (let* ((asqr (math-sqr a)) (asqr4 (math-div asqr 4)) (y (let ((solve-full nil) calc-next-why) (math-solve-cubic solve-var (math-sub (math-sub (math-mul 4 (math-mul b d)) (math-mul asqr d)) (math-sqr c)) (math-sub (math-mul a c) (math-mul 4 d)) (math-neg b) 1))) (rsqr (math-add (math-sub asqr4 b) y)) (r (list 'calcFunc-sqrt rsqr)) (sign1 (math-solve-get-sign 1)) (de (list 'calcFunc-sqrt (math-add (math-sub (math-mul 3 asqr4) (math-mul 2 b)) (if (Math-zerop rsqr) (math-mul 2 (math-mul sign1 (list 'calcFunc-sqrt (math-sub (math-sqr y) (math-mul 4 d))))) (math-sub (math-mul sign1 (math-div (math-sub (math-sub (math-mul 4 (math-mul a b)) (math-mul 8 c)) (math-mul asqr a)) (math-mul 4 r))) rsqr)))))) (math-normalize (math-sub (math-add (math-mul sign1 (math-div r 2)) (math-solve-get-sign (math-div de 2))) (math-div a 4)))) nil t) ) (defun math-poly-all-roots (var p &optional math-factoring) (catch 'ouch (let* ((math-symbolic-solve calc-symbolic-mode) (roots nil) (deg (1- (length p))) (orig-p (reverse p)) (math-int-coefs nil) (math-int-scale nil) (math-double-roots nil) (math-int-factors nil) (math-int-threshold nil) (pp p)) ;; If rational coefficients, look for exact rational factors. (while (and pp (Math-ratp (car pp))) (setq pp (cdr pp))) (if pp (if (or math-factoring math-symbolic-solve) (throw 'ouch nil)) (let ((lead (car orig-p)) (calc-prefer-frac t) (scale (apply 'math-lcm-denoms p))) (setq math-int-scale (math-abs (math-mul scale lead)) math-int-threshold (math-div '(float 5 -2) math-int-scale) math-int-coefs (cdr (math-div (cons 'vec orig-p) lead))))) (if (> deg 4) (let ((calc-prefer-frac nil) (calc-symbolic-mode nil) (pp p) (def-p (copy-sequence orig-p))) (while pp (if (Math-numberp (car pp)) (setq pp (cdr pp)) (throw 'ouch nil))) (while (> deg (if math-symbolic-solve 2 4)) (let* ((x (math-poly-any-root def-p '(float 0 0) nil)) b c pp) (if (and (eq (car-safe x) 'cplx) (math-nearly-zerop (nth 2 x) (nth 1 x))) (setq x (calcFunc-re x))) (or math-factoring (setq roots (cons x roots))) (or (math-numberp x) (setq x (math-evaluate-expr x))) (setq pp def-p b (car def-p)) (while (setq pp (cdr pp)) (setq c (car pp)) (setcar pp b) (setq b (math-add (math-mul x b) c))) (setq def-p (cdr def-p) deg (1- deg)))) (setq p (reverse def-p)))) (if (> deg 1) (let ((solve-var '(var DUMMY var-DUMMY)) (math-solve-sign nil) (math-solve-ranges nil) (solve-full 'all)) (if (= (length p) (length math-int-coefs)) (setq p (reverse math-int-coefs))) (setq roots (append (cdr (apply (cond ((= deg 2) 'math-solve-quadratic) ((= deg 3) 'math-solve-cubic) (t 'math-solve-quartic)) solve-var p)) roots))) (if (> deg 0) (setq roots (cons (math-div (math-neg (car p)) (nth 1 p)) roots)))) (if math-factoring (progn (while roots (math-poly-integer-root (car roots)) (setq roots (cdr roots))) (list math-int-factors (nreverse math-int-coefs) math-int-scale)) (let ((vec nil) res) (while roots (let ((root (car roots)) (solve-full (and solve-full 'all))) (if (math-floatp root) (setq root (math-poly-any-root orig-p root t))) (setq vec (append vec (cdr (or (math-try-solve-for var root nil t) (throw 'ouch nil)))))) (setq roots (cdr roots))) (setq vec (cons 'vec (nreverse vec))) (if math-symbolic-solve (setq vec (math-normalize vec))) (if (eq solve-full t) (list 'calcFunc-subscr vec (math-solve-get-int 1 (1- (length orig-p)) 1)) vec))))) ) (setq math-symbolic-solve nil) (defun math-lcm-denoms (&rest fracs) (let ((den 1)) (while fracs (if (eq (car-safe (car fracs)) 'frac) (setq den (calcFunc-lcm den (nth 2 (car fracs))))) (setq fracs (cdr fracs))) den) ) (defun math-poly-any-root (p x polish) ; p is a reverse poly coeff list (let* ((newt (if (math-zerop x) (math-poly-newton-root p '(cplx (float 123 -6) (float 1 -4)) 4) (math-poly-newton-root p x 4))) (res (if (math-zerop (cdr newt)) (car newt) (if (and (math-lessp (cdr newt) '(float 1 -3)) (not polish)) (setq newt (math-poly-newton-root p (car newt) 30))) (if (math-zerop (cdr newt)) (car newt) (math-poly-laguerre-root p x polish))))) (and math-symbolic-solve (math-floatp res) (throw 'ouch nil)) res) ) (defun math-poly-newton-root (p x iters) (let* ((calc-prefer-frac nil) (calc-symbolic-mode nil) (try-integer math-int-coefs) (dx x) b d) (while (and (> (setq iters (1- iters)) 0) (let ((pp p)) (math-working "newton" x) (setq b (car p) d 0) (while (setq pp (cdr pp)) (setq d (math-add (math-mul x d) b) b (math-add (math-mul x b) (car pp)))) (not (math-zerop d))) (progn (setq dx (math-div b d) x (math-sub x dx)) (if try-integer (let ((adx (math-abs-approx dx))) (and (math-lessp adx math-int-threshold) (let ((iroot (math-poly-integer-root x))) (if iroot (setq x iroot dx 0) (setq try-integer nil)))))) (or (not (or (eq dx 0) (math-nearly-zerop dx (math-abs-approx x)))) (progn (setq dx 0) nil))))) (cons x (if (math-zerop x) 1 (math-div (math-abs-approx dx) (math-abs-approx x))))) ) (defun math-poly-integer-root (x) (and (math-lessp (calcFunc-xpon (math-abs-approx x)) calc-internal-prec) math-int-coefs (let* ((calc-prefer-frac t) (xre (calcFunc-re x)) (xim (calcFunc-im x)) (xresq (math-sqr xre)) (ximsq (math-sqr xim))) (if (math-lessp ximsq (calcFunc-scf xresq -1)) ;; Look for linear factor (let* ((rnd (math-div (math-round (math-mul xre math-int-scale)) math-int-scale)) (icp math-int-coefs) (rem (car icp)) (newcoef nil)) (while (setq icp (cdr icp)) (setq newcoef (cons rem newcoef) rem (math-add (car icp) (math-mul rem rnd)))) (and (math-zerop rem) (progn (setq math-int-coefs (nreverse newcoef) math-int-factors (cons (list (math-neg rnd)) math-int-factors)) rnd))) ;; Look for irreducible quadratic factor (let* ((rnd1 (math-div (math-round (math-mul xre (math-mul -2 math-int-scale))) math-int-scale)) (sqscale (math-sqr math-int-scale)) (rnd0 (math-div (math-round (math-mul (math-add xresq ximsq) sqscale)) sqscale)) (rem1 (car math-int-coefs)) (icp (cdr math-int-coefs)) (rem0 (car icp)) (newcoef nil) (found (assoc (list rnd0 rnd1 (math-posp xim)) math-double-roots)) this) (if found (setq math-double-roots (delq found math-double-roots) rem0 0 rem1 0) (while (setq icp (cdr icp)) (setq this rem1 newcoef (cons rem1 newcoef) rem1 (math-sub rem0 (math-mul this rnd1)) rem0 (math-sub (car icp) (math-mul this rnd0))))) (and (math-zerop rem0) (math-zerop rem1) (let ((aa (math-div rnd1 -2))) (or found (setq math-int-coefs (reverse newcoef) math-double-roots (cons (list (list rnd0 rnd1 (math-negp xim))) math-double-roots) math-int-factors (cons (cons rnd0 rnd1) math-int-factors))) (math-add aa (let ((calc-symbolic-mode math-symbolic-solve)) (math-mul (math-sqrt (math-sub (math-sqr aa) rnd0)) (if (math-negp xim) -1 1)))))))))) ) (setq math-int-coefs nil) ;;; The following routine is from Numerical Recipes, section 9.5. (defun math-poly-laguerre-root (p x polish) (let* ((calc-prefer-frac nil) (calc-symbolic-mode nil) (iters 0) (m (1- (length p))) (try-newt (not polish)) (tried-newt nil) b d f x1 dx dxold) (while (and (or (< (setq iters (1+ iters)) 50) (math-reject-arg x "*Laguerre's method failed to converge")) (let ((err (math-abs-approx (car p))) (abx (math-abs-approx x)) (pp p)) (setq b (car p) d 0 f 0) (while (setq pp (cdr pp)) (setq f (math-add (math-mul x f) d) d (math-add (math-mul x d) b) b (math-add (math-mul x b) (car pp)) err (math-add (math-abs-approx b) (math-mul abx err)))) (math-lessp (calcFunc-scf err (- -2 calc-internal-prec)) (math-abs-approx b))) (or (not (math-zerop d)) (not (math-zerop f)) (progn (setq x (math-pow (math-neg b) (list 'frac 1 m))) nil)) (let* ((g (math-div d b)) (g2 (math-sqr g)) (h (math-sub g2 (math-mul 2 (math-div f b)))) (sq (math-sqrt (math-mul (1- m) (math-sub (math-mul m h) g2)))) (gp (math-add g sq)) (gm (math-sub g sq))) (if (math-lessp (calcFunc-abssqr gp) (calcFunc-abssqr gm)) (setq gp gm)) (setq dx (math-div m gp) x1 (math-sub x dx)) (if (and try-newt (math-lessp (math-abs-approx dx) (calcFunc-scf (math-abs-approx x) -3))) (let ((newt (math-poly-newton-root p x1 7))) (setq tried-newt t try-newt nil) (if (math-zerop (cdr newt)) (setq x (car newt) x1 x) (if (math-lessp (cdr newt) '(float 1 -6)) (let ((newt2 (math-poly-newton-root p (car newt) 20))) (if (math-zerop (cdr newt2)) (setq x (car newt2) x1 x) (setq x (car newt)))))))) (not (or (eq x x1) (math-nearly-equal x x1)))) (let ((cdx (math-abs-approx dx))) (setq x x1 tried-newt nil) (prog1 (or (<= iters 6) (math-lessp cdx dxold) (progn (if polish (let ((digs (calcFunc-xpon (math-div (math-abs-approx x) cdx)))) (calc-record-why "*Could not attain full precision") (if (natnump digs) (let ((calc-internal-prec (max 3 digs))) (setq x (math-normalize x)))))) nil)) (setq dxold cdx))) (or polish (math-lessp (calcFunc-scf (math-abs-approx x) (- calc-internal-prec)) dxold)))) (or (and (math-floatp x) (math-poly-integer-root x)) x)) ) (defun math-solve-above-dummy (x) (and (not (Math-primp x)) (if (and (equal (nth 1 x) '(var SOLVEDUM SOLVEDUM)) (= (length x) 2)) x (let ((res nil)) (while (and (setq x (cdr x)) (not (setq res (math-solve-above-dummy (car x)))))) res))) ) (defun math-solve-find-root-term (x neg) ; sets "t2", "t3" (if (math-solve-find-root-in-prod x) (setq t3 neg t1 x) (and (memq (car-safe x) '(+ -)) (or (math-solve-find-root-term (nth 1 x) neg) (math-solve-find-root-term (nth 2 x) (if (eq (car x) '-) (not neg) neg))))) ) (defun math-solve-find-root-in-prod (x) (and (consp x) (math-expr-contains x solve-var) (or (and (eq (car x) 'calcFunc-sqrt) (setq t2 2)) (and (eq (car x) '^) (or (and (memq (math-quarter-integer (nth 2 x)) '(1 2 3)) (setq t2 2)) (and (eq (car-safe (nth 2 x)) 'frac) (eq (nth 2 (nth 2 x)) 3) (setq t2 3)))) (and (memq (car x) '(* /)) (or (and (not (math-expr-contains (nth 1 x) solve-var)) (math-solve-find-root-in-prod (nth 2 x))) (and (not (math-expr-contains (nth 2 x) solve-var)) (math-solve-find-root-in-prod (nth 1 x))))))) ) (defun math-solve-system (exprs solve-vars solve-full) (setq exprs (mapcar 'list (if (Math-vectorp exprs) (cdr exprs) (list exprs))) solve-vars (if (Math-vectorp solve-vars) (cdr solve-vars) (list solve-vars))) (or (let ((math-solve-simplifying nil)) (math-solve-system-rec exprs solve-vars nil)) (let ((math-solve-simplifying t)) (math-solve-system-rec exprs solve-vars nil))) ) ;;; The following backtracking solver works by choosing a variable ;;; and equation, and trying to solve the equation for the variable. ;;; If it succeeds it calls itself recursively with that variable and ;;; equation removed from their respective lists, and with the solution ;;; added to solns as well as being substituted into all existing ;;; equations. The algorithm terminates when any solution path ;;; manages to remove all the variables from var-list. ;;; To support calcFunc-roots, entries in eqn-list and solns are ;;; actually lists of equations. (defun math-solve-system-rec (eqn-list var-list solns) (if var-list (let ((v var-list) (res nil)) ;; Try each variable in turn. (while (and v (let* ((vv (car v)) (e eqn-list) (elim (eq (car-safe vv) 'calcFunc-elim))) (if elim (setq vv (nth 1 vv))) ;; Try each equation in turn. (while (and e (let ((e2 (car e)) (eprev nil) res2) (setq res nil) ;; Try to solve for vv the list of equations e2. (while (and e2 (setq res2 (or (and (eq (car e2) eprev) res2) (math-solve-for (car e2) 0 vv solve-full)))) (setq eprev (car e2) res (cons (if (eq solve-full 'all) (cdr res2) (list res2)) res) e2 (cdr e2))) (if e2 (setq res nil) ;; Found a solution. Now try other variables. (setq res (nreverse res) res (math-solve-system-rec (mapcar 'math-solve-system-subst (delq (car e) (copy-sequence eqn-list))) (delq (car v) (copy-sequence var-list)) (let ((math-solve-simplifying nil) (s (mapcar (function (lambda (x) (cons (car x) (math-solve-system-subst (cdr x))))) solns))) (if elim s (cons (cons vv (apply 'append res)) s))))) (not res)))) (setq e (cdr e))) (not res))) (setq v (cdr v))) res) ;; Eliminated all variables, so now put solution into the proper format. (setq solns (sort solns (function (lambda (x y) (not (memq (car x) (memq (car y) solve-vars))))))) (if (eq solve-full 'all) (math-transpose (math-normalize (cons 'vec (if solns (mapcar (function (lambda (x) (cons 'vec (cdr x)))) solns) (mapcar (function (lambda (x) (cons 'vec x))) eqn-list))))) (math-normalize (cons 'vec (if solns (mapcar (function (lambda (x) (cons 'calcFunc-eq x))) solns) (mapcar 'car eqn-list)))))) ) (defun math-solve-system-subst (x) ; uses "res" and "v" (let ((accum nil) (res2 res)) (while x (setq accum (nconc accum (mapcar (function (lambda (r) (if math-solve-simplifying (math-simplify (math-expr-subst (car x) vv r)) (math-expr-subst (car x) vv r)))) (car res2))) x (cdr x) res2 (cdr res2))) accum) ) (defun math-get-from-counter (name) (let ((ctr (assq name calc-command-flags))) (if ctr (setcdr ctr (1+ (cdr ctr))) (setq ctr (cons name 1) calc-command-flags (cons ctr calc-command-flags))) (cdr ctr)) ) (defun math-solve-get-sign (val) (setq val (math-simplify val)) (if (and (eq (car-safe val) '*) (Math-numberp (nth 1 val))) (list '* (nth 1 val) (math-solve-get-sign (nth 2 val))) (and (eq (car-safe val) 'calcFunc-sqrt) (eq (car-safe (nth 1 val)) '^) (setq val (math-normalize (list '^ (nth 1 (nth 1 val)) (math-div (nth 2 (nth 1 val)) 2))))) (if solve-full (if (and (calc-var-value 'var-GenCount) (Math-natnump var-GenCount) (not (eq solve-full 'all))) (prog1 (math-mul (list 'calcFunc-as var-GenCount) val) (setq var-GenCount (math-add var-GenCount 1)) (calc-refresh-evaltos 'var-GenCount)) (let* ((var (concat "s" (math-get-from-counter 'solve-sign))) (var2 (list 'var (intern var) (intern (concat "var-" var))))) (if (eq solve-full 'all) (setq math-solve-ranges (cons (list var2 1 -1) math-solve-ranges))) (math-mul var2 val))) (calc-record-why "*Choosing positive solution") val)) ) (defun math-solve-get-int (val &optional range first) (if solve-full (if (and (calc-var-value 'var-GenCount) (Math-natnump var-GenCount) (not (eq solve-full 'all))) (prog1 (math-mul val (list 'calcFunc-an var-GenCount)) (setq var-GenCount (math-add var-GenCount 1)) (calc-refresh-evaltos 'var-GenCount)) (let* ((var (concat "n" (math-get-from-counter 'solve-int))) (var2 (list 'var (intern var) (intern (concat "var-" var))))) (if (and range (eq solve-full 'all)) (setq math-solve-ranges (cons (cons var2 (cdr (calcFunc-index range (or first 0)))) math-solve-ranges))) (math-mul val var2))) (calc-record-why "*Choosing 0 for arbitrary integer in solution") 0) ) (defun math-solve-sign (sign expr) (and sign (let ((s1 (math-possible-signs expr))) (cond ((memq s1 '(4 6)) sign) ((memq s1 '(1 3)) (- sign))))) ) (defun math-looks-evenp (expr) (if (Math-integerp expr) (math-evenp expr) (if (memq (car expr) '(* /)) (math-looks-evenp (nth 1 expr)))) ) (defun math-solve-for (lhs rhs solve-var solve-full &optional sign) (if (math-expr-contains rhs solve-var) (math-solve-for (math-sub lhs rhs) 0 solve-var solve-full) (and (math-expr-contains lhs solve-var) (math-with-extra-prec 1 (let* ((math-poly-base-variable solve-var) (res (math-try-solve-for lhs rhs sign))) (if (and (eq solve-full 'all) (math-known-realp solve-var)) (let ((old-len (length res)) new-len) (setq res (delq nil (mapcar (function (lambda (x) (and (not (memq (car-safe x) '(cplx polar))) x))) res)) new-len (length res)) (if (< new-len old-len) (calc-record-why (if (= new-len 1) "*All solutions were complex" (format "*Omitted %d complex solutions" (- old-len new-len))))))) res)))) ) (defun math-solve-eqn (expr var full) (if (memq (car-safe expr) '(calcFunc-neq calcFunc-lt calcFunc-gt calcFunc-leq calcFunc-geq)) (let ((res (math-solve-for (cons '- (cdr expr)) 0 var full (if (eq (car expr) 'calcFunc-neq) nil 1)))) (and res (if (eq math-solve-sign 1) (list (car expr) var res) (if (eq math-solve-sign -1) (list (car expr) res var) (or (eq (car expr) 'calcFunc-neq) (calc-record-why "*Can't determine direction of inequality")) (and (memq (car expr) '(calcFunc-neq calcFunc-lt calcFunc-gt)) (list 'calcFunc-neq var res)))))) (let ((res (math-solve-for expr 0 var full))) (and res (list 'calcFunc-eq var res)))) ) (defun math-reject-solution (expr var func) (if (math-expr-contains expr var) (or (equal (car calc-next-why) '(* "Unable to find a symbolic solution")) (calc-record-why "*Unable to find a solution"))) (list func expr var) ) (defun calcFunc-solve (expr var) (or (if (or (Math-vectorp expr) (Math-vectorp var)) (math-solve-system expr var nil) (math-solve-eqn expr var nil)) (math-reject-solution expr var 'calcFunc-solve)) ) (defun calcFunc-fsolve (expr var) (or (if (or (Math-vectorp expr) (Math-vectorp var)) (math-solve-system expr var t) (math-solve-eqn expr var t)) (math-reject-solution expr var 'calcFunc-fsolve)) ) (defun calcFunc-roots (expr var) (let ((math-solve-ranges nil)) (or (if (or (Math-vectorp expr) (Math-vectorp var)) (math-solve-system expr var 'all) (math-solve-for expr 0 var 'all)) (math-reject-solution expr var 'calcFunc-roots))) ) (defun calcFunc-finv (expr var) (let ((res (math-solve-for expr math-integ-var var nil))) (if res (math-normalize (math-expr-subst res math-integ-var var)) (math-reject-solution expr var 'calcFunc-finv))) ) (defun calcFunc-ffinv (expr var) (let ((res (math-solve-for expr math-integ-var var t))) (if res (math-normalize (math-expr-subst res math-integ-var var)) (math-reject-solution expr var 'calcFunc-finv))) ) (put 'calcFunc-inv 'math-inverse (function (lambda (x) (math-div 1 x)))) (put 'calcFunc-inv 'math-inverse-sign -1) (put 'calcFunc-sqrt 'math-inverse (function (lambda (x) (math-sqr x)))) (put 'calcFunc-conj 'math-inverse (function (lambda (x) (list 'calcFunc-conj x)))) (put 'calcFunc-abs 'math-inverse (function (lambda (x) (math-solve-get-sign x)))) (put 'calcFunc-deg 'math-inverse (function (lambda (x) (list 'calcFunc-rad x)))) (put 'calcFunc-deg 'math-inverse-sign 1) (put 'calcFunc-rad 'math-inverse (function (lambda (x) (list 'calcFunc-deg x)))) (put 'calcFunc-rad 'math-inverse-sign 1) (put 'calcFunc-ln 'math-inverse (function (lambda (x) (list 'calcFunc-exp x)))) (put 'calcFunc-ln 'math-inverse-sign 1) (put 'calcFunc-log10 'math-inverse (function (lambda (x) (list 'calcFunc-exp10 x)))) (put 'calcFunc-log10 'math-inverse-sign 1) (put 'calcFunc-lnp1 'math-inverse (function (lambda (x) (list 'calcFunc-expm1 x)))) (put 'calcFunc-lnp1 'math-inverse-sign 1) (put 'calcFunc-exp 'math-inverse (function (lambda (x) (math-add (math-normalize (list 'calcFunc-ln x)) (math-mul 2 (math-mul '(var pi var-pi) (math-solve-get-int '(var i var-i)))))))) (put 'calcFunc-exp 'math-inverse-sign 1) (put 'calcFunc-expm1 'math-inverse (function (lambda (x) (math-add (math-normalize (list 'calcFunc-lnp1 x)) (math-mul 2 (math-mul '(var pi var-pi) (math-solve-get-int '(var i var-i)))))))) (put 'calcFunc-expm1 'math-inverse-sign 1) (put 'calcFunc-sin 'math-inverse (function (lambda (x) (let ((n (math-solve-get-int 1))) (math-add (math-mul (math-normalize (list 'calcFunc-arcsin x)) (math-pow -1 n)) (math-mul (math-half-circle t) n)))))) (put 'calcFunc-cos 'math-inverse (function (lambda (x) (math-add (math-solve-get-sign (math-normalize (list 'calcFunc-arccos x))) (math-solve-get-int (math-full-circle t)))))) (put 'calcFunc-tan 'math-inverse (function (lambda (x) (math-add (math-normalize (list 'calcFunc-arctan x)) (math-solve-get-int (math-half-circle t)))))) (put 'calcFunc-arcsin 'math-inverse (function (lambda (x) (math-normalize (list 'calcFunc-sin x))))) (put 'calcFunc-arccos 'math-inverse (function (lambda (x) (math-normalize (list 'calcFunc-cos x))))) (put 'calcFunc-arctan 'math-inverse (function (lambda (x) (math-normalize (list 'calcFunc-tan x))))) (put 'calcFunc-sinh 'math-inverse (function (lambda (x) (let ((n (math-solve-get-int 1))) (math-add (math-mul (math-normalize (list 'calcFunc-arcsinh x)) (math-pow -1 n)) (math-mul (math-half-circle t) (math-mul '(var i var-i) n))))))) (put 'calcFunc-sinh 'math-inverse-sign 1) (put 'calcFunc-cosh 'math-inverse (function (lambda (x) (math-add (math-solve-get-sign (math-normalize (list 'calcFunc-arccosh x))) (math-mul (math-full-circle t) (math-solve-get-int '(var i var-i))))))) (put 'calcFunc-tanh 'math-inverse (function (lambda (x) (math-add (math-normalize (list 'calcFunc-arctanh x)) (math-mul (math-half-circle t) (math-solve-get-int '(var i var-i))))))) (put 'calcFunc-tanh 'math-inverse-sign 1) (put 'calcFunc-arcsinh 'math-inverse (function (lambda (x) (math-normalize (list 'calcFunc-sinh x))))) (put 'calcFunc-arcsinh 'math-inverse-sign 1) (put 'calcFunc-arccosh 'math-inverse (function (lambda (x) (math-normalize (list 'calcFunc-cosh x))))) (put 'calcFunc-arctanh 'math-inverse (function (lambda (x) (math-normalize (list 'calcFunc-tanh x))))) (put 'calcFunc-arctanh 'math-inverse-sign 1) (defun calcFunc-taylor (expr var num) (let ((x0 0) (v var)) (if (memq (car-safe var) '(+ - calcFunc-eq)) (setq x0 (if (eq (car var) '+) (math-neg (nth 2 var)) (nth 2 var)) v (nth 1 var))) (or (and (eq (car-safe v) 'var) (math-expr-contains expr v) (natnump num) (let ((accum (math-expr-subst expr v x0)) (var2 (if (eq (car var) 'calcFunc-eq) (cons '- (cdr var)) var)) (n 0) (nfac 1) (fprime expr)) (while (and (<= (setq n (1+ n)) num) (setq fprime (calcFunc-deriv fprime v nil t))) (setq fprime (math-simplify fprime) nfac (math-mul nfac n) accum (math-add accum (math-div (math-mul (math-pow var2 n) (math-expr-subst fprime v x0)) nfac)))) (and fprime (math-normalize accum)))) (list 'calcFunc-taylor expr var num))) ) calc-2.02c/calc-alg-3.el100644 22403 13 156526 5402630502 13216 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-alg-3.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-alg-3 () nil) (defun calc-find-root (var) (interactive "sVariable(s) to solve for: ") (calc-slow-wrapper (let ((func (if (calc-is-hyperbolic) 'calcFunc-wroot 'calcFunc-root))) (if (or (equal var "") (equal var "$")) (calc-enter-result 2 "root" (list func (calc-top-n 3) (calc-top-n 1) (calc-top-n 2))) (let ((var (if (and (string-match ",\\|[^ ] +[^ ]" var) (not (string-match "\\[" var))) (math-read-expr (concat "[" var "]")) (math-read-expr var)))) (if (eq (car-safe var) 'error) (error "Bad format in expression: %s" (nth 1 var))) (calc-enter-result 1 "root" (list func (calc-top-n 2) var (calc-top-n 1))))))) ) (defun calc-find-minimum (var) (interactive "sVariable(s) to minimize over: ") (calc-slow-wrapper (let ((func (if (calc-is-inverse) (if (calc-is-hyperbolic) 'calcFunc-wmaximize 'calcFunc-maximize) (if (calc-is-hyperbolic) 'calcFunc-wminimize 'calcFunc-minimize))) (tag (if (calc-is-inverse) "max" "min"))) (if (or (equal var "") (equal var "$")) (calc-enter-result 2 tag (list func (calc-top-n 3) (calc-top-n 1) (calc-top-n 2))) (let ((var (if (and (string-match ",\\|[^ ] +[^ ]" var) (not (string-match "\\[" var))) (math-read-expr (concat "[" var "]")) (math-read-expr var)))) (if (eq (car-safe var) 'error) (error "Bad format in expression: %s" (nth 1 var))) (calc-enter-result 1 tag (list func (calc-top-n 2) var (calc-top-n 1))))))) ) (defun calc-find-maximum (var) (interactive "sVariable to maximize over: ") (calc-invert-func) (calc-find-minimum var) ) (defun calc-poly-interp (arg) (interactive "P") (calc-slow-wrapper (let ((data (calc-top 2))) (if (or (consp arg) (eq arg 0) (eq arg 2)) (setq data (cons 'vec (calc-top-list 2 2))) (or (null arg) (error "Bad prefix argument"))) (if (calc-is-hyperbolic) (calc-enter-result 1 "rati" (list 'calcFunc-ratint data (calc-top 1))) (calc-enter-result 1 "poli" (list 'calcFunc-polint data (calc-top 1)))))) ) (defun calc-curve-fit (arg &optional model coefnames varnames) (interactive "P") (calc-slow-wrapper (setq calc-aborted-prefix nil) (let ((func (if (calc-is-inverse) 'calcFunc-xfit (if (calc-is-hyperbolic) 'calcFunc-efit 'calcFunc-fit))) key (which 0) n nvars temp data (homog nil) (msgs '( "(Press ? for help)" "1 = linear or multilinear" "2-9 = polynomial fits; i = interpolating polynomial" "p = a x^b, ^ = a b^x" "e = a exp(b x), x = exp(a + b x), l = a + b ln(x)" "E = a 10^(b x), X = 10^(a + b x), L = a + b log10(x)" "q = a + b (x-c)^2" "g = (a/b sqrt(2 pi)) exp(-0.5*((x-c)/b)^2)" "h prefix = homogeneous model (no constant term)" "' = alg entry, $ = stack, u = Model1, U = Model2"))) (while (not model) (message "Fit to model: %s:%s" (nth which msgs) (if homog " h" "")) (setq key (read-char)) (cond ((= key ?\C-g) (keyboard-quit)) ((= key ??) (setq which (% (1+ which) (length msgs)))) ((memq key '(?h ?H)) (setq homog (not homog))) ((progn (if (eq key ?\$) (setq n 1) (setq n 0)) (cond ((null arg) (setq n (1+ n) data (calc-top n))) ((or (consp arg) (eq arg 0)) (setq n (+ n 2) data (calc-top n) data (if (math-matrixp data) (append data (list (calc-top (1- n)))) (list 'vec data (calc-top (1- n)))))) ((> (setq arg (prefix-numeric-value arg)) 0) (setq data (cons 'vec (calc-top-list arg (1+ n))) n (+ n arg))) (t (error "Bad prefix argument"))) (or (math-matrixp data) (not (cdr (cdr data))) (error "Data matrix is not a matrix!")) (setq nvars (- (length data) 2) coefnames nil varnames nil) nil)) ((= key ?1) ; linear or multilinear (calc-get-fit-variables nvars (1+ nvars) (and homog 0)) (setq model (math-mul coefnames (cons 'vec (cons 1 (cdr varnames)))))) ((and (>= key ?2) (<= key ?9)) ; polynomial (calc-get-fit-variables 1 (- key ?0 -1) (and homog 0)) (setq model (math-build-polynomial-expr (cdr coefnames) (nth 1 varnames)))) ((= key ?i) ; exact polynomial (calc-get-fit-variables 1 (1- (length (nth 1 data))) (and homog 0)) (setq model (math-build-polynomial-expr (cdr coefnames) (nth 1 varnames)))) ((= key ?p) ; power law (calc-get-fit-variables nvars (1+ nvars) (and homog 1)) (setq model (math-mul (nth 1 coefnames) (calcFunc-reduce '(var mul var-mul) (calcFunc-map '(var pow var-pow) varnames (cons 'vec (cdr (cdr coefnames)))))))) ((= key ?^) ; exponential law (calc-get-fit-variables nvars (1+ nvars) (and homog 1)) (setq model (math-mul (nth 1 coefnames) (calcFunc-reduce '(var mul var-mul) (calcFunc-map '(var pow var-pow) (cons 'vec (cdr (cdr coefnames))) varnames))))) ((memq key '(?e ?E)) (calc-get-fit-variables nvars (1+ nvars) (and homog 1)) (setq model (math-mul (nth 1 coefnames) (calcFunc-reduce '(var mul var-mul) (calcFunc-map (if (eq key ?e) '(var exp var-exp) '(calcFunc-lambda (var a var-a) (^ 10 (var a var-a)))) (calcFunc-map '(var mul var-mul) (cons 'vec (cdr (cdr coefnames))) varnames)))))) ((memq key '(?x ?X)) (calc-get-fit-variables nvars (1+ nvars) (and homog 0)) (setq model (math-mul coefnames (cons 'vec (cons 1 (cdr varnames))))) (setq model (if (eq key ?x) (list 'calcFunc-exp model) (list '^ 10 model)))) ((memq key '(?l ?L)) (calc-get-fit-variables nvars (1+ nvars) (and homog 0)) (setq model (math-mul coefnames (cons 'vec (cons 1 (cdr (calcFunc-map (if (eq key ?l) '(var ln var-ln) '(var log10 var-log10)) varnames))))))) ((= key ?q) (calc-get-fit-variables nvars (1+ (* 2 nvars)) (and homog 0)) (let ((c coefnames) (v varnames)) (setq model (nth 1 c)) (while (setq v (cdr v) c (cdr (cdr c))) (setq model (math-add model (list '* (car c) (list '^ (list '- (car v) (nth 1 c)) 2))))))) ((= key ?g) (setq model (math-read-expr "(AFit / BFit sqrt(2 pi)) exp(-0.5 * ((XFit - CFit) / BFit)^2)") varnames '(vec (var XFit var-XFit)) coefnames '(vec (var AFit var-AFit) (var BFit var-BFit) (var CFit var-CFit))) (calc-get-fit-variables 1 (1- (length coefnames)) (and homog 1))) ((memq key '(?\$ ?\' ?u ?U)) (let* ((defvars nil) (record-entry nil)) (if (eq key ?\') (let* ((calc-dollar-values calc-arg-values) (calc-dollar-used 0) (calc-hashes-used 0)) (setq model (calc-do-alg-entry "" "Model formula: ")) (if (/= (length model) 1) (error "Bad format")) (setq model (car model) record-entry t) (if (> calc-dollar-used 0) (setq coefnames (cons 'vec (nthcdr (- (length calc-arg-values) calc-dollar-used) (reverse calc-arg-values)))) (if (> calc-hashes-used 0) (setq coefnames (cons 'vec (calc-invent-args calc-hashes-used)))))) (progn (setq model (cond ((eq key ?u) (calc-var-value 'var-Model1)) ((eq key ?U) (calc-var-value 'var-Model2)) (t (calc-top 1)))) (or model (error "User model not yet defined")) (if (math-vectorp model) (if (and (memq (length model) '(3 4)) (not (math-objvecp (nth 1 model))) (math-vectorp (nth 2 model)) (or (null (nth 3 model)) (math-vectorp (nth 3 model)))) (setq varnames (nth 2 model) coefnames (or (nth 3 model) (cons 'vec (math-all-vars-but model varnames))) model (nth 1 model)) (error "Incorrect model specifier"))))) (or varnames (let ((with-y (eq (car-safe model) 'calcFunc-eq))) (if coefnames (calc-get-fit-variables (if with-y (1+ nvars) nvars) (1- (length coefnames)) (math-all-vars-but model coefnames) nil with-y) (let* ((coefs (math-all-vars-but model nil)) (vars nil) (n (- (length coefs) nvars (if with-y 2 1))) p) (if (< n 0) (error "Not enough variables in model")) (setq p (nthcdr n coefs)) (setq vars (cdr p)) (setcdr p nil) (calc-get-fit-variables (if with-y (1+ nvars) nvars) (length coefs) vars coefs with-y))))) (if record-entry (calc-record (list 'vec model varnames coefnames) "modl")))) (t (beep)))) (let ((calc-fit-to-trail t)) (calc-enter-result n (substring (symbol-name func) 9) (list func model (if (= (length varnames) 2) (nth 1 varnames) varnames) (if (= (length coefnames) 2) (nth 1 coefnames) coefnames) data)) (if (consp calc-fit-to-trail) (calc-record (calc-normalize calc-fit-to-trail) "parm"))))) ) (defun calc-invent-independent-variables (n &optional but) (calc-invent-variables n but '(x y z t) "x") ) (defun calc-invent-parameter-variables (n &optional but) (calc-invent-variables n but '(a b c d) "a") ) (defun calc-invent-variables (num but names base) (let ((vars nil) (n num) (nn 0) var) (while (and (> n 0) names) (setq var (math-build-var-name (if (consp names) (car names) (concat base (setq nn (1+ nn)))))) (or (math-expr-contains (cons 'vec but) var) (setq vars (cons var vars) n (1- n))) (or (symbolp names) (setq names (cdr names)))) (if (= n 0) (nreverse vars) (calc-invent-variables num but t base))) ) (defun calc-get-fit-variables (nv nc &optional defv defc with-y homog) (or (= nv (if with-y (1+ nvars) nvars)) (error "Wrong number of data vectors for this type of model")) (if (integerp defv) (setq homog defv defv nil)) (if homog (setq nc (1- nc))) (or defv (setq defv (calc-invent-independent-variables nv))) (or defc (setq defc (calc-invent-parameter-variables nc defv))) (let ((vars (read-string (format "Fitting variables: (default %s; %s) " (mapconcat 'symbol-name (mapcar (function (lambda (v) (nth 1 v))) defv) ",") (mapconcat 'symbol-name (mapcar (function (lambda (v) (nth 1 v))) defc) ",")))) (coefs nil)) (setq vars (if (string-match "\\[" vars) (math-read-expr vars) (math-read-expr (concat "[" vars "]")))) (if (eq (car-safe vars) 'error) (error "Bad format in expression: %s" (nth 2 vars))) (or (math-vectorp vars) (error "Expected a variable or vector of variables")) (if (equal vars '(vec)) (setq vars (cons 'vec defv) coefs (cons 'vec defc)) (if (math-vectorp (nth 1 vars)) (if (and (= (length vars) 3) (math-vectorp (nth 2 vars))) (setq coefs (nth 2 vars) vars (nth 1 vars)) (error "Expected independent variables vector, then parameters vector")) (setq coefs (cons 'vec defc)))) (or (= nv (1- (length vars))) (and (not with-y) (= (1+ nv) (1- (length vars)))) (error "Expected %d independent variable%s" nv (if (= nv 1) "" "s"))) (or (= nc (1- (length coefs))) (error "Expected %d parameter variable%s" nc (if (= nc 1) "" "s"))) (if homog (setq coefs (cons 'vec (cons homog (cdr coefs))))) (if varnames (setq model (math-multi-subst model (cdr varnames) (cdr vars)))) (if coefnames (setq model (math-multi-subst model (cdr coefnames) (cdr coefs)))) (setq varnames vars coefnames coefs)) ) ;;; The following algorithms are from Numerical Recipes chapter 9. ;;; "rtnewt" with safety kludges (defun math-newton-root (expr deriv guess orig-guess limit) (math-working "newton" guess) (let* ((var-DUMMY guess) next dval) (setq next (math-evaluate-expr expr) dval (math-evaluate-expr deriv)) (if (and (Math-numberp next) (Math-numberp dval) (not (Math-zerop dval))) (progn (setq next (math-sub guess (math-div next dval))) (if (math-nearly-equal guess (setq next (math-float next))) (progn (setq var-DUMMY next) (list 'vec next (math-evaluate-expr expr))) (if (Math-lessp (math-abs-approx (math-sub next orig-guess)) limit) (math-newton-root expr deriv next orig-guess limit) (math-reject-arg next "*Newton's method failed to converge")))) (math-reject-arg next "*Newton's method encountered a singularity"))) ) ;;; Inspired by "rtsafe" (defun math-newton-search-root (expr deriv guess vguess ostep oostep low vlow high vhigh) (let ((var-DUMMY guess) (better t) pos step next vnext) (if guess (math-working "newton" (list 'intv 0 low high)) (math-working "bisect" (list 'intv 0 low high)) (setq ostep (math-mul-float (math-sub-float high low) '(float 5 -1)) guess (math-add-float low ostep) var-DUMMY guess vguess (math-evaluate-expr expr)) (or (Math-realp vguess) (progn (setq ostep (math-mul-float ostep '(float 6 -1)) guess (math-add-float low ostep) var-DUMMY guess vguess (math-evaluate-expr expr)) (or (math-realp vguess) (progn (setq ostep (math-mul-float ostep '(float 123456 -5)) guess (math-add-float low ostep) var-DUMMY guess vguess nil)))))) (or vguess (setq vguess (math-evaluate-expr expr))) (or (Math-realp vguess) (math-reject-arg guess "*Newton's method encountered a singularity")) (setq vguess (math-float vguess)) (if (eq (Math-negp vlow) (setq pos (Math-posp vguess))) (setq high guess vhigh vguess) (if (eq (Math-negp vhigh) pos) (setq low guess vlow vguess) (setq better nil))) (if (or (Math-zerop vguess) (math-nearly-equal low high)) (list 'vec guess vguess) (setq step (math-evaluate-expr deriv)) (if (and (Math-realp step) (not (Math-zerop step)) (setq step (math-div-float vguess (math-float step)) next (math-sub-float guess step)) (not (math-lessp-float high next)) (not (math-lessp-float next low))) (progn (setq var-DUMMY next vnext (math-evaluate-expr expr)) (if (or (Math-zerop vnext) (math-nearly-equal next guess)) (list 'vec next vnext) (if (and better (math-lessp-float (math-abs (or oostep (math-sub-float high low))) (math-abs (math-mul-float '(float 2 0) step)))) (math-newton-search-root expr deriv nil nil nil ostep low vlow high vhigh) (math-newton-search-root expr deriv next vnext step ostep low vlow high vhigh)))) (if (or (and (Math-posp vlow) (Math-posp vhigh)) (and (Math-negp vlow) (Math-negp vhigh))) (math-search-root expr deriv low vlow high vhigh) (math-newton-search-root expr deriv nil nil nil ostep low vlow high vhigh))))) ) ;;; Search for a root in an interval with no overt zero crossing. (defun math-search-root (expr deriv low vlow high vhigh) (let (found) (if root-widen (let ((iters 0) (iterlim (if (eq root-widen 'point) (+ calc-internal-prec 10) 20)) (factor (if (eq root-widen 'point) '(float 9 0) '(float 16 -1))) (prev nil) vprev waslow diff) (while (or (and (math-posp vlow) (math-posp vhigh)) (and (math-negp vlow) (math-negp vhigh))) (math-working "widen" (list 'intv 0 low high)) (if (> (setq iters (1+ iters)) iterlim) (math-reject-arg (list 'intv 0 low high) "*Unable to bracket root")) (if (= iters calc-internal-prec) (setq factor '(float 16 -1))) (setq diff (math-mul-float (math-sub-float high low) factor)) (if (Math-zerop diff) (setq high (calcFunc-incr high 10)) (if (math-lessp-float (math-abs vlow) (math-abs vhigh)) (setq waslow t prev low low (math-sub low diff) var-DUMMY low vprev vlow vlow (math-evaluate-expr expr)) (setq waslow nil prev high high (math-add high diff) var-DUMMY high vprev vhigh vhigh (math-evaluate-expr expr))))) (if prev (if waslow (setq high prev vhigh vprev) (setq low prev vlow vprev))) (setq found t)) (or (Math-realp vlow) (math-reject-arg vlow 'realp)) (or (Math-realp vhigh) (math-reject-arg vhigh 'realp)) (let ((xvals (list low high)) (yvals (list vlow vhigh)) (pos (Math-posp vlow)) (levels 0) (step (math-sub-float high low)) xp yp var-DUMMY) (while (and (<= (setq levels (1+ levels)) 5) (not found)) (setq xp xvals yp yvals step (math-mul-float step '(float 497 -3))) (while (and (cdr xp) (not found)) (if (Math-realp (car yp)) (setq low (car xp) vlow (car yp))) (setq high (math-add-float (car xp) step) var-DUMMY high vhigh (math-evaluate-expr expr)) (math-working "search" high) (if (and (Math-realp vhigh) (eq (math-negp vhigh) pos)) (setq found t) (setcdr xp (cons high (cdr xp))) (setcdr yp (cons vhigh (cdr yp))) (setq xp (cdr (cdr xp)) yp (cdr (cdr yp)))))))) (if found (if (Math-zerop vhigh) (list 'vec high vhigh) (if (Math-zerop vlow) (list 'vec low vlow) (if deriv (math-newton-search-root expr deriv nil nil nil nil low vlow high vhigh) (math-bisect-root expr low vlow high vhigh)))) (math-reject-arg (list 'intv 3 low high) "*Unable to find a sign change in this interval"))) ) ;;; "rtbis" (but we should be using Brent's method) (defun math-bisect-root (expr low vlow high vhigh) (let ((step (math-sub-float high low)) (pos (Math-posp vhigh)) var-DUMMY mid vmid) (while (not (or (math-nearly-equal low (setq step (math-mul-float step '(float 5 -1)) mid (math-add-float low step))) (progn (setq var-DUMMY mid vmid (math-evaluate-expr expr)) (Math-zerop vmid)))) (math-working "bisect" mid) (if (eq (Math-posp vmid) pos) (setq high mid vhigh vmid) (setq low mid vlow vmid))) (list 'vec mid vmid)) ) ;;; "mnewt" (defun math-newton-multi (expr jacob n guess orig-guess limit) (let ((m -1) (p guess) p2 expr-val jacob-val next) (while (< (setq p (cdr p) m (1+ m)) n) (set (nth 2 (aref math-root-vars m)) (car p))) (setq expr-val (math-evaluate-expr expr) jacob-val (math-evaluate-expr jacob)) (or (and (math-constp expr-val) (math-constp jacob-val)) (math-reject-arg guess "*Newton's method encountered a singularity")) (setq next (math-add guess (math-div (math-float (math-neg expr-val)) (math-float jacob-val))) p guess p2 next) (math-working "newton" next) (while (and (setq p (cdr p) p2 (cdr p2)) (math-nearly-equal (car p) (car p2)))) (if p (if (Math-lessp (math-abs-approx (math-sub next orig-guess)) limit) (math-newton-multi expr jacob n next orig-guess limit) (math-reject-arg nil "*Newton's method failed to converge")) (list 'vec next expr-val))) ) (defvar math-root-vars [(var DUMMY var-DUMMY)]) (defun math-find-root (expr var guess root-widen) (if (eq (car-safe expr) 'vec) (let ((n (1- (length expr))) (calc-symbolic-mode nil) (var-DUMMY nil) (jacob (list 'vec)) p p2 m row) (or (eq (car-safe var) 'vec) (math-reject-arg var 'vectorp)) (or (= (length var) (1+ n)) (math-dimension-error)) (setq expr (copy-sequence expr)) (while (>= n (length math-root-vars)) (let ((symb (intern (concat "math-root-v" (int-to-string (length math-root-vars)))))) (setq math-root-vars (vconcat math-root-vars (vector (list 'var symb symb)))))) (setq m -1) (while (< (setq m (1+ m)) n) (set (nth 2 (aref math-root-vars m)) nil)) (setq m -1 p var) (while (setq m (1+ m) p (cdr p)) (or (eq (car-safe (car p)) 'var) (math-reject-arg var "*Expected a variable")) (setq p2 expr) (while (setq p2 (cdr p2)) (setcar p2 (math-expr-subst (car p2) (car p) (aref math-root-vars m))))) (or (eq (car-safe guess) 'vec) (math-reject-arg guess 'vectorp)) (or (= (length guess) (1+ n)) (math-dimension-error)) (setq guess (copy-sequence guess) p guess) (while (setq p (cdr p)) (or (Math-numberp (car guess)) (math-reject-arg guess 'numberp)) (setcar p (math-float (car p)))) (setq p expr) (while (setq p (cdr p)) (if (assq (car-safe (car p)) calc-tweak-eqn-table) (setcar p (math-sub (nth 1 (car p)) (nth 2 (car p))))) (setcar p (math-evaluate-expr (car p))) (setq row (list 'vec) m -1) (while (< (setq m (1+ m)) n) (nconc row (list (math-evaluate-expr (or (calcFunc-deriv (car p) (aref math-root-vars m) nil t) (math-reject-arg expr "*Formulas must be differentiable")))))) (nconc jacob (list row))) (setq m (math-abs-approx guess)) (math-newton-multi expr jacob n guess guess (if (math-zerop m) '(float 1 3) (math-mul m 10)))) (or (eq (car-safe var) 'var) (math-reject-arg var "*Expected a variable")) (or (math-expr-contains expr var) (math-reject-arg expr "*Formula does not contain specified variable")) (if (assq (car expr) calc-tweak-eqn-table) (setq expr (math-sub (nth 1 expr) (nth 2 expr)))) (math-with-extra-prec 2 (setq expr (math-expr-subst expr var '(var DUMMY var-DUMMY))) (let* ((calc-symbolic-mode nil) (var-DUMMY nil) (expr (math-evaluate-expr expr)) (deriv (calcFunc-deriv expr '(var DUMMY var-DUMMY) nil t)) low high vlow vhigh) (and deriv (setq deriv (math-evaluate-expr deriv))) (setq guess (math-float guess)) (if (and (math-numberp guess) deriv) (math-newton-root expr deriv guess guess (if (math-zerop guess) '(float 1 6) (math-mul (math-abs-approx guess) 100))) (if (Math-realp guess) (setq low guess high guess var-DUMMY guess vlow (math-evaluate-expr expr) vhigh vlow root-widen 'point) (if (eq (car guess) 'intv) (progn (or (math-constp guess) (math-reject-arg guess 'constp)) (setq low (nth 2 guess) high (nth 3 guess)) (if (memq (nth 1 guess) '(0 1)) (setq low (calcFunc-incr low 1 high))) (if (memq (nth 1 guess) '(0 2)) (setq high (calcFunc-incr high -1 low))) (setq var-DUMMY low vlow (math-evaluate-expr expr) var-DUMMY high vhigh (math-evaluate-expr expr))) (if (math-complexp guess) (math-reject-arg "*Complex root finder must have derivative") (math-reject-arg guess 'realp)))) (if (Math-zerop vlow) (list 'vec low vlow) (if (Math-zerop vhigh) (list 'vec high vhigh) (if (and deriv (Math-numberp vlow) (Math-numberp vhigh)) (math-newton-search-root expr deriv nil nil nil nil low vlow high vhigh) (if (or (and (Math-posp vlow) (Math-posp vhigh)) (and (Math-negp vlow) (Math-negp vhigh)) (not (Math-numberp vlow)) (not (Math-numberp vhigh))) (math-search-root expr deriv low vlow high vhigh) (math-bisect-root expr low vlow high vhigh))))))))) ) (defun calcFunc-root (expr var guess) (math-find-root expr var guess nil) ) (defun calcFunc-wroot (expr var guess) (math-find-root expr var guess t) ) ;;; The following algorithms come from Numerical Recipes, chapter 10. (defun math-min-eval (expr a) (if (Math-vectorp a) (let ((m -1)) (while (setq m (1+ m) a (cdr a)) (set (nth 2 (aref math-min-vars m)) (car a)))) (setq var-DUMMY a)) (setq a (math-evaluate-expr expr)) (if (Math-ratp a) (math-float a) (if (eq (car a) 'float) a (math-reject-arg a 'realp))) ) ;;; A bracket for a minimum is a < b < c where f(b) < f(a) and f(b) < f(c). ;;; "mnbrak" (defun math-widen-min (expr a b) (let ((done nil) (iters 30) incr c va vb vc u vu r q ulim bc ba qr) (or b (setq b (math-mul a '(float 101 -2)))) (setq va (math-min-eval expr a) vb (math-min-eval expr b)) (if (math-lessp-float va vb) (setq u a a b b u vu va va vb vb vu)) (setq c (math-add-float b (math-mul-float '(float 161803 -5) (math-sub-float b a))) vc (math-min-eval expr c)) (while (and (not done) (math-lessp-float vc vb)) (math-working "widen" (list 'intv 0 a c)) (if (= (setq iters (1- iters)) 0) (math-reject-arg nil (format "*Unable to find a %s near the interval" math-min-or-max))) (setq bc (math-sub-float b c) ba (math-sub-float b a) r (math-mul-float ba (math-sub-float vb vc)) q (math-mul-float bc (math-sub-float vb va)) qr (math-sub-float q r)) (if (math-lessp-float (math-abs qr) '(float 1 -20)) (setq qr (if (math-negp qr) '(float -1 -20) '(float 1 -20)))) (setq u (math-sub-float b (math-div-float (math-sub-float (math-mul-float bc q) (math-mul-float ba r)) (math-mul-float '(float 2 0) qr))) ulim (math-add-float b (math-mul-float '(float -1 2) bc)) incr (math-negp bc)) (if (if incr (math-lessp-float b u) (math-lessp-float u b)) (if (if incr (math-lessp-float u c) (math-lessp-float c u)) (if (math-lessp-float (setq vu (math-min-eval expr u)) vc) (setq a b va vb b u vb vu done t) (if (math-lessp-float vb vu) (setq c u vc vu done t) (setq u (math-add-float c (math-mul-float '(float -161803 -5) bc)) vu (math-min-eval expr u)))) (if (if incr (math-lessp-float u ulim) (math-lessp-float ulim u)) (if (math-lessp-float (setq vu (math-min-eval expr u)) vc) (setq b c vb vc c u vc vu u (math-add-float c (math-mul-float '(float -161803 -5) (math-sub-float b c))) vu (math-min-eval expr u))) (setq u ulim vu (math-min-eval expr u)))) (setq u (math-add-float c (math-mul-float '(float -161803 -5) bc)) vu (math-min-eval expr u))) (setq a b va vb b c vb vc c u vc vu)) (if (math-lessp-float a c) (list a va b vb c vc) (list c vc b vb a va))) ) (defun math-narrow-min (expr a c intv) (let ((xvals (list a c)) (yvals (list (math-min-eval expr a) (math-min-eval expr c))) (levels 0) (step (math-sub-float c a)) (found nil) xp yp b) (while (and (<= (setq levels (1+ levels)) 5) (not found)) (setq xp xvals yp yvals step (math-mul-float step '(float 497 -3))) (while (and (cdr xp) (not found)) (setq b (math-add-float (car xp) step)) (math-working "search" b) (setcdr xp (cons b (cdr xp))) (setcdr yp (cons (math-min-eval expr b) (cdr yp))) (if (and (math-lessp-float (nth 1 yp) (car yp)) (math-lessp-float (nth 1 yp) (nth 2 yp))) (setq found t) (setq xp (cdr xp) yp (cdr yp)) (if (and (cdr (cdr yp)) (math-lessp-float (nth 1 yp) (car yp)) (math-lessp-float (nth 1 yp) (nth 2 yp))) (setq found t) (setq xp (cdr xp) yp (cdr yp)))))) (if found (list (car xp) (car yp) (nth 1 xp) (nth 1 yp) (nth 2 xp) (nth 2 yp)) (or (if (math-lessp-float (car yvals) (nth 1 yvals)) (and (memq (nth 1 intv) '(2 3)) (let ((min (car yvals))) (while (and (setq yvals (cdr yvals)) (math-lessp-float min (car yvals)))) (and (not yvals) (list (nth 2 intv) min)))) (and (memq (nth 1 intv) '(1 3)) (setq yvals (nreverse yvals)) (let ((min (car yvals))) (while (and (setq yvals (cdr yvals)) (math-lessp-float min (car yvals)))) (and (not yvals) (list (nth 3 intv) min))))) (math-reject-arg nil (format "*Unable to find a %s in the interval" math-min-or-max))))) ) ;;; "brent" (defun math-brent-min (expr prec a va x vx b vb) (let ((iters (+ 20 (* 5 prec))) (w x) (vw vx) (v x) (vv vx) (tol (list 'float 1 (- -1 prec))) (zeps (list 'float 1 (- -5 prec))) (e '(float 0 0)) u vu xm tol1 tol2 etemp p q r xv xw) (while (progn (setq xm (math-mul-float '(float 5 -1) (math-add-float a b)) tol1 (math-add-float zeps (math-mul-float tol (math-abs x))) tol2 (math-mul-float tol1 '(float 2 0))) (math-lessp-float (math-sub-float tol2 (math-mul-float '(float 5 -1) (math-sub-float b a))) (math-abs (math-sub-float x xm)))) (if (= (setq iters (1- iters)) 0) (math-reject-arg nil (format "*Unable to converge on a %s" math-min-or-max))) (math-working "brent" x) (if (math-lessp-float (math-abs e) tol1) (setq e (if (math-lessp-float x xm) (math-sub-float b x) (math-sub-float a x)) d (math-mul-float '(float 381966 -6) e)) (setq xw (math-sub-float x w) r (math-mul-float xw (math-sub-float vx vv)) xv (math-sub-float x v) q (math-mul-float xv (math-sub-float vx vw)) p (math-sub-float (math-mul-float xv q) (math-mul-float xw r)) q (math-mul-float '(float 2 0) (math-sub-float q r))) (if (math-posp q) (setq p (math-neg-float p)) (setq q (math-neg-float q))) (setq etemp e e d) (if (and (math-lessp-float (math-abs p) (math-abs (math-mul-float '(float 5 -1) (math-mul-float q etemp)))) (math-lessp-float (math-mul-float q (math-sub-float a x)) p) (math-lessp-float p (math-mul-float q (math-sub-float b x)))) (progn (setq d (math-div-float p q) u (math-add-float x d)) (if (or (math-lessp-float (math-sub-float u a) tol2) (math-lessp-float (math-sub-float b u) tol2)) (setq d (if (math-lessp-float xm x) (math-neg-float tol1) tol1)))) (setq e (if (math-lessp-float x xm) (math-sub-float b x) (math-sub-float a x)) d (math-mul-float '(float 381966 -6) e)))) (setq u (math-add-float x (if (math-lessp-float (math-abs d) tol1) (if (math-negp d) (math-neg-float tol1) tol1) d)) vu (math-min-eval expr u)) (if (math-lessp-float vx vu) (progn (if (math-lessp-float u x) (setq a u) (setq b u)) (if (or (equal w x) (not (math-lessp-float vw vu))) (setq v w vv vw w u vw vu) (if (or (equal v x) (equal v w) (not (math-lessp-float vv vu))) (setq v u vv vu)))) (if (math-lessp-float u x) (setq b x) (setq a x)) (setq v w vv vw w x vw vx x u vx vu))) (list 'vec x vx)) ) ;;; "powell" (defun math-powell-min (expr n guesses prec) (let* ((f1dim (math-line-min-func expr n)) (xi (calcFunc-idn 1 n)) (p (cons 'vec (mapcar 'car guesses))) (pt p) (ftol (list 'float 1 (- prec))) (fret (math-min-eval expr p)) fp ptt fptt xit i ibig del diff res) (while (progn (setq fp fret ibig 0 del '(float 0 0) i 0) (while (<= (setq i (1+ i)) n) (setq fptt fret res (math-line-min f1dim p (math-mat-col xi i) n prec) p (let ((calc-internal-prec prec)) (math-normalize (car res))) fret (nth 2 res) diff (math-abs (math-sub-float fptt fret))) (if (math-lessp-float del diff) (setq del diff ibig i))) (math-lessp-float (math-mul-float ftol (math-add-float (math-abs fp) (math-abs fret))) (math-mul-float '(float 2 0) (math-abs (math-sub-float fp fret))))) (setq ptt (math-sub (math-mul '(float 2 0) p) pt) xit (math-sub p pt) pt p fptt (math-min-eval expr ptt)) (if (and (math-lessp-float fptt fp) (math-lessp-float (math-mul-float (math-mul-float '(float 2 0) (math-add-float (math-sub-float fp (math-mul-float '(float 2 0) fret)) fptt)) (math-sqr-float (math-sub-float (math-sub-float fp fret) del))) (math-mul-float del (math-sqr-float (math-sub-float fp fptt))))) (progn (setq res (math-line-min f1dim p xit n prec) p (car res) fret (nth 2 res) i 0) (while (<= (setq i (1+ i)) n) (setcar (nthcdr ibig (nth i xi)) (nth i (nth 1 res))))))) (list 'vec p fret)) ) (defun math-line-min-func (expr n) (let ((m -1)) (while (< (setq m (1+ m)) n) (set (nth 2 (aref math-min-vars m)) (list '+ (list '* '(var DUMMY var-DUMMY) (list 'calcFunc-mrow '(var line-xi line-xi) (1+ m))) (list 'calcFunc-mrow '(var line-p line-p) (1+ m))))) (math-evaluate-expr expr)) ) (defun math-line-min (f1dim line-p line-xi n prec) (let* ((var-DUMMY nil) (expr (math-evaluate-expr f1dim)) (params (math-widen-min expr '(float 0 0) '(float 1 0))) (res (apply 'math-brent-min expr prec params)) (xi (math-mul (nth 1 res) line-xi))) (list (math-add line-p xi) xi (nth 2 res))) ) (defvar math-min-vars [(var DUMMY var-DUMMY)]) (defun math-find-minimum (expr var guess min-widen) (let* ((calc-symbolic-mode nil) (n 0) (var-DUMMY nil) (isvec (math-vectorp var)) g guesses) (or (math-vectorp var) (setq var (list 'vec var))) (or (math-vectorp guess) (setq guess (list 'vec guess))) (or (= (length var) (length guess)) (math-dimension-error)) (while (setq var (cdr var) guess (cdr guess)) (or (eq (car-safe (car var)) 'var) (math-reject-arg (car vg) "*Expected a variable")) (or (math-expr-contains expr (car var)) (math-reject-arg (car var) "*Formula does not contain specified variable")) (while (>= (1+ n) (length math-min-vars)) (let ((symb (intern (concat "math-min-v" (int-to-string (length math-min-vars)))))) (setq math-min-vars (vconcat math-min-vars (vector (list 'var symb symb)))))) (set (nth 2 (aref math-min-vars n)) nil) (set (nth 2 (aref math-min-vars (1+ n))) nil) (if (math-complexp (car guess)) (setq expr (math-expr-subst expr (car var) (list '+ (aref math-min-vars n) (list '* (aref math-min-vars (1+ n)) '(cplx 0 1)))) guesses (let ((g (math-float (math-complex (car guess))))) (cons (list (nth 2 g) nil nil) (cons (list (nth 1 g) nil nil t) guesses))) n (+ n 2)) (setq expr (math-expr-subst expr (car var) (aref math-min-vars n)) guesses (cons (if (math-realp (car guess)) (list (math-float (car guess)) nil nil) (if (and (eq (car-safe (car guess)) 'intv) (math-constp (car guess))) (list (math-mul (math-add (nth 2 (car guess)) (nth 3 (car guess))) '(float 5 -1)) (math-float (nth 2 (car guess))) (math-float (nth 3 (car guess))) (car guess)) (math-reject-arg (car guess) 'realp))) guesses) n (1+ n)))) (setq guesses (nreverse guesses) expr (math-evaluate-expr expr)) (if (= n 1) (let* ((params (if (nth 1 (car guesses)) (if min-widen (math-widen-min expr (nth 1 (car guesses)) (nth 2 (car guesses))) (math-narrow-min expr (nth 1 (car guesses)) (nth 2 (car guesses)) (nth 3 (car guesses)))) (math-widen-min expr (car (car guesses)) nil))) (prec calc-internal-prec) (res (if (cdr (cdr params)) (math-with-extra-prec (+ calc-internal-prec 2) (apply 'math-brent-min expr prec params)) (cons 'vec params)))) (if isvec (list 'vec (list 'vec (nth 1 res)) (nth 2 res)) res)) (let* ((prec calc-internal-prec) (res (math-with-extra-prec (+ calc-internal-prec 2) (math-powell-min expr n guesses prec))) (p (nth 1 res)) (vec (list 'vec))) (while (setq p (cdr p)) (if (nth 3 (car guesses)) (progn (nconc vec (list (math-normalize (list 'cplx (car p) (nth 1 p))))) (setq p (cdr p) guesses (cdr guesses))) (nconc vec (list (car p)))) (setq guesses (cdr guesses))) (if isvec (list 'vec vec (nth 2 res)) (list 'vec (nth 1 vec) (nth 2 res)))))) ) (setq math-min-or-max "minimum") (defun calcFunc-minimize (expr var guess) (let ((calc-internal-prec (max (/ calc-internal-prec 2) 3)) (math-min-or-max "minimum")) (math-find-minimum (math-normalize expr) (math-normalize var) (math-normalize guess) nil)) ) (defun calcFunc-wminimize (expr var guess) (let ((calc-internal-prec (max (/ calc-internal-prec 2) 3)) (math-min-or-max "minimum")) (math-find-minimum (math-normalize expr) (math-normalize var) (math-normalize guess) t)) ) (defun calcFunc-maximize (expr var guess) (let* ((calc-internal-prec (max (/ calc-internal-prec 2) 3)) (math-min-or-max "maximum") (res (math-find-minimum (math-normalize (math-neg expr)) (math-normalize var) (math-normalize guess) nil))) (list 'vec (nth 1 res) (math-neg (nth 2 res)))) ) (defun calcFunc-wmaximize (expr var guess) (let* ((calc-internal-prec (max (/ calc-internal-prec 2) 3)) (math-min-or-max "maximum") (res (math-find-minimum (math-normalize (math-neg expr)) (math-normalize var) (math-normalize guess) t))) (list 'vec (nth 1 res) (math-neg (nth 2 res)))) ) ;;; The following algorithms come from Numerical Recipes, chapter 3. (defun calcFunc-polint (data x) (or (math-matrixp data) (math-reject-arg data 'matrixp)) (or (= (length data) 3) (math-reject-arg data "*Wrong number of data rows")) (or (> (length (nth 1 data)) 2) (math-reject-arg data "*Too few data points")) (if (and (math-vectorp x) (or (math-constp x) math-expand-formulas)) (cons 'vec (mapcar (function (lambda (x) (calcFunc-polint data x))) (cdr x))) (or (math-objectp x) math-expand-formulas (math-reject-arg x 'objectp)) (math-with-extra-prec 2 (cons 'vec (math-poly-interp (cdr (nth 1 data)) (cdr (nth 2 data)) x nil)))) ) (put 'calcFunc-polint 'math-expandable t) (defun calcFunc-ratint (data x) (or (math-matrixp data) (math-reject-arg data 'matrixp)) (or (= (length data) 3) (math-reject-arg data "*Wrong number of data rows")) (or (> (length (nth 1 data)) 2) (math-reject-arg data "*Too few data points")) (if (and (math-vectorp x) (or (math-constp x) math-expand-formulas)) (cons 'vec (mapcar (function (lambda (x) (calcFunc-ratint data x))) (cdr x))) (or (math-objectp x) math-expand-formulas (math-reject-arg x 'objectp)) (math-with-extra-prec 2 (cons 'vec (math-poly-interp (cdr (nth 1 data)) (cdr (nth 2 data)) x (cdr (cdr (cdr (nth 1 data)))))))) ) (put 'calcFunc-ratint 'math-expandable t) (defun math-poly-interp (xa ya x ratp) (let ((n (length xa)) (dif nil) (ns nil) (xax nil) (c (copy-sequence ya)) (d (copy-sequence ya)) (i 0) (m 0) y dy (xp xa) xpm cp dp temp) (while (<= (setq i (1+ i)) n) (setq xax (cons (math-sub (car xp) x) xax) xp (cdr xp) temp (math-abs (car xax))) (if (or (null dif) (math-lessp temp dif)) (setq dif temp ns i))) (setq xax (nreverse xax) ns (1- ns) y (nth ns ya)) (if (math-zerop dif) (list y 0) (while (< (setq m (1+ m)) n) (setq i 0 xp xax xpm (nthcdr m xax) cp c dp d) (while (<= (setq i (1+ i)) (- n m)) (if ratp (let ((t2 (math-div (math-mul (car xp) (car dp)) (car xpm)))) (setq temp (math-div (math-sub (nth 1 cp) (car dp)) (math-sub t2 (nth 1 cp)))) (setcar dp (math-mul (nth 1 cp) temp)) (setcar cp (math-mul t2 temp))) (if (math-equal (car xp) (car xpm)) (math-reject-arg (cons 'vec xa) "*Duplicate X values")) (setq temp (math-div (math-sub (nth 1 cp) (car dp)) (math-sub (car xp) (car xpm)))) (setcar dp (math-mul (car xpm) temp)) (setcar cp (math-mul (car xp) temp))) (setq cp (cdr cp) dp (cdr dp) xp (cdr xp) xpm (cdr xpm))) (if (< (+ ns ns) (- n m)) (setq dy (nth ns c)) (setq ns (1- ns) dy (nth ns d))) (setq y (math-add y dy))) (list y dy))) ) ;;; The following algorithms come from Numerical Recipes, chapter 4. (defun calcFunc-ninteg (expr var lo hi) (setq lo (math-evaluate-expr lo) hi (math-evaluate-expr hi)) (or (math-numberp lo) (math-infinitep lo) (math-reject-arg lo 'numberp)) (or (math-numberp hi) (math-infinitep hi) (math-reject-arg hi 'numberp)) (if (math-lessp hi lo) (math-neg (calcFunc-ninteg expr var hi lo)) (setq expr (math-expr-subst expr var '(var DUMMY var-DUMMY))) (let ((var-DUMMY nil) (calc-symbolic-mode nil) (calc-prefer-frac nil) (sum 0)) (setq expr (math-evaluate-expr expr)) (if (equal lo '(neg (var inf var-inf))) (let ((thi (if (math-lessp hi '(float -2 0)) hi '(float -2 0)))) (setq sum (math-ninteg-romberg 'math-ninteg-midpoint expr (math-float lo) (math-float thi) 'inf) lo thi))) (if (equal hi '(var inf var-inf)) (let ((tlo (if (math-lessp '(float 2 0) lo) lo '(float 2 0)))) (setq sum (math-add sum (math-ninteg-romberg 'math-ninteg-midpoint expr (math-float tlo) (math-float hi) 'inf)) hi tlo))) (or (math-equal lo hi) (setq sum (math-add sum (math-ninteg-romberg 'math-ninteg-midpoint expr (math-float lo) (math-float hi) nil)))) sum)) ) ;;; Open Romberg method; "qromo" in section 4.4. (defun math-ninteg-romberg (func expr lo hi mode) (let ((curh '(float 1 0)) (h nil) (s nil) (j 0) (ss nil) (prec calc-internal-prec) (integ-temp nil)) (math-with-extra-prec 2 ;; Limit on "j" loop must be 14 or less to keep "it" from overflowing. (or (while (and (null ss) (<= (setq j (1+ j)) 8)) (setq s (nconc s (list (funcall func expr lo hi mode))) h (nconc h (list curh))) (if (>= j 3) (let ((res (math-poly-interp h s '(float 0 0) nil))) (if (math-lessp (math-abs (nth 1 res)) (calcFunc-scf (math-abs (car res)) (- prec))) (setq math-ninteg-convergence j ss (car res))))) (if (>= j 5) (setq s (cdr s) h (cdr h))) (setq curh (math-div-float curh '(float 9 0)))) ss (math-reject-arg nil (format "*Integral failed to converge"))))) ) (defun math-ninteg-evaluate (expr x mode) (if (eq mode 'inf) (setq x (math-div '(float 1 0) x))) (let* ((var-DUMMY x) (res (math-evaluate-expr expr))) (or (Math-numberp res) (math-reject-arg res "*Integrand does not evaluate to a number")) (if (eq mode 'inf) (setq res (math-mul res (math-sqr x)))) res) ) (defun math-ninteg-midpoint (expr lo hi mode) ; uses "integ-temp" (if (eq mode 'inf) (let ((math-infinite-mode t) temp) (setq temp (math-div 1 lo) lo (math-div 1 hi) hi temp))) (if integ-temp (let* ((it3 (* 3 (car integ-temp))) (math-working-step-2 (* 2 (car integ-temp))) (math-working-step 0) (range (math-sub hi lo)) (del (math-div range (math-float it3))) (del2 (math-add del del)) (del3 (math-add del del2)) (x (math-add lo (math-mul '(float 5 -1) del))) (sum '(float 0 0)) (j 0) temp) (while (<= (setq j (1+ j)) (car integ-temp)) (setq math-working-step (1+ math-working-step) temp (math-ninteg-evaluate expr x mode) math-working-step (1+ math-working-step) sum (math-add sum (math-add temp (math-ninteg-evaluate expr (math-add x del2) mode))) x (math-add x del3))) (setq integ-temp (list it3 (math-add (math-div (nth 1 integ-temp) '(float 3 0)) (math-mul sum del))))) (setq integ-temp (list 1 (math-mul (math-sub hi lo) (math-ninteg-evaluate expr (math-mul (math-add lo hi) '(float 5 -1)) mode))))) (nth 1 integ-temp) ) ;;; The following algorithms come from Numerical Recipes, chapter 14. (setq math-dummy-vars [(var DUMMY var-DUMMY)]) (setq math-dummy-counter 0) (defun math-dummy-variable () (if (= math-dummy-counter (length math-dummy-vars)) (let ((symb (intern (format "math-dummy-%d" math-dummy-counter)))) (setq math-dummy-vars (vconcat math-dummy-vars (vector (list 'var symb symb)))))) (set (nth 2 (aref math-dummy-vars math-dummy-counter)) nil) (prog1 (aref math-dummy-vars math-dummy-counter) (setq math-dummy-counter (1+ math-dummy-counter))) ) (defun calcFunc-fit (expr vars &optional coefs data) (let ((math-in-fit 10)) (math-with-extra-prec 2 (math-general-fit expr vars coefs data nil))) ) (defun calcFunc-efit (expr vars &optional coefs data) (let ((math-in-fit 10)) (math-with-extra-prec 2 (math-general-fit expr vars coefs data 'sdev))) ) (defun calcFunc-xfit (expr vars &optional coefs data) (let ((math-in-fit 10)) (math-with-extra-prec 2 (math-general-fit expr vars coefs data 'full))) ) (defun math-general-fit (expr vars coefs data mode) (let ((calc-simplify-mode nil) (math-dummy-counter math-dummy-counter) (math-in-fit 1) (extended (eq mode 'full)) (first-coef math-dummy-counter) first-var (plain-expr expr) orig-expr have-sdevs need-chisq chisq (x-funcs nil) (y-filter nil) y-dummy (coef-filters nil) new-coefs (xy-values nil) (weights nil) (var-YVAL nil) (var-YVALX nil) covar beta n nn m mm v dummy p) ;; Validate and parse arguments. (or data (if coefs (setq data coefs coefs nil) (if (math-vectorp expr) (if (memq (length expr) '(3 4)) (setq data vars vars (nth 2 expr) coefs (nth 3 expr) expr (nth 1 expr)) (math-dimension-error)) (setq data vars vars nil coefs nil)))) (or (math-matrixp data) (math-reject-arg data 'matrixp)) (setq v (1- (length data)) n (1- (length (nth 1 data)))) (or (math-vectorp vars) (null vars) (setq vars (list 'vec vars))) (or (math-vectorp coefs) (null coefs) (setq coefs (list 'vec coefs))) (or coefs (setq coefs (cons 'vec (math-all-vars-but expr vars)))) (or vars (if (<= (1- (length coefs)) v) (math-reject-arg coefs "*Not enough variables in model") (setq coefs (copy-sequence coefs)) (let ((p (nthcdr (- (length coefs) v (if (eq (car-safe expr) 'calcFunc-eq) 1 0)) coefs))) (setq vars (cons 'vec (cdr p))) (setcdr p nil)))) (or (= (1- (length vars)) v) (= (length vars) v) (math-reject-arg vars "*Number of variables does not match data")) (setq m (1- (length coefs))) (if (< m 1) (math-reject-arg coefs "*Need at least one parameter")) ;; Rewrite expr in terms of fitparam and fitvar, make into an equation. (setq p coefs) (while (setq p (cdr p)) (or (eq (car-safe (car p)) 'var) (math-reject-arg (car p) "*Expected a variable")) (setq dummy (math-dummy-variable) expr (math-expr-subst expr (car p) (list 'calcFunc-fitparam (- math-dummy-counter first-coef))))) (setq first-var math-dummy-counter p vars) (while (setq p (cdr p)) (or (eq (car-safe (car p)) 'var) (math-reject-arg (car p) "*Expected a variable")) (setq dummy (math-dummy-variable) expr (math-expr-subst expr (car p) (list 'calcFunc-fitvar (- math-dummy-counter first-var))))) (if (< math-dummy-counter (+ first-var v)) (setq dummy (math-dummy-variable))) ; dependent variable may be unnamed (setq y-dummy dummy orig-expr expr) (or (eq (car-safe expr) 'calcFunc-eq) (setq expr (list 'calcFunc-eq (list 'calcFunc-fitvar v) expr))) (let ((calc-symbolic-mode nil)) ;; Apply rewrites to put expr into a linear-like form. (setq expr (math-evaluate-expr expr) expr (math-rewrite (list 'calcFunc-fitmodel expr) '(var FitRules var-FitRules)) math-in-fit 2 expr (math-evaluate-expr expr)) (or (and (eq (car-safe expr) 'calcFunc-fitsystem) (= (length expr) 4) (math-vectorp (nth 2 expr)) (math-vectorp (nth 3 expr)) (> (length (nth 2 expr)) 1) (= (length (nth 3 expr)) (1+ m))) (math-reject-arg plain-expr "*Model expression is too complex")) (setq y-filter (nth 1 expr) x-funcs (vconcat (cdr (nth 2 expr))) coef-filters (nth 3 expr) mm (length x-funcs)) (if (equal y-filter y-dummy) (setq y-filter nil)) ;; Build the (square) system of linear equations to be solved. (setq beta (cons 'vec (make-list mm 0)) covar (cons 'vec (mapcar 'copy-sequence (make-list mm beta)))) (let* ((ptrs (vconcat (cdr data))) (isigsq 1) (xvals (make-vector mm 0)) (i 0) j k xval yval sigmasqr wt covj covjk covk betaj lud) (while (<= (setq i (1+ i)) n) ;; Assign various independent variables for this data point. (setq j 0 sigmasqr nil) (while (< j v) (aset ptrs j (cdr (aref ptrs j))) (setq xval (car (aref ptrs j))) (if (= j (1- v)) (if sigmasqr (progn (if (eq (car-safe xval) 'sdev) (setq sigmasqr (math-add (math-sqr (nth 2 xval)) sigmasqr) xval (nth 1 xval))) (if y-filter (setq xval (math-make-sdev xval (math-sqrt sigmasqr)))))) (if (eq (car-safe xval) 'sdev) (setq sigmasqr (math-add (math-sqr (nth 2 xval)) (or sigmasqr 0)) xval (nth 1 xval)))) (set (nth 2 (aref math-dummy-vars (+ first-var j))) xval) (setq j (1+ j))) ;; Compute Y value for this data point. (if y-filter (setq yval (math-evaluate-expr y-filter)) (setq yval (symbol-value (nth 2 y-dummy)))) (if (eq (car-safe yval) 'sdev) (setq sigmasqr (math-sqr (nth 2 yval)) yval (nth 1 yval))) (if (= i 1) (setq have-sdevs sigmasqr need-chisq (or extended (and (eq mode 'sdev) (not have-sdevs))))) (if have-sdevs (if sigmasqr (progn (setq isigsq (math-div 1 sigmasqr)) (if need-chisq (setq weights (cons isigsq weights)))) (math-reject-arg yval "*Mixed error forms and plain numbers")) (if sigmasqr (math-reject-arg yval "*Mixed error forms and plain numbers"))) ;; Compute X values for this data point and update covar and beta. (if (eq (car-safe xval) 'sdev) (set (nth 2 y-dummy) (nth 1 xval))) (setq j 0 covj covar betaj beta) (while (< j mm) (setq wt (math-evaluate-expr (aref x-funcs j))) (aset xvals j wt) (setq wt (math-mul wt isigsq) betaj (cdr betaj) covjk (car (setq covj (cdr covj))) k 0) (while (<= k j) (setq covjk (cdr covjk)) (setcar covjk (math-add (car covjk) (math-mul wt (aref xvals k)))) (setq k (1+ k))) (setcar betaj (math-add (car betaj) (math-mul wt yval))) (setq j (1+ j))) (if need-chisq (setq xy-values (cons (append xvals (list yval)) xy-values)))) ;; Fill in symmetric half of covar matrix. (setq j 0 covj covar) (while (< j (1- mm)) (setq k j j (1+ j) covjk (nthcdr j (car (setq covj (cdr covj)))) covk (nthcdr j covar)) (while (< (setq k (1+ k)) mm) (setq covjk (cdr covjk) covk (cdr covk)) (setcar covjk (nth j (car covk)))))) ;; Solve the linear system. (if mode (progn (setq covar (math-matrix-inv-raw covar)) (if covar (setq beta (math-mul covar beta)) (if (math-zerop (math-abs beta)) (setq covar (calcFunc-diag 0 (1- (length beta)))) (math-reject-arg orig-expr "*Singular matrix"))) (or (math-vectorp covar) (setq covar (list 'vec (list 'vec covar))))) (setq beta (math-div beta covar))) ;; Compute chi-square statistic if necessary. (if need-chisq (let (bp xp sum) (setq chisq 0) (while xy-values (setq bp beta xp (car xy-values) sum 0) (while (setq bp (cdr bp)) (setq sum (math-add sum (math-mul (car bp) (car xp))) xp (cdr xp))) (setq sum (math-sqr (math-sub (car xp) sum))) (if weights (setq sum (math-mul sum (car weights)))) (setq chisq (math-add chisq sum) weights (cdr weights) xy-values (cdr xy-values))))) ;; Convert coefficients back into original terms. (setq new-coefs (copy-sequence beta)) (let* ((bp new-coefs) (cp covar) (sigdat 1) (math-in-fit 3) (j 0)) (and mode (not have-sdevs) (setq sigdat (if (<= n mm) 0 (math-div chisq (- n mm))))) (if mode (while (setq bp (cdr bp)) (setcar bp (math-make-sdev (car bp) (math-sqrt (math-mul (nth (setq j (1+ j)) (car (setq cp (cdr cp)))) sigdat)))))) (setq new-coefs (math-evaluate-expr coef-filters)) (if calc-fit-to-trail (let ((bp new-coefs) (cp coefs) (vec nil)) (while (setq bp (cdr bp) cp (cdr cp)) (setq vec (cons (list 'calcFunc-eq (car cp) (car bp)) vec))) (setq calc-fit-to-trail (cons 'vec (nreverse vec))))))) ;; Substitute best-fit coefficients back into original formula. (setq expr (math-multi-subst orig-expr (let ((n v) (vec nil)) (while (>= n 1) (setq vec (cons (list 'calcFunc-fitvar n) vec) n (1- n))) (setq n m) (while (>= n 1) (setq vec (cons (list 'calcFunc-fitparam n) vec) n (1- n))) vec) (append (cdr new-coefs) (cdr vars)))) ;; Package the result. (math-normalize (if extended (list 'vec expr beta covar (let ((p coef-filters) (n 0)) (while (and (setq n (1+ n) p (cdr p)) (eq (car-safe (car p)) 'calcFunc-fitdummy) (eq (nth 1 (car p)) n))) (if p coef-filters (list 'vec))) chisq (if (and have-sdevs (> n mm)) (list 'calcFunc-utpc chisq (- n mm)) '(var nan var-nan))) expr))) ) (setq math-in-fit 0) (setq calc-fit-to-trail nil) (defun calcFunc-fitvar (x) (if (>= math-in-fit 2) (progn (setq x (aref math-dummy-vars (+ first-var x -1))) (or (calc-var-value (nth 2 x)) x)) (math-reject-arg x)) ) (defun calcFunc-fitparam (x) (if (>= math-in-fit 2) (progn (setq x (aref math-dummy-vars (+ first-coef x -1))) (or (calc-var-value (nth 2 x)) x)) (math-reject-arg x)) ) (defun calcFunc-fitdummy (x) (if (= math-in-fit 3) (nth x new-coefs) (math-reject-arg x)) ) (defun calcFunc-hasfitvars (expr) (if (Math-primp expr) 0 (if (eq (car expr) 'calcFunc-fitvar) (nth 1 expr) (apply 'max (mapcar 'calcFunc-hasfitvars (cdr expr))))) ) (defun calcFunc-hasfitparams (expr) (if (Math-primp expr) 0 (if (eq (car expr) 'calcFunc-fitparam) (nth 1 expr) (apply 'max (mapcar 'calcFunc-hasfitparams (cdr expr))))) ) (defun math-all-vars-but (expr but) (let* ((vars (math-all-vars-in expr)) (p but)) (while p (setq vars (delq (assoc (car-safe p) vars) vars) p (cdr p))) (sort (mapcar 'car vars) (function (lambda (x y) (string< (nth 1 x) (nth 1 y)))))) ) (defun math-all-vars-in (expr) (let ((vars nil) found) (math-all-vars-rec expr) vars) ) (defun math-all-vars-rec (expr) (if (Math-primp expr) (if (eq (car-safe expr) 'var) (or (math-const-var expr) (if (setq found (assoc expr vars)) (setcdr found (1+ (cdr found))) (setq vars (cons (cons expr 1) vars))))) (while (setq expr (cdr expr)) (math-all-vars-rec (car expr)))) ) calc-2.02c/calc-prog.el100644 22403 13 202527 5547406513 13270 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-prog.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-prog () nil) (defun calc-equal-to (arg) (interactive "P") (calc-wrapper (if (and (integerp arg) (> arg 2)) (calc-enter-result arg "eq" (cons 'calcFunc-eq (calc-top-list-n arg))) (calc-binary-op "eq" 'calcFunc-eq arg))) ) (defun calc-remove-equal (arg) (interactive "P") (calc-wrapper (calc-unary-op "rmeq" 'calcFunc-rmeq arg)) ) (defun calc-not-equal-to (arg) (interactive "P") (calc-wrapper (if (and (integerp arg) (> arg 2)) (calc-enter-result arg "neq" (cons 'calcFunc-neq (calc-top-list-n arg))) (calc-binary-op "neq" 'calcFunc-neq arg))) ) (defun calc-less-than (arg) (interactive "P") (calc-wrapper (calc-binary-op "lt" 'calcFunc-lt arg)) ) (defun calc-greater-than (arg) (interactive "P") (calc-wrapper (calc-binary-op "gt" 'calcFunc-gt arg)) ) (defun calc-less-equal (arg) (interactive "P") (calc-wrapper (calc-binary-op "leq" 'calcFunc-leq arg)) ) (defun calc-greater-equal (arg) (interactive "P") (calc-wrapper (calc-binary-op "geq" 'calcFunc-geq arg)) ) (defun calc-in-set (arg) (interactive "P") (calc-wrapper (calc-binary-op "in" 'calcFunc-in arg)) ) (defun calc-logical-and (arg) (interactive "P") (calc-wrapper (calc-binary-op "land" 'calcFunc-land arg 1)) ) (defun calc-logical-or (arg) (interactive "P") (calc-wrapper (calc-binary-op "lor" 'calcFunc-lor arg 0)) ) (defun calc-logical-not (arg) (interactive "P") (calc-wrapper (calc-unary-op "lnot" 'calcFunc-lnot arg)) ) (defun calc-logical-if () (interactive) (calc-wrapper (calc-enter-result 3 "if" (cons 'calcFunc-if (calc-top-list-n 3)))) ) (defun calc-timing (n) (interactive "P") (calc-wrapper (calc-change-mode 'calc-timing n nil t) (message (if calc-timing "Reporting timing of slow commands in Trail." "Not reporting timing of commands."))) ) (defun calc-pass-errors () (interactive) ;; The following two cases are for the new, optimizing byte compiler ;; or the standard 18.57 byte compiler, respectively. (condition-case err (let ((place (aref (nth 2 (nth 2 (symbol-function 'calc-do))) 15))) (or (memq (car-safe (car-safe place)) '(error xxxerror)) (setq place (aref (nth 2 (nth 2 (symbol-function 'calc-do))) 27))) (or (memq (car (car place)) '(error xxxerror)) (error "foo")) (setcar (car place) 'xxxerror)) (error (error "The calc-do function has been modified; unable to patch."))) ) (defun calc-user-define () (interactive) (message "Define user key: z-") (let ((key (read-char))) (if (= (calc-user-function-classify key) 0) (error "Can't redefine \"?\" key")) (let ((func (intern (completing-read (concat "Set key z " (char-to-string key) " to command: ") obarray 'commandp t "calc-")))) (let* ((kmap (calc-user-key-map)) (old (assq key kmap))) (if old (setcdr old func) (setcdr kmap (cons (cons key func) (cdr kmap))))))) ) (defun calc-user-undefine () (interactive) (message "Undefine user key: z-") (let ((key (read-char))) (if (= (calc-user-function-classify key) 0) (error "Can't undefine \"?\" key")) (let* ((kmap (calc-user-key-map))) (delq (or (assq key kmap) (assq (upcase key) kmap) (assq (downcase key) kmap) (error "No such user key is defined")) kmap))) ) (defun calc-user-define-formula () (interactive) (calc-wrapper (let* ((form (calc-top 1)) (arglist nil) (is-lambda (and (eq (car-safe form) 'calcFunc-lambda) (>= (length form) 2))) odef key keyname cmd cmd-base func alist is-symb) (if is-lambda (setq arglist (mapcar (function (lambda (x) (nth 1 x))) (nreverse (cdr (reverse (cdr form))))) form (nth (1- (length form)) form)) (calc-default-formula-arglist form) (setq arglist (sort arglist 'string-lessp))) (message "Define user key: z-") (setq key (read-char)) (if (= (calc-user-function-classify key) 0) (error "Can't redefine \"?\" key")) (setq key (and (not (memq key '(13 32))) key) keyname (and key (if (or (and (<= ?0 key) (<= key ?9)) (and (<= ?a key) (<= key ?z)) (and (<= ?A key) (<= key ?Z))) (char-to-string key) (format "%03d" key))) odef (assq key (calc-user-key-map))) (while (progn (setq cmd (completing-read "Define M-x command name: " obarray 'commandp nil (if (and odef (symbolp (cdr odef))) (symbol-name (cdr odef)) "calc-")) cmd-base (and (string-match "\\`calc-\\(.+\\)\\'" cmd) (math-match-substring cmd 1)) cmd (and (not (or (string-equal cmd "") (string-equal cmd "calc-"))) (intern cmd))) (and cmd (fboundp cmd) odef (not (y-or-n-p (if (get cmd 'calc-user-defn) (concat "Replace previous definition for " (symbol-name cmd) "? ") "That name conflicts with a built-in Emacs function. Replace this function? ")))))) (if (and key (not cmd)) (setq cmd (intern (concat "calc-User-" keyname)))) (while (progn (setq func (completing-read "Define algebraic function name: " obarray 'fboundp nil (concat "calcFunc-" (if cmd-base (if (string-match "\\`User-.+" cmd-base) (concat "User" (substring cmd-base 5)) cmd-base) ""))) func (and (not (or (string-equal func "") (string-equal func "calcFunc-"))) (intern func))) (and func (fboundp func) (not (fboundp cmd)) odef (not (y-or-n-p (if (get func 'calc-user-defn) (concat "Replace previous definition for " (symbol-name func) "? ") "That name conflicts with a built-in Emacs function. Replace this function? ")))))) (if (not func) (setq func (intern (concat "calcFunc-User" (or keyname (and cmd (symbol-name cmd)) (format "%05d" (% (random) 10000))))))) (if is-lambda (setq alist arglist) (while (progn (setq alist (read-from-minibuffer "Function argument list: " (if arglist (prin1-to-string arglist) "()") minibuffer-local-map t)) (and (not (calc-subsetp alist arglist)) (not (y-or-n-p "Okay for arguments that don't appear in formula to be ignored? ")))))) (setq is-symb (and alist func (y-or-n-p "Leave it symbolic for non-constant arguments? "))) (setq alist (mapcar (function (lambda (x) (or (cdr (assq x '((nil . arg-nil) (t . arg-t)))) x))) alist)) (if cmd (progn (calc-need-macros) (fset cmd (list 'lambda '() '(interactive) (list 'calc-wrapper (list 'calc-enter-result (length alist) (let ((name (symbol-name (or func cmd)))) (and (string-match "\\([^-][^-]?[^-]?[^-]?\\)[^-]*\\'" name) (math-match-substring name 1))) (list 'cons (list 'quote func) (list 'calc-top-list-n (length alist))))))) (put cmd 'calc-user-defn t))) (let ((body (list 'math-normalize (calc-fix-user-formula form)))) (fset func (append (list 'lambda alist) (and is-symb (mapcar (function (lambda (v) (list 'math-check-const v t))) alist)) (list body)))) (put func 'calc-user-defn form) (setq math-integral-cache-state nil) (if key (let* ((kmap (calc-user-key-map)) (old (assq key kmap))) (if old (setcdr old cmd) (setcdr kmap (cons (cons key cmd) (cdr kmap))))))) (message "")) ) (defun calc-default-formula-arglist (form) (if (consp form) (if (eq (car form) 'var) (if (or (memq (nth 1 form) arglist) (math-const-var form)) () (setq arglist (cons (nth 1 form) arglist))) (calc-default-formula-arglist-step (cdr form)))) ) (defun calc-default-formula-arglist-step (l) (and l (progn (calc-default-formula-arglist (car l)) (calc-default-formula-arglist-step (cdr l)))) ) (defun calc-subsetp (a b) (or (null a) (and (memq (car a) b) (calc-subsetp (cdr a) b))) ) (defun calc-fix-user-formula (f) (if (consp f) (let (temp) (cond ((and (eq (car f) 'var) (memq (setq temp (or (cdr (assq (nth 1 f) '((nil . arg-nil) (t . arg-t)))) (nth 1 f))) alist)) temp) ((or (math-constp f) (eq (car f) 'var)) (list 'quote f)) ((and (eq (car f) 'calcFunc-eval) (= (length f) 2)) (list 'let '((calc-simplify-mode nil)) (list 'math-normalize (calc-fix-user-formula (nth 1 f))))) ((and (eq (car f) 'calcFunc-evalsimp) (= (length f) 2)) (list 'math-simplify (calc-fix-user-formula (nth 1 f)))) ((and (eq (car f) 'calcFunc-evalextsimp) (= (length f) 2)) (list 'math-simplify-extended (calc-fix-user-formula (nth 1 f)))) (t (cons 'list (cons (list 'quote (car f)) (mapcar 'calc-fix-user-formula (cdr f))))))) f) ) (defun calc-user-define-composition () (interactive) (calc-wrapper (if (eq calc-language 'unform) (error "Can't define formats for unformatted mode")) (let* ((comp (calc-top 1)) (func (intern (completing-read "Define format for which function: " obarray 'fboundp nil "calcFunc-"))) (comps (get func 'math-compose-forms)) entry entry2 (arglist nil) (alist nil)) (if (math-zerop comp) (if (setq entry (assq calc-language comps)) (put func 'math-compose-forms (delq entry comps))) (calc-default-formula-arglist comp) (setq arglist (sort arglist 'string-lessp)) (while (progn (setq alist (read-from-minibuffer "Composition argument list: " (if arglist (prin1-to-string arglist) "()") minibuffer-local-map t)) (and (not (calc-subsetp alist arglist)) (y-or-n-p "Okay for arguments that don't appear in formula to be invisible? ")))) (or (setq entry (assq calc-language comps)) (put func 'math-compose-forms (cons (setq entry (list calc-language)) comps))) (or (setq entry2 (assq (length alist) (cdr entry))) (setcdr entry (cons (setq entry2 (list (length alist))) (cdr entry)))) (setcdr entry2 (list 'lambda alist (calc-fix-user-formula comp)))) (calc-pop-stack 1) (calc-do-refresh))) ) (defun calc-user-define-kbd-macro (arg) (interactive "P") (or last-kbd-macro (error "No keyboard macro defined")) (message "Define last kbd macro on user key: z-") (let ((key (read-char))) (if (= (calc-user-function-classify key) 0) (error "Can't redefine \"?\" key")) (let ((cmd (intern (completing-read "Full name for new command: " obarray 'commandp nil (concat "calc-User-" (if (or (and (>= key ?a) (<= key ?z)) (and (>= key ?A) (<= key ?Z)) (and (>= key ?0) (<= key ?9))) (char-to-string key) (format "%03d" key))))))) (and (fboundp cmd) (not (let ((f (symbol-function cmd))) (or (stringp f) (and (consp f) (eq (car-safe (nth 3 f)) 'calc-execute-kbd-macro))))) (error "Function %s is already defined and not a keyboard macro" cmd)) (put cmd 'calc-user-defn t) (fset cmd (if (< (prefix-numeric-value arg) 0) last-kbd-macro (list 'lambda '(arg) '(interactive "P") (list 'calc-execute-kbd-macro (vector (key-description last-kbd-macro) last-kbd-macro) 'arg (format "z%c" key))))) (let* ((kmap (calc-user-key-map)) (old (assq key kmap))) (if old (setcdr old cmd) (setcdr kmap (cons (cons key cmd) (cdr kmap))))))) ) (defun calc-edit-user-syntax () (interactive) (calc-wrapper (let ((lang calc-language)) (calc-edit-mode (list 'calc-finish-user-syntax-edit (list 'quote lang)) t (format "Editing %s-Mode Syntax Table" (cond ((null lang) "Normal") ((eq lang 'tex) "TeX") (t (capitalize (symbol-name lang)))))) (calc-write-parse-table (cdr (assq lang calc-user-parse-tables)) lang))) (calc-show-edit-buffer) ) (defun calc-finish-user-syntax-edit (lang) (let ((tab (calc-read-parse-table calc-original-buffer lang)) (entry (assq lang calc-user-parse-tables))) (if tab (setcdr (or entry (car (setq calc-user-parse-tables (cons (list lang) calc-user-parse-tables)))) tab) (if entry (setq calc-user-parse-tables (delq entry calc-user-parse-tables))))) (switch-to-buffer calc-original-buffer) ) (defun calc-write-parse-table (tab calc-lang) (let ((p tab)) (while p (calc-write-parse-table-part (car (car p))) (insert ":= " (let ((math-format-hash-args t)) (math-format-flat-expr (cdr (car p)) 0)) "\n") (setq p (cdr p)))) ) (defun calc-write-parse-table-part (p) (while p (cond ((stringp (car p)) (let ((s (car p))) (if (and (string-match "\\`\\\\dots\\>" s) (not (eq calc-lang 'tex))) (setq s (concat ".." (substring s 5)))) (if (or (and (string-match "[a-zA-Z0-9\"{}]\\|\\`:=\\'\\|\\`#\\|\\`%%" s) (string-match "[^a-zA-Z0-9\\]" s)) (and (assoc s '((")") ("]") (">"))) (not (cdr p)))) (insert (prin1-to-string s) " ") (insert s " ")))) ((integerp (car p)) (insert "#") (or (= (car p) 0) (insert "/" (int-to-string (car p)))) (insert " ")) ((and (eq (car (car p)) '\?) (equal (car (nth 2 (car p))) "$$")) (insert (car (nth 1 (car p))) " ")) (t (insert "{ ") (calc-write-parse-table-part (nth 1 (car p))) (insert "}" (symbol-name (car (car p)))) (if (nth 2 (car p)) (calc-write-parse-table-part (list (car (nth 2 (car p))))) (insert " ")))) (setq p (cdr p))) ) (defun calc-read-parse-table (calc-buf calc-lang) (let ((tab nil)) (while (progn (skip-chars-forward "\n\t ") (not (eobp))) (if (looking-at "%%") (end-of-line) (let ((pt (point)) (p (calc-read-parse-table-part ":=[\n\t ]+" ":="))) (or (stringp (car p)) (and (integerp (car p)) (stringp (nth 1 p))) (progn (goto-char pt) (error "Malformed syntax rule"))) (let ((pos (point))) (end-of-line) (let* ((str (buffer-substring pos (point))) (exp (save-excursion (set-buffer calc-buf) (let ((calc-user-parse-tables nil) (calc-language nil) (math-expr-opers math-standard-opers) (calc-hashes-used 0)) (math-read-expr (if (string-match ",[ \t]*\\'" str) (substring str 0 (match-beginning 0)) str)))))) (if (eq (car-safe exp) 'error) (progn (goto-char (+ pos (nth 1 exp))) (error (nth 2 exp)))) (setq tab (nconc tab (list (cons p exp))))))))) tab) ) (defun calc-fix-token-name (name &optional unquoted) (cond ((string-match "\\`\\.\\." name) (concat "\\dots" (substring name 2))) ((and (equal name "{") (memq calc-lang '(tex eqn))) "(") ((and (equal name "}") (memq calc-lang '(tex eqn))) ")") ((and (equal name "&") (eq calc-lang 'tex)) ",") ((equal name "#") (search-backward "#") (error "Token '#' is reserved")) ((and unquoted (string-match "#" name)) (error "Tokens containing '#' must be quoted")) ((not (string-match "[^ ]" name)) (search-backward "\"" nil t) (error "Blank tokens are not allowed")) (t name)) ) (defun calc-read-parse-table-part (term eterm) (let ((part nil) (quoted nil)) (while (progn (skip-chars-forward "\n\t ") (if (eobp) (error "Expected '%s'" eterm)) (not (looking-at term))) (cond ((looking-at "%%") (end-of-line)) ((looking-at "{[\n\t ]") (forward-char 2) (let ((p (calc-read-parse-table-part "}" "}"))) (or (looking-at "[+*?]") (error "Expected '+', '*', or '?'")) (let ((sym (intern (buffer-substring (point) (1+ (point)))))) (forward-char 1) (looking-at "[^\n\t ]*") (let ((sep (buffer-substring (point) (match-end 0)))) (goto-char (match-end 0)) (and (eq sym '\?) (> (length sep) 0) (not (equal sep "$")) (not (equal sep ".")) (error "Separator not allowed with { ... }?")) (if (string-match "\\`\"" sep) (setq sep (read-from-string sep))) (setq sep (calc-fix-token-name sep)) (setq part (nconc part (list (list sym p (and (> (length sep) 0) (cons sep p)))))))))) ((looking-at "}") (error "Too many }'s")) ((looking-at "\"") (setq quoted (calc-fix-token-name (read (current-buffer))) part (nconc part (list quoted)))) ((looking-at "#\\(\\(/[0-9]+\\)?\\)[\n\t ]") (setq part (nconc part (list (if (= (match-beginning 1) (match-end 1)) 0 (string-to-int (buffer-substring (1+ (match-beginning 1)) (match-end 1))))))) (goto-char (match-end 0))) ((looking-at ":=[\n\t ]") (error "Misplaced ':='")) (t (looking-at "[^\n\t ]*") (let ((end (match-end 0))) (setq part (nconc part (list (calc-fix-token-name (buffer-substring (point) end) t)))) (goto-char end))))) (goto-char (match-end 0)) (let ((len (length part))) (while (and (> len 1) (let ((last (nthcdr (setq len (1- len)) part))) (and (assoc (car last) '((")") ("]") (">"))) (not (eq (car last) quoted)) (setcar last (list '\? (list (car last)) '("$$")))))))) part) ) (defun calc-user-define-invocation () (interactive) (or last-kbd-macro (error "No keyboard macro defined")) (setq calc-invocation-macro last-kbd-macro) (message "Use `M-# Z' to invoke this macro") ) (defun calc-user-define-edit (prefix) (interactive "P") ; but no calc-wrapper! (message "Edit definition of command: z-") (let* ((key (read-char)) (def (or (assq key (calc-user-key-map)) (assq (upcase key) (calc-user-key-map)) (assq (downcase key) (calc-user-key-map)) (error "No command defined for that key"))) (cmd (cdr def))) (if (symbolp cmd) (setq cmd (symbol-function cmd))) (cond ((or (stringp cmd) (and (consp cmd) (eq (car-safe (nth 3 cmd)) 'calc-execute-kbd-macro))) (if (and (>= (prefix-numeric-value prefix) 0) (fboundp 'edit-kbd-macro) (symbolp (cdr def)) (eq major-mode 'calc-mode)) (progn (if (and (< (window-width) (screen-width)) calc-display-trail) (let ((win (get-buffer-window (calc-trail-buffer)))) (if win (delete-window win)))) (edit-kbd-macro (cdr def) prefix nil (function (lambda (x) (and calc-display-trail (calc-wrapper (calc-trail-display 1 t))))) (function (lambda (cmd) (if (stringp (symbol-function cmd)) (symbol-function cmd) (let ((mac (nth 1 (nth 3 (symbol-function cmd))))) (if (vectorp mac) (aref mac 1) mac))))) (function (lambda (new cmd) (if (stringp (symbol-function cmd)) (fset cmd new) (let ((mac (cdr (nth 3 (symbol-function cmd))))) (if (vectorp (car mac)) (progn (aset (car mac) 0 (key-description new)) (aset (car mac) 1 new)) (setcar mac new)))))))) (let ((keys (progn (and (fboundp 'edit-kbd-macro) (edit-kbd-macro nil)) (fboundp 'MacEdit-parse-keys)))) (calc-wrapper (calc-edit-mode (list 'calc-finish-macro-edit (list 'quote def) keys) t) (if keys (let (top (fill-column 70) (fill-prefix nil)) (insert "Notations: RET, SPC, TAB, DEL, LFD, NUL" ", C-xxx, M-xxx.\n\n") (setq top (point)) (insert (if (stringp cmd) (key-description cmd) (if (vectorp (nth 1 (nth 3 cmd))) (aref (nth 1 (nth 3 cmd)) 0) (key-description (nth 1 (nth 3 cmd))))) "\n") (if (>= (prog2 (forward-char -1) (current-column) (forward-char 1)) (screen-width)) (fill-region top (point)))) (insert "Press C-q to quote control characters like RET" " and TAB.\n" (if (stringp cmd) cmd (if (vectorp (nth 1 (nth 3 cmd))) (aref (nth 1 (nth 3 cmd)) 1) (nth 1 (nth 3 cmd))))))) (calc-show-edit-buffer) (forward-line (if keys 2 1))))) (t (let* ((func (calc-stack-command-p cmd)) (defn (and func (symbolp func) (get func 'calc-user-defn)))) (if (and defn (calc-valid-formula-func func)) (progn (calc-wrapper (calc-edit-mode (list 'calc-finish-formula-edit (list 'quote func))) (insert (math-showing-full-precision (math-format-nice-expr defn (screen-width))) "\n")) (calc-show-edit-buffer)) (error "That command's definition cannot be edited")))))) ) (defun calc-finish-macro-edit (def keys) (forward-line 1) (if (and keys (looking-at "\n")) (forward-line 1)) (let* ((true-str (buffer-substring (point) (point-max))) (str true-str)) (if keys (setq str (MacEdit-parse-keys str))) (if (symbolp (cdr def)) (if (stringp (symbol-function (cdr def))) (fset (cdr def) str) (let ((mac (cdr (nth 3 (symbol-function (cdr def)))))) (if (vectorp (car mac)) (progn (aset (car mac) 0 (if keys true-str (key-description str))) (aset (car mac) 1 str)) (setcar mac str)))) (setcdr def str))) ) ;;; The following are hooks into the MacEdit package from macedit.el. (put 'calc-execute-extended-command 'MacEdit-print (function (lambda () (setq macro-str (concat "\excalc-" macro-str)))) ) (put 'calcDigit-start 'MacEdit-print (function (lambda () (if calc-algebraic-mode (calc-macro-edit-algebraic) (MacEdit-unread-chars key-last) (let ((str "") (min-bsp 0) ch last) (while (and (setq ch (MacEdit-read-char)) (or (and (>= ch ?0) (<= ch ?9)) (memq ch '(?\. ?e ?\_ ?n ?\: ?\# ?M ?o ?h ?\@ ?\")) (and (memq ch '(?\' ?m ?s)) (string-match "[@oh]" str)) (and (or (and (>= ch ?a) (<= ch ?z)) (and (>= ch ?A) (<= ch ?Z))) (string-match "^[-+]?\\(1[1-9]\\|[2-9][0-9]\\)#" str)) (and (memq ch '(?\177 ?\C-h)) (> (length str) 0)) (and (memq ch '(?+ ?-)) (> (length str) 0) (eq (aref str (1- (length str))) ?e)))) (if (or (and (>= ch ?0) (<= ch ?9)) (and (or (not (memq ch '(?\177 ?\C-h))) (<= (length str) min-bsp)) (setq min-bsp (1+ (length str))))) (setq str (concat str (char-to-string ch))) (setq str (substring str 0 -1)))) (if (memq ch '(32 10 13)) (setq str (concat str (char-to-string ch))) (MacEdit-unread-chars ch)) (insert "type \"") (MacEdit-insert-string str) (insert "\"\n"))))) ) (defun calc-macro-edit-algebraic () (MacEdit-unread-chars key-last) (let ((str "") (min-bsp 0)) (while (progn (MacEdit-lookup-key calc-alg-ent-map) (or (and (memq key-symbol '(self-insert-command calcAlg-previous)) (< (length str) 60)) (memq key-symbol '(backward-delete-char delete-backward-char backward-delete-char-untabify)) (eq key-last 9))) (setq macro-str (substring macro-str (length key-str))) (if (or (eq key-symbol 'self-insert-command) (and (or (not (memq key-symbol '(backward-delete-char delete-backward-char backward-delete-char-untabify))) (<= (length str) min-bsp)) (setq min-bsp (+ (length str) (length key-str))))) (setq str (concat str key-str)) (setq str (substring str 0 -1)))) (if (memq key-last '(10 13)) (setq str (concat str key-str) macro-str (substring macro-str (length key-str)))) (if (> (length str) 0) (progn (insert "type \"") (MacEdit-insert-string str) (insert "\"\n")))) ) (put 'calc-algebraic-entry 'MacEdit-print 'calc-macro-edit-algebraic) (put 'calc-auto-algebraic-entry 'MacEdit-print 'calc-macro-edit-algebraic) (defun calc-macro-edit-variable (&optional no-cmd) (let ((str "") ch) (or no-cmd (insert (symbol-name key-symbol) "\n")) (if (memq (MacEdit-peek-char) '(?\+ ?\- ?\* ?\/ ?\^ ?\|)) (setq str (char-to-string (MacEdit-read-char)))) (if (and (setq ch (MacEdit-peek-char)) (>= ch ?0) (<= ch ?9)) (insert "type \"" str (char-to-string (MacEdit-read-char)) "\"\n") (if (> (length str) 0) (insert "type \"" str "\"\n")) (MacEdit-read-argument))) ) (put 'calc-store 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-store-into 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-store-neg 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-store-plus 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-store-minus 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-store-times 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-store-div 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-store-power 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-store-concat 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-store-inv 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-store-decr 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-store-incr 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-store-exchange 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-unstore 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-recall 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-let 'MacEdit-print 'calc-macro-edit-variable) (put 'calc-permanent-variable 'MacEdit-print 'calc-macro-edit-variable) (defun calc-macro-edit-variable-2 () (calc-macro-edit-variable) (calc-macro-edit-variable t) ) (put 'calc-copy-variable 'MacEdit-print 'calc-macro-edit-variable-2) (put 'calc-declare-variable 'MacEdit-print 'calc-macro-edit-variable-2) (defun calc-macro-edit-quick-digit () (insert "type \"" key-str "\" # " (symbol-name key-symbol) "\n") ) (put 'calc-store-quick 'MacEdit-print 'calc-macro-edit-quick-digit) (put 'calc-store-into-quick 'MacEdit-print 'calc-macro-edit-quick-digit) (put 'calc-recall-quick 'MacEdit-print 'calc-macro-edit-quick-digit) (put 'calc-select-part 'MacEdit-print 'calc-macro-edit-quick-digit) (put 'calc-clean-num 'MacEdit-print 'calc-macro-edit-quick-digit) (defun calc-finish-formula-edit (func) (let ((buf (current-buffer)) (str (buffer-substring (point) (point-max))) (start (point)) (body (calc-valid-formula-func func))) (set-buffer calc-original-buffer) (let ((val (math-read-expr str))) (if (eq (car-safe val) 'error) (progn (set-buffer buf) (goto-char (+ start (nth 1 val))) (error (nth 2 val)))) (setcar (cdr body) (let ((alist (nth 1 (symbol-function func)))) (calc-fix-user-formula val))) (put func 'calc-user-defn val))) ) (defun calc-valid-formula-func (func) (let ((def (symbol-function func))) (and (consp def) (eq (car def) 'lambda) (progn (setq def (cdr (cdr def))) (while (and def (not (eq (car (car def)) 'math-normalize))) (setq def (cdr def))) (car def)))) ) (defun calc-get-user-defn () (interactive) (calc-wrapper (message "Get definition of command: z-") (let* ((key (read-char)) (def (or (assq key (calc-user-key-map)) (assq (upcase key) (calc-user-key-map)) (assq (downcase key) (calc-user-key-map)) (error "No command defined for that key"))) (cmd (cdr def))) (if (symbolp cmd) (setq cmd (symbol-function cmd))) (cond ((stringp cmd) (message "Keyboard macro: %s" cmd)) (t (let* ((func (calc-stack-command-p cmd)) (defn (and func (symbolp func) (get func 'calc-user-defn)))) (if defn (progn (and (calc-valid-formula-func func) (setq defn (append '(calcFunc-lambda) (mapcar 'math-build-var-name (nth 1 (symbol-function func))) (list defn)))) (calc-enter-result 0 "gdef" defn)) (error "That command is not defined by a formula"))))))) ) (defun calc-user-define-permanent () (interactive) (calc-wrapper (message "Record in %s the command: z-" calc-settings-file) (let* ((key (read-char)) (def (or (assq key (calc-user-key-map)) (assq (upcase key) (calc-user-key-map)) (assq (downcase key) (calc-user-key-map)) (and (eq key ?\') (cons nil (intern (completing-read (format "Record in %s the function: " calc-settings-file) obarray 'fboundp nil "calcFunc-")))) (error "No command defined for that key")))) (set-buffer (find-file-noselect (substitute-in-file-name calc-settings-file))) (goto-char (point-max)) (let* ((cmd (cdr def)) (fcmd (and cmd (symbolp cmd) (symbol-function cmd))) (func nil) (pt (point)) (fill-column 70) (fill-prefix nil) str q-ok) (insert "\n;;; Definition stored by Calc on " (current-time-string) "\n(put 'calc-define '" (if (symbolp cmd) (symbol-name cmd) (format "key%d" key)) " '(progn\n") (if (and fcmd (eq (car-safe fcmd) 'lambda) (get cmd 'calc-user-defn)) (let ((pt (point))) (and (eq (car-safe (nth 3 fcmd)) 'calc-execute-kbd-macro) (vectorp (nth 1 (nth 3 fcmd))) (progn (and (fboundp 'edit-kbd-macro) (edit-kbd-macro nil)) (fboundp 'MacEdit-parse-keys)) (setq q-ok t) (aset (nth 1 (nth 3 fcmd)) 1 nil)) (insert (setq str (prin1-to-string (cons 'defun (cons cmd (cdr fcmd))))) "\n") (or (and (string-match "\"" str) (not q-ok)) (fill-region pt (point))) (indent-rigidly pt (point) 2) (delete-region pt (1+ pt)) (insert " (put '" (symbol-name cmd) " 'calc-user-defn '" (prin1-to-string (get cmd 'calc-user-defn)) ")\n") (setq func (calc-stack-command-p cmd)) (let ((ffunc (and func (symbolp func) (symbol-function func))) (pt (point))) (and ffunc (eq (car-safe ffunc) 'lambda) (get func 'calc-user-defn) (progn (insert (setq str (prin1-to-string (cons 'defun (cons func (cdr ffunc))))) "\n") (or (and (string-match "\"" str) (not q-ok)) (fill-region pt (point))) (indent-rigidly pt (point) 2) (delete-region pt (1+ pt)) (setq pt (point)) (insert "(put '" (symbol-name func) " 'calc-user-defn '" (prin1-to-string (get func 'calc-user-defn)) ")\n") (fill-region pt (point)) (indent-rigidly pt (point) 2) (delete-region pt (1+ pt)))))) (and (stringp fcmd) (insert " (fset '" (prin1-to-string cmd) " " (prin1-to-string fcmd) ")\n"))) (or func (setq func (and cmd (symbolp cmd) (fboundp cmd) cmd))) (if (get func 'math-compose-forms) (let ((pt (point))) (insert "(put '" (symbol-name cmd) " 'math-compose-forms '" (prin1-to-string (get func 'math-compose-forms)) ")\n") (fill-region pt (point)) (indent-rigidly pt (point) 2) (delete-region pt (1+ pt)))) (if (car def) (insert " (define-key calc-mode-map " (prin1-to-string (concat "z" (char-to-string key))) " '" (prin1-to-string cmd) ")\n"))) (insert "))\n") (save-buffer))) ) (defun calc-stack-command-p (cmd) (if (and cmd (symbolp cmd)) (and (fboundp cmd) (calc-stack-command-p (symbol-function cmd))) (and (consp cmd) (eq (car cmd) 'lambda) (setq cmd (or (assq 'calc-wrapper cmd) (assq 'calc-slow-wrapper cmd))) (setq cmd (assq 'calc-enter-result cmd)) (memq (car (nth 3 cmd)) '(cons list)) (eq (car (nth 1 (nth 3 cmd))) 'quote) (nth 1 (nth 1 (nth 3 cmd))))) ) (defun calc-call-last-kbd-macro (arg) (interactive "P") (and defining-kbd-macro (error "Can't execute anonymous macro while defining one")) (or last-kbd-macro (error "No kbd macro has been defined")) (calc-execute-kbd-macro last-kbd-macro arg) ) (defun calc-execute-kbd-macro (mac arg &rest prefix) (if (and (vectorp mac) (> (length mac) 0) (stringp (aref mac 0))) (setq mac (or (aref mac 1) (aset mac 1 (progn (and (fboundp 'edit-kbd-macro) (edit-kbd-macro nil)) (MacEdit-parse-keys (aref mac 0))))))) (if (< (prefix-numeric-value arg) 0) (execute-kbd-macro mac (- (prefix-numeric-value arg))) (if calc-executing-macro (execute-kbd-macro mac arg) (calc-slow-wrapper (let ((old-stack-whole (copy-sequence calc-stack)) (old-stack-top calc-stack-top) (old-buffer-size (buffer-size)) (old-refresh-count calc-refresh-count)) (unwind-protect (let ((calc-executing-macro mac)) (execute-kbd-macro mac arg)) (calc-select-buffer) (let ((new-stack (reverse calc-stack)) (old-stack (reverse old-stack-whole))) (while (and new-stack old-stack (equal (car new-stack) (car old-stack))) (setq new-stack (cdr new-stack) old-stack (cdr old-stack))) (or (equal prefix '(nil)) (calc-record-list (if (> (length new-stack) 1) (mapcar 'car new-stack) '("")) (or (car prefix) "kmac"))) (calc-record-undo (list 'set 'saved-stack-top old-stack-top)) (and old-stack (calc-record-undo (list 'pop 1 (mapcar 'car old-stack)))) (let ((calc-stack old-stack-whole) (calc-stack-top 0)) (calc-cursor-stack-index (length old-stack))) (if (and (= old-buffer-size (buffer-size)) (= old-refresh-count calc-refresh-count)) (let ((buffer-read-only nil)) (delete-region (point) (point-max)) (while new-stack (calc-record-undo (list 'push 1)) (insert (math-format-stack-value (car new-stack)) "\n") (setq new-stack (cdr new-stack))) (calc-renumber-stack)) (while new-stack (calc-record-undo (list 'push 1)) (setq new-stack (cdr new-stack))) (calc-refresh)) (calc-record-undo (list 'set 'saved-stack-top 0)))))))) ) (defun calc-push-list-in-macro (vals m sels) (let ((entry (list (car vals) 1 (car sels))) (mm (+ (or m 1) calc-stack-top))) (if (> mm 1) (setcdr (nthcdr (- mm 2) calc-stack) (cons entry (nthcdr (1- mm) calc-stack))) (setq calc-stack (cons entry calc-stack)))) ) (defun calc-pop-stack-in-macro (n mm) (if (> mm 1) (setcdr (nthcdr (- mm 2) calc-stack) (nthcdr (+ n mm -1) calc-stack)) (setq calc-stack (nthcdr n calc-stack))) ) (defun calc-kbd-if () (interactive) (calc-wrapper (let ((cond (calc-top-n 1))) (calc-pop-stack 1) (if (math-is-true cond) (if defining-kbd-macro (message "If true...")) (if defining-kbd-macro (message "Condition is false; skipping to Z: or Z] ...")) (calc-kbd-skip-to-else-if t)))) ) (defun calc-kbd-else-if () (interactive) (calc-kbd-if) ) (defun calc-kbd-skip-to-else-if (else-okay) (let ((count 0) ch) (while (>= count 0) (setq ch (read-char)) (if (= ch -1) (error "Unterminated Z[ in keyboard macro")) (if (= ch ?Z) (progn (setq ch (read-char)) (cond ((= ch ?\[) (setq count (1+ count))) ((= ch ?\]) (setq count (1- count))) ((= ch ?\:) (and (= count 0) else-okay (setq count -1))) ((eq ch 7) (keyboard-quit)))))) (and defining-kbd-macro (if (= ch ?\:) (message "Else...") (message "End-if...")))) ) (defun calc-kbd-end-if () (interactive) (if defining-kbd-macro (message "End-if...")) ) (defun calc-kbd-else () (interactive) (if defining-kbd-macro (message "Else; skipping to Z] ...")) (calc-kbd-skip-to-else-if nil) ) (defun calc-kbd-repeat () (interactive) (let (count) (calc-wrapper (setq count (math-trunc (calc-top-n 1))) (or (Math-integerp count) (error "Count must be an integer")) (if (Math-integer-negp count) (setq count 0)) (or (integerp count) (setq count 1000000)) (calc-pop-stack 1)) (calc-kbd-loop count)) ) (defun calc-kbd-for (dir) (interactive "P") (let (init final) (calc-wrapper (setq init (calc-top-n 2) final (calc-top-n 1)) (or (and (math-anglep init) (math-anglep final)) (error "Initial and final values must be real numbers")) (calc-pop-stack 2)) (calc-kbd-loop nil init final (and dir (prefix-numeric-value dir)))) ) (defun calc-kbd-loop (rpt-count &optional initial final dir) (interactive "P") (setq rpt-count (if rpt-count (prefix-numeric-value rpt-count) 1000000)) (let* ((count 0) (parts nil) (body "") (open last-command-char) (counter initial) ch) (or executing-macro (message "Reading loop body...")) (while (>= count 0) (setq ch (read-char)) (if (= ch -1) (error "Unterminated Z%c in keyboard macro" open)) (if (= ch ?Z) (progn (setq ch (read-char) body (concat body "Z" (char-to-string ch))) (cond ((memq ch '(?\< ?\( ?\{)) (setq count (1+ count))) ((memq ch '(?\> ?\) ?\})) (setq count (1- count))) ((and (= ch ?/) (= count 0)) (setq parts (nconc parts (list (concat (substring body 0 -2) "Z]"))) body "")) ((eq ch 7) (keyboard-quit)))) (setq body (concat body (char-to-string ch))))) (if (/= ch (cdr (assq open '( (?\< . ?\>) (?\( . ?\)) (?\{ . ?\}) )))) (error "Mismatched Z%c and Z%c in keyboard macro" open ch)) (or executing-macro (message "Looping...")) (setq body (concat (substring body 0 -2) "Z]")) (and (not executing-macro) (= rpt-count 1000000) (null parts) (null counter) (progn (message "Warning: Infinite loop! Not executing.") (setq rpt-count 0))) (or (not initial) dir (setq dir (math-compare final initial))) (calc-wrapper (while (> rpt-count 0) (let ((part parts)) (if counter (if (cond ((eq dir 0) (Math-equal final counter)) ((eq dir 1) (Math-lessp final counter)) ((eq dir -1) (Math-lessp counter final))) (setq rpt-count 0) (calc-push counter))) (while (and part (> rpt-count 0)) (execute-kbd-macro (car part)) (if (math-is-true (calc-top-n 1)) (setq rpt-count 0) (setq part (cdr part))) (calc-pop-stack 1)) (if (> rpt-count 0) (progn (execute-kbd-macro body) (if counter (let ((step (calc-top-n 1))) (calc-pop-stack 1) (setq counter (calcFunc-add counter step))) (setq rpt-count (1- rpt-count)))))))) (or executing-macro (message "Looping...done"))) ) (defun calc-kbd-end-repeat () (interactive) (error "Unbalanced Z> in keyboard macro") ) (defun calc-kbd-end-for () (interactive) (error "Unbalanced Z) in keyboard macro") ) (defun calc-kbd-end-loop () (interactive) (error "Unbalanced Z} in keyboard macro") ) (defun calc-kbd-break () (interactive) (calc-wrapper (let ((cond (calc-top-n 1))) (calc-pop-stack 1) (if (math-is-true cond) (error "Keyboard macro aborted.")))) ) (defun calc-kbd-push (arg) (interactive "P") (calc-wrapper (let* ((defs (and arg (> (prefix-numeric-value arg) 0))) (var-q0 (and (boundp 'var-q0) var-q0)) (var-q1 (and (boundp 'var-q1) var-q1)) (var-q2 (and (boundp 'var-q2) var-q2)) (var-q3 (and (boundp 'var-q3) var-q3)) (var-q4 (and (boundp 'var-q4) var-q4)) (var-q5 (and (boundp 'var-q5) var-q5)) (var-q6 (and (boundp 'var-q6) var-q6)) (var-q7 (and (boundp 'var-q7) var-q7)) (var-q8 (and (boundp 'var-q8) var-q8)) (var-q9 (and (boundp 'var-q9) var-q9)) (calc-internal-prec (if defs 12 calc-internal-prec)) (calc-word-size (if defs 32 calc-word-size)) (calc-angle-mode (if defs 'deg calc-angle-mode)) (calc-simplify-mode (if defs nil calc-simplify-mode)) (calc-algebraic-mode (if arg nil calc-algebraic-mode)) (calc-incomplete-algebraic-mode (if arg nil calc-incomplete-algebraic-mode)) (calc-symbolic-mode (if defs nil calc-symbolic-mode)) (calc-matrix-mode (if defs nil calc-matrix-mode)) (calc-prefer-frac (if defs nil calc-prefer-frac)) (calc-complex-mode (if defs nil calc-complex-mode)) (calc-infinite-mode (if defs nil calc-infinite-mode)) (count 0) (body "") ch) (if (or executing-macro defining-kbd-macro) (progn (if defining-kbd-macro (message "Reading body...")) (while (>= count 0) (setq ch (read-char)) (if (= ch -1) (error "Unterminated Z` in keyboard macro")) (if (= ch ?Z) (progn (setq ch (read-char) body (concat body "Z" (char-to-string ch))) (cond ((eq ch ?\`) (setq count (1+ count))) ((eq ch ?\') (setq count (1- count))) ((eq ch 7) (keyboard-quit)))) (setq body (concat body (char-to-string ch))))) (if defining-kbd-macro (message "Reading body...done")) (let ((calc-kbd-push-level 0)) (execute-kbd-macro (substring body 0 -2)))) (let ((calc-kbd-push-level (1+ calc-kbd-push-level))) (message "Saving modes; type Z' to restore") (recursive-edit))))) ) (setq calc-kbd-push-level 0) (defun calc-kbd-pop () (interactive) (if (> calc-kbd-push-level 0) (progn (message "Mode settings restored") (exit-recursive-edit)) (error "Unbalanced Z' in keyboard macro")) ) (defun calc-kbd-report (msg) (interactive "sMessage: ") (calc-wrapper (let ((executing-macro nil) (defining-kbd-macro nil)) (math-working msg (calc-top-n 1)))) ) (defun calc-kbd-query (msg) (interactive "sPrompt: ") (calc-wrapper (let ((executing-macro nil) (defining-kbd-macro nil)) (calc-alg-entry nil (and (not (equal msg "")) msg)))) ) ;;;; Logical operations. (defun calcFunc-eq (a b &rest more) (if more (let* ((args (cons a (cons b (copy-sequence more)))) (res 1) (p args) p2) (while (and (cdr p) (not (eq res 0))) (setq p2 p) (while (and (setq p2 (cdr p2)) (not (eq res 0))) (setq res (math-two-eq (car p) (car p2))) (if (eq res 1) (setcdr p (delq (car p2) (cdr p))))) (setq p (cdr p))) (if (eq res 0) 0 (if (cdr args) (cons 'calcFunc-eq args) 1))) (or (math-two-eq a b) (if (and (or (math-looks-negp a) (math-zerop a)) (or (math-looks-negp b) (math-zerop b))) (list 'calcFunc-eq (math-neg a) (math-neg b)) (list 'calcFunc-eq a b)))) ) (defun calcFunc-neq (a b &rest more) (if more (let* ((args (cons a (cons b more))) (res 0) (all t) (p args) p2) (while (and (cdr p) (not (eq res 1))) (setq p2 p) (while (and (setq p2 (cdr p2)) (not (eq res 1))) (setq res (math-two-eq (car p) (car p2))) (or res (setq all nil))) (setq p (cdr p))) (if (eq res 1) 0 (if all 1 (cons 'calcFunc-neq args)))) (or (cdr (assq (math-two-eq a b) '((0 . 1) (1 . 0)))) (if (and (or (math-looks-negp a) (math-zerop a)) (or (math-looks-negp b) (math-zerop b))) (list 'calcFunc-neq (math-neg a) (math-neg b)) (list 'calcFunc-neq a b)))) ) (defun math-two-eq (a b) (if (eq (car-safe a) 'vec) (if (eq (car-safe b) 'vec) (if (= (length a) (length b)) (let ((res 1)) (while (and (setq a (cdr a) b (cdr b)) (not (eq res 0))) (if res (setq res (math-two-eq (car a) (car b))) (if (eq (math-two-eq (car a) (car b)) 0) (setq res 0)))) res) 0) (if (Math-objectp b) 0 nil)) (if (eq (car-safe b) 'vec) (if (Math-objectp a) 0 nil) (let ((res (math-compare a b))) (if (= res 0) 1 (if (and (= res 2) (not (and (Math-scalarp a) (Math-scalarp b)))) nil 0))))) ) (defun calcFunc-lt (a b) (let ((res (math-compare a b))) (if (= res -1) 1 (if (= res 2) (if (and (or (math-looks-negp a) (math-zerop a)) (or (math-looks-negp b) (math-zerop b))) (list 'calcFunc-gt (math-neg a) (math-neg b)) (list 'calcFunc-lt a b)) 0))) ) (defun calcFunc-gt (a b) (let ((res (math-compare a b))) (if (= res 1) 1 (if (= res 2) (if (and (or (math-looks-negp a) (math-zerop a)) (or (math-looks-negp b) (math-zerop b))) (list 'calcFunc-lt (math-neg a) (math-neg b)) (list 'calcFunc-gt a b)) 0))) ) (defun calcFunc-leq (a b) (let ((res (math-compare a b))) (if (= res 1) 0 (if (= res 2) (if (and (or (math-looks-negp a) (math-zerop a)) (or (math-looks-negp b) (math-zerop b))) (list 'calcFunc-geq (math-neg a) (math-neg b)) (list 'calcFunc-leq a b)) 1))) ) (defun calcFunc-geq (a b) (let ((res (math-compare a b))) (if (= res -1) 0 (if (= res 2) (if (and (or (math-looks-negp a) (math-zerop a)) (or (math-looks-negp b) (math-zerop b))) (list 'calcFunc-leq (math-neg a) (math-neg b)) (list 'calcFunc-geq a b)) 1))) ) (defun calcFunc-rmeq (a) (if (math-vectorp a) (math-map-vec 'calcFunc-rmeq a) (if (assq (car-safe a) calc-tweak-eqn-table) (if (and (eq (car-safe (nth 2 a)) 'var) (math-objectp (nth 1 a))) (nth 1 a) (nth 2 a)) (if (eq (car-safe a) 'calcFunc-assign) (nth 2 a) (if (eq (car-safe a) 'calcFunc-evalto) (nth 1 a) (list 'calcFunc-rmeq a))))) ) (defun calcFunc-land (a b) (cond ((Math-zerop a) a) ((Math-zerop b) b) ((math-is-true a) b) ((math-is-true b) a) (t (list 'calcFunc-land a b))) ) (defun calcFunc-lor (a b) (cond ((Math-zerop a) b) ((Math-zerop b) a) ((math-is-true a) a) ((math-is-true b) b) (t (list 'calcFunc-lor a b))) ) (defun calcFunc-lnot (a) (if (Math-zerop a) 1 (if (math-is-true a) 0 (let ((op (and (= (length a) 3) (assq (car a) calc-tweak-eqn-table)))) (if op (cons (nth 2 op) (cdr a)) (list 'calcFunc-lnot a))))) ) (defun calcFunc-if (c e1 e2) (if (Math-zerop c) e2 (if (and (math-is-true c) (not (Math-vectorp c))) e1 (or (and (Math-vectorp c) (math-constp c) (let ((ee1 (if (Math-vectorp e1) (if (= (length c) (length e1)) (cdr e1) (calc-record-why "*Dimension error" e1)) (list e1))) (ee2 (if (Math-vectorp e2) (if (= (length c) (length e2)) (cdr e2) (calc-record-why "*Dimension error" e2)) (list e2)))) (and ee1 ee2 (cons 'vec (math-if-vector (cdr c) ee1 ee2))))) (list 'calcFunc-if c e1 e2)))) ) (defun math-if-vector (c e1 e2) (and c (cons (if (Math-zerop (car c)) (car e2) (car e1)) (math-if-vector (cdr c) (or (cdr e1) e1) (or (cdr e2) e2)))) ) (defun math-normalize-logical-op (a) (or (and (eq (car a) 'calcFunc-if) (= (length a) 4) (let ((a1 (math-normalize (nth 1 a)))) (if (Math-zerop a1) (math-normalize (nth 3 a)) (if (Math-numberp a1) (math-normalize (nth 2 a)) (if (and (Math-vectorp (nth 1 a)) (math-constp (nth 1 a))) (calcFunc-if (nth 1 a) (math-normalize (nth 2 a)) (math-normalize (nth 3 a))) (let ((calc-simplify-mode 'none)) (list 'calcFunc-if a1 (math-normalize (nth 2 a)) (math-normalize (nth 3 a))))))))) a) ) (defun calcFunc-in (a b) (or (and (eq (car-safe b) 'vec) (let ((bb b)) (while (and (setq bb (cdr bb)) (not (if (memq (car-safe (car bb)) '(vec intv)) (eq (calcFunc-in a (car bb)) 1) (Math-equal a (car bb)))))) (if bb 1 (and (math-constp a) (math-constp bb) 0)))) (and (eq (car-safe b) 'intv) (let ((res (math-compare a (nth 2 b))) res2) (cond ((= res -1) 0) ((and (= res 0) (or (/= (nth 1 b) 2) (Math-lessp (nth 2 b) (nth 3 b)))) (if (memq (nth 1 b) '(2 3)) 1 0)) ((= (setq res2 (math-compare a (nth 3 b))) 1) 0) ((and (= res2 0) (or (/= (nth 1 b) 1) (Math-lessp (nth 2 b) (nth 3 b)))) (if (memq (nth 1 b) '(1 3)) 1 0)) ((/= res 1) nil) ((/= res2 -1) nil) (t 1)))) (and (Math-equal a b) 1) (and (math-constp a) (math-constp b) 0) (list 'calcFunc-in a b)) ) (defun calcFunc-typeof (a) (cond ((Math-integerp a) 1) ((eq (car a) 'frac) 2) ((eq (car a) 'float) 3) ((eq (car a) 'hms) 4) ((eq (car a) 'cplx) 5) ((eq (car a) 'polar) 6) ((eq (car a) 'sdev) 7) ((eq (car a) 'intv) 8) ((eq (car a) 'mod) 9) ((eq (car a) 'date) (if (Math-integerp (nth 1 a)) 10 11)) ((eq (car a) 'var) (if (memq (nth 2 a) '(var-inf var-uinf var-nan)) 12 100)) ((eq (car a) 'vec) (if (math-matrixp a) 102 101)) (t (math-calcFunc-to-var func))) ) (defun calcFunc-integer (a) (if (Math-integerp a) 1 (if (Math-objvecp a) 0 (list 'calcFunc-integer a))) ) (defun calcFunc-real (a) (if (Math-realp a) 1 (if (Math-objvecp a) 0 (list 'calcFunc-real a))) ) (defun calcFunc-constant (a) (if (math-constp a) 1 (if (Math-objvecp a) 0 (list 'calcFunc-constant a))) ) (defun calcFunc-refers (a b) (if (math-expr-contains a b) 1 (if (eq (car-safe a) 'var) (list 'calcFunc-refers a b) 0)) ) (defun calcFunc-negative (a) (if (math-looks-negp a) 1 (if (or (math-zerop a) (math-posp a)) 0 (list 'calcFunc-negative a))) ) (defun calcFunc-variable (a) (if (eq (car-safe a) 'var) 1 (if (Math-objvecp a) 0 (list 'calcFunc-variable a))) ) (defun calcFunc-nonvar (a) (if (eq (car-safe a) 'var) (list 'calcFunc-nonvar a) 1) ) (defun calcFunc-istrue (a) (if (math-is-true a) 1 0) ) ;;;; User-programmability. ;;; Compiling Lisp-like forms to use the math library. (defun math-do-defmath (func args body) (calc-need-macros) (let* ((fname (intern (concat "calcFunc-" (symbol-name func)))) (doc (if (stringp (car body)) (list (car body)))) (clargs (mapcar 'math-clean-arg args)) (body (math-define-function-body (if (stringp (car body)) (cdr body) body) clargs))) (list 'progn (if (and (consp (car body)) (eq (car (car body)) 'interactive)) (let ((inter (car body))) (setq body (cdr body)) (if (or (> (length inter) 2) (integerp (nth 1 inter))) (let ((hasprefix nil) (hasmulti nil)) (if (stringp (nth 1 inter)) (progn (cond ((equal (nth 1 inter) "p") (setq hasprefix t)) ((equal (nth 1 inter) "m") (setq hasmulti t)) (t (error "Can't handle interactive code string \"%s\"" (nth 1 inter)))) (setq inter (cdr inter)))) (if (not (integerp (nth 1 inter))) (error "Expected an integer in interactive specification")) (append (list 'defun (intern (concat "calc-" (symbol-name func))) (if (or hasprefix hasmulti) '(&optional n) ())) doc (if (or hasprefix hasmulti) '((interactive "P")) '((interactive))) (list (append '(calc-slow-wrapper) (and hasmulti (list (list 'setq 'n (list 'if 'n (list 'prefix-numeric-value 'n) (nth 1 inter))))) (list (list 'calc-enter-result (if hasmulti 'n (nth 1 inter)) (nth 2 inter) (if hasprefix (list 'append (list 'quote (list fname)) (list 'calc-top-list-n (nth 1 inter)) (list 'and 'n (list 'list (list 'math-normalize (list 'prefix-numeric-value 'n))))) (list 'cons (list 'quote fname) (list 'calc-top-list-n (if hasmulti 'n (nth 1 inter))))))))))) (append (list 'defun (intern (concat "calc-" (symbol-name func))) args) doc (list inter (cons 'calc-wrapper body)))))) (append (list 'defun fname clargs) doc (math-do-arg-list-check args nil nil) body))) ) (defun math-clean-arg (arg) (if (consp arg) (math-clean-arg (nth 1 arg)) arg) ) (defun math-do-arg-check (arg var is-opt is-rest) (if is-opt (let ((chk (math-do-arg-check arg var nil nil))) (list (cons 'and (cons var (if (cdr chk) (setq chk (list (cons 'progn chk))) chk))))) (and (consp arg) (let* ((rest (math-do-arg-check (nth 1 arg) var is-opt is-rest)) (qual (car arg)) (qqual (list 'quote qual)) (qual-name (symbol-name qual)) (chk (intern (concat "math-check-" qual-name)))) (if (fboundp chk) (append rest (list (if is-rest (list 'setq var (list 'mapcar (list 'quote chk) var)) (list 'setq var (list chk var))))) (if (fboundp (setq chk (intern (concat "math-" qual-name)))) (append rest (list (if is-rest (list 'mapcar (list 'function (list 'lambda '(x) (list 'or (list chk 'x) (list 'math-reject-arg 'x qqual)))) var) (list 'or (list chk var) (list 'math-reject-arg var qqual))))) (if (and (string-match "\\`not-\\(.*\\)\\'" qual-name) (fboundp (setq chk (intern (concat "math-" (math-match-substring qual-name 1)))))) (append rest (list (if is-rest (list 'mapcar (list 'function (list 'lambda '(x) (list 'and (list chk 'x) (list 'math-reject-arg 'x qqual)))) var) (list 'and (list chk var) (list 'math-reject-arg var qqual))))) (error "Unknown qualifier `%s'" qual-name))))))) ) (defun math-do-arg-list-check (args is-opt is-rest) (cond ((null args) nil) ((consp (car args)) (append (math-do-arg-check (car args) (math-clean-arg (car args)) is-opt is-rest) (math-do-arg-list-check (cdr args) is-opt is-rest))) ((eq (car args) '&optional) (math-do-arg-list-check (cdr args) t nil)) ((eq (car args) '&rest) (math-do-arg-list-check (cdr args) nil t)) (t (math-do-arg-list-check (cdr args) is-opt is-rest))) ) (defconst math-prim-funcs '( (~= . math-nearly-equal) (% . math-mod) (lsh . calcFunc-lsh) (ash . calcFunc-ash) (logand . calcFunc-and) (logandc2 . calcFunc-diff) (logior . calcFunc-or) (logxor . calcFunc-xor) (lognot . calcFunc-not) (equal . equal) ; need to leave these ones alone! (eq . eq) (and . and) (or . or) (if . if) (^ . math-pow) (expt . math-pow) ) ) (defconst math-prim-vars '( (nil . nil) (t . t) (&optional . &optional) (&rest . &rest) ) ) (defun math-define-function-body (body env) (let ((body (math-define-body body env))) (if (math-body-refers-to body 'math-return) (list (cons 'catch (cons '(quote math-return) body))) body)) ) (defun math-define-body (body exp-env) (math-define-list body) ) (defun math-define-list (body &optional quote) (cond ((null body) nil) ((and (eq (car body) ':) (stringp (nth 1 body))) (cons (let* ((math-read-expr-quotes t) (exp (math-read-plain-expr (nth 1 body) t))) (math-define-exp exp)) (math-define-list (cdr (cdr body))))) (quote (cons (cond ((consp (car body)) (math-define-list (cdr body) t)) (t (car body))) (math-define-list (cdr body)))) (t (cons (math-define-exp (car body)) (math-define-list (cdr body))))) ) (defun math-define-exp (exp) (cond ((consp exp) (let ((func (car exp))) (cond ((memq func '(quote function)) (if (and (consp (nth 1 exp)) (eq (car (nth 1 exp)) 'lambda)) (cons 'quote (math-define-lambda (nth 1 exp) exp-env)) exp)) ((memq func '(let let* for foreach)) (let ((head (nth 1 exp)) (body (cdr (cdr exp)))) (if (memq func '(let let*)) () (setq func (cdr (assq func '((for . math-for) (foreach . math-foreach))))) (if (not (listp (car head))) (setq head (list head)))) (macroexpand (cons func (cons (math-define-let head) (math-define-body body (nconc (math-define-let-env head) exp-env))))))) ((and (memq func '(setq setf)) (math-complicated-lhs (cdr exp))) (if (> (length exp) 3) (cons 'progn (math-define-setf-list (cdr exp))) (math-define-setf (nth 1 exp) (nth 2 exp)))) ((eq func 'condition-case) (cons func (cons (nth 1 exp) (math-define-body (cdr (cdr exp)) (cons (nth 1 exp) exp-env))))) ((eq func 'cond) (cons func (math-define-cond (cdr exp)))) ((and (consp func) ; ('spam a b) == force use of plain spam (eq (car func) 'quote)) (cons func (math-define-list (cdr exp)))) ((symbolp func) (let ((args (math-define-list (cdr exp))) (prim (assq func math-prim-funcs))) (cond (prim (cons (cdr prim) args)) ((eq func 'floatp) (list 'eq (car args) '(quote float))) ((eq func '+) (math-define-binop 'math-add 0 (car args) (cdr args))) ((eq func '-) (if (= (length args) 1) (cons 'math-neg args) (math-define-binop 'math-sub 0 (car args) (cdr args)))) ((eq func '*) (math-define-binop 'math-mul 1 (car args) (cdr args))) ((eq func '/) (math-define-binop 'math-div 1 (car args) (cdr args))) ((eq func 'min) (math-define-binop 'math-min 0 (car args) (cdr args))) ((eq func 'max) (math-define-binop 'math-max 0 (car args) (cdr args))) ((eq func '<) (if (and (math-numberp (nth 1 args)) (math-zerop (nth 1 args))) (list 'math-negp (car args)) (cons 'math-lessp args))) ((eq func '>) (if (and (math-numberp (nth 1 args)) (math-zerop (nth 1 args))) (list 'math-posp (car args)) (list 'math-lessp (nth 1 args) (nth 0 args)))) ((eq func '<=) (list 'not (if (and (math-numberp (nth 1 args)) (math-zerop (nth 1 args))) (list 'math-posp (car args)) (list 'math-lessp (nth 1 args) (nth 0 args))))) ((eq func '>=) (list 'not (if (and (math-numberp (nth 1 args)) (math-zerop (nth 1 args))) (list 'math-negp (car args)) (cons 'math-lessp args)))) ((eq func '=) (if (and (math-numberp (nth 1 args)) (math-zerop (nth 1 args))) (list 'math-zerop (nth 0 args)) (if (and (integerp (nth 1 args)) (/= (% (nth 1 args) 10) 0)) (cons 'math-equal-int args) (cons 'math-equal args)))) ((eq func '/=) (list 'not (if (and (math-numberp (nth 1 args)) (math-zerop (nth 1 args))) (list 'math-zerop (nth 0 args)) (if (and (integerp (nth 1 args)) (/= (% (nth 1 args) 10) 0)) (cons 'math-equal-int args) (cons 'math-equal args))))) ((eq func '1+) (list 'math-add (car args) 1)) ((eq func '1-) (list 'math-add (car args) -1)) ((eq func 'not) ; optimize (not (not x)) => x (if (eq (car-safe args) func) (car (nth 1 args)) (cons func args))) ((and (eq func 'elt) (cdr (cdr args))) (math-define-elt (car args) (cdr args))) (t (macroexpand (let* ((name (symbol-name func)) (cfunc (intern (concat "calcFunc-" name))) (mfunc (intern (concat "math-" name)))) (cond ((fboundp cfunc) (cons cfunc args)) ((fboundp mfunc) (cons mfunc args)) ((or (fboundp func) (string-match "\\`calcFunc-.*" name)) (cons func args)) (t (cons cfunc args))))))))) (t (cons func args))))) ((symbolp exp) (let ((prim (assq exp math-prim-vars)) (name (symbol-name exp))) (cond (prim (cdr prim)) ((memq exp exp-env) exp) ((string-match "-" name) exp) (t (intern (concat "var-" name)))))) ((integerp exp) (if (or (<= exp -1000000) (>= exp 1000000)) (list 'quote (math-normalize exp)) exp)) (t exp)) ) (defun math-define-cond (forms) (and forms (cons (math-define-list (car forms)) (math-define-cond (cdr forms)))) ) (defun math-complicated-lhs (body) (and body (or (not (symbolp (car body))) (math-complicated-lhs (cdr (cdr body))))) ) (defun math-define-setf-list (body) (and body (cons (math-define-setf (nth 0 body) (nth 1 body)) (math-define-setf-list (cdr (cdr body))))) ) (defun math-define-setf (place value) (setq place (math-define-exp place) value (math-define-exp value)) (cond ((symbolp place) (list 'setq place value)) ((eq (car-safe place) 'nth) (list 'setcar (list 'nthcdr (nth 1 place) (nth 2 place)) value)) ((eq (car-safe place) 'elt) (list 'setcar (list 'nthcdr (nth 2 place) (nth 1 place)) value)) ((eq (car-safe place) 'car) (list 'setcar (nth 1 place) value)) ((eq (car-safe place) 'cdr) (list 'setcdr (nth 1 place) value)) (t (error "Bad place form for setf: %s" place))) ) (defun math-define-binop (op ident arg1 rest) (if rest (math-define-binop op ident (list op arg1 (car rest)) (cdr rest)) (or arg1 ident)) ) (defun math-define-let (vlist) (and vlist (cons (if (consp (car vlist)) (cons (car (car vlist)) (math-define-list (cdr (car vlist)))) (car vlist)) (math-define-let (cdr vlist)))) ) (defun math-define-let-env (vlist) (and vlist (cons (if (consp (car vlist)) (car (car vlist)) (car vlist)) (math-define-let-env (cdr vlist)))) ) (defun math-define-lambda (exp exp-env) (nconc (list (nth 0 exp) ; 'lambda (nth 1 exp)) ; arg list (math-define-function-body (cdr (cdr exp)) (append (nth 1 exp) exp-env))) ) (defun math-define-elt (seq idx) (if idx (math-define-elt (list 'elt seq (car idx)) (cdr idx)) seq) ) ;;; Useful programming macros. (defmacro math-while (head &rest body) (let ((body (cons 'while (cons head body)))) (if (math-body-refers-to body 'math-break) (cons 'catch (cons '(quote math-break) (list body))) body)) ) (defmacro math-for (head &rest body) (let ((body (if head (math-handle-for head body) (cons 'while (cons t body))))) (if (math-body-refers-to body 'math-break) (cons 'catch (cons '(quote math-break) (list body))) body)) ) (defun math-handle-for (head body) (let* ((var (nth 0 (car head))) (init (nth 1 (car head))) (limit (nth 2 (car head))) (step (or (nth 3 (car head)) 1)) (body (if (cdr head) (list (math-handle-for (cdr head) body)) body)) (all-ints (and (integerp init) (integerp limit) (integerp step))) (const-limit (or (integerp limit) (and (eq (car-safe limit) 'quote) (math-realp (nth 1 limit))))) (const-step (or (integerp step) (and (eq (car-safe step) 'quote) (math-realp (nth 1 step))))) (save-limit (if const-limit limit (make-symbol ""))) (save-step (if const-step step (make-symbol "")))) (cons 'let (cons (append (if const-limit nil (list (list save-limit limit))) (if const-step nil (list (list save-step step))) (list (list var init))) (list (cons 'while (cons (if all-ints (if (> step 0) (list '<= var save-limit) (list '>= var save-limit)) (list 'not (if const-step (if (or (math-posp step) (math-posp (cdr-safe step))) (list 'math-lessp save-limit var) (list 'math-lessp var save-limit)) (list 'if (list 'math-posp save-step) (list 'math-lessp save-limit var) (list 'math-lessp var save-limit))))) (append body (list (list 'setq var (list (if all-ints '+ 'math-add) var save-step)))))))))) ) (defmacro math-foreach (head &rest body) (let ((body (math-handle-foreach head body))) (if (math-body-refers-to body 'math-break) (cons 'catch (cons '(quote math-break) (list body))) body)) ) (defun math-handle-foreach (head body) (let ((var (nth 0 (car head))) (data (nth 1 (car head))) (body (if (cdr head) (list (math-handle-foreach (cdr head) body)) body))) (cons 'let (cons (list (list var data)) (list (cons 'while (cons var (append body (list (list 'setq var (list 'cdr var)))))))))) ) (defun math-body-refers-to (body thing) (or (equal body thing) (and (consp body) (or (math-body-refers-to (car body) thing) (math-body-refers-to (cdr body) thing)))) ) (defun math-break (&optional value) (throw 'math-break value) ) (defun math-return (&optional value) (throw 'math-return value) ) (defun math-composite-inequalities (x op) (if (memq (nth 1 op) '(calcFunc-eq calcFunc-neq)) (if (eq (car x) (nth 1 op)) (append x (list (math-read-expr-level (nth 3 op)))) (throw 'syntax "Syntax error")) (list 'calcFunc-in (nth 2 x) (if (memq (nth 1 op) '(calcFunc-lt calcFunc-leq)) (if (memq (car x) '(calcFunc-lt calcFunc-leq)) (math-make-intv (+ (if (eq (car x) 'calcFunc-leq) 2 0) (if (eq (nth 1 op) 'calcFunc-leq) 1 0)) (nth 1 x) (math-read-expr-level (nth 3 op))) (throw 'syntax "Syntax error")) (if (memq (car x) '(calcFunc-gt calcFunc-geq)) (math-make-intv (+ (if (eq (nth 1 op) 'calcFunc-geq) 2 0) (if (eq (car x) 'calcFunc-geq) 1 0)) (math-read-expr-level (nth 3 op)) (nth 1 x)) (throw 'syntax "Syntax error"))))) ) calc-2.02c/calc-bin.el100644 22403 13 60445 5402630526 13043 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-bin.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-bin () nil) ;;; b-prefix binary commands. (defun calc-and (n) (interactive "P") (calc-slow-wrapper (calc-enter-result 2 "and" (append '(calcFunc-and) (calc-top-list-n 2) (and n (list (prefix-numeric-value n)))))) ) (defun calc-or (n) (interactive "P") (calc-slow-wrapper (calc-enter-result 2 "or" (append '(calcFunc-or) (calc-top-list-n 2) (and n (list (prefix-numeric-value n)))))) ) (defun calc-xor (n) (interactive "P") (calc-slow-wrapper (calc-enter-result 2 "xor" (append '(calcFunc-xor) (calc-top-list-n 2) (and n (list (prefix-numeric-value n)))))) ) (defun calc-diff (n) (interactive "P") (calc-slow-wrapper (calc-enter-result 2 "diff" (append '(calcFunc-diff) (calc-top-list-n 2) (and n (list (prefix-numeric-value n)))))) ) (defun calc-not (n) (interactive "P") (calc-slow-wrapper (calc-enter-result 1 "not" (append '(calcFunc-not) (calc-top-list-n 1) (and n (list (prefix-numeric-value n)))))) ) (defun calc-lshift-binary (n) (interactive "P") (calc-slow-wrapper (let ((hyp (if (calc-is-hyperbolic) 2 1))) (calc-enter-result hyp "lsh" (append '(calcFunc-lsh) (calc-top-list-n hyp) (and n (list (prefix-numeric-value n))))))) ) (defun calc-rshift-binary (n) (interactive "P") (calc-slow-wrapper (let ((hyp (if (calc-is-hyperbolic) 2 1))) (calc-enter-result hyp "rsh" (append '(calcFunc-rsh) (calc-top-list-n hyp) (and n (list (prefix-numeric-value n))))))) ) (defun calc-lshift-arith (n) (interactive "P") (calc-slow-wrapper (let ((hyp (if (calc-is-hyperbolic) 2 1))) (calc-enter-result hyp "ash" (append '(calcFunc-ash) (calc-top-list-n hyp) (and n (list (prefix-numeric-value n))))))) ) (defun calc-rshift-arith (n) (interactive "P") (calc-slow-wrapper (let ((hyp (if (calc-is-hyperbolic) 2 1))) (calc-enter-result hyp "rash" (append '(calcFunc-rash) (calc-top-list-n hyp) (and n (list (prefix-numeric-value n))))))) ) (defun calc-rotate-binary (n) (interactive "P") (calc-slow-wrapper (let ((hyp (if (calc-is-hyperbolic) 2 1))) (calc-enter-result hyp "rot" (append '(calcFunc-rot) (calc-top-list-n hyp) (and n (list (prefix-numeric-value n))))))) ) (defun calc-clip (n) (interactive "P") (calc-slow-wrapper (calc-enter-result 1 "clip" (append '(calcFunc-clip) (calc-top-list-n 1) (and n (list (prefix-numeric-value n)))))) ) (defun calc-word-size (n) (interactive "P") (calc-wrapper (or n (setq n (read-string (format "Binary word size: (default %d) " calc-word-size)))) (setq n (if (stringp n) (if (equal n "") calc-word-size (if (string-match "\\`[-+]?[0-9]+\\'" n) (string-to-int n) (error "Expected an integer"))) (prefix-numeric-value n))) (or (= n calc-word-size) (if (> (math-abs n) 100) (calc-change-mode 'calc-word-size n calc-leading-zeros) (calc-change-mode '(calc-word-size calc-previous-modulo) (list n (math-power-of-2 (math-abs n))) calc-leading-zeros))) (if (< n 0) (message "Binary word size is %d bits (2's complement)." (- n)) (message "Binary word size is %d bits." n))) ) ;;; d-prefix mode commands. (defun calc-radix (n) (interactive "NDisplay radix (2-36): ") (calc-wrapper (if (and (>= n 2) (<= n 36)) (progn (calc-change-mode 'calc-number-radix n t) ;; also change global value so minibuffer sees it (setq-default calc-number-radix calc-number-radix)) (setq n calc-number-radix)) (message "Number radix is %d." n)) ) (defun calc-decimal-radix () (interactive) (calc-radix 10) ) (defun calc-binary-radix () (interactive) (calc-radix 2) ) (defun calc-octal-radix () (interactive) (calc-radix 8) ) (defun calc-hex-radix () (interactive) (calc-radix 16) ) (defun calc-leading-zeros (n) (interactive "P") (calc-wrapper (if (calc-change-mode 'calc-leading-zeros n t t) (message "Zero-padding integers to %d digits (assuming radix %d)." (let* ((calc-internal-prec 6)) (math-compute-max-digits (math-abs calc-word-size) calc-number-radix)) calc-number-radix) (message "Omitting leading zeros on integers."))) ) (defvar math-power-of-2-cache (list 1 2 4 8 16 32 64 128 256 512 1024)) (defvar math-big-power-of-2-cache nil) (defun math-power-of-2 (n) ; [I I] [Public] (if (and (natnump n) (<= n 100)) (or (nth n math-power-of-2-cache) (let* ((i (length math-power-of-2-cache)) (val (nth (1- i) math-power-of-2-cache))) (while (<= i n) (setq val (math-mul val 2) math-power-of-2-cache (nconc math-power-of-2-cache (list val)) i (1+ i))) val)) (let ((found (assq n math-big-power-of-2-cache))) (if found (cdr found) (let ((po2 (math-ipow 2 n))) (setq math-big-power-of-2-cache (cons (cons n po2) math-big-power-of-2-cache)) po2)))) ) (defun math-integer-log2 (n) ; [I I] [Public] (let ((i 0) (p math-power-of-2-cache) val) (while (and p (Math-natnum-lessp (setq val (car p)) n)) (setq p (cdr p) i (1+ i))) (if p (and (equal val n) i) (while (Math-natnum-lessp (prog1 (setq val (math-mul val 2)) (setq math-power-of-2-cache (nconc math-power-of-2-cache (list val)))) n) (setq i (1+ i))) (and (equal val n) i))) ) ;;; Bitwise operations. (defun calcFunc-and (a b &optional w) ; [I I I] [Public] (cond ((Math-messy-integerp w) (calcFunc-and a b (math-trunc w))) ((and w (not (integerp w))) (math-reject-arg w 'fixnump)) ((and (integerp a) (integerp b)) (math-clip (logand a b) w)) ((or (eq (car-safe a) 'mod) (eq (car-safe b) 'mod)) (math-binary-modulo-args 'calcFunc-and a b w)) ((not (Math-num-integerp a)) (math-reject-arg a 'integerp)) ((not (Math-num-integerp b)) (math-reject-arg b 'integerp)) (t (math-clip (cons 'bigpos (math-and-bignum (math-binary-arg a w) (math-binary-arg b w))) w))) ) (defun math-binary-arg (a w) (if (not (Math-integerp a)) (setq a (math-trunc a))) (if (Math-integer-negp a) (math-not-bignum (cdr (math-bignum-test (math-sub -1 a))) (math-abs (if w (math-trunc w) calc-word-size))) (cdr (Math-bignum-test a))) ) (defun math-binary-modulo-args (f a b w) (let (mod) (if (eq (car-safe a) 'mod) (progn (setq mod (nth 2 a) a (nth 1 a)) (if (eq (car-safe b) 'mod) (if (equal mod (nth 2 b)) (setq b (nth 1 b)) (math-reject-arg b "*Inconsistent modulos")))) (setq mod (nth 2 b) b (nth 1 b))) (if (Math-messy-integerp mod) (setq mod (math-trunc mod)) (or (Math-integerp mod) (math-reject-arg mod 'integerp))) (let ((bits (math-integer-log2 mod))) (if bits (if w (if (/= w bits) (calc-record-why "*Warning: Modulo inconsistent with word size")) (setq w bits)) (calc-record-why "*Warning: Modulo is not a power of 2")) (math-make-mod (if b (funcall f a b w) (funcall f a w)) mod))) ) (defun math-and-bignum (a b) ; [l l l] (and a b (let ((qa (math-div-bignum-digit a 512)) (qb (math-div-bignum-digit b 512))) (math-mul-bignum-digit (math-and-bignum (math-norm-bignum (car qa)) (math-norm-bignum (car qb))) 512 (logand (cdr qa) (cdr qb))))) ) (defun calcFunc-or (a b &optional w) ; [I I I] [Public] (cond ((Math-messy-integerp w) (calcFunc-or a b (math-trunc w))) ((and w (not (integerp w))) (math-reject-arg w 'fixnump)) ((and (integerp a) (integerp b)) (math-clip (logior a b) w)) ((or (eq (car-safe a) 'mod) (eq (car-safe b) 'mod)) (math-binary-modulo-args 'calcFunc-or a b w)) ((not (Math-num-integerp a)) (math-reject-arg a 'integerp)) ((not (Math-num-integerp b)) (math-reject-arg b 'integerp)) (t (math-clip (cons 'bigpos (math-or-bignum (math-binary-arg a w) (math-binary-arg b w))) w))) ) (defun math-or-bignum (a b) ; [l l l] (and (or a b) (let ((qa (math-div-bignum-digit a 512)) (qb (math-div-bignum-digit b 512))) (math-mul-bignum-digit (math-or-bignum (math-norm-bignum (car qa)) (math-norm-bignum (car qb))) 512 (logior (cdr qa) (cdr qb))))) ) (defun calcFunc-xor (a b &optional w) ; [I I I] [Public] (cond ((Math-messy-integerp w) (calcFunc-xor a b (math-trunc w))) ((and w (not (integerp w))) (math-reject-arg w 'fixnump)) ((and (integerp a) (integerp b)) (math-clip (logxor a b) w)) ((or (eq (car-safe a) 'mod) (eq (car-safe b) 'mod)) (math-binary-modulo-args 'calcFunc-xor a b w)) ((not (Math-num-integerp a)) (math-reject-arg a 'integerp)) ((not (Math-num-integerp b)) (math-reject-arg b 'integerp)) (t (math-clip (cons 'bigpos (math-xor-bignum (math-binary-arg a w) (math-binary-arg b w))) w))) ) (defun math-xor-bignum (a b) ; [l l l] (and (or a b) (let ((qa (math-div-bignum-digit a 512)) (qb (math-div-bignum-digit b 512))) (math-mul-bignum-digit (math-xor-bignum (math-norm-bignum (car qa)) (math-norm-bignum (car qb))) 512 (logxor (cdr qa) (cdr qb))))) ) (defun calcFunc-diff (a b &optional w) ; [I I I] [Public] (cond ((Math-messy-integerp w) (calcFunc-diff a b (math-trunc w))) ((and w (not (integerp w))) (math-reject-arg w 'fixnump)) ((and (integerp a) (integerp b)) (math-clip (logand a (lognot b)) w)) ((or (eq (car-safe a) 'mod) (eq (car-safe b) 'mod)) (math-binary-modulo-args 'calcFunc-diff a b w)) ((not (Math-num-integerp a)) (math-reject-arg a 'integerp)) ((not (Math-num-integerp b)) (math-reject-arg b 'integerp)) (t (math-clip (cons 'bigpos (math-diff-bignum (math-binary-arg a w) (math-binary-arg b w))) w))) ) (defun math-diff-bignum (a b) ; [l l l] (and a (let ((qa (math-div-bignum-digit a 512)) (qb (math-div-bignum-digit b 512))) (math-mul-bignum-digit (math-diff-bignum (math-norm-bignum (car qa)) (math-norm-bignum (car qb))) 512 (logand (cdr qa) (lognot (cdr qb)))))) ) (defun calcFunc-not (a &optional w) ; [I I] [Public] (cond ((Math-messy-integerp w) (calcFunc-not a (math-trunc w))) ((eq (car-safe a) 'mod) (math-binary-modulo-args 'calcFunc-not a nil w)) ((and w (not (integerp w))) (math-reject-arg w 'fixnump)) ((not (Math-num-integerp a)) (math-reject-arg a 'integerp)) ((< (or w (setq w calc-word-size)) 0) (math-clip (calcFunc-not a (- w)) w)) (t (math-normalize (cons 'bigpos (math-not-bignum (math-binary-arg a w) w))))) ) (defun math-not-bignum (a w) ; [l l] (let ((q (math-div-bignum-digit a 512))) (if (<= w 9) (list (logand (lognot (cdr q)) (1- (lsh 1 w)))) (math-mul-bignum-digit (math-not-bignum (math-norm-bignum (car q)) (- w 9)) 512 (logxor (cdr q) 511)))) ) (defun calcFunc-lsh (a &optional n w) ; [I I] [Public] (setq a (math-trunc a) n (if n (math-trunc n) 1)) (if (eq (car-safe a) 'mod) (math-binary-modulo-args 'calcFunc-lsh a n w) (setq w (if w (math-trunc w) calc-word-size)) (or (integerp w) (math-reject-arg w 'fixnump)) (or (Math-integerp a) (math-reject-arg a 'integerp)) (or (Math-integerp n) (math-reject-arg n 'integerp)) (if (< w 0) (math-clip (calcFunc-lsh a n (- w)) w) (if (Math-integer-negp a) (setq a (math-clip a w))) (cond ((or (Math-lessp n (- w)) (Math-lessp w n)) 0) ((< n 0) (math-quotient (math-clip a w) (math-power-of-2 (- n)))) (t (math-clip (math-mul a (math-power-of-2 n)) w))))) ) (defun calcFunc-rsh (a &optional n w) ; [I I] [Public] (calcFunc-lsh a (math-neg (or n 1)) w) ) (defun calcFunc-ash (a &optional n w) ; [I I] [Public] (if (or (null n) (not (Math-negp n))) (calcFunc-lsh a n w) (setq a (math-trunc a) n (if n (math-trunc n) 1)) (if (eq (car-safe a) 'mod) (math-binary-modulo-args 'calcFunc-ash a n w) (setq w (if w (math-trunc w) calc-word-size)) (or (integerp w) (math-reject-arg w 'fixnump)) (or (Math-integerp a) (math-reject-arg a 'integerp)) (or (Math-integerp n) (math-reject-arg n 'integerp)) (if (< w 0) (math-clip (calcFunc-ash a n (- w)) w) (if (Math-integer-negp a) (setq a (math-clip a w))) (let ((two-to-sizem1 (math-power-of-2 (1- w))) (sh (calcFunc-lsh a n w))) (cond ((Math-natnum-lessp a two-to-sizem1) sh) ((Math-lessp n (- 1 w)) (math-add (math-mul two-to-sizem1 2) -1)) (t (let ((two-to-n (math-power-of-2 (- n)))) (math-add (calcFunc-lsh (math-add two-to-n -1) (+ w n) w) sh)))))))) ) (defun calcFunc-rash (a &optional n w) ; [I I] [Public] (calcFunc-ash a (math-neg (or n 1)) w) ) (defun calcFunc-rot (a &optional n w) ; [I I] [Public] (setq a (math-trunc a) n (if n (math-trunc n) 1)) (if (eq (car-safe a) 'mod) (math-binary-modulo-args 'calcFunc-rot a n w) (setq w (if w (math-trunc w) calc-word-size)) (or (integerp w) (math-reject-arg w 'fixnump)) (or (Math-integerp a) (math-reject-arg a 'integerp)) (or (Math-integerp n) (math-reject-arg n 'integerp)) (if (< w 0) (math-clip (calcFunc-rot a n (- w)) w) (if (Math-integer-negp a) (setq a (math-clip a w))) (cond ((or (Math-integer-negp n) (not (Math-natnum-lessp n w))) (calcFunc-rot a (math-mod n w) w)) (t (math-add (calcFunc-lsh a (- n w) w) (calcFunc-lsh a n w)))))) ) (defun math-clip (a &optional w) ; [I I] [Public] (cond ((Math-messy-integerp w) (math-clip a (math-trunc w))) ((eq (car-safe a) 'mod) (math-binary-modulo-args 'math-clip a nil w)) ((and w (not (integerp w))) (math-reject-arg w 'fixnump)) ((not (Math-num-integerp a)) (math-reject-arg a 'integerp)) ((< (or w (setq w calc-word-size)) 0) (setq a (math-clip a (- w))) (if (Math-natnum-lessp a (math-power-of-2 (- -1 w))) a (math-sub a (math-power-of-2 (- w))))) ((Math-negp a) (math-normalize (cons 'bigpos (math-binary-arg a w)))) ((and (integerp a) (< a 1000000)) (if (>= w 20) a (logand a (1- (lsh 1 w))))) (t (math-normalize (cons 'bigpos (math-clip-bignum (cdr (math-bignum-test (math-trunc a))) w))))) ) (fset 'calcFunc-clip (symbol-function 'math-clip)) (defun math-clip-bignum (a w) ; [l l] (let ((q (math-div-bignum-digit a 512))) (if (<= w 9) (list (logand (cdr q) (1- (lsh 1 w)))) (math-mul-bignum-digit (math-clip-bignum (math-norm-bignum (car q)) (- w 9)) 512 (cdr q)))) ) (defvar math-max-digits-cache nil) (defun math-compute-max-digits (w r) (let* ((pair (+ (* r 100000) w)) (res (assq pair math-max-digits-cache))) (if res (cdr res) (let* ((calc-command-flags nil) (digs (math-ceiling (math-div w (math-real-log2 r))))) (setq math-max-digits-cache (cons (cons pair digs) math-max-digits-cache)) digs))) ) (defvar math-log2-cache (list '(2 . 1) '(4 . 2) '(8 . 3) '(10 . (float 332193 -5)) '(16 . 4) '(32 . 5))) (defun math-real-log2 (x) ;;; calc-internal-prec must be 6 (let ((res (assq x math-log2-cache))) (if res (cdr res) (let* ((calc-symbolic-mode nil) (calc-display-working-message nil) (log (calcFunc-log x 2))) (setq math-log2-cache (cons (cons x log) math-log2-cache)) log))) ) (defconst math-radix-digits ["0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S" "T" "U" "V" "W" "X" "Y" "Z"]) (defun math-format-radix (a) ; [X S] (if (< a calc-number-radix) (if (< a 0) (concat "-" (math-format-radix (- a))) (math-format-radix-digit a)) (let ((s "")) (while (> a 0) (setq s (concat (math-format-radix-digit (% a calc-number-radix)) s) a (/ a calc-number-radix))) s)) ) (defconst math-binary-digits ["000" "001" "010" "011" "100" "101" "110" "111"]) (defun math-format-binary (a) ; [X S] (if (< a 8) (if (< a 0) (concat "-" (math-format-binary (- a))) (math-format-radix a)) (let ((s "")) (while (> a 7) (setq s (concat (aref math-binary-digits (% a 8)) s) a (/ a 8))) (concat (math-format-radix a) s))) ) (defun math-format-bignum-radix (a) ; [X L] (cond ((null a) "0") ((and (null (cdr a)) (< (car a) calc-number-radix)) (math-format-radix-digit (car a))) (t (let ((q (math-div-bignum-digit a calc-number-radix))) (concat (math-format-bignum-radix (math-norm-bignum (car q))) (math-format-radix-digit (cdr q)))))) ) (defun math-format-bignum-binary (a) ; [X L] (cond ((null a) "0") ((null (cdr a)) (math-format-binary (car a))) (t (let ((q (math-div-bignum-digit a 512))) (concat (math-format-bignum-binary (math-norm-bignum (car q))) (aref math-binary-digits (/ (cdr q) 64)) (aref math-binary-digits (% (/ (cdr q) 8) 8)) (aref math-binary-digits (% (cdr q) 8)))))) ) (defun math-format-bignum-octal (a) ; [X L] (cond ((null a) "0") ((null (cdr a)) (math-format-radix (car a))) (t (let ((q (math-div-bignum-digit a 512))) (concat (math-format-bignum-octal (math-norm-bignum (car q))) (math-format-radix-digit (/ (cdr q) 64)) (math-format-radix-digit (% (/ (cdr q) 8) 8)) (math-format-radix-digit (% (cdr q) 8)))))) ) (defun math-format-bignum-hex (a) ; [X L] (cond ((null a) "0") ((null (cdr a)) (math-format-radix (car a))) (t (let ((q (math-div-bignum-digit a 256))) (concat (math-format-bignum-hex (math-norm-bignum (car q))) (math-format-radix-digit (/ (cdr q) 16)) (math-format-radix-digit (% (cdr q) 16)))))) ) ;;; Decompose into integer and fractional parts, without depending ;;; on calc-internal-prec. (defun math-float-parts (a need-frac) ; returns ( int frac fracdigs ) (if (>= (nth 2 a) 0) (list (math-scale-rounding (nth 1 a) (nth 2 a)) '(float 0 0) 0) (let* ((d (math-numdigs (nth 1 a))) (n (- (nth 2 a)))) (if need-frac (if (>= n d) (list 0 a n) (let ((qr (math-idivmod (nth 1 a) (math-scale-int 1 n)))) (list (car qr) (math-make-float (cdr qr) (- n)) n))) (list (math-scale-rounding (nth 1 a) (nth 2 a)) '(float 0 0) 0)))) ) (defun math-format-radix-float (a prec) (let ((fmt (car calc-float-format)) (figs (nth 1 calc-float-format)) (point calc-point-char) (str nil)) (if (eq fmt 'fix) (let* ((afigs (math-abs figs)) (fp (math-float-parts a (> afigs 0))) (calc-internal-prec (+ 3 (max (nth 2 fp) (math-convert-radix-digits afigs t)))) (int (car fp)) (frac (math-round (math-mul (math-normalize (nth 1 fp)) (math-radix-float-power afigs))))) (if (not (and (math-zerop frac) (math-zerop int) (< figs 0))) (let ((math-radix-explicit-format nil)) (let ((calc-group-digits nil)) (setq str (if (> afigs 0) (math-format-number frac) "")) (if (< (length str) afigs) (setq str (concat (make-string (- afigs (length str)) ?0) str)) (if (> (length str) afigs) (setq str (substring str 1) int (math-add int 1)))) (setq str (concat (math-format-number int) point str))) (if calc-group-digits (setq str (math-group-float str)))) (setq figs 0)))) (or str (let* ((prec calc-internal-prec) (afigs (if (> figs 0) figs (max 1 (+ figs (1- (math-convert-radix-digits (max prec (math-numdigs (nth 1 a))))))))) (calc-internal-prec (+ 3 (math-convert-radix-digits afigs t))) (explo -1) (vlo (math-radix-float-power explo)) (exphi 1) (vhi (math-radix-float-power exphi)) expmid vmid eadj) (setq a (math-normalize a)) (if (Math-zerop a) (setq explo 0) (if (math-lessp-float '(float 1 0) a) (while (not (math-lessp-float a vhi)) (setq explo exphi vlo vhi exphi (math-mul exphi 2) vhi (math-radix-float-power exphi))) (while (math-lessp-float a vlo) (setq exphi explo vhi vlo explo (math-mul explo 2) vlo (math-radix-float-power explo)))) (while (not (eq (math-sub exphi explo) 1)) (setq expmid (math-div2 (math-add explo exphi)) vmid (math-radix-float-power expmid)) (if (math-lessp-float a vmid) (setq exphi expmid vhi vmid) (setq explo expmid vlo vmid))) (setq a (math-div-float a vlo))) (let* ((sc (math-round (math-mul a (math-radix-float-power (1- afigs))))) (math-radix-explicit-format nil)) (let ((calc-group-digits nil)) (setq str (math-format-number sc)))) (if (> (length str) afigs) (setq str (substring str 0 -1) explo (1+ explo))) (if (and (eq fmt 'float) (math-lessp explo (+ (if (= figs 0) (1- (math-convert-radix-digits prec)) afigs) calc-display-sci-high 1)) (math-lessp calc-display-sci-low explo)) (let ((dpos (1+ explo))) (cond ((<= dpos 0) (setq str (concat "0" point (make-string (- dpos) ?0) str))) ((> dpos (length str)) (setq str (concat str (make-string (- dpos (length str)) ?0) point))) (t (setq str (concat (substring str 0 dpos) point (substring str dpos))))) (setq explo nil)) (setq eadj (if (eq fmt 'eng) (min (math-mod explo 3) (length str)) 0) str (concat (substring str 0 (1+ eadj)) point (substring str (1+ eadj))))) (setq pos (length str)) (while (eq (aref str (1- pos)) ?0) (setq pos (1- pos))) (and explo (eq (aref str (1- pos)) ?.) (setq pos (1- pos))) (setq str (substring str 0 pos)) (if calc-group-digits (setq str (math-group-float str))) (if explo (let ((estr (let ((calc-number-radix 10) (calc-group-digits nil)) (setq estr (math-format-number (math-sub explo eadj)))))) (setq str (if (or (memq calc-language '(math maple)) (> calc-number-radix 14)) (format "%s*%d.^%s" str calc-number-radix estr) (format "%se%s" str estr))))))) str) ) (defun math-convert-radix-digits (n &optional to-dec) (let ((key (cons n (cons to-dec calc-number-radix)))) (or (cdr (assoc key math-radix-digits-cache)) (let* ((calc-internal-prec 6) (log (math-div (math-real-log2 calc-number-radix) '(float 332193 -5)))) (cdr (car (setq math-radix-digits-cache (cons (cons key (math-ceiling (if to-dec (math-mul n log) (math-div n log)))) math-radix-digits-cache))))))) ) (setq math-radix-digits-cache nil) (defun math-radix-float-power (n) (if (eq n 0) '(float 1 0) (or (and (eq calc-number-radix (car math-radix-float-cache-tag)) (<= calc-internal-prec (cdr math-radix-float-cache-tag))) (setq math-radix-float-cache-tag (cons calc-number-radix calc-internal-prec) math-radix-float-cache nil)) (math-normalize (or (cdr (assoc n math-radix-float-cache)) (cdr (car (setq math-radix-float-cache (cons (cons n (let ((calc-internal-prec (cdr math-radix-float-cache-tag))) (if (math-negp n) (math-div-float '(float 1 0) (math-radix-float-power (math-neg n))) (math-mul-float (math-sqr-float (math-radix-float-power (math-div2 n))) (if (math-evenp n) '(float 1 0) (math-float calc-number-radix)))))) math-radix-float-cache))))))) ) (setq math-radix-float-cache-tag nil) calc-2.02c/calc-fin.el100644 22403 13 31641 5402630572 13044 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-fin.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-fin () nil) ;;; Financial functions. (defun calc-fin-pv () (interactive) (calc-slow-wrapper (if (calc-is-hyperbolic) (calc-enter-result 3 "pvl" (cons 'calcFunc-pvl (calc-top-list-n 3))) (if (calc-is-inverse) (calc-enter-result 3 "pvb" (cons 'calcFunc-pvb (calc-top-list-n 3))) (calc-enter-result 3 "pv" (cons 'calcFunc-pv (calc-top-list-n 3)))))) ) (defun calc-fin-npv (arg) (interactive "p") (calc-slow-wrapper (if (calc-is-inverse) (calc-vector-op "npvb" 'calcFunc-npvb (1+ arg)) (calc-vector-op "npv" 'calcFunc-npv (1+ arg)))) ) (defun calc-fin-fv () (interactive) (calc-slow-wrapper (if (calc-is-hyperbolic) (calc-enter-result 3 "fvl" (cons 'calcFunc-fvl (calc-top-list-n 3))) (if (calc-is-inverse) (calc-enter-result 3 "fvb" (cons 'calcFunc-fvb (calc-top-list-n 3))) (calc-enter-result 3 "fv" (cons 'calcFunc-fv (calc-top-list-n 3)))))) ) (defun calc-fin-pmt () (interactive) (calc-slow-wrapper (if (calc-is-hyperbolic) (calc-enter-result 3 "fvl" (cons 'calcFunc-fvl (calc-top-list-n 3))) (if (calc-is-inverse) (calc-enter-result 3 "pmtb" (cons 'calcFunc-pmtb (calc-top-list-n 3))) (calc-enter-result 3 "pmt" (cons 'calcFunc-pmt (calc-top-list-n 3)))))) ) (defun calc-fin-nper () (interactive) (calc-slow-wrapper (if (calc-is-hyperbolic) (calc-enter-result 3 "nprl" (cons 'calcFunc-nperl (calc-top-list-n 3))) (if (calc-is-inverse) (calc-enter-result 3 "nprb" (cons 'calcFunc-nperb (calc-top-list-n 3))) (calc-enter-result 3 "nper" (cons 'calcFunc-nper (calc-top-list-n 3)))))) ) (defun calc-fin-rate () (interactive) (calc-slow-wrapper (calc-pop-push-record 3 (if (calc-is-hyperbolic) "ratl" (if (calc-is-inverse) "ratb" "rate")) (calc-to-percentage (calc-normalize (cons (if (calc-is-hyperbolic) 'calcFunc-ratel (if (calc-is-hyperbolic) 'calcFunc-rateb 'calcFunc-rate)) (calc-top-list-n 3)))))) ) (defun calc-fin-irr (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-inverse) (calc-vector-op "irrb" 'calcFunc-irrb arg) (calc-vector-op "irr" 'calcFunc-irr arg))) ) (defun calc-fin-sln () (interactive) (calc-slow-wrapper (calc-enter-result 3 "sln" (cons 'calcFunc-sln (calc-top-list-n 3)))) ) (defun calc-fin-syd () (interactive) (calc-slow-wrapper (calc-enter-result 4 "syd" (cons 'calcFunc-syd (calc-top-list-n 4)))) ) (defun calc-fin-ddb () (interactive) (calc-slow-wrapper (calc-enter-result 4 "ddb" (cons 'calcFunc-ddb (calc-top-list-n 4)))) ) (defun calc-to-percentage (x) (cond ((Math-objectp x) (setq x (math-mul x 100)) (if (Math-num-integerp x) (setq x (math-trunc x))) (list 'calcFunc-percent x)) ((Math-vectorp x) (cons 'vec (mapcar 'calc-to-percentage (cdr x)))) (t x)) ) (defun calc-convert-percent () (interactive) (calc-slow-wrapper (calc-pop-push-record 1 "c%" (calc-to-percentage (calc-top-n 1)))) ) (defun calc-percent-change () (interactive) (calc-slow-wrapper (let ((res (calc-normalize (cons 'calcFunc-relch (calc-top-list 2))))) (calc-pop-push-record 2 "%ch" (calc-to-percentage res)))) ) ;;; Financial functions. (defun calcFunc-pv (rate num amount &optional lump) (math-check-financial rate num) (math-with-extra-prec 2 (let ((p (math-pow (math-add 1 rate) num))) (math-add (math-mul amount (math-div (math-sub 1 (math-div 1 p)) rate)) (math-div (or lump 0) p)))) ) (put 'calcFunc-pv 'math-expandable t) (defun calcFunc-pvl (rate num amount) (calcFunc-pv rate num 0 amount) ) (put 'calcFunc-pvl 'math-expandable t) (defun calcFunc-pvb (rate num amount &optional lump) (math-check-financial rate num) (math-with-extra-prec 2 (let* ((p (math-pow (math-add 1 rate) num))) (math-add (math-mul amount (math-div (math-mul (math-sub 1 (math-div 1 p)) (math-add 1 rate)) rate)) (math-div (or lump 0) p)))) ) (put 'calcFunc-pvb 'math-expandable t) (defun calcFunc-npv (rate &rest flows) (math-check-financial rate 1) (math-with-extra-prec 2 (let* ((flat (math-flatten-many-vecs flows)) (pp (math-add 1 rate)) (p pp) (accum 0)) (while (setq flat (cdr flat)) (setq accum (math-add accum (math-div (car flat) p)) p (math-mul p pp))) accum)) ) (put 'calcFunc-npv 'math-expandable t) (defun calcFunc-npvb (rate &rest flows) (math-check-financial rate 1) (math-with-extra-prec 2 (let* ((flat (math-flatten-many-vecs flows)) (pp (math-add 1 rate)) (p 1) (accum 0)) (while (setq flat (cdr flat)) (setq accum (math-add accum (math-div (car flat) p)) p (math-mul p pp))) accum)) ) (put 'calcFunc-npvb 'math-expandable t) (defun calcFunc-fv (rate num amount &optional initial) (math-check-financial rate num) (math-with-extra-prec 2 (let ((p (math-pow (math-add 1 rate) num))) (math-add (math-mul amount (math-div (math-sub p 1) rate)) (math-mul (or initial 0) p)))) ) (put 'calcFunc-fv 'math-expandable t) (defun calcFunc-fvl (rate num amount) (calcFunc-fv rate num 0 amount) ) (put 'calcFunc-fvl 'math-expandable t) (defun calcFunc-fvb (rate num amount &optional initial) (math-check-financial rate num) (math-with-extra-prec 2 (let ((p (math-pow (math-add 1 rate) num))) (math-add (math-mul amount (math-div (math-mul (math-sub p 1) (math-add 1 rate)) rate)) (math-mul (or initial 0) p)))) ) (put 'calcFunc-fvb 'math-expandable t) (defun calcFunc-pmt (rate num amount &optional lump) (math-check-financial rate num) (math-with-extra-prec 2 (let ((p (math-pow (math-add 1 rate) num))) (math-div (math-mul (math-sub amount (math-div (or lump 0) p)) rate) (math-sub 1 (math-div 1 p))))) ) (put 'calcFunc-pmt 'math-expandable t) (defun calcFunc-pmtb (rate num amount &optional lump) (math-check-financial rate num) (math-with-extra-prec 2 (let ((p (math-pow (math-add 1 rate) num))) (math-div (math-mul (math-sub amount (math-div (or lump 0) p)) rate) (math-mul (math-sub 1 (math-div 1 p)) (math-add 1 rate))))) ) (put 'calcFunc-pmtb 'math-expandable t) (defun calcFunc-nper (rate pmt amount &optional lump) (math-compute-nper rate pmt amount lump nil) ) (put 'calcFunc-nper 'math-expandable t) (defun calcFunc-nperb (rate pmt amount &optional lump) (math-compute-nper rate pmt amount lump 'b) ) (put 'calcFunc-nperb 'math-expandable t) (defun calcFunc-nperl (rate pmt amount) (math-compute-nper rate pmt amount nil 'l) ) (put 'calcFunc-nperl 'math-expandable t) (defun math-compute-nper (rate pmt amount lump bflag) (and lump (math-zerop lump) (setq lump nil)) (and lump (math-zerop pmt) (setq amount lump lump nil bflag 'l)) (or (math-objectp rate) (and math-expand-formulas (null lump)) (math-reject-arg rate 'numberp)) (and (math-zerop rate) (math-reject-arg rate 'nonzerop)) (or (math-objectp pmt) (and math-expand-formulas (null lump)) (math-reject-arg pmt 'numberp)) (or (math-objectp amount) (and math-expand-formulas (null lump)) (math-reject-arg amount 'numberp)) (if lump (progn (or (math-objectp lump) (math-reject-arg lump 'numberp)) (let ((root (math-find-root (list 'calcFunc-eq (list (if bflag 'calcFunc-pvb 'calcFunc-pv) rate '(var DUMMY var-DUMMY) pmt lump) amount) '(var DUMMY var-DUMMY) '(intv 3 0 100) t))) (if (math-vectorp root) (nth 1 root) root))) (math-with-extra-prec 2 (let ((temp (if (eq bflag 'l) (math-div amount pmt) (math-sub 1 (math-div (math-mul amount rate) (if bflag (math-mul pmt (math-add 1 rate)) pmt)))))) (if (or (math-posp temp) math-expand-formulas) (math-neg (calcFunc-log temp (math-add 1 rate))) (math-reject-arg pmt "*Payment too small to cover interest rate"))))) ) (defun calcFunc-rate (num pmt amount &optional lump) (math-compute-rate num pmt amount lump 'calcFunc-pv) ) (defun calcFunc-rateb (num pmt amount &optional lump) (math-compute-rate num pmt amount lump 'calcFunc-pvb) ) (defun math-compute-rate (num pmt amount lump func) (or (math-objectp num) (math-reject-arg num 'numberp)) (or (math-objectp pmt) (math-reject-arg pmt 'numberp)) (or (math-objectp amount) (math-reject-arg amount 'numberp)) (or (null lump) (math-objectp lump) (math-reject-arg lump 'numberp)) (let ((root (math-find-root (list 'calcFunc-eq (list func '(var DUMMY var-DUMMY) num pmt (or lump 0)) amount) '(var DUMMY var-DUMMY) '(intv 3 (float 1 -4) 1) t))) (if (math-vectorp root) (nth 1 root) root)) ) (defun calcFunc-ratel (num pmt amount) (or (math-objectp num) math-expand-formulas (math-reject-arg num 'numberp)) (or (math-objectp pmt) math-expand-formulas (math-reject-arg pmt 'numberp)) (or (math-objectp amount) math-expand-formulas (math-reject-arg amount 'numberp)) (math-with-extra-prec 2 (math-sub (math-pow (math-div pmt amount) (math-div 1 num)) 1)) ) (defun calcFunc-irr (&rest vecs) (math-compute-irr vecs 'calcFunc-npv) ) (defun calcFunc-irrb (&rest vecs) (math-compute-irr vecs 'calcFunc-npvb) ) (defun math-compute-irr (vecs func) (let* ((flat (math-flatten-many-vecs vecs)) (root (math-find-root (list func '(var DUMMY var-DUMMY) flat) '(var DUMMY var-DUMMY) '(intv 3 (float 1 -4) 1) t))) (if (math-vectorp root) (nth 1 root) root)) ) (defun math-check-financial (rate num) (or (math-objectp rate) math-expand-formulas (math-reject-arg rate 'numberp)) (and (math-zerop rate) (math-reject-arg rate 'nonzerop)) (or (math-objectp num) math-expand-formulas (math-reject-arg num 'numberp)) ) (defun calcFunc-sln (cost salvage life &optional period) (or (math-realp cost) math-expand-formulas (math-reject-arg cost 'realp)) (or (math-realp salvage) math-expand-formulas (math-reject-arg salvage 'realp)) (or (math-realp life) math-expand-formulas (math-reject-arg life 'realp)) (if (math-zerop life) (math-reject-arg life 'nonzerop)) (if (and period (if (math-num-integerp period) (or (Math-lessp life period) (not (math-posp period))) (math-reject-arg period 'integerp))) 0 (math-div (math-sub cost salvage) life)) ) (put 'calcFunc-sln 'math-expandable t) (defun calcFunc-syd (cost salvage life period) (or (math-realp cost) math-expand-formulas (math-reject-arg cost 'realp)) (or (math-realp salvage) math-expand-formulas (math-reject-arg salvage 'realp)) (or (math-realp life) math-expand-formulas (math-reject-arg life 'realp)) (if (math-zerop life) (math-reject-arg life 'nonzerop)) (or (math-realp period) math-expand-formulas (math-reject-arg period 'realp)) (if (or (Math-lessp life period) (not (math-posp period))) 0 (math-div (math-mul (math-sub cost salvage) (math-add (math-sub life period) 1)) (math-div (math-mul life (math-add life 1)) 2))) ) (put 'calcFunc-syd 'math-expandable t) (defun calcFunc-ddb (cost salvage life period) (if (math-messy-integerp period) (setq period (math-trunc period))) (or (integerp period) (math-reject-arg period 'fixnump)) (or (math-realp cost) (math-reject-arg cost 'realp)) (or (math-realp salvage) (math-reject-arg salvage 'realp)) (or (math-realp life) (math-reject-arg life 'realp)) (if (math-zerop life) (math-reject-arg life 'nonzerop)) (if (or (Math-lessp life period) (<= period 0)) 0 (let ((book cost) (res 0)) (while (>= (setq period (1- period)) 0) (setq res (math-div (math-mul book 2) life) book (math-sub book res)) (if (Math-lessp book salvage) (setq res (math-add res (math-sub book salvage)) book salvage))) res)) ) calc-2.02c/calc-mode.el100644 22403 13 51501 5547406510 13214 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-mode.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-mode () nil) (defun calc-line-numbering (n) (interactive "P") (calc-wrapper (message (if (calc-change-mode 'calc-line-numbering n t t) "Displaying stack level numbers." "Hiding stack level numbers."))) ) (defun calc-line-breaking (n) (interactive "P") (calc-wrapper (setq n (if n (and (> (setq n (prefix-numeric-value n)) 0) (or (< n 5) n)) (not calc-line-breaking))) (if (calc-change-mode 'calc-line-breaking n t) (if (integerp calc-line-breaking) (message "Breaking lines longer than %d characters." n) (message "Breaking long lines in Stack display.")) (message "Not breaking long lines in Stack display."))) ) (defun calc-left-justify (n) (interactive "P") (calc-wrapper (and n (setq n (prefix-numeric-value n))) (calc-change-mode '(calc-display-just calc-display-origin) (list nil n) t) (if n (message "Displaying stack entries indented by %d." n) (message "Displaying stack entries left-justified."))) ) (defun calc-center-justify (n) (interactive "P") (calc-wrapper (and n (setq n (prefix-numeric-value n))) (calc-change-mode '(calc-display-just calc-display-origin) (list 'center n) t) (if n (message "Displaying stack entries centered on column %d." n) (message "Displaying stack entries centered in window."))) ) (defun calc-right-justify (n) (interactive "P") (calc-wrapper (and n (setq n (prefix-numeric-value n))) (calc-change-mode '(calc-display-just calc-display-origin) (list 'right n) t) (if n (message "Displaying stack entries right-justified to column %d." n) (message "Displaying stack entries right-justified in window."))) ) (defun calc-left-label (s) (interactive "sLefthand label: ") (calc-wrapper (or (equal s "") (setq s (concat s " "))) (calc-change-mode 'calc-left-label s t)) ) (defun calc-right-label (s) (interactive "sRighthand label: ") (calc-wrapper (or (equal s "") (setq s (concat " " s))) (calc-change-mode 'calc-right-label s t)) ) (defun calc-auto-why (n) (interactive "P") (calc-wrapper (if n (progn (setq n (prefix-numeric-value n)) (if (<= n 0) (setq n nil) (if (> n 1) (setq n t)))) (setq n (and (not (eq calc-auto-why t)) (if calc-auto-why t 1)))) (calc-change-mode 'calc-auto-why n nil) (cond ((null n) (message "User must press `w' to explain unsimplified results.")) ((eq n t) (message "Automatically doing `w' to explain unsimplified results.")) (t (message "Automatically doing `w' only for unusual messages.")))) ) (defun calc-group-digits (n) (interactive "P") (calc-wrapper (if n (progn (setq n (prefix-numeric-value n)) (cond ((or (> n 0) (< n -1))) ((= n -1) (setq n nil)) (t (setq n calc-group-digits)))) (setq n (not calc-group-digits))) (calc-change-mode 'calc-group-digits n t) (cond ((null n) (message "Grouping is off.")) ((integerp n) (message "Grouping every %d digits." (math-abs n))) (t (message "Grouping is on.")))) ) (defun calc-group-char (ch) (interactive "cGrouping character: ") (calc-wrapper (or (>= ch 32) (error "Control characters not allowed for grouping.")) (if (= ch ?\\) (setq ch "\\,") (setq ch (char-to-string ch))) (calc-change-mode 'calc-group-char ch calc-group-digits) (message "Digit grouping character is \"%s\"." ch)) ) (defun calc-point-char (ch) (interactive "cCharacter to use as decimal point: ") (calc-wrapper (or (>= ch 32) (error "Control characters not allowed as decimal point.")) (calc-change-mode 'calc-point-char (char-to-string ch) t) (message "Decimal point character is \"%c\"." ch)) ) (defun calc-normal-notation (n) (interactive "P") (calc-wrapper (calc-change-mode 'calc-float-format (let* ((val (if n (prefix-numeric-value n) 0)) (mode (/ (+ val 5000) 10000))) (if (or (< val -5000) (> mode 3)) (error "Prefix out of range")) (setq n (list (aref [float sci eng fix] mode) (- (% (+ val 5000) 10000) 5000)))) t) (if (eq (nth 1 n) 0) (message "Displaying floating-point numbers normally.") (if (> (nth 1 n) 0) (message "Displaying floating-point numbers with %d significant digits." (nth 1 n)) (message "Displaying floating-point numbers with (precision%d)." (nth 1 n))))) ) (defun calc-fix-notation (n) (interactive "NDigits after decimal point: ") (calc-wrapper (calc-change-mode 'calc-float-format (setq n (list 'fix (if n (prefix-numeric-value n) 0))) t) (message "Displaying floats with %d digits after decimal." (math-abs (nth 1 n)))) ) (defun calc-sci-notation (n) (interactive "P") (calc-wrapper (calc-change-mode 'calc-float-format (setq n (list 'sci (if n (prefix-numeric-value n) 0))) t) (if (eq (nth 1 n) 0) (message "Displaying floats in scientific notation.") (if (> (nth 1 n) 0) (message "Displaying scientific notation with %d significant digits." (nth 1 n)) (message "Displaying scientific notation with (precision%d)." (nth 1 n))))) ) (defun calc-eng-notation (n) (interactive "P") (calc-wrapper (calc-change-mode 'calc-float-format (setq n (list 'eng (if n (prefix-numeric-value n) 0))) t) (if (eq (nth 1 n) 0) (message "Displaying floats in engineering notation.") (if (> (nth 1 n) 0) (message "Displaying engineering notation with %d significant digits." (nth 1 n)) (message "Displaying engineering notation with (precision%d)." (nth 1 n))))) ) (defun calc-truncate-stack (n &optional rel) (interactive "P") (calc-wrapper (let ((oldtop calc-stack-top) (newtop calc-stack-top)) (calc-record-undo (list 'set 'saved-stack-top calc-stack-top)) (let ((calc-stack-top 0) (nn (prefix-numeric-value n))) (setq newtop (if n (progn (if rel (setq nn (+ oldtop nn)) (if (< nn 0) (setq nn (+ nn (calc-stack-size))) (setq nn (1+ nn)))) (if (< nn 1) 1 (if (> nn (calc-stack-size)) (calc-stack-size) nn))) (max 1 (calc-locate-cursor-element (point))))) (if (= newtop oldtop) () (calc-pop-stack 1 oldtop t) (calc-push-list '(top-of-stack) newtop) (if calc-line-numbering (calc-refresh)))) (calc-record-undo (list 'set 'saved-stack-top 0)) (setq calc-stack-top newtop))) ) (defun calc-truncate-up (n) (interactive "p") (calc-truncate-stack n t) ) (defun calc-truncate-down (n) (interactive "p") (calc-truncate-stack (- n) t) ) (defun calc-display-raw (arg) (interactive "P") (calc-wrapper (setq calc-display-raw (if calc-display-raw nil (if arg 0 t))) (calc-do-refresh) (if calc-display-raw (message "Press d ' again to cancel \"raw\" display mode."))) ) ;;; Mode commands. (defun calc-save-modes (&optional quiet) (interactive) (calc-wrapper (let (pos (vals (mapcar (function (lambda (v) (symbol-value (car v)))) calc-mode-var-list))) (set-buffer (find-file-noselect (substitute-in-file-name calc-settings-file))) (goto-char (point-min)) (if (and (search-forward ";;; Mode settings stored by Calc" nil t) (progn (beginning-of-line) (setq pos (point)) (search-forward "\n;;; End of mode settings" nil t))) (progn (beginning-of-line) (forward-line 1) (delete-region pos (point))) (goto-char (point-max)) (insert "\n\n") (forward-char -1)) (insert ";;; Mode settings stored by Calc on " (current-time-string) "\n") (let ((list calc-mode-var-list)) (while list (let* ((v (car (car list))) (def (nth 1 (car list))) (val (car vals))) (or (equal val def) (progn (insert "(setq " (symbol-name v) " ") (if (and (or (listp val) (symbolp val)) (not (memq val '(nil t)))) (insert "'")) (insert (prin1-to-string val) ")\n")))) (setq list (cdr list) vals (cdr vals)))) (run-hooks 'calc-mode-save-hook) (insert ";;; End of mode settings\n") (if quiet (let ((executing-macro "")) ; what a kludge! (save-buffer)) (save-buffer)))) ) (defun calc-settings-file-name (name &optional arg) (interactive "sSettings file name (normally ~/.emacs): \nP") (calc-wrapper (setq arg (if arg (prefix-numeric-value arg) 0)) (if (equal name "") (message "Calc settings file is \"%s\"" calc-settings-file) (if (< (math-abs arg) 2) (let ((list calc-mode-var-list)) (while list (set (car (car list)) (nth 1 (car list))) (setq list (cdr list))))) (setq calc-settings-file name) (or (and (string-match "\\.emacs" calc-settings-file) (> arg 0)) (< arg 0) (load name t) (message "New file")))) ) (defun math-get-modes-vec () (list 'vec calc-internal-prec calc-word-size (calc-stack-size) calc-number-radix (+ (if (<= (nth 1 calc-float-format) 0) (+ calc-internal-prec (nth 1 calc-float-format)) (nth 1 calc-float-format)) (cdr (assq (car calc-float-format) '((float . 0) (sci . 10000) (eng . 20000) (fix . 30000))))) (cond ((eq calc-angle-mode 'rad) 2) ((eq calc-angle-mode 'hms) 3) (t 1)) (if calc-symbolic-mode 1 0) (if calc-prefer-frac 1 0) (if (eq calc-complex-mode 'polar) 1 0) (cond ((eq calc-matrix-mode 'scalar) 0) ((eq calc-matrix-mode 'matrix) -2) (calc-matrix-mode) (t -1)) (cond ((eq calc-simplify-mode 'none) -1) ((eq calc-simplify-mode 'num) 0) ((eq calc-simplify-mode 'binary) 2) ((eq calc-simplify-mode 'alg) 3) ((eq calc-simplify-mode 'ext) 4) ((eq calc-simplify-mode 'units) 5) (t 1)) (cond ((eq calc-infinite-mode 1) 0) (calc-infinite-mode 1) (t -1))) ) (defun calc-get-modes (n) (interactive "P") (calc-wrapper (let ((modes (math-get-modes-vec))) (calc-enter-result 0 "mode" (if n (if (and (>= (setq n (prefix-numeric-value n)) 1) (< n (length modes))) (nth n modes) (error "Prefix out of range")) modes)))) ) (defun calc-shift-prefix (arg) (interactive "P") (calc-wrapper (setq calc-shift-prefix (if arg (> (prefix-numeric-value arg) 0) (not calc-shift-prefix))) (calc-init-prefixes) (message (if calc-shift-prefix "Prefix keys are now case-insensitive" "Prefix keys must be unshifted (except V, Z)"))) ) (defun calc-mode-record-mode (n) (interactive "P") (calc-wrapper (calc-change-mode 'calc-mode-save-mode (cond ((null n) (cond ((not calc-embedded-info) (if (eq calc-mode-save-mode 'save) 'local 'save)) ((eq calc-mode-save-mode 'local) 'edit) ((eq calc-mode-save-mode 'edit) 'perm) ((eq calc-mode-save-mode 'perm) 'global) ((eq calc-mode-save-mode 'global) 'save) ((eq calc-mode-save-mode 'save) nil) ((eq calc-mode-save-mode nil) 'local))) ((= (setq n (prefix-numeric-value n)) 0) nil) ((= n 2) 'edit) ((= n 3) 'perm) ((= n 4) 'global) ((= n 5) 'save) (t 'local))) (message (cond ((and (eq calc-mode-save-mode 'local) calc-embedded-info) "Recording mode changes with [calc-mode: ...]") ((eq calc-mode-save-mode 'edit) "Recording mode changes with [calc-edit-mode: ...]") ((eq calc-mode-save-mode 'perm) "Recording mode changes with [calc-perm-mode: ...]") ((eq calc-mode-save-mode 'global) "Recording mode changes with [calc-global-mode: ...]") ((eq calc-mode-save-mode 'save) (format "Recording mode changes in \"%s\"." calc-settings-file)) (t "Not recording mode changes permanently.")))) ) (defun calc-total-algebraic-mode (flag) (interactive "P") (if calc-emacs-type-19 (error "Total algebraic mode not yet supported for Emacs 19")) (calc-wrapper (if (eq calc-algebraic-mode 'total) (calc-algebraic-mode nil) (calc-change-mode '(calc-algebraic-mode calc-incomplete-algebraic-mode) '(total nil)) (use-local-map calc-alg-map) (message "All keys begin algebraic entry; use Meta (ESC) for Calc keys."))) ) (defun calc-algebraic-mode (flag) (interactive "P") (calc-wrapper (if flag (calc-change-mode '(calc-algebraic-mode calc-incomplete-algebraic-mode) (list nil (not calc-incomplete-algebraic-mode))) (calc-change-mode '(calc-algebraic-mode calc-incomplete-algebraic-mode) (list (not calc-algebraic-mode) nil))) (use-local-map calc-mode-map) (message (if calc-algebraic-mode "Numeric keys and ( and [ begin algebraic entry." (if calc-incomplete-algebraic-mode "Only ( and [ begin algebraic entry." "No keys except ' and $ begin algebraic entry.")))) ) (defun calc-symbolic-mode (n) (interactive "P") (calc-wrapper (message (if (calc-change-mode 'calc-symbolic-mode n nil t) "Inexact computations like sqrt(2) are deferred." "Numerical computations are always done immediately."))) ) (defun calc-infinite-mode (n) (interactive "P") (calc-wrapper (if (eq n 0) (progn (calc-change-mode 'calc-infinite-mode 1) (message "Computations like 1 / 0 produce \"inf\".")) (message (if (calc-change-mode 'calc-infinite-mode n nil t) "Computations like 1 / 0 produce \"uinf\"." "Computations like 1 / 0 are left unsimplified.")))) ) (defun calc-matrix-mode (arg) (interactive "P") (calc-wrapper (calc-change-mode 'calc-matrix-mode (cond ((eq arg 0) 'scalar) ((< (prefix-numeric-value arg) 1) (and (< (prefix-numeric-value arg) -1) 'matrix)) (arg (prefix-numeric-value arg)) ((eq calc-matrix-mode 'matrix) 'scalar) ((eq calc-matrix-mode 'scalar) nil) (t 'matrix))) (if (integerp calc-matrix-mode) (message "Variables are assumed to be %dx%d matrices." calc-matrix-mode calc-matrix-mode) (message (if (eq calc-matrix-mode 'matrix) "Variables are assumed to be matrices." (if calc-matrix-mode "Variables are assumed to be scalars (non-matrices)." "Variables are not assumed to be matrix or scalar."))))) ) (defun calc-set-simplify-mode (mode arg msg) (calc-change-mode 'calc-simplify-mode (if arg (and (> (prefix-numeric-value arg) 0) mode) (and (not (eq calc-simplify-mode mode)) mode))) (message (if (eq calc-simplify-mode mode) msg "Default simplifications enabled.")) ) (defun calc-no-simplify-mode (arg) (interactive "P") (calc-wrapper (calc-set-simplify-mode 'none arg "All default simplifications are disabled.")) ) (defun calc-num-simplify-mode (arg) (interactive "P") (calc-wrapper (calc-set-simplify-mode 'num arg "Default simplifications apply only if arguments are numeric.")) ) (defun calc-default-simplify-mode (arg) (interactive "p") (cond ((= arg 1) (calc-wrapper (calc-set-simplify-mode nil nil "Usual default simplifications are enabled."))) ((= arg 0) (calc-num-simplify-mode 1)) ((< arg 0) (calc-no-simplify-mode 1)) ((= arg 2) (calc-bin-simplify-mode 1)) ((= arg 3) (calc-alg-simplify-mode 1)) ((= arg 4) (calc-ext-simplify-mode 1)) ((= arg 5) (calc-units-simplify-mode 1)) (t (error "Prefix argument out of range"))) ) (defun calc-bin-simplify-mode (arg) (interactive "P") (calc-wrapper (calc-set-simplify-mode 'binary arg (format "Binary simplification occurs by default (word size=%d)." calc-word-size))) ) (defun calc-alg-simplify-mode (arg) (interactive "P") (calc-wrapper (calc-set-simplify-mode 'alg arg "Algebraic simplification occurs by default.")) ) (defun calc-ext-simplify-mode (arg) (interactive "P") (calc-wrapper (calc-set-simplify-mode 'ext arg "Extended algebraic simplification occurs by default.")) ) (defun calc-units-simplify-mode (arg) (interactive "P") (calc-wrapper (calc-set-simplify-mode 'units arg "Units simplification occurs by default.")) ) (defun calc-auto-recompute (arg) (interactive "P") (calc-wrapper (calc-change-mode 'calc-auto-recompute arg nil t) (calc-refresh-evaltos) (message (if calc-auto-recompute "Automatically recomputing `=>' forms when necessary." "Not recomputing `=>' forms automatically."))) ) (defun calc-working (n) (interactive "P") (calc-wrapper (cond ((consp n) (calc-pop-push-record 0 "work" (cond ((eq calc-display-working-message t) 1) (calc-display-working-message 2) (t 0)))) ((eq n 2) (calc-change-mode 'calc-display-working-message 'lots)) ((eq n 0) (calc-change-mode 'calc-display-working-message nil)) ((eq n 1) (calc-change-mode 'calc-display-working-message t))) (cond ((eq calc-display-working-message t) (message "\"Working...\" messages enabled.")) (calc-display-working-message (message "Detailed \"Working...\" messages enabled.")) (t (message "\"Working...\" messages disabled.")))) ) (defun calc-always-load-extensions () (interactive) (calc-wrapper (if (setq calc-always-load-extensions (not calc-always-load-extensions)) (message "Always loading extensions package.") (message "Loading extensions package on demand only."))) ) (defun calc-matrix-left-justify () (interactive) (calc-wrapper (calc-change-mode 'calc-matrix-just nil t) (message "Matrix elements will be left-justified in columns.")) ) (defun calc-matrix-center-justify () (interactive) (calc-wrapper (calc-change-mode 'calc-matrix-just 'center t) (message "Matrix elements will be centered in columns.")) ) (defun calc-matrix-right-justify () (interactive) (calc-wrapper (calc-change-mode 'calc-matrix-just 'right t) (message "Matrix elements will be right-justified in columns.")) ) (defun calc-full-vectors (n) (interactive "P") (calc-wrapper (message (if (calc-change-mode 'calc-full-vectors n t t) "Displaying long vectors in full." "Displaying long vectors in [a, b, c, ..., z] notation."))) ) (defun calc-full-trail-vectors (n) (interactive "P") (calc-wrapper (message (if (calc-change-mode 'calc-full-trail-vectors n nil t) "Recording long vectors in full." "Recording long vectors in [a, b, c, ..., z] notation."))) ) (defun calc-break-vectors (n) (interactive "P") (calc-wrapper (message (if (calc-change-mode 'calc-break-vectors n t t) "Displaying vector elements one-per-line." "Displaying vector elements all on one line."))) ) (defun calc-vector-commas () (interactive) (calc-wrapper (if (calc-change-mode 'calc-vector-commas (if calc-vector-commas nil ",") t) (message "Separating vector elements with \",\".") (message "Separating vector elements with spaces."))) ) (defun calc-vector-brackets () (interactive) (calc-wrapper (if (calc-change-mode 'calc-vector-brackets (if (equal calc-vector-brackets "[]") nil "[]") t) (message "Surrounding vectors with \"[]\".") (message "Not surrounding vectors with brackets."))) ) (defun calc-vector-braces () (interactive) (calc-wrapper (if (calc-change-mode 'calc-vector-brackets (if (equal calc-vector-brackets "{}") nil "{}") t) (message "Surrounding vectors with \"{}\".") (message "Not surrounding vectors with brackets."))) ) (defun calc-vector-parens () (interactive) (calc-wrapper (if (calc-change-mode 'calc-vector-brackets (if (equal calc-vector-brackets "()") nil "()") t) (message "Surrounding vectors with \"()\".") (message "Not surrounding vectors with brackets."))) ) (defun calc-matrix-brackets (arg) (interactive "sCode letters (R, O, C, P): ") (calc-wrapper (let ((code (append (and (string-match "[rR]" arg) '(R)) (and (string-match "[oO]" arg) '(O)) (and (string-match "[cC]" arg) '(C)) (and (string-match "[pP]" arg) '(P)))) (bad (string-match "[^rRoOcCpP ]" arg))) (if bad (error "Unrecognized character: %c" (aref arg bad))) (calc-change-mode 'calc-matrix-brackets code t))) ) calc-2.02c/calc-vec.el100644 22403 13 133500 5402631010 13046 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-vec.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-vec () nil) (defun calc-display-strings (n) (interactive "P") (calc-wrapper (message (if (calc-change-mode 'calc-display-strings n t t) "Displaying vectors of integers as quoted strings." "Displaying vectors of integers normally."))) ) (defun calc-pack (n) (interactive "P") (calc-wrapper (let* ((nn (if n 1 2)) (mode (if n (prefix-numeric-value n) (calc-top-n 1))) (mode (if (and (Math-vectorp mode) (cdr mode)) (cdr mode) (if (integerp mode) mode (error "Packing mode must be an integer or vector of integers")))) (num (calc-pack-size mode)) (items (calc-top-list num nn))) (calc-enter-result (+ nn num -1) "pack" (calc-pack-items mode items)))) ) (defun calc-pack-size (mode) (cond ((consp mode) (let ((size 1)) (while mode (or (integerp (car mode)) (error "Vector of integers expected")) (setq size (* size (calc-pack-size (car mode))) mode (cdr mode))) (if (= size 0) (error "Zero dimensions not allowed") size))) ((>= mode 0) mode) (t (or (cdr (assq mode '((-3 . 3) (-13 . 1) (-14 . 3) (-15 . 6)))) 2))) ) (defun calc-pack-items (mode items) (cond ((consp mode) (if (cdr mode) (let* ((size (calc-pack-size (cdr mode))) (len (length items)) (new nil) p row) (while (> len 0) (setq p (nthcdr (1- size) items) row items items (cdr p) len (- len size)) (setcdr p nil) (setq new (cons (calc-pack-items (cdr mode) row) new))) (calc-pack-items (car mode) (nreverse new))) (calc-pack-items (car mode) items))) ((>= mode 0) (cons 'vec items)) ((= mode -3) (if (and (math-objvecp (car items)) (math-objvecp (nth 1 items)) (math-objvecp (nth 2 items))) (if (and (math-num-integerp (car items)) (math-num-integerp (nth 1 items))) (if (math-realp (nth 2 items)) (cons 'hms items) (error "Seconds must be real")) (error "Hours and minutes must be integers")) (math-normalize (list '+ (list '+ (if (eq calc-angle-mode 'rad) (list '* (car items) '(hms 1 0 0)) (car items)) (list '* (nth 1 items) '(hms 0 1 0))) (list '* (nth 2 items) '(hms 0 0 1)))))) ((= mode -13) (if (math-realp (car items)) (cons 'date items) (if (eq (car-safe (car items)) 'date) (car items) (if (math-objvecp (car items)) (error "Date value must be real") (cons 'calcFunc-date items))))) ((memq mode '(-14 -15)) (let ((p items)) (while (and p (math-objvecp (car p))) (or (math-integerp (car p)) (error "Components must be integers")) (setq p (cdr p))) (if p (cons 'calcFunc-date items) (list 'date (math-dt-to-date items))))) ((or (eq (car-safe (car items)) 'vec) (eq (car-safe (nth 1 items)) 'vec)) (let* ((x (car items)) (vx (eq (car-safe x) 'vec)) (y (nth 1 items)) (vy (eq (car-safe y) 'vec)) (z nil) (n (1- (length (if vx x y))))) (and vx vy (/= n (1- (length y))) (error "Vectors must be the same length")) (while (>= (setq n (1- n)) 0) (setq z (cons (calc-pack-items mode (list (if vx (car (setq x (cdr x))) x) (if vy (car (setq y (cdr y))) y))) z))) (cons 'vec (nreverse z)))) ((= mode -1) (if (and (math-realp (car items)) (math-realp (nth 1 items))) (cons 'cplx items) (if (and (math-objectp (car items)) (math-objectp (nth 1 items))) (error "Components must be real")) (math-normalize (list '+ (car items) (list '* (nth 1 items) '(cplx 0 1)))))) ((= mode -2) (if (and (math-realp (car items)) (math-anglep (nth 1 items))) (cons 'polar items) (if (and (math-objectp (car items)) (math-objectp (nth 1 items))) (error "Components must be real")) (math-normalize (list '* (car items) (if (math-anglep (nth 1 items)) (list 'polar 1 (nth 1 items)) (list 'calcFunc-exp (list '* (math-to-radians-2 (nth 1 items)) (list 'polar 1 (math-quarter-circle nil))))))))) ((= mode -4) (let ((x (car items)) (sigma (nth 1 items))) (if (or (math-scalarp x) (not (math-objvecp x))) (if (or (math-anglep sigma) (not (math-objvecp sigma))) (math-make-sdev x sigma) (error "Error component must be real")) (error "Mean component must be real or complex")))) ((= mode -5) (let ((a (car items)) (m (nth 1 items))) (if (and (math-anglep a) (math-anglep m)) (if (math-posp m) (math-make-mod a m) (error "Modulus must be positive")) (if (and (math-objectp a) (math-objectp m)) (error "Components must be real")) (list 'calcFunc-makemod a m)))) ((memq mode '(-6 -7 -8 -9)) (let ((lo (car items)) (hi (nth 1 items))) (if (and (or (math-anglep lo) (eq (car lo) 'date) (not (math-objvecp lo))) (or (math-anglep hi) (eq (car hi) 'date) (not (math-objvecp hi)))) (math-make-intv (+ mode 9) lo hi) (error "Components must be real")))) ((eq mode -10) (if (math-zerop (nth 1 items)) (error "Denominator must not be zero") (if (and (math-integerp (car items)) (math-integerp (nth 1 items))) (math-normalize (cons 'frac items)) (if (and (math-objectp (car items)) (math-objectp (nth 1 items))) (error "Components must be integers")) (cons 'calcFunc-fdiv items)))) ((memq mode '(-11 -12)) (if (and (math-realp (car items)) (math-integerp (nth 1 items))) (calcFunc-scf (math-float (car items)) (nth 1 items)) (if (and (math-objectp (car items)) (math-objectp (nth 1 items))) (error "Components must be integers")) (math-normalize (list 'calcFunc-scf (list 'calcFunc-float (car items)) (nth 1 items))))) (t (error "Invalid packing mode: %d" mode))) ) (defun calc-unpack (mode) (interactive "P") (calc-wrapper (let ((calc-unpack-with-type t)) (calc-pop-push-record-list 1 "unpk" (calc-unpack-item (and mode (prefix-numeric-value mode)) (calc-top))))) ) (defun calc-unpack-type (item) (cond ((eq (car-safe item) 'vec) (1- (length item))) ((eq (car-safe item) 'intv) (- (nth 1 item) 9)) (t (or (cdr (assq (car-safe item) '( (cplx . -1) (polar . -2) (hms . -3) (sdev . -4) (mod . -5) (frac . -10) (float . -11) (date . -13) ))) (error "Argument must be a composite object")))) ) (defun calc-unpack-item (mode item) (cond ((not mode) (if (or (and (not (memq (car-safe item) '(frac float cplx polar vec hms date sdev mod intv))) (math-objvecp item)) (eq (car-safe item) 'var)) (error "Argument must be a composite object or function call")) (if (eq (car item) 'intv) (cdr (cdr item)) (cdr item))) ((> mode 0) (let ((dims nil) type new row) (setq item (list item)) (while (> mode 0) (setq type (calc-unpack-type (car item)) dims (cons type dims) new (calc-unpack-item nil (car item))) (while (setq item (cdr item)) (or (= (calc-unpack-type (car item)) type) (error "Inconsistent types or dimensions in vector elements")) (setq new (append new (calc-unpack-item nil (car item))))) (setq item new mode (1- mode))) (if (cdr dims) (setq dims (list (cons 'vec (nreverse dims))))) (cond ((eq calc-unpack-with-type 'pair) (list (car dims) (cons 'vec item))) (calc-unpack-with-type (append item dims)) (t item)))) ((eq calc-unpack-with-type 'pair) (let ((calc-unpack-with-type nil)) (list mode (cons 'vec (calc-unpack-item mode item))))) ((= mode -3) (if (eq (car-safe item) 'hms) (cdr item) (error "Argument must be an HMS form"))) ((= mode -13) (if (eq (car-safe item) 'date) (cdr item) (error "Argument must be a date form"))) ((= mode -14) (if (eq (car-safe item) 'date) (math-date-to-dt (math-floor (nth 1 item))) (error "Argument must be a date form"))) ((= mode -15) (if (eq (car-safe item) 'date) (append (math-date-to-dt (nth 1 item)) (and (not (math-integerp (nth 1 item))) (list 0 0 0))) (error "Argument must be a date form"))) ((eq (car-safe item) 'vec) (let ((x nil) (y nil) res) (while (setq item (cdr item)) (setq res (calc-unpack-item mode (car item)) x (cons (car res) x) y (cons (nth 1 res) y))) (list (cons 'vec (nreverse x)) (cons 'vec (nreverse y))))) ((= mode -1) (if (eq (car-safe item) 'cplx) (cdr item) (if (eq (car-safe item) 'polar) (cdr (math-complex item)) (if (Math-realp item) (list item 0) (error "Argument must be a complex number"))))) ((= mode -2) (if (or (memq (car-safe item) '(cplx polar)) (Math-realp item)) (cdr (math-polar item)) (error "Argument must be a complex number"))) ((= mode -4) (if (eq (car-safe item) 'sdev) (cdr item) (list item 0))) ((= mode -5) (if (eq (car-safe item) 'mod) (cdr item) (error "Argument must be a modulo form"))) ((memq mode '(-6 -7 -8 -9)) (if (eq (car-safe item) 'intv) (cdr (cdr item)) (list item item))) ((= mode -10) (if (eq (car-safe item) 'frac) (cdr item) (if (Math-integerp item) (list item 1) (error "Argument must be a rational number")))) ((= mode -11) (if (eq (car-safe item) 'float) (list (nth 1 item) (math-normalize (nth 2 item))) (error "Expected a floating-point number"))) ((= mode -12) (if (eq (car-safe item) 'float) (list (calcFunc-mant item) (calcFunc-xpon item)) (error "Expected a floating-point number"))) (t (error "Invalid unpacking mode: %d" mode))) ) (setq calc-unpack-with-type nil) (defun calc-diag (n) (interactive "P") (calc-wrapper (calc-enter-result 1 "diag" (if n (list 'calcFunc-diag (calc-top-n 1) (prefix-numeric-value n)) (list 'calcFunc-diag (calc-top-n 1))))) ) (defun calc-ident (n) (interactive "NDimension of identity matrix = ") (calc-wrapper (calc-enter-result 0 "idn" (if (eq n 0) '(calcFunc-idn 1) (list 'calcFunc-idn 1 (prefix-numeric-value n))))) ) (defun calc-index (n &optional stack) (interactive "NSize of vector = \nP") (calc-wrapper (if (consp stack) (calc-enter-result 3 "indx" (cons 'calcFunc-index (calc-top-list-n 3))) (calc-enter-result 0 "indx" (list 'calcFunc-index (prefix-numeric-value n))))) ) (defun calc-build-vector (n) (interactive "NSize of vector = ") (calc-wrapper (calc-enter-result 1 "bldv" (list 'calcFunc-cvec (calc-top-n 1) (prefix-numeric-value n)))) ) (defun calc-cons (arg) (interactive "P") (calc-wrapper (if (calc-is-hyperbolic) (calc-binary-op "rcns" 'calcFunc-rcons arg) (calc-binary-op "cons" 'calcFunc-cons arg))) ) (defun calc-head (arg) (interactive "P") (calc-wrapper (if (calc-is-inverse) (if (calc-is-hyperbolic) (calc-unary-op "rtai" 'calcFunc-rtail arg) (calc-unary-op "tail" 'calcFunc-tail arg)) (if (calc-is-hyperbolic) (calc-unary-op "rhed" 'calcFunc-rhead arg) (calc-unary-op "head" 'calcFunc-head arg)))) ) (defun calc-tail (arg) (interactive "P") (calc-invert-func) (calc-head arg) ) (defun calc-vlength (arg) (interactive "P") (calc-wrapper (if (calc-is-hyperbolic) (calc-unary-op "dims" 'calcFunc-mdims arg) (calc-unary-op "len" 'calcFunc-vlen arg))) ) (defun calc-arrange-vector (n) (interactive "NNumber of columns = ") (calc-wrapper (calc-enter-result 1 "arng" (list 'calcFunc-arrange (calc-top-n 1) (prefix-numeric-value n)))) ) (defun calc-vector-find (arg) (interactive "P") (calc-wrapper (let ((func (cons 'calcFunc-find (calc-top-list-n 2)))) (calc-enter-result 2 "find" (if arg (append func (list (prefix-numeric-value arg))) func)))) ) (defun calc-subvector () (interactive) (calc-wrapper (if (calc-is-inverse) (calc-enter-result 3 "rsvc" (cons 'calcFunc-rsubvec (calc-top-list-n 3))) (calc-enter-result 3 "svec" (cons 'calcFunc-subvec (calc-top-list-n 3))))) ) (defun calc-reverse-vector (arg) (interactive "P") (calc-wrapper (calc-unary-op "rev" 'calcFunc-rev arg)) ) (defun calc-mask-vector (arg) (interactive "P") (calc-wrapper (calc-binary-op "vmsk" 'calcFunc-vmask arg)) ) (defun calc-expand-vector (arg) (interactive "P") (calc-wrapper (if (calc-is-hyperbolic) (calc-enter-result 3 "vexp" (cons 'calcFunc-vexp (calc-top-list-n 3))) (calc-binary-op "vexp" 'calcFunc-vexp arg))) ) (defun calc-sort () (interactive) (calc-slow-wrapper (if (calc-is-inverse) (calc-enter-result 1 "rsrt" (list 'calcFunc-rsort (calc-top-n 1))) (calc-enter-result 1 "sort" (list 'calcFunc-sort (calc-top-n 1))))) ) (defun calc-grade () (interactive) (calc-slow-wrapper (if (calc-is-inverse) (calc-enter-result 1 "rgrd" (list 'calcFunc-rgrade (calc-top-n 1))) (calc-enter-result 1 "grad" (list 'calcFunc-grade (calc-top-n 1))))) ) (defun calc-histogram (n) (interactive "NNumber of bins: ") (calc-slow-wrapper (if calc-hyperbolic-flag (calc-enter-result 2 "hist" (list 'calcFunc-histogram (calc-top-n 2) (calc-top-n 1) (prefix-numeric-value n))) (calc-enter-result 1 "hist" (list 'calcFunc-histogram (calc-top-n 1) (prefix-numeric-value n))))) ) (defun calc-transpose (arg) (interactive "P") (calc-wrapper (calc-unary-op "trn" 'calcFunc-trn arg)) ) (defun calc-conj-transpose (arg) (interactive "P") (calc-wrapper (calc-unary-op "ctrn" 'calcFunc-ctrn arg)) ) (defun calc-cross (arg) (interactive "P") (calc-wrapper (calc-binary-op "cros" 'calcFunc-cross arg)) ) (defun calc-remove-duplicates (arg) (interactive "P") (calc-wrapper (calc-unary-op "rdup" 'calcFunc-rdup arg)) ) (defun calc-set-union (arg) (interactive "P") (calc-wrapper (calc-binary-op "unio" 'calcFunc-vunion arg '(vec) 'calcFunc-rdup)) ) (defun calc-set-intersect (arg) (interactive "P") (calc-wrapper (calc-binary-op "intr" 'calcFunc-vint arg '(vec) 'calcFunc-rdup)) ) (defun calc-set-difference (arg) (interactive "P") (calc-wrapper (calc-binary-op "diff" 'calcFunc-vdiff arg '(vec) 'calcFunc-rdup)) ) (defun calc-set-xor (arg) (interactive "P") (calc-wrapper (calc-binary-op "xor" 'calcFunc-vxor arg '(vec) 'calcFunc-rdup)) ) (defun calc-set-complement (arg) (interactive "P") (calc-wrapper (calc-unary-op "cmpl" 'calcFunc-vcompl arg)) ) (defun calc-set-floor (arg) (interactive "P") (calc-wrapper (calc-unary-op "vflr" 'calcFunc-vfloor arg)) ) (defun calc-set-enumerate (arg) (interactive "P") (calc-wrapper (calc-unary-op "enum" 'calcFunc-venum arg)) ) (defun calc-set-span (arg) (interactive "P") (calc-wrapper (calc-unary-op "span" 'calcFunc-vspan arg)) ) (defun calc-set-cardinality (arg) (interactive "P") (calc-wrapper (calc-unary-op "card" 'calcFunc-vcard arg)) ) (defun calc-unpack-bits (arg) (interactive "P") (calc-wrapper (if (calc-is-inverse) (calc-unary-op "bpck" 'calcFunc-vpack arg) (calc-unary-op "bupk" 'calcFunc-vunpack arg))) ) (defun calc-pack-bits (arg) (interactive "P") (calc-invert-func) (calc-unpack-bits arg) ) (defun calc-rnorm (arg) (interactive "P") (calc-wrapper (calc-unary-op "rnrm" 'calcFunc-rnorm arg)) ) (defun calc-cnorm (arg) (interactive "P") (calc-wrapper (calc-unary-op "cnrm" 'calcFunc-cnorm arg)) ) (defun calc-mrow (n &optional nn) (interactive "NRow number: \nP") (calc-wrapper (if (consp nn) (calc-enter-result 2 "mrow" (cons 'calcFunc-mrow (calc-top-list-n 2))) (setq n (prefix-numeric-value n)) (if (= n 0) (calc-enter-result 1 "getd" (list 'calcFunc-getdiag (calc-top-n 1))) (if (< n 0) (calc-enter-result 1 "rrow" (list 'calcFunc-mrrow (calc-top-n 1) (- n))) (calc-enter-result 1 "mrow" (list 'calcFunc-mrow (calc-top-n 1) n)))))) ) (defun calc-mcol (n &optional nn) (interactive "NColumn number: \nP") (calc-wrapper (if (consp nn) (calc-enter-result 2 "mcol" (cons 'calcFunc-mcol (calc-top-list-n 2))) (setq n (prefix-numeric-value n)) (if (= n 0) (calc-enter-result 1 "getd" (list 'calcFunc-getdiag (calc-top-n 1))) (if (< n 0) (calc-enter-result 1 "rcol" (list 'calcFunc-mrcol (calc-top-n 1) (- n))) (calc-enter-result 1 "mcol" (list 'calcFunc-mcol (calc-top-n 1) n)))))) ) ;;;; Vectors. (defun calcFunc-mdims (m) (or (math-vectorp m) (math-reject-arg m 'vectorp)) (cons 'vec (math-mat-dimens m)) ) ;;; Apply a function elementwise to vector A. [V X V; N X N] [Public] (defun math-map-vec (f a) (if (math-vectorp a) (cons 'vec (mapcar f (cdr a))) (funcall f a)) ) (defun math-dimension-error () (calc-record-why "*Dimension error") (signal 'wrong-type-argument nil) ) ;;; Build a vector out of a list of objects. [Public] (defun calcFunc-vec (&rest objs) (cons 'vec objs) ) ;;; Build a constant vector or matrix. [Public] (defun calcFunc-cvec (obj &rest dims) (math-make-vec-dimen obj dims) ) (defun math-make-vec-dimen (obj dims) (if dims (if (natnump (car dims)) (if (or (cdr dims) (not (math-numberp obj))) (cons 'vec (copy-sequence (make-list (car dims) (math-make-vec-dimen obj (cdr dims))))) (cons 'vec (make-list (car dims) obj))) (math-reject-arg (car dims) 'fixnatnump)) obj) ) (defun calcFunc-head (vec) (if (and (Math-vectorp vec) (cdr vec)) (nth 1 vec) (calc-record-why 'vectorp vec) (list 'calcFunc-head vec)) ) (defun calcFunc-tail (vec) (if (and (Math-vectorp vec) (cdr vec)) (cons 'vec (cdr (cdr vec))) (calc-record-why 'vectorp vec) (list 'calcFunc-tail vec)) ) (defun calcFunc-cons (head tail) (if (Math-vectorp tail) (cons 'vec (cons head (cdr tail))) (calc-record-why 'vectorp tail) (list 'calcFunc-cons head tail)) ) (defun calcFunc-rhead (vec) (if (and (Math-vectorp vec) (cdr vec)) (let ((vec (copy-sequence vec))) (setcdr (nthcdr (- (length vec) 2) vec) nil) vec) (calc-record-why 'vectorp vec) (list 'calcFunc-rhead vec)) ) (defun calcFunc-rtail (vec) (if (and (Math-vectorp vec) (cdr vec)) (nth (1- (length vec)) vec) (calc-record-why 'vectorp vec) (list 'calcFunc-rtail vec)) ) (defun calcFunc-rcons (head tail) (if (Math-vectorp head) (append head (list tail)) (calc-record-why 'vectorp head) (list 'calcFunc-rcons head tail)) ) ;;; Apply a function elementwise to vectors A and B. [O X O O] [Public] (defun math-map-vec-2 (f a b) (if (math-vectorp a) (if (math-vectorp b) (let ((v nil)) (while (setq a (cdr a)) (or (setq b (cdr b)) (math-dimension-error)) (setq v (cons (funcall f (car a) (car b)) v))) (if a (math-dimension-error)) (cons 'vec (nreverse v))) (let ((v nil)) (while (setq a (cdr a)) (setq v (cons (funcall f (car a) b) v))) (cons 'vec (nreverse v)))) (if (math-vectorp b) (let ((v nil)) (while (setq b (cdr b)) (setq v (cons (funcall f a (car b)) v))) (cons 'vec (nreverse v))) (funcall f a b))) ) ;;; "Reduce" a function over a vector (left-associatively). [O X V] [Public] (defun math-reduce-vec (f a) (if (math-vectorp a) (if (cdr a) (let ((accum (car (setq a (cdr a))))) (while (setq a (cdr a)) (setq accum (funcall f accum (car a)))) accum) 0) a) ) ;;; Reduce a function over the columns of matrix A. [V X V] [Public] (defun math-reduce-cols (f a) (if (math-matrixp a) (cons 'vec (math-reduce-cols-col-step f (cdr a) 1 (length (nth 1 a)))) a) ) (defun math-reduce-cols-col-step (f a col cols) (and (< col cols) (cons (math-reduce-cols-row-step f (nth col (car a)) col (cdr a)) (math-reduce-cols-col-step f a (1+ col) cols))) ) (defun math-reduce-cols-row-step (f tot col a) (if a (math-reduce-cols-row-step f (funcall f tot (nth col (car a))) col (cdr a)) tot) ) (defun math-dot-product (a b) (if (setq a (cdr a) b (cdr b)) (let ((accum (math-mul (car a) (car b)))) (while (setq a (cdr a) b (cdr b)) (setq accum (math-add accum (math-mul (car a) (car b))))) accum) 0) ) ;;; Return the number of elements in vector V. [Public] (defun calcFunc-vlen (v) (if (math-vectorp v) (1- (length v)) (if (math-objectp v) 0 (list 'calcFunc-vlen v))) ) ;;; Get the Nth row of a matrix. (defun calcFunc-mrow (mat n) ; [Public] (if (Math-vectorp n) (math-map-vec (function (lambda (x) (calcFunc-mrow mat x))) n) (if (and (eq (car-safe n) 'intv) (math-constp n)) (calcFunc-subvec mat (math-add (nth 2 n) (if (memq (nth 1 n) '(2 3)) 0 1)) (math-add (nth 3 n) (if (memq (nth 1 n) '(1 3)) 1 0))) (or (and (integerp (setq n (math-check-integer n))) (> n 0)) (math-reject-arg n 'fixposintp)) (or (Math-vectorp mat) (math-reject-arg mat 'vectorp)) (or (nth n mat) (math-reject-arg n "*Index out of range")))) ) (defun calcFunc-subscr (mat n &optional m) (setq mat (calcFunc-mrow mat n)) (if m (if (math-num-integerp n) (calcFunc-mrow mat m) (calcFunc-mcol mat m)) mat) ) ;;; Get the Nth column of a matrix. (defun math-mat-col (mat n) (cons 'vec (mapcar (function (lambda (x) (elt x n))) (cdr mat))) ) (defun calcFunc-mcol (mat n) ; [Public] (if (Math-vectorp n) (calcFunc-trn (math-map-vec (function (lambda (x) (calcFunc-mcol mat x))) n)) (if (and (eq (car-safe n) 'intv) (math-constp n)) (if (math-matrixp mat) (math-map-vec (function (lambda (x) (calcFunc-mrow x n))) mat) (calcFunc-mrow mat n)) (or (and (integerp (setq n (math-check-integer n))) (> n 0)) (math-reject-arg n 'fixposintp)) (or (Math-vectorp mat) (math-reject-arg mat 'vectorp)) (or (if (math-matrixp mat) (and (< n (length (nth 1 mat))) (math-mat-col mat n)) (nth n mat)) (math-reject-arg n "*Index out of range")))) ) ;;; Remove the Nth row from a matrix. (defun math-mat-less-row (mat n) (if (<= n 0) (cdr mat) (cons (car mat) (math-mat-less-row (cdr mat) (1- n)))) ) (defun calcFunc-mrrow (mat n) ; [Public] (and (integerp (setq n (math-check-integer n))) (> n 0) (< n (length mat)) (math-mat-less-row mat n)) ) ;;; Remove the Nth column from a matrix. (defun math-mat-less-col (mat n) (cons 'vec (mapcar (function (lambda (x) (math-mat-less-row x n))) (cdr mat))) ) (defun calcFunc-mrcol (mat n) ; [Public] (and (integerp (setq n (math-check-integer n))) (> n 0) (if (math-matrixp mat) (and (< n (length (nth 1 mat))) (math-mat-less-col mat n)) (math-mat-less-row mat n))) ) (defun calcFunc-getdiag (mat) ; [Public] (if (math-square-matrixp mat) (cons 'vec (math-get-diag-step (cdr mat) 1)) (calc-record-why 'square-matrixp mat) (list 'calcFunc-getdiag mat)) ) (defun math-get-diag-step (row n) (and row (cons (nth n (car row)) (math-get-diag-step (cdr row) (1+ n)))) ) (defun math-transpose (mat) ; [Public] (let ((m nil) (col (length (nth 1 mat)))) (while (> (setq col (1- col)) 0) (setq m (cons (math-mat-col mat col) m))) (cons 'vec m)) ) (defun calcFunc-trn (mat) (if (math-vectorp mat) (if (math-matrixp mat) (math-transpose mat) (math-col-matrix mat)) (if (math-numberp mat) mat (math-reject-arg mat 'matrixp))) ) (defun calcFunc-ctrn (mat) (calcFunc-conj (calcFunc-trn mat)) ) (defun calcFunc-pack (mode els) (or (Math-vectorp els) (math-reject-arg els 'vectorp)) (if (and (Math-vectorp mode) (cdr mode)) (setq mode (cdr mode)) (or (integerp mode) (math-reject-arg mode 'fixnump))) (condition-case err (if (= (calc-pack-size mode) (1- (length els))) (calc-pack-items mode (cdr els)) (math-reject-arg els "*Wrong number of elements")) (error (math-reject-arg els (nth 1 err)))) ) (defun calcFunc-unpack (mode thing) (or (integerp mode) (math-reject-arg mode 'fixnump)) (condition-case err (cons 'vec (calc-unpack-item mode thing)) (error (math-reject-arg thing (nth 1 err)))) ) (defun calcFunc-unpackt (mode thing) (let ((calc-unpack-with-type 'pair)) (calcFunc-unpack mode thing)) ) (defun calcFunc-arrange (vec cols) ; [Public] (setq cols (math-check-fixnum cols t)) (if (math-vectorp vec) (let* ((flat (math-flatten-vector vec)) (mat (list 'vec)) next) (if (<= cols 0) (nconc mat flat) (while (>= (length flat) cols) (setq next (nthcdr cols flat)) (setcdr (nthcdr (1- cols) flat) nil) (setq mat (nconc mat (list (cons 'vec flat))) flat next)) (if flat (setq mat (nconc mat (list (cons 'vec flat))))) mat))) ) (defun math-flatten-vector (vec) ; [L V] (if (math-vectorp vec) (apply 'append (mapcar 'math-flatten-vector (cdr vec))) (list vec)) ) (defun calcFunc-vconcat (a b) (math-normalize (list '| a b)) ) (defun calcFunc-vconcatrev (a b) (math-normalize (list '| b a)) ) (defun calcFunc-append (v1 v2) (if (and (math-vectorp v1) (math-vectorp v2)) (append v1 (cdr v2)) (list 'calcFunc-append v1 v2)) ) (defun calcFunc-appendrev (v1 v2) (calcFunc-append v2 v1) ) ;;; Copy a matrix. [Public] (defun math-copy-matrix (m) (if (math-vectorp (nth 1 m)) (cons 'vec (mapcar 'copy-sequence (cdr m))) (copy-sequence m)) ) ;;; Convert a scalar or vector into an NxN diagonal matrix. [Public] (defun calcFunc-diag (a &optional n) (and n (not (integerp n)) (setq n (math-check-fixnum n))) (if (math-vectorp a) (if (and n (/= (length a) (1+ n))) (list 'calcFunc-diag a n) (if (math-matrixp a) (if (and n (/= (length (elt a 1)) (1+ n))) (list 'calcFunc-diag a n) a) (cons 'vec (math-diag-step (cdr a) 0 (1- (length a)))))) (if n (cons 'vec (math-diag-step (make-list n a) 0 n)) (list 'calcFunc-diag a))) ) (defun calcFunc-idn (a &optional n) (if n (if (math-vectorp a) (math-reject-arg a 'numberp) (calcFunc-diag a n)) (if (integerp calc-matrix-mode) (calcFunc-idn a calc-matrix-mode) (list 'calcFunc-idn a))) ) (defun math-mimic-ident (a m) (if (math-square-matrixp m) (calcFunc-idn a (1- (length m))) (if (math-vectorp m) (if (math-zerop a) (cons 'vec (mapcar (function (lambda (x) (if (math-vectorp x) (math-mimic-ident a x) a))) (cdr m))) (math-dimension-error)) (calcFunc-idn a))) ) (defun math-diag-step (a n m) (if (< n m) (cons (cons 'vec (nconc (make-list n 0) (cons (car a) (make-list (1- (- m n)) 0)))) (math-diag-step (cdr a) (1+ n) m)) nil) ) ;;; Create a vector of consecutive integers. [Public] (defun calcFunc-index (n &optional start incr) (if (math-messy-integerp n) (math-float (calcFunc-index (math-trunc n) start incr)) (and (not (integerp n)) (setq n (math-check-fixnum n))) (let ((vec nil)) (if start (progn (if (>= n 0) (while (>= (setq n (1- n)) 0) (setq vec (cons start vec) start (math-add start (or incr 1)))) (while (<= (setq n (1+ n)) 0) (setq vec (cons start vec) start (math-mul start (or incr 2))))) (setq vec (nreverse vec))) (if (>= n 0) (while (> n 0) (setq vec (cons n vec) n (1- n))) (let ((i -1)) (while (>= i n) (setq vec (cons i vec) i (1- i)))))) (cons 'vec vec))) ) ;;; Find an element in a vector. (defun calcFunc-find (vec x &optional start) (setq start (if start (math-check-fixnum start t) 1)) (if (< start 1) (math-reject-arg start 'posp)) (setq vec (nthcdr start vec)) (let ((n start)) (while (and vec (not (Math-equal x (car vec)))) (setq n (1+ n) vec (cdr vec))) (if vec n 0)) ) ;;; Return a subvector of a vector. (defun calcFunc-subvec (vec start &optional end) (setq start (math-check-fixnum start t) end (math-check-fixnum (or end 0) t)) (or (math-vectorp vec) (math-reject-arg vec 'vectorp)) (let ((len (1- (length vec)))) (if (<= start 0) (setq start (+ len start 1))) (if (<= end 0) (setq end (+ len end 1))) (if (or (> start len) (<= end start)) '(vec) (setq vec (nthcdr start vec)) (if (<= end len) (let ((chop (nthcdr (- end start 1) (setq vec (copy-sequence vec))))) (setcdr chop nil))) (cons 'vec vec))) ) ;;; Remove a subvector from a vector. (defun calcFunc-rsubvec (vec start &optional end) (setq start (math-check-fixnum start t) end (math-check-fixnum (or end 0) t)) (or (math-vectorp vec) (math-reject-arg vec 'vectorp)) (let ((len (1- (length vec)))) (if (<= start 0) (setq start (+ len start 1))) (if (<= end 0) (setq end (+ len end 1))) (if (or (> start len) (<= end start)) vec (let ((tail (nthcdr end vec)) (chop (nthcdr (1- start) (setq vec (copy-sequence vec))))) (setcdr chop nil) (append vec tail)))) ) ;;; Reverse the order of the elements of a vector. (defun calcFunc-rev (vec) (if (math-vectorp vec) (cons 'vec (reverse (cdr vec))) (math-reject-arg vec 'vectorp)) ) ;;; Compress a vector according to a mask vector. (defun calcFunc-vmask (mask vec) (if (math-numberp mask) (if (math-zerop mask) '(vec) vec) (or (math-vectorp mask) (math-reject-arg mask 'vectorp)) (or (math-constp mask) (math-reject-arg mask 'constp)) (or (math-vectorp vec) (math-reject-arg vec 'vectorp)) (or (= (length mask) (length vec)) (math-dimension-error)) (let ((new nil)) (while (setq mask (cdr mask) vec (cdr vec)) (or (math-zerop (car mask)) (setq new (cons (car vec) new)))) (cons 'vec (nreverse new)))) ) ;;; Expand a vector according to a mask vector. (defun calcFunc-vexp (mask vec &optional filler) (or (math-vectorp mask) (math-reject-arg mask 'vectorp)) (or (math-constp mask) (math-reject-arg mask 'constp)) (or (math-vectorp vec) (math-reject-arg vec 'vectorp)) (let ((new nil) (fvec (and filler (math-vectorp filler)))) (while (setq mask (cdr mask)) (if (math-zerop (car mask)) (setq new (cons (or (if fvec (car (setq filler (cdr filler))) filler) (car mask)) new)) (setq vec (cdr vec) new (cons (or (car vec) (car mask)) new)))) (cons 'vec (nreverse new))) ) ;;; Compute the row and column norms of a vector or matrix. [Public] (defun calcFunc-rnorm (a) (if (and (Math-vectorp a) (math-constp a)) (if (math-matrixp a) (math-reduce-vec 'math-max (math-map-vec 'calcFunc-cnorm a)) (math-reduce-vec 'math-max (math-map-vec 'math-abs a))) (calc-record-why 'vectorp a) (list 'calcFunc-rnorm a)) ) (defun calcFunc-cnorm (a) (if (and (Math-vectorp a) (math-constp a)) (if (math-matrixp a) (math-reduce-vec 'math-max (math-reduce-cols 'math-add-abs a)) (math-reduce-vec 'math-add-abs a)) (calc-record-why 'vectorp a) (list 'calcFunc-cnorm a)) ) (defun math-add-abs (a b) (math-add (math-abs a) (math-abs b)) ) ;;; Sort the elements of a vector into increasing order. (defun calcFunc-sort (vec) ; [Public] (if (math-vectorp vec) (cons 'vec (sort (copy-sequence (cdr vec)) 'math-beforep)) (math-reject-arg vec 'vectorp)) ) (defun calcFunc-rsort (vec) ; [Public] (if (math-vectorp vec) (cons 'vec (nreverse (sort (copy-sequence (cdr vec)) 'math-beforep))) (math-reject-arg vec 'vectorp)) ) (defun calcFunc-grade (grade-vec) (if (math-vectorp grade-vec) (let* ((len (1- (length grade-vec)))) (cons 'vec (sort (cdr (calcFunc-index len)) 'math-grade-beforep))) (math-reject-arg grade-vec 'vectorp)) ) (defun calcFunc-rgrade (grade-vec) (if (math-vectorp grade-vec) (let* ((len (1- (length grade-vec)))) (cons 'vec (nreverse (sort (cdr (calcFunc-index len)) 'math-grade-beforep)))) (math-reject-arg grade-vec 'vectorp)) ) (defun math-grade-beforep (i j) (math-beforep (nth i grade-vec) (nth j grade-vec)) ) ;;; Compile a histogram of data from a vector. (defun calcFunc-histogram (vec wts &optional n) (or n (setq n wts wts 1)) (or (Math-vectorp vec) (math-reject-arg vec 'vectorp)) (if (Math-vectorp wts) (or (= (length vec) (length wts)) (math-dimension-error))) (or (natnump n) (math-reject-arg n 'fixnatnump)) (let ((res (make-vector n 0)) (vp vec) (wvec (Math-vectorp wts)) (wp wts) bin) (while (setq vp (cdr vp)) (setq bin (car vp)) (or (natnump bin) (setq bin (math-floor bin))) (and (natnump bin) (< bin n) (aset res bin (math-add (aref res bin) (if wvec (car (setq wp (cdr wp))) wts))))) (cons 'vec (append res nil))) ) ;;; Set operations. (defun calcFunc-vunion (a b) (if (Math-objectp a) (setq a (list 'vec a)) (or (math-vectorp a) (math-reject-arg a 'vectorp))) (if (Math-objectp b) (setq b (list b)) (or (math-vectorp b) (math-reject-arg b 'vectorp)) (setq b (cdr b))) (calcFunc-rdup (append a b)) ) (defun calcFunc-vint (a b) (if (and (math-simple-set a) (math-simple-set b)) (progn (setq a (cdr (calcFunc-rdup a))) (setq b (cdr (calcFunc-rdup b))) (let ((vec (list 'vec))) (while (and a b) (if (math-beforep (car a) (car b)) (setq a (cdr a)) (if (Math-equal (car a) (car b)) (setq vec (cons (car a) vec) a (cdr a))) (setq b (cdr b)))) (nreverse vec))) (calcFunc-vcompl (calcFunc-vunion (calcFunc-vcompl a) (calcFunc-vcompl b)))) ) (defun calcFunc-vdiff (a b) (if (and (math-simple-set a) (math-simple-set b)) (progn (setq a (cdr (calcFunc-rdup a))) (setq b (cdr (calcFunc-rdup b))) (let ((vec (list 'vec))) (while a (while (and b (math-beforep (car b) (car a))) (setq b (cdr b))) (if (and b (Math-equal (car a) (car b))) (setq a (cdr a) b (cdr b)) (setq vec (cons (car a) vec) a (cdr a)))) (nreverse vec))) (calcFunc-vcompl (calcFunc-vunion (calcFunc-vcompl a) b))) ) (defun calcFunc-vxor (a b) (if (and (math-simple-set a) (math-simple-set b)) (progn (setq a (cdr (calcFunc-rdup a))) (setq b (cdr (calcFunc-rdup b))) (let ((vec (list 'vec))) (while (or a b) (if (and a (or (not b) (math-beforep (car a) (car b)))) (setq vec (cons (car a) vec) a (cdr a)) (if (and a (Math-equal (car a) (car b))) (setq a (cdr a)) (setq vec (cons (car b) vec))) (setq b (cdr b)))) (nreverse vec))) (let ((ca (calcFunc-vcompl a)) (cb (calcFunc-vcompl b))) (calcFunc-vunion (calcFunc-vcompl (calcFunc-vunion ca b)) (calcFunc-vcompl (calcFunc-vunion a cb))))) ) (defun calcFunc-vcompl (a) (setq a (math-prepare-set a)) (let ((vec (list 'vec)) (prev '(neg (var inf var-inf))) (closed 2)) (while (setq a (cdr a)) (or (and (equal (nth 2 (car a)) '(neg (var inf var-inf))) (memq (nth 1 (car a)) '(2 3))) (setq vec (cons (list 'intv (+ closed (if (memq (nth 1 (car a)) '(0 1)) 1 0)) prev (nth 2 (car a))) vec))) (setq prev (nth 3 (car a)) closed (if (memq (nth 1 (car a)) '(0 2)) 2 0))) (or (and (equal prev '(var inf var-inf)) (= closed 0)) (setq vec (cons (list 'intv (+ closed 1) prev '(var inf var-inf)) vec))) (math-clean-set (nreverse vec))) ) (defun calcFunc-vspan (a) (setq a (math-prepare-set a)) (if (cdr a) (let ((last (nth (1- (length a)) a))) (math-make-intv (+ (logand (nth 1 (nth 1 a)) 2) (logand (nth 1 last) 1)) (nth 2 (nth 1 a)) (nth 3 last))) '(intv 2 0 0)) ) (defun calcFunc-vfloor (a &optional always-vec) (setq a (math-prepare-set a)) (let ((vec (list 'vec)) (p a) (prev nil) b mask) (while (setq p (cdr p)) (setq mask (nth 1 (car p)) a (nth 2 (car p)) b (nth 3 (car p))) (and (memq mask '(0 1)) (not (math-infinitep a)) (setq mask (logior mask 2)) (math-num-integerp a) (setq a (math-add a 1))) (setq a (math-ceiling a)) (and (memq mask '(0 2)) (not (math-infinitep b)) (setq mask (logior mask 1)) (math-num-integerp b) (setq b (math-sub b 1))) (setq b (math-floor b)) (if (and prev (Math-equal (math-sub a 1) (nth 3 prev))) (setcar (nthcdr 3 prev) b) (or (Math-lessp b a) (setq vec (cons (setq prev (list 'intv mask a b)) vec))))) (setq vec (nreverse vec)) (math-clean-set vec always-vec)) ) (defun calcFunc-vcard (a) (setq a (calcFunc-vfloor a t)) (or (math-constp a) (math-reject-arg a "*Set must be finite")) (let ((count 0)) (while (setq a (cdr a)) (if (eq (car-safe (car a)) 'intv) (setq count (math-add count (math-sub (nth 3 (car a)) (nth 2 (car a)))))) (setq count (math-add count 1))) count) ) (defun calcFunc-venum (a) (setq a (calcFunc-vfloor a t)) (or (math-constp a) (math-reject-arg a "*Set must be finite")) (let ((p a) next) (while (cdr p) (setq next (cdr p)) (if (eq (car-safe (nth 1 p)) 'intv) (setcdr p (nconc (cdr (calcFunc-index (math-add (math-sub (nth 3 (nth 1 p)) (nth 2 (nth 1 p))) 1) (nth 2 (nth 1 p)))) (cdr (cdr p))))) (setq p next)) a) ) (defun calcFunc-vpack (a) (setq a (calcFunc-vfloor a t)) (if (and (cdr a) (math-negp (if (eq (car-safe (nth 1 a)) 'intv) (nth 2 (nth 1 a)) (nth 1 a)))) (math-reject-arg (nth 1 a) 'posp)) (let ((accum 0)) (while (setq a (cdr a)) (if (eq (car-safe (car a)) 'intv) (if (equal (nth 3 (car a)) '(var inf var-inf)) (setq accum (math-sub accum (math-power-of-2 (nth 2 (car a))))) (setq accum (math-add accum (math-sub (math-power-of-2 (1+ (nth 3 (car a)))) (math-power-of-2 (nth 2 (car a))))))) (setq accum (math-add accum (math-power-of-2 (car a)))))) accum) ) (defun calcFunc-vunpack (a &optional w) (or (math-num-integerp a) (math-reject-arg a 'integerp)) (if w (setq a (math-clip a w))) (if (math-messy-integerp a) (setq a (math-trunc a))) (let* ((calc-number-radix 2) (neg (math-negp a)) (aa (if neg (math-sub -1 a) a)) (str (if (eq aa 0) "" (if (consp aa) (math-format-bignum-binary (cdr aa)) (math-format-binary aa)))) (zero (if neg ?1 ?0)) (one (if neg ?0 ?1)) (len (length str)) (vec (list 'vec)) (pos (1- len)) pos2) (while (>= pos 0) (if (eq (aref str pos) zero) (setq pos (1- pos)) (setq pos2 pos) (while (and (>= pos 0) (eq (aref str pos) one)) (setq pos (1- pos))) (setq vec (cons (if (= pos (1- pos2)) (- len pos2 1) (list 'intv 3 (- len pos2 1) (- len pos 2))) vec)))) (if neg (setq vec (cons (list 'intv 2 len '(var inf var-inf)) vec))) (math-clean-set (nreverse vec))) ) (defun calcFunc-rdup (a) (if (math-simple-set a) (progn (and (Math-objectp a) (setq a (list 'vec a))) (or (math-vectorp a) (math-reject-arg a 'vectorp)) (setq a (sort (copy-sequence (cdr a)) 'math-beforep)) (let ((p a)) (while (cdr p) (if (Math-equal (car p) (nth 1 p)) (setcdr p (cdr (cdr p))) (setq p (cdr p))))) (cons 'vec a)) (math-clean-set (math-prepare-set a))) ) (defun math-prepare-set (a) (if (Math-objectp a) (setq a (list 'vec a)) (or (math-vectorp a) (math-reject-arg a 'vectorp)) (setq a (cons 'vec (sort (copy-sequence (cdr a)) 'math-beforep)))) (let ((p a) res) ;; Convert all elements to non-empty intervals. (while (cdr p) (if (eq (car-safe (nth 1 p)) 'intv) (if (math-intv-constp (nth 1 p)) (if (and (memq (nth 1 (nth 1 p)) '(0 1 2)) (Math-equal (nth 2 (nth 1 p)) (nth 3 (nth 1 p)))) (setcdr p (cdr (cdr p))) (setq p (cdr p))) (math-reject-arg (nth 1 p) 'constp)) (or (Math-anglep (nth 1 p)) (eq (car (nth 1 p)) 'date) (equal (nth 1 p) '(var inf var-inf)) (equal (nth 1 p) '(neg (var inf var-inf))) (math-reject-arg (nth 1 p) 'realp)) (setcar (cdr p) (list 'intv 3 (nth 1 p) (nth 1 p))) (setq p (cdr p)))) ;; Combine redundant intervals. (setq p a) (while (cdr (cdr p)) (if (or (memq (setq res (math-compare (nth 3 (nth 1 p)) (nth 2 (nth 2 p)))) '(-1 2)) (and (eq res 0) (memq (nth 1 (nth 1 p)) '(0 2)) (memq (nth 1 (nth 2 p)) '(0 1)))) (setq p (cdr p)) (setq res (math-compare (nth 3 (nth 1 p)) (nth 3 (nth 2 p)))) (setcdr p (cons (list 'intv (+ (logand (logior (nth 1 (nth 1 p)) (if (Math-equal (nth 2 (nth 1 p)) (nth 2 (nth 2 p))) (nth 1 (nth 2 p)) 0)) 2) (logand (logior (if (memq res '(1 0 2)) (nth 1 (nth 1 p)) 0) (if (memq res '(-1 0 2)) (nth 1 (nth 2 p)) 0)) 1)) (nth 2 (nth 1 p)) (if (eq res 1) (nth 3 (nth 1 p)) (nth 3 (nth 2 p)))) (cdr (cdr (cdr p)))))))) a ) (defun math-clean-set (a &optional always-vec) (let ((p a) res) (while (cdr p) (if (and (eq (car-safe (nth 1 p)) 'intv) (Math-equal (nth 2 (nth 1 p)) (nth 3 (nth 1 p)))) (setcar (cdr p) (nth 2 (nth 1 p)))) (setq p (cdr p))) (if (and (not (cdr (cdr a))) (eq (car-safe (nth 1 a)) 'intv) (not always-vec)) (nth 1 a) a)) ) (defun math-simple-set (a) (or (and (Math-objectp a) (not (eq (car-safe a) 'intv))) (and (Math-vectorp a) (progn (while (and (setq a (cdr a)) (not (eq (car-safe (car a)) 'intv)))) (null a)))) ) ;;; Compute a right-handed vector cross product. [O O O] [Public] (defun calcFunc-cross (a b) (if (and (eq (car-safe a) 'vec) (= (length a) 4)) (if (and (eq (car-safe b) 'vec) (= (length b) 4)) (list 'vec (math-sub (math-mul (nth 2 a) (nth 3 b)) (math-mul (nth 3 a) (nth 2 b))) (math-sub (math-mul (nth 3 a) (nth 1 b)) (math-mul (nth 1 a) (nth 3 b))) (math-sub (math-mul (nth 1 a) (nth 2 b)) (math-mul (nth 2 a) (nth 1 b)))) (math-reject-arg b "*Three-vector expected")) (math-reject-arg a "*Three-vector expected")) ) (defun math-read-brackets (space-sep close) (and space-sep (setq space-sep (not (math-check-for-commas)))) (math-read-token) (while (eq exp-token 'space) (math-read-token)) (if (or (equal exp-data close) (eq exp-token 'end)) (progn (math-read-token) '(vec)) (let ((save-exp-pos exp-pos) (save-exp-old-pos exp-old-pos) (save-exp-token exp-token) (save-exp-data exp-data) (vals (let ((exp-keep-spaces space-sep)) (if (or (equal exp-data "\\dots") (equal exp-data "\\ldots")) '(vec (neg (var inf var-inf))) (catch 'syntax (math-read-vector)))))) (if (stringp vals) (if space-sep (let ((error-exp-pos exp-pos) (error-exp-old-pos exp-old-pos) vals2) (setq exp-pos save-exp-pos exp-old-pos save-exp-old-pos exp-token save-exp-token exp-data save-exp-data) (let ((exp-keep-spaces nil)) (setq vals2 (catch 'syntax (math-read-vector)))) (if (and (not (stringp vals2)) (or (assoc exp-data '(("\\ldots") ("\\dots") (";"))) (equal exp-data close) (eq exp-token 'end))) (setq space-sep nil vals vals2) (setq exp-pos error-exp-pos exp-old-pos error-exp-old-pos) (throw 'syntax vals))) (throw 'syntax vals))) (if (or (equal exp-data "\\dots") (equal exp-data "\\ldots")) (progn (math-read-token) (setq vals (if (> (length vals) 2) (cons 'calcFunc-mul (cdr vals)) (nth 1 vals))) (let ((exp2 (if (or (equal exp-data close) (equal exp-data ")") (eq exp-token 'end)) '(var inf var-inf) (math-read-expr-level 0)))) (setq vals (list 'intv (if (equal exp-data ")") 2 3) vals exp2))) (if (not (or (equal exp-data close) (equal exp-data ")") (eq exp-token 'end))) (throw 'syntax "Expected `]'"))) (if (equal exp-data ";") (let ((exp-keep-spaces space-sep)) (setq vals (cons 'vec (math-read-matrix (list vals)))))) (if (not (or (equal exp-data close) (eq exp-token 'end))) (throw 'syntax "Expected `]'"))) (or (eq exp-token 'end) (math-read-token)) vals)) ) (defun math-check-for-commas (&optional balancing) (let ((count 0) (pos (1- exp-pos))) (while (and (>= count 0) (setq pos (string-match (if balancing "[],[{}()<>]" "[],[{}()]") exp-str (1+ pos))) (or (/= (aref exp-str pos) ?,) (> count 0) balancing)) (cond ((memq (aref exp-str pos) '(?\[ ?\{ ?\( ?\<)) (setq count (1+ count))) ((memq (aref exp-str pos) '(?\] ?\} ?\) ?\>)) (setq count (1- count))))) (if balancing pos (and pos (= (aref exp-str pos) ?,)))) ) (defun math-read-vector () (let* ((val (list (math-read-expr-level 0))) (last val)) (while (progn (while (eq exp-token 'space) (math-read-token)) (and (not (eq exp-token 'end)) (not (equal exp-data ";")) (not (equal exp-data close)) (not (equal exp-data "\\dots")) (not (equal exp-data "\\ldots")))) (if (equal exp-data ",") (math-read-token)) (while (eq exp-token 'space) (math-read-token)) (let ((rest (list (math-read-expr-level 0)))) (setcdr last rest) (setq last rest))) (cons 'vec val)) ) (defun math-read-matrix (mat) (while (equal exp-data ";") (math-read-token) (while (eq exp-token 'space) (math-read-token)) (setq mat (nconc mat (list (math-read-vector))))) mat ) calc-2.02c/calc-embed.el100644 22403 13 121071 5402630556 13363 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-embed.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-embed () nil) (defun calc-show-plain (n) (interactive "P") (calc-wrapper (calc-set-command-flag 'renum-stack) (message (if (calc-change-mode 'calc-show-plain n nil t) "Including \"plain\" formulas in Calc Embedded mode." "Omitting \"plain\" formulas in Calc Embedded mode."))) ) ;;; Things to do for Embedded Mode: ;;; ;;; Detect and strip off unexpected labels during reading. ;;; ;;; Get calc-grab-region to use math-read-big-expr. ;;; If calc-show-plain, main body should have only righthand side of => expr. ;;; Handle tabs that have crept into embedded formulas. ;;; After "switching to new formula", home cursor to that formula. ;;; Do something like \evalto ... \to for \gets operators. ;;; (defvar calc-embedded-modes nil) (defvar calc-embedded-globals nil) (defvar calc-embedded-active nil) (make-variable-buffer-local 'calc-embedded-all-active) (make-variable-buffer-local 'calc-embedded-some-active) (defvar calc-embedded-open-formula "\\`\\|^\n\\|\\$\\$?\\|\\\\\\[\\|^\\\\begin.*\n\\|^@.*\n\\|^\\.EQ.*\n\\|\\\\(\\|^%\n\\|^\\.\\\\\"\n" "*A regular expression for the opening delimiter of a formula used by calc-embedded.") (defvar calc-embedded-close-formula "\\'\\|\n$\\|\\$\\$?\\|\\\\]\\|^\\\\end.*\n\\|^@.*\n\\|^\\.EN.*\n\\|\\\\)\\|\n%\n\\|^\\.\\\\\"\n" "*A regular expression for the closing delimiter of a formula used by calc-embedded.") (defvar calc-embedded-open-word "^\\|[^-+0-9.eE]" "*A regular expression for the opening delimiter of a formula used by calc-embedded-word.") (defvar calc-embedded-close-word "$\\|[^-+0-9.eE]" "*A regular expression for the closing delimiter of a formula used by calc-embedded-word.") (defvar calc-embedded-open-plain "%%% " "*A string which is the opening delimiter for a \"plain\" formula. If calc-show-plain mode is enabled, this is inserted at the front of each formula.") (defvar calc-embedded-close-plain " %%%\n" "*A string which is the closing delimiter for a \"plain\" formula. See calc-embedded-open-plain.") (defvar calc-embedded-open-new-formula "\n\n" "*A string which is inserted at front of formula by calc-embedded-new-formula.") (defvar calc-embedded-close-new-formula "\n\n" "*A string which is inserted at end of formula by calc-embedded-new-formula.") (defvar calc-embedded-announce-formula "%Embed\n\\(% .*\n\\)*" "*A regular expression which is sure to be followed by a calc-embedded formula." ) (defvar calc-embedded-open-mode "% " "*A string which should precede calc-embedded mode annotations. This is not required to be present for user-written mode annotations.") (defvar calc-embedded-close-mode "\n" "*A string which should follow calc-embedded mode annotations. This is not required to be present for user-written mode annotations.") (defconst calc-embedded-mode-vars '(("precision" . calc-internal-prec) ("word-size" . calc-word-size) ("angles" . calc-angle-mode) ("symbolic" . calc-symbolic-mode) ("matrix" . calc-matrix-mode) ("fractions" . calc-prefer-frac) ("complex" . calc-complex-mode) ("simplify" . calc-simplify-mode) ("language" . the-language) ("plain" . calc-show-plain) ("break" . calc-line-breaking) ("justify" . the-display-just) ("left-label" . calc-left-label) ("right-label" . calc-right-label) ("radix" . calc-number-radix) ("leading-zeros" . calc-leading-zeros) ("grouping" . calc-group-digits) ("group-char" . calc-group-char) ("point-char" . calc-point-char) ("frac-format" . calc-frac-format) ("float-format" . calc-float-format) ("complex-format" . calc-complex-format) ("hms-format" . calc-hms-format) ("date-format" . calc-date-format) ("matrix-justify" . calc-matrix-just) ("full-vectors" . calc-full-vectors) ("break-vectors" . calc-break-vectors) ("vector-commas" . calc-vector-commas) ("vector-brackets" . calc-vector-brackets) ("matrix-brackets" . calc-matrix-brackets) ("strings" . calc-display-strings) )) ;;; Format of calc-embedded-info vector: ;;; 0 Editing buffer. ;;; 1 Calculator buffer. ;;; 2 Top of current formula (marker). ;;; 3 Bottom of current formula (marker). ;;; 4 Top of current formula's delimiters (marker). ;;; 5 Bottom of current formula's delimiters (marker). ;;; 6 String representation of current formula. ;;; 7 Non-nil if formula is embedded within a single line. ;;; 8 Internal representation of current formula. ;;; 9 Variable assigned by this formula, or nil. ;;; 10 List of variables upon which this formula depends. ;;; 11 Evaluated value of the formula, or nil. ;;; 12 Mode settings for current formula. ;;; 13 Local mode settings for current formula. ;;; 14 Permanent mode settings for current formula. ;;; 15 Global mode settings for editing buffer. ;;; calc-embedded-active is an a-list keyed on buffers; each cdr is a ;;; sorted list of calc-embedded-infos in that buffer. We do this ;;; rather than using buffer-local variables because the latter are ;;; thrown away when a buffer changes major modes. (defun calc-do-embedded (arg end obeg oend) (if calc-embedded-info ;; Turn embedded mode off or switch to a new buffer. (cond ((eq (current-buffer) (aref calc-embedded-info 1)) (let ((calcbuf (current-buffer)) (buf (aref calc-embedded-info 0))) (calc-embedded-original-buffer t) (calc-embedded nil) (switch-to-buffer calcbuf))) ((eq (current-buffer) (aref calc-embedded-info 0)) (let* ((info calc-embedded-info) (mode calc-embedded-modes)) (save-excursion (set-buffer (aref info 1)) (if (and (> (calc-stack-size) 0) (equal (calc-top 1 'full) (aref info 8))) (let ((calc-no-refresh-evaltos t)) (if (calc-top 1 'sel) (calc-unselect 1)) (calc-embedded-set-modes (aref info 15) (aref info 12) (aref info 14)) (let ((calc-embedded-info nil)) (calc-wrapper (calc-pop-stack)))) (calc-set-mode-line))) (setq calc-embedded-info nil mode-line-buffer-identification (car mode) truncate-lines (nth 2 mode) buffer-read-only nil) (use-local-map (nth 1 mode)) (set-buffer-modified-p (buffer-modified-p)) (or calc-embedded-quiet (message "Back to %s mode." mode-name)))) (t (if (buffer-name (aref calc-embedded-info 0)) (save-excursion (set-buffer (aref calc-embedded-info 0)) (or (y-or-n-p "Cancel Calc Embedded mode in buffer %s? " (buffer-name)) (keyboard-quit)) (calc-embedded nil))) (calc-embedded arg end obeg oend))) ;; Turn embedded mode on. (calc-plain-buffer-only) (let ((modes (list mode-line-buffer-identification (current-local-map) truncate-lines)) top bot outer-top outer-bot info chg ident) (barf-if-buffer-read-only) (or calc-embedded-globals (calc-find-globals)) (setq info (calc-embedded-make-info (point) nil t arg end obeg oend)) (if (eq (car-safe (aref info 8)) 'error) (progn (goto-char (nth 1 (aref info 8))) (error (nth 2 (aref info 8))))) (let ((mode-line-buffer-identification mode-line-buffer-identification) (calc-embedded-info info) (calc-embedded-no-reselect t)) (calc-wrapper (let* ((okay nil) (calc-no-refresh-evaltos t)) (setq chg (calc-embedded-set-modes (aref info 15) (aref info 12) (aref info 13))) (if (aref info 8) (calc-push (calc-normalize (aref info 8))) (calc-alg-entry))) (setq calc-undo-list nil calc-redo-list nil ident mode-line-buffer-identification))) (setq calc-embedded-info info calc-embedded-modes modes mode-line-buffer-identification ident truncate-lines t buffer-read-only t) (set-buffer-modified-p (buffer-modified-p)) (use-local-map calc-mode-map) (setq calc-no-refresh-evaltos nil) (and chg calc-any-evaltos (calc-wrapper (calc-refresh-evaltos))) (or (eq calc-embedded-quiet t) (message "Embedded Calc mode enabled. %s to return to normal." (if calc-embedded-quiet "Type `M-# x'" "Give this command again"))))) (scroll-down 0) ; fix a bug which occurs when truncate-lines is changed. ) (setq calc-embedded-quiet nil) (defun calc-embedded-select (arg) (interactive "P") (calc-embedded arg) (and calc-embedded-info (eq (car-safe (aref calc-embedded-info 8)) 'calcFunc-evalto) (calc-select-part 1)) (and calc-embedded-info (or (eq (car-safe (aref calc-embedded-info 8)) 'calcFunc-assign) (and (eq (car-safe (aref calc-embedded-info 8)) 'calcFunc-evalto) (eq (car-safe (nth 1 (aref calc-embedded-info 8))) 'calcFunc-assign))) (calc-select-part 2)) ) (defun calc-embedded-update-formula (arg) (interactive "P") (if arg (let ((entry (assq (current-buffer) calc-embedded-active))) (while (setq entry (cdr entry)) (and (eq (car-safe (aref (car entry) 8)) 'calcFunc-evalto) (or (not (consp arg)) (and (<= (aref (car entry) 2) (region-beginning)) (>= (aref (car entry) 3) (region-end)))) (save-excursion (calc-embedded-update (car entry) 14 t t))))) (if (and calc-embedded-info (eq (current-buffer) (aref calc-embedded-info 0)) (>= (point) (aref calc-embedded-info 4)) (<= (point) (aref calc-embedded-info 5))) (calc-evaluate 1) (let* ((opt (point)) (info (calc-embedded-make-info (point) nil t)) (pt (- opt (aref info 4)))) (or (eq (car-safe (aref info 8)) 'error) (progn (save-excursion (calc-embedded-update info 14 'eval t)) (goto-char (+ (aref info 4) pt))))))) ) (defun calc-embedded-edit (arg) (interactive "P") (let ((info (calc-embedded-make-info (point) nil t arg)) str) (if (eq (car-safe (aref info 8)) 'error) (progn (goto-char (nth 1 (aref info 8))) (error (nth 2 (aref info 8))))) (calc-wrapper (setq str (math-showing-full-precision (math-format-nice-expr (aref info 8) (screen-width)))) (calc-edit-mode (list 'calc-embedded-finish-edit info)) (insert str "\n"))) (calc-show-edit-buffer) ) (defun calc-embedded-finish-edit (info) (let ((buf (current-buffer)) (str (buffer-substring (point) (point-max))) (start (point)) pos) (switch-to-buffer calc-original-buffer) (let ((val (save-excursion (set-buffer (aref info 1)) (let ((calc-language nil) (math-expr-opers math-standard-opers)) (math-read-expr str))))) (if (eq (car-safe val) 'error) (progn (switch-to-buffer buf) (goto-char (+ start (nth 1 val))) (error (nth 2 val)))) (calc-embedded-original-buffer t info) (aset info 8 val) (calc-embedded-update info 14 t t))) ) (defun calc-do-embedded-activate (arg cbuf) (calc-plain-buffer-only) (if arg (calc-embedded-forget)) (calc-find-globals) (if (< (prefix-numeric-value arg) 0) (message "Deactivating %s for Calc Embedded mode." (buffer-name)) (message "Activating %s for Calc Embedded mode..." (buffer-name)) (save-excursion (let* ((active (assq (current-buffer) calc-embedded-active)) (info active) (pat " := \\| \\\\gets \\| => \\| \\\\evalto ")) (if calc-embedded-announce-formula (setq pat (format "%s\\|\\(%s\\)" pat calc-embedded-announce-formula))) (while (setq info (cdr info)) (or (equal (buffer-substring (aref (car info) 2) (aref (car info) 3)) (aref (car info) 6)) (setcdr active (delq (car info) (cdr active))))) (goto-char (point-min)) (while (re-search-forward pat nil t) (if (looking-at calc-embedded-open-formula) (goto-char (match-end 1))) (setq info (calc-embedded-make-info (point) cbuf nil)) (or (eq (car-safe (aref info 8)) 'error) (goto-char (aref info 5)))))) (message "Activating %s for Calc Embedded mode...done" (buffer-name))) (calc-embedded-active-state t) ) (defun calc-plain-buffer-only () (if (memq major-mode '(calc-mode calc-trail-mode calc-edit-mode)) (error "This command should be used in a normal editing buffer")) ) (defun calc-embedded-active-state (state) (or (assq 'calc-embedded-all-active minor-mode-alist) (setq minor-mode-alist (cons '(calc-embedded-all-active " Active") (cons '(calc-embedded-some-active " ~Active") minor-mode-alist)))) (let ((active (assq (current-buffer) calc-embedded-active))) (or (cdr active) (setq state nil))) (and (eq state 'more) calc-embedded-all-active (setq state t)) (setq calc-embedded-all-active (eq state t) calc-embedded-some-active (not (memq state '(nil t)))) (set-buffer-modified-p (buffer-modified-p)) ) (defun calc-embedded-original-buffer (switch &optional info) (or info (setq info calc-embedded-info)) (or (buffer-name (aref info 0)) (progn (error "Calc embedded mode: Original buffer has been killed"))) (if switch (set-buffer (aref info 0))) ) (defun calc-embedded-word () (interactive) (calc-embedded '(4)) ) (defun calc-embedded-mark-formula (&optional body-only) "Put point at the beginning of this Calc formula, mark at the end. This normally marks the whole formula, including surrounding delimiters. With any prefix argument, marks only the formula itself." (interactive "P") (and (eq major-mode 'calc-mode) (error "This command should be used in a normal editing buffer")) (let (top bot outer-top outer-bot) (save-excursion (calc-embedded-find-bounds body-only)) (push-mark (if body-only bot outer-bot) t) (goto-char (if body-only top outer-top))) ) (defun calc-embedded-find-bounds (&optional plain) ;; (while (and (bolp) (eq (following-char) ?\n)) ;; (forward-char 1)) (and (eolp) (bolp) (not (eq (char-after (- (point) 2)) ?\n)) (forward-char -1)) (let ((home (point))) (or (and (looking-at calc-embedded-open-formula) (not (looking-at calc-embedded-close-formula))) (re-search-backward calc-embedded-open-formula nil t) (error "Can't find start of formula")) (and (eq (preceding-char) ?\$) ; backward search for \$\$? won't back (eq (following-char) ?\$) ; up over a second $, so do it by hand. (forward-char -1)) (setq outer-top (point)) (goto-char (match-end 0)) (if (eq (following-char) ?\n) (forward-char 1)) (or (bolp) (while (eq (following-char) ?\ ) (forward-char 1))) (or (eq plain 'plain) (if (looking-at (regexp-quote calc-embedded-open-plain)) (progn (goto-char (match-end 0)) (search-forward calc-embedded-close-plain)))) (setq top (point)) (or (re-search-forward calc-embedded-close-formula nil t) (error "Can't find end of formula")) (if (< (point) home) (error "Not inside a formula")) (and (eq (following-char) ?\n) (not (bolp)) (forward-char 1)) (setq outer-bot (point)) (goto-char (match-beginning 0)) (if (eq (preceding-char) ?\n) (backward-char 1)) (or (eolp) (while (eq (preceding-char) ?\ ) (backward-char 1))) (setq bot (point))) ) (defun calc-embedded-kill-formula () "Kill the formula surrounding point. If Calc Embedded mode was active, this deactivates it. The formula (including its surrounding delimiters) is saved in the kill ring. The command \\[yank] can retrieve it from there." (interactive) (and calc-embedded-info (calc-embedded nil)) (calc-embedded-mark-formula) (kill-region (point) (mark)) (pop-mark) ) (defun calc-embedded-copy-formula-as-kill () "Save the formula surrounding point as if killed, but don't kill it." (interactive) (save-excursion (calc-embedded-mark-formula) (copy-region-as-kill (point) (mark)) (pop-mark)) ) (defun calc-embedded-duplicate () (interactive) (let ((already calc-embedded-info) top bot outer-top outer-bot new-top) (if calc-embedded-info (progn (setq top (+ (aref calc-embedded-info 2)) bot (+ (aref calc-embedded-info 3)) outer-top (+ (aref calc-embedded-info 4)) outer-bot (+ (aref calc-embedded-info 5))) (calc-embedded nil)) (calc-embedded-find-bounds)) (goto-char outer-bot) (insert "\n") (setq new-top (point)) (insert-buffer-substring (current-buffer) outer-top outer-bot) (goto-char (+ new-top (- top outer-top))) (let ((calc-embedded-quiet (if already t 'x))) (calc-embedded (+ new-top (- top outer-top)) (+ new-top (- bot outer-top)) new-top (+ new-top (- outer-bot outer-top))))) ) (defun calc-embedded-next (arg) (interactive "P") (setq arg (prefix-numeric-value arg)) (let* ((active (cdr (assq (current-buffer) calc-embedded-active))) (p active) (num (length active))) (or active (error "No active formulas in buffer")) (cond ((= arg 0)) ((= arg -1) (if (<= (point) (aref (car active) 3)) (goto-char (aref (nth (1- num) active) 2)) (while (and (cdr p) (> (point) (aref (nth 1 p) 3))) (setq p (cdr p))) (goto-char (aref (car p) 2)))) ((< arg -1) (calc-embedded-next -1) (calc-embedded-next (+ (* num 1000) arg 1))) (t (setq arg (1+ (% (1- arg) num))) (while (and p (>= (point) (aref (car p) 2))) (setq p (cdr p))) (while (> (setq arg (1- arg)) 0) (setq p (if p (cdr p) (cdr active)))) (goto-char (aref (car (or p active)) 2))))) ) (defun calc-embedded-previous (arg) (interactive "p") (calc-embedded-next (- (prefix-numeric-value arg))) ) (defun calc-embedded-new-formula () (interactive) (and (eq major-mode 'calc-mode) (error "This command should be used in a normal editing buffer")) (if calc-embedded-info (calc-embedded nil)) (let (top bot outer-top outer-bot) (if (and (eq (preceding-char) ?\n) (string-match "\\`\n" calc-embedded-open-new-formula)) (progn (setq outer-top (1- (point))) (forward-char -1) (insert (substring calc-embedded-open-new-formula 1))) (setq outer-top (point)) (insert calc-embedded-open-new-formula)) (setq top (point)) (insert " ") (setq bot (point)) (insert calc-embedded-close-new-formula) (if (and (eq (following-char) ?\n) (string-match "\n\\'" calc-embedded-close-new-formula)) (delete-char 1)) (setq outer-bot (point)) (goto-char top) (let ((calc-embedded-quiet 'x)) (calc-embedded top bot outer-top outer-bot))) ) (defun calc-embedded-forget () (interactive) (setq calc-embedded-active (delq (assq (current-buffer) calc-embedded-active) calc-embedded-active)) (calc-embedded-active-state nil) ) (defun calc-embedded-set-modes (gmodes modes local-modes &optional temp) (let ((the-language (calc-embedded-language)) (the-display-just (calc-embedded-justify)) (v gmodes) (changed nil) found value) (while v (or (symbolp (car v)) (and (setq found (assq (car (car v)) modes)) (not (eq (cdr found) 'default))) (and (setq found (assq (car (car v)) local-modes)) (not (eq (cdr found) 'default))) (progn (if (eq (setq value (cdr (car v))) 'default) (setq value (cdr (assq (car (car v)) calc-mode-var-list)))) (equal (symbol-value (car (car v))) value)) (progn (setq changed t) (if temp (setq prev-modes (cons (cons (car (car v)) (symbol-value (car (car v)))) prev-modes))) (set (car (car v)) value))) (setq v (cdr v))) (setq v modes) (while v (or (and (setq found (assq (car (car v)) local-modes)) (not (eq (cdr found) 'default))) (eq (setq value (cdr (car v))) 'default) (equal (symbol-value (car (car v))) value) (progn (setq changed t) (if temp (setq prev-modes (cons (cons (car (car v)) (symbol-value (car (car v)))) prev-modes))) (set (car (car v)) value))) (setq v (cdr v))) (setq v local-modes) (while v (or (eq (setq value (cdr (car v))) 'default) (equal (symbol-value (car (car v))) value) (progn (setq changed t) (if temp (setq prev-modes (cons (cons (car (car v)) (symbol-value (car (car v)))) prev-modes))) (set (car (car v)) value))) (setq v (cdr v))) (and changed (not (eq temp t)) (progn (calc-embedded-set-justify the-display-just) (calc-embedded-set-language the-language))) (and changed (not temp) (progn (setq calc-full-float-format (list (if (eq (car calc-float-format) 'fix) 'float (car calc-float-format)) 0)) (calc-refresh))) changed) ) (defun calc-embedded-language () (if calc-language-option (list calc-language calc-language-option) calc-language) ) (defun calc-embedded-set-language (lang) (let ((option nil)) (if (consp lang) (setq option (nth 1 lang) lang (car lang))) (or (and (eq lang calc-language) (equal option calc-language-option)) (calc-set-language lang option t))) ) (defun calc-embedded-justify () (if calc-display-origin (list calc-display-just calc-display-origin) calc-display-just) ) (defun calc-embedded-set-justify (just) (if (consp just) (setq calc-display-origin (nth 1 just) calc-display-just (car just)) (setq calc-display-just just calc-display-origin nil)) ) (defun calc-find-globals () (interactive) (and (eq major-mode 'calc-mode) (error "This command should be used in a normal editing buffer")) (make-local-variable 'calc-embedded-globals) (let ((case-fold-search nil) (modes nil) (save-pt (point)) found value) (goto-char (point-min)) (while (re-search-forward "\\[calc-global-mode: *\\([-a-z]+\\): *\\(\"\\([^\"\n\\]\\|\\\\.\\)*\"\\|[- ()a-zA-Z0-9]+\\)\\]" nil t) (and (setq found (assoc (buffer-substring (match-beginning 1) (match-end 1)) calc-embedded-mode-vars)) (or (assq (cdr found) modes) (setq modes (cons (cons (cdr found) (car (read-from-string (buffer-substring (match-beginning 2) (match-end 2))))) modes))))) (setq calc-embedded-globals (cons t modes)) (goto-char save-pt)) ) (defun calc-embedded-find-modes () (let ((case-fold-search nil) (save-pt (point)) (no-defaults t) (modes nil) (emodes nil) (pmodes nil) found value) (while (and no-defaults (search-backward "[calc-" nil t)) (forward-char 6) (or (and (looking-at "mode: *\\([-a-z]+\\): *\\(\"\\([^\"\n\\]\\|\\\\.\\)*\"\\|[- ()a-zA-Z0-9]+\\)]") (setq found (assoc (buffer-substring (match-beginning 1) (match-end 1)) calc-embedded-mode-vars)) (or (assq (cdr found) modes) (setq modes (cons (cons (cdr found) (car (read-from-string (buffer-substring (match-beginning 2) (match-end 2))))) modes)))) (and (looking-at "perm-mode: *\\([-a-z]+\\): *\\(\"\\([^\"\n\\]\\|\\\\.\\)*\"\\|[- ()a-zA-Z0-9]+\\)]") (setq found (assoc (buffer-substring (match-beginning 1) (match-end 1)) calc-embedded-mode-vars)) (or (assq (cdr found) pmodes) (setq pmodes (cons (cons (cdr found) (car (read-from-string (buffer-substring (match-beginning 2) (match-end 2))))) pmodes)))) (and (looking-at "edit-mode: *\\([-a-z]+\\): *\\(\"\\([^\"\n\\]\\|\\\\.\\)*\"\\|[- ()a-zA-Z0-9]+\\)]") (setq found (assoc (buffer-substring (match-beginning 1) (match-end 1)) calc-embedded-mode-vars)) (or (assq (cdr found) emodes) (setq emodes (cons (cons (cdr found) (car (read-from-string (buffer-substring (match-beginning 2) (match-end 2))))) emodes)))) (and (looking-at "defaults]") (setq no-defaults nil))) (backward-char 6)) (goto-char save-pt) (list modes emodes pmodes)) ) (defun calc-embedded-make-info (point cbuf fresh &optional top bot outer-top outer-bot) (let* ((bufentry (assq (current-buffer) calc-embedded-active)) (found bufentry) (force (and fresh top)) (fixed top) (new-info nil) info str) (or found (setq found (list (current-buffer)) calc-embedded-active (cons found calc-embedded-active))) (while (and (cdr found) (> point (aref (car (cdr found)) 3))) (setq found (cdr found))) (if (and (cdr found) (>= point (aref (nth 1 found) 2))) (setq info (nth 1 found)) (setq info (make-vector 16 nil) new-info t fresh t) (aset info 0 (current-buffer)) (aset info 1 (or cbuf (save-excursion (calc-create-buffer) (current-buffer))))) (if (and (integerp top) (not bot)) ; started with a user-supplied argument (progn (if (= (setq arg (prefix-numeric-value arg)) 0) (progn (aset info 2 (copy-marker (region-beginning))) (aset info 3 (copy-marker (region-end)))) (aset info (if (> arg 0) 2 3) (point-marker)) (forward-line arg) (aset info (if (> arg 0) 3 2) (point-marker))) (aset info 4 (copy-marker (aref info 2))) (aset info 5 (copy-marker (aref info 3)))) (if (aref info 4) (setq top (aref info 2) fixed top) (if (consp top) (let ((calc-embedded-open-formula calc-embedded-open-word) (calc-embedded-close-formula calc-embedded-close-word)) (calc-embedded-find-bounds 'plain)) (or top (calc-embedded-find-bounds 'plain))) (aset info 2 (copy-marker (min top bot))) (aset info 3 (copy-marker (max top bot))) (aset info 4 (copy-marker (or outer-top (aref info 2)))) (aset info 5 (copy-marker (or outer-bot (aref info 3)))))) (goto-char (aref info 2)) (if new-info (progn (or (bolp) (aset info 7 t)) (goto-char (aref info 3)) (or (bolp) (eolp) (aset info 7 t)))) (if fresh (let ((modes (calc-embedded-find-modes))) (aset info 12 (car modes)) (aset info 13 (nth 1 modes)) (aset info 14 (nth 2 modes)))) (aset info 15 calc-embedded-globals) (setq str (buffer-substring (aref info 2) (aref info 3))) (if (or force (not (equal str (aref info 6)))) (if (and fixed (aref info 6)) (progn (aset info 4 nil) (calc-embedded-make-info point cbuf nil) (setq new-info nil)) (let* ((open-plain calc-embedded-open-plain) (close-plain calc-embedded-close-plain) (pref-len (length open-plain)) (vars-used nil) suff-pos val temp) (save-excursion (set-buffer (aref info 1)) (calc-embedded-set-modes (aref info 15) (aref info 12) (aref info 14)) (if (and (> (length str) pref-len) (equal (substring str 0 pref-len) open-plain) (setq suff-pos (string-match (regexp-quote close-plain) str pref-len))) (setq val (math-read-plain-expr (substring str pref-len suff-pos))) (if (string-match "[^ \t\n]" str) (setq pref-len 0 val (math-read-big-expr str)) (setq val nil)))) (if (eq (car-safe val) 'error) (setq val (list 'error (+ (aref info 2) pref-len (nth 1 val)) (nth 2 val)))) (aset info 6 str) (aset info 8 val) (setq temp val) (if (eq (car-safe temp) 'calcFunc-evalto) (setq temp (nth 1 temp)) (if (eq (car-safe temp) 'error) (if new-info (setq new-info nil) (setcdr found (delq info (cdr found))) (calc-embedded-active-state 'less)))) (aset info 9 (and (eq (car-safe temp) 'calcFunc-assign) (nth 1 temp))) (if (memq (car-safe val) '(calcFunc-evalto calcFunc-assign)) (calc-embedded-find-vars val)) (aset info 10 vars-used) (aset info 11 nil)))) (if new-info (progn (setcdr found (cons info (cdr found))) (calc-embedded-active-state 'more))) info) ) (defun calc-embedded-find-vars (x) (cond ((Math-primp x) (and (eq (car-safe x) 'var) (not (assoc x vars-used)) (setq vars-used (cons (list x) vars-used)))) ((eq (car x) 'calcFunc-evalto) (calc-embedded-find-vars (nth 1 x))) ((eq (car x) 'calcFunc-assign) (calc-embedded-find-vars (nth 2 x))) (t (and (eq (car x) 'calcFunc-subscr) (eq (car-safe (nth 1 x)) 'var) (Math-primp (nth 2 x)) (not (assoc x vars-used)) (setq vars-used (cons (list x) vars-used))) (while (setq x (cdr x)) (calc-embedded-find-vars (car x))))) ) (defun calc-embedded-evaluate-expr (x) (let ((vars-used (aref calc-embedded-info 10))) (or vars-used (calc-embedded-find-vars x)) (if vars-used (let ((active (assq (aref calc-embedded-info 0) calc-embedded-active)) (args nil)) (save-excursion (calc-embedded-original-buffer t) (or active (progn (calc-embedded-activate) (setq active (assq (aref calc-embedded-info 0) calc-embedded-active)))) (while vars-used (calc-embedded-eval-get-var (car (car vars-used)) active) (setq vars-used (cdr vars-used)))) (calc-embedded-subst x)) (calc-normalize (math-evaluate-expr-rec x)))) ) (defun calc-embedded-subst (x) (if (and (eq (car-safe x) 'calcFunc-evalto) (cdr x)) (let ((rhs (calc-embedded-subst (nth 1 x)))) (list 'calcFunc-evalto (nth 1 x) (if (eq (car-safe rhs) 'calcFunc-assign) (nth 2 rhs) rhs))) (if (and (eq (car-safe x) 'calcFunc-assign) (= (length x) 3)) (list 'calcFunc-assign (nth 1 x) (calc-embedded-subst (nth 2 x))) (calc-normalize (math-evaluate-expr-rec (math-multi-subst-rec x))))) ) (defun calc-embedded-eval-get-var (var base) (let ((entry base) (point (aref calc-embedded-info 2)) (last nil) val) (while (and (setq entry (cdr entry)) (or (not (equal var (aref (car entry) 9))) (and (> point (aref (car entry) 3)) (setq last entry))))) (if last (setq entry last)) (if entry (progn (setq entry (car entry)) (if (equal (buffer-substring (aref entry 2) (aref entry 3)) (aref entry 6)) (progn (or (aref entry 11) (save-excursion (calc-embedded-update entry 14 t nil))) (setq val (aref entry 11)) (if (eq (car-safe val) 'calcFunc-evalto) (setq val (nth 2 val))) (if (eq (car-safe val) 'calcFunc-assign) (setq val (nth 2 val))) (setq args (cons (cons var val) args))) (calc-embedded-activate) (calc-embedded-eval-get-var var base))))) ) (defun calc-embedded-update (info which need-eval need-display &optional str entry old-val) (let* ((prev-modes nil) (open-plain calc-embedded-open-plain) (close-plain calc-embedded-close-plain) (vars-used nil) (evalled nil) (val (aref info 8)) (old-eval (aref info 11))) (or old-val (setq old-val val)) (if (eq (car-safe val) 'calcFunc-evalto) (setq need-display t)) (unwind-protect (progn (set-buffer (aref info 1)) (and which (calc-embedded-set-modes (aref info 15) (aref info 12) (aref info which) (if need-display 'full t))) (if (memq (car-safe val) '(calcFunc-evalto calcFunc-assign)) (calc-embedded-find-vars val)) (if need-eval (let ((calc-embedded-info info)) (setq val (math-evaluate-expr val) evalled val))) (if (or (eq need-eval 'eval) (eq (car-safe val) 'calcFunc-evalto)) (aset info 8 val)) (aset info 9 nil) (aset info 10 vars-used) (aset info 11 nil) (if (or need-display (eq (car-safe val) 'calcFunc-evalto)) (let ((extra (if (eq calc-language 'big) 1 0))) (or entry (setq entry (list val 1 nil))) (or str (progn (setq str (let ((calc-line-numbering nil)) (math-format-stack-value entry))) (if (eq calc-language 'big) (setq str (substring str 0 -1))))) (and calc-show-plain (setq str (concat open-plain (math-showing-full-precision (math-format-flat-expr val 0)) close-plain str))) (save-excursion (calc-embedded-original-buffer t info) (or (equal str (aref info 6)) (let ((delta (- (aref info 5) (aref info 3))) (buffer-read-only nil)) (goto-char (aref info 2)) (delete-region (point) (aref info 3)) (and (> (nth 1 entry) (1+ extra)) (aref info 7) (progn (aset info 7 nil) (delete-horizontal-space) (insert "\n\n") (delete-horizontal-space) (backward-char 1))) (insert str) (set-marker (aref info 3) (point)) (set-marker (aref info 5) (+ (point) delta)) (aset info 6 str)))))) (if (eq (car-safe val) 'calcFunc-evalto) (progn (setq evalled (nth 2 val) val (nth 1 val)))) (if (eq (car-safe val) 'calcFunc-assign) (progn (aset info 9 (nth 1 val)) (aset info 11 (or evalled (let ((calc-embedded-info info)) (math-evaluate-expr (nth 2 val))))) (or (equal old-eval (aref info 11)) (calc-embedded-var-change (nth 1 val) (aref info 0)))) (if (eq (car-safe old-val) 'calcFunc-evalto) (setq old-val (nth 1 old-val))) (if (eq (car-safe old-val) 'calcFunc-assign) (calc-embedded-var-change (nth 1 old-val) (aref info 0))))) (set-buffer (aref info 1)) (while prev-modes (cond ((eq (car (car prev-modes)) 'the-language) (if need-display (calc-embedded-set-language (cdr (car prev-modes))))) ((eq (car (car prev-modes)) 'the-display-just) (if need-display (calc-embedded-set-justify (cdr (car prev-modes))))) (t (set (car (car prev-modes)) (cdr (car prev-modes))))) (setq prev-modes (cdr prev-modes))))) ) ;;; These are hooks called by the main part of Calc. (defun calc-embedded-select-buffer () (if (eq (current-buffer) (aref calc-embedded-info 0)) (let ((info calc-embedded-info) horiz vert) (if (and (or (< (point) (aref info 4)) (> (point) (aref info 5))) (not calc-embedded-no-reselect)) (let ((calc-embedded-quiet t)) (message "(Switching Calc Embedded mode to new formula.)") (calc-embedded nil) (calc-embedded nil))) (setq horiz (max (min (current-column) (- (point) (aref info 2))) 0) vert (if (<= (aref info 2) (point)) (- (count-lines (aref info 2) (point)) (if (bolp) 0 1)) 0)) (set-buffer (aref info 1)) (if calc-show-plain (if (= vert 0) (setq horiz 0) (setq vert (1- vert)))) (calc-cursor-stack-index 1) (if calc-line-numbering (setq horiz (+ horiz 4))) (if (> vert 0) (forward-line vert)) (forward-char (min horiz (- (point-max) (point))))) (calc-select-buffer)) ) (setq calc-embedded-no-reselect nil) (defun calc-embedded-finish-command () (let ((buf (current-buffer)) horiz vert) (save-excursion (set-buffer (aref calc-embedded-info 1)) (if (> (calc-stack-size) 0) (let ((pt (point)) (col (current-column)) (bol (bolp))) (calc-cursor-stack-index 0) (if (< pt (point)) (progn (calc-cursor-stack-index 1) (if (>= pt (point)) (progn (setq horiz (- col (if calc-line-numbering 4 0)) vert (- (count-lines (point) pt) (if bol 0 1))) (if calc-show-plain (setq vert (max 1 (1+ vert)))))))) (goto-char pt)))) (if horiz (progn (set-buffer (aref calc-embedded-info 0)) (goto-char (aref calc-embedded-info 2)) (if (> vert 0) (forward-line vert)) (forward-char (max horiz 0)) (set-buffer buf)))) ) (defun calc-embedded-stack-change () (or calc-executing-macro (save-excursion (set-buffer (aref calc-embedded-info 1)) (let* ((info calc-embedded-info) (extra-line (if (eq calc-language 'big) 1 0)) (the-point (point)) (empty (= (calc-stack-size) 0)) (entry (if empty (list '(var empty var-empty) 1 nil) (calc-top 1 'entry))) (old-val (aref info 8)) top bot str) (if empty (setq str "empty") (save-excursion (calc-cursor-stack-index 1) (setq top (point)) (calc-cursor-stack-index 0) (setq bot (- (point) extra-line)) (setq str (buffer-substring top (- bot 1)))) (if calc-line-numbering (let ((pos 0)) (setq str (substring str 4)) (while (setq pos (string-match "\n...." str pos)) (setq str (concat (substring str 0 (1+ pos)) (substring str (+ pos 5))) pos (1+ pos)))))) (calc-embedded-original-buffer t) (aset info 8 (car entry)) (calc-embedded-update info 13 nil t str entry old-val)))) ) (defun calc-embedded-mode-line-change () (let ((str mode-line-buffer-identification)) (save-excursion (calc-embedded-original-buffer t) (setq mode-line-buffer-identification str) (set-buffer-modified-p (buffer-modified-p)))) ) (defun calc-embedded-modes-change (vars) (if (eq (car vars) 'calc-language) (setq vars '(the-language))) (if (eq (car vars) 'calc-display-just) (setq vars '(the-display-just))) (while (and vars (not (rassq (car vars) calc-embedded-mode-vars))) (setq vars (cdr vars))) (if (and vars calc-mode-save-mode (not (eq calc-mode-save-mode 'save))) (save-excursion (let* ((save-mode calc-mode-save-mode) (header (if (eq save-mode 'local) "calc-mode:" (format "calc-%s-mode:" save-mode))) (the-language (calc-embedded-language)) (the-display-just (calc-embedded-justify)) (values (mapcar 'symbol-value vars)) (num (cond ((eq save-mode 'local) 12) ((eq save-mode 'edit) 13) ((eq save-mode 'perm) 14) (t nil))) base limit mname mlist) (calc-embedded-original-buffer t) (save-excursion (if (eq save-mode 'global) (setq base (point-max) limit (point-min) mlist calc-embedded-globals) (goto-char (aref calc-embedded-info 4)) (beginning-of-line) (setq base (point) limit (max (- (point) 1000) (point-min)) mlist (and num (aref calc-embedded-info num))) (and (re-search-backward (format "\\(%s\\)[^\001]*\\(%s\\)\\|\\[calc-defaults]" calc-embedded-open-formula calc-embedded-close-formula) limit t) (setq limit (point)))) (while vars (goto-char base) (if (setq mname (car (rassq (car vars) calc-embedded-mode-vars))) (let ((buffer-read-only nil) (found (assq (car vars) mlist))) (if found (setcdr found (car values)) (setq mlist (cons (cons (car vars) (car values)) mlist)) (if num (aset calc-embedded-info num mlist) (if (eq save-mode 'global) (setq calc-embedded-globals mlist)))) (if (re-search-backward (format "\\[%s *%s: *\\(\"\\([^\"\n\\]\\|\\\\.\\)*\"\\|[- ()a-zA-Z0-9]+\\)]" header mname) limit t) (progn (goto-char (match-beginning 1)) (delete-region (point) (match-end 1)) (insert (prin1-to-string (car values)))) (goto-char base) (insert-before-markers calc-embedded-open-mode "[" header " " mname ": " (prin1-to-string (car values)) "]" calc-embedded-close-mode)))) (setq vars (cdr vars) values (cdr values))))))) ) (defun calc-embedded-var-change (var &optional buf) (if (symbolp var) (setq var (list 'var (if (string-match "\\`var-.+\\'" (symbol-name var)) (intern (substring (symbol-name var) 4)) var) var))) (save-excursion (let ((manual (not calc-auto-recompute)) (bp calc-embedded-active) (first t)) (if buf (setq bp (memq (assq buf bp) bp))) (while bp (let ((calc-embedded-no-reselect t) (p (and (buffer-name (car (car bp))) (cdr (car bp))))) (while p (if (assoc var (aref (car p) 10)) (if manual (if (aref (car p) 11) (progn (aset (car p) 11 nil) (if (aref (car p) 9) (calc-embedded-var-change (aref (car p) 9))))) (set-buffer (aref (car p) 0)) (if (equal (buffer-substring (aref (car p) 2) (aref (car p) 3)) (aref (car p) 6)) (let ((calc-embedded-info nil)) (or calc-embedded-quiet (message "Recomputing...")) (setq first nil) (calc-wrapper (set-buffer (aref (car p) 0)) (calc-embedded-update (car p) 14 t nil))) (setcdr (car bp) (delq (car p) (cdr (car bp)))) (message "(Tried to recompute but formula was changed or missing.)")))) (setq p (cdr p)))) (setq bp (if buf nil (cdr bp)))) (or first calc-embedded-quiet (message "")))) ) calc-2.02c/calc-lang.el100644 22403 13 107574 5402630643 13241 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-lang.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-lang () nil) ;;; Alternate entry/display languages. (defun calc-set-language (lang &optional option no-refresh) (setq math-expr-opers (or (get lang 'math-oper-table) math-standard-opers) math-expr-function-mapping (get lang 'math-function-table) math-expr-variable-mapping (get lang 'math-variable-table) calc-language-input-filter (get lang 'math-input-filter) calc-language-output-filter (get lang 'math-output-filter) calc-vector-brackets (or (get lang 'math-vector-brackets) "[]") calc-complex-format (get lang 'math-complex-format) calc-radix-formatter (get lang 'math-radix-formatter) calc-function-open (or (get lang 'math-function-open) "(") calc-function-close (or (get lang 'math-function-close) ")")) (if no-refresh (setq calc-language lang calc-language-option option) (calc-change-mode '(calc-language calc-language-option) (list lang option) t)) ) (defun calc-normal-language () (interactive) (calc-wrapper (calc-set-language nil) (message "Normal language mode.")) ) (defun calc-flat-language () (interactive) (calc-wrapper (calc-set-language 'flat) (message "Flat language mode (all stack entries shown on one line).")) ) (defun calc-big-language () (interactive) (calc-wrapper (calc-set-language 'big) (message "\"Big\" language mode.")) ) (defun calc-unformatted-language () (interactive) (calc-wrapper (calc-set-language 'unform) (message "Unformatted language mode.")) ) (defun calc-c-language () (interactive) (calc-wrapper (calc-set-language 'c) (message "`C' language mode.")) ) (put 'c 'math-oper-table '( ( "u+" ident -1 1000 ) ( "u-" neg -1 1000 ) ( "u!" calcFunc-lnot -1 1000 ) ( "~" calcFunc-not -1 1000 ) ( "*" * 190 191 ) ( "/" / 190 191 ) ( "%" % 190 191 ) ( "+" + 180 181 ) ( "-" - 180 181 ) ( "<<" calcFunc-lsh 170 171 ) ( ">>" calcFunc-rsh 170 171 ) ( "<" calcFunc-lt 160 161 ) ( ">" calcFunc-gt 160 161 ) ( "<=" calcFunc-leq 160 161 ) ( ">=" calcFunc-geq 160 161 ) ( "==" calcFunc-eq 150 151 ) ( "!=" calcFunc-neq 150 151 ) ( "&" calcFunc-and 140 141 ) ( "^" calcFunc-xor 131 130 ) ( "|" calcFunc-or 120 121 ) ( "&&" calcFunc-land 110 111 ) ( "||" calcFunc-lor 100 101 ) ( "?" (math-read-if) 91 90 ) ( "!!!" calcFunc-pnot -1 88 ) ( "&&&" calcFunc-pand 85 86 ) ( "|||" calcFunc-por 75 76 ) ( "=" calcFunc-assign 51 50 ) ( ":=" calcFunc-assign 51 50 ) ( "::" calcFunc-condition 45 46 ) )) ; should support full assignments (put 'c 'math-function-table '( ( acos . calcFunc-arccos ) ( acosh . calcFunc-arccosh ) ( asin . calcFunc-arcsin ) ( asinh . calcFunc-arcsinh ) ( atan . calcFunc-arctan ) ( atan2 . calcFunc-arctan2 ) ( atanh . calcFunc-arctanh ) )) (put 'c 'math-variable-table '( ( M_PI . var-pi ) ( M_E . var-e ) )) (put 'c 'math-vector-brackets "{}") (put 'c 'math-radix-formatter (function (lambda (r s) (if (= r 16) (format "0x%s" s) (if (= r 8) (format "0%s" s) (format "%d#%s" r s)))))) (defun calc-pascal-language (n) (interactive "P") (calc-wrapper (and n (setq n (prefix-numeric-value n))) (calc-set-language 'pascal n) (message (if (and n (/= n 0)) (if (> n 0) "Pascal language mode (all uppercase)." "Pascal language mode (all lowercase).") "Pascal language mode."))) ) (put 'pascal 'math-oper-table '( ( "not" calcFunc-lnot -1 1000 ) ( "*" * 190 191 ) ( "/" / 190 191 ) ( "and" calcFunc-and 190 191 ) ( "div" calcFunc-idiv 190 191 ) ( "mod" % 190 191 ) ( "u+" ident -1 185 ) ( "u-" neg -1 185 ) ( "+" + 180 181 ) ( "-" - 180 181 ) ( "or" calcFunc-or 180 181 ) ( "xor" calcFunc-xor 180 181 ) ( "shl" calcFunc-lsh 180 181 ) ( "shr" calcFunc-rsh 180 181 ) ( "in" calcFunc-in 160 161 ) ( "<" calcFunc-lt 160 161 ) ( ">" calcFunc-gt 160 161 ) ( "<=" calcFunc-leq 160 161 ) ( ">=" calcFunc-geq 160 161 ) ( "=" calcFunc-eq 160 161 ) ( "<>" calcFunc-neq 160 161 ) ( "!!!" calcFunc-pnot -1 85 ) ( "&&&" calcFunc-pand 80 81 ) ( "|||" calcFunc-por 75 76 ) ( ":=" calcFunc-assign 51 50 ) ( "::" calcFunc-condition 45 46 ) )) (put 'pascal 'math-input-filter 'calc-input-case-filter) (put 'pascal 'math-output-filter 'calc-output-case-filter) (put 'pascal 'math-radix-formatter (function (lambda (r s) (if (= r 16) (format "$%s" s) (format "%d#%s" r s))))) (defun calc-input-case-filter (str) (cond ((or (null calc-language-option) (= calc-language-option 0)) str) (t (downcase str))) ) (defun calc-output-case-filter (str) (cond ((or (null calc-language-option) (= calc-language-option 0)) str) ((> calc-language-option 0) (upcase str)) (t (downcase str))) ) (defun calc-fortran-language (n) (interactive "P") (calc-wrapper (and n (setq n (prefix-numeric-value n))) (calc-set-language 'fortran n) (message (if (and n (/= n 0)) (if (> n 0) "FORTRAN language mode (all uppercase)." "FORTRAN language mode (all lowercase).") "FORTRAN language mode."))) ) (put 'fortran 'math-oper-table '( ( "u/" (math-parse-fortran-vector) -1 1 ) ( "/" (math-parse-fortran-vector-end) 1 -1 ) ( "**" ^ 201 200 ) ( "u+" ident -1 191 ) ( "u-" neg -1 191 ) ( "*" * 190 191 ) ( "/" / 190 191 ) ( "+" + 180 181 ) ( "-" - 180 181 ) ( ".LT." calcFunc-lt 160 161 ) ( ".GT." calcFunc-gt 160 161 ) ( ".LE." calcFunc-leq 160 161 ) ( ".GE." calcFunc-geq 160 161 ) ( ".EQ." calcFunc-eq 160 161 ) ( ".NE." calcFunc-neq 160 161 ) ( ".NOT." calcFunc-lnot -1 121 ) ( ".AND." calcFunc-land 110 111 ) ( ".OR." calcFunc-lor 100 101 ) ( "!!!" calcFunc-pnot -1 85 ) ( "&&&" calcFunc-pand 80 81 ) ( "|||" calcFunc-por 75 76 ) ( "=" calcFunc-assign 51 50 ) ( ":=" calcFunc-assign 51 50 ) ( "::" calcFunc-condition 45 46 ) )) (put 'fortran 'math-vector-brackets "//") (put 'fortran 'math-function-table '( ( acos . calcFunc-arccos ) ( acosh . calcFunc-arccosh ) ( aimag . calcFunc-im ) ( aint . calcFunc-ftrunc ) ( asin . calcFunc-arcsin ) ( asinh . calcFunc-arcsinh ) ( atan . calcFunc-arctan ) ( atan2 . calcFunc-arctan2 ) ( atanh . calcFunc-arctanh ) ( conjg . calcFunc-conj ) ( log . calcFunc-ln ) ( nint . calcFunc-round ) ( real . calcFunc-re ) )) (put 'fortran 'math-input-filter 'calc-input-case-filter) (put 'fortran 'math-output-filter 'calc-output-case-filter) (defun math-parse-fortran-vector (op) (let ((math-parsing-fortran-vector '(end . "\000"))) (prog1 (math-read-brackets t "]") (setq exp-token (car math-parsing-fortran-vector) exp-data (cdr math-parsing-fortran-vector)))) ) (defun math-parse-fortran-vector-end (x op) (if math-parsing-fortran-vector (progn (setq math-parsing-fortran-vector (cons exp-token exp-data) exp-token 'end exp-data "\000") x) (throw 'syntax "Unmatched closing `/'")) ) (setq math-parsing-fortran-vector nil) (defun math-parse-fortran-subscr (sym args) (setq sym (math-build-var-name sym)) (while args (setq sym (list 'calcFunc-subscr sym (car args)) args (cdr args))) sym ) (defun calc-tex-language (n) (interactive "P") (calc-wrapper (and n (setq n (prefix-numeric-value n))) (calc-set-language 'tex n) (message (if (and n (/= n 0)) (if (> n 0) "TeX language mode with \\hbox{func}(\\hbox{var})." "TeX language mode with \\func{\\hbox{var}}.") "TeX language mode."))) ) (put 'tex 'math-oper-table '( ( "u+" ident -1 1000 ) ( "u-" neg -1 1000 ) ( "\\hat" calcFunc-hat -1 950 ) ( "\\check" calcFunc-check -1 950 ) ( "\\tilde" calcFunc-tilde -1 950 ) ( "\\acute" calcFunc-acute -1 950 ) ( "\\grave" calcFunc-grave -1 950 ) ( "\\dot" calcFunc-dot -1 950 ) ( "\\ddot" calcFunc-dotdot -1 950 ) ( "\\breve" calcFunc-breve -1 950 ) ( "\\bar" calcFunc-bar -1 950 ) ( "\\vec" calcFunc-Vec -1 950 ) ( "\\underline" calcFunc-under -1 950 ) ( "u|" calcFunc-abs -1 0 ) ( "|" closing 0 -1 ) ( "\\lfloor" calcFunc-floor -1 0 ) ( "\\rfloor" closing 0 -1 ) ( "\\lceil" calcFunc-ceil -1 0 ) ( "\\rceil" closing 0 -1 ) ( "\\pm" sdev 300 300 ) ( "!" calcFunc-fact 210 -1 ) ( "^" ^ 201 200 ) ( "_" calcFunc-subscr 201 200 ) ( "\\times" * 191 190 ) ( "*" * 191 190 ) ( "2x" * 191 190 ) ( "+" + 180 181 ) ( "-" - 180 181 ) ( "\\over" / 170 171 ) ( "/" / 170 171 ) ( "\\choose" calcFunc-choose 170 171 ) ( "\\mod" % 170 171 ) ( "<" calcFunc-lt 160 161 ) ( ">" calcFunc-gt 160 161 ) ( "\\leq" calcFunc-leq 160 161 ) ( "\\geq" calcFunc-geq 160 161 ) ( "=" calcFunc-eq 160 161 ) ( "\\neq" calcFunc-neq 160 161 ) ( "\\ne" calcFunc-neq 160 161 ) ( "\\lnot" calcFunc-lnot -1 121 ) ( "\\land" calcFunc-land 110 111 ) ( "\\lor" calcFunc-lor 100 101 ) ( "?" (math-read-if) 91 90 ) ( "!!!" calcFunc-pnot -1 85 ) ( "&&&" calcFunc-pand 80 81 ) ( "|||" calcFunc-por 75 76 ) ( "\\gets" calcFunc-assign 51 50 ) ( ":=" calcFunc-assign 51 50 ) ( "::" calcFunc-condition 45 46 ) ( "\\to" calcFunc-evalto 40 41 ) ( "\\to" calcFunc-evalto 40 -1 ) ( "=>" calcFunc-evalto 40 41 ) ( "=>" calcFunc-evalto 40 -1 ) )) (put 'tex 'math-function-table '( ( \\arccos . calcFunc-arccos ) ( \\arcsin . calcFunc-arcsin ) ( \\arctan . calcFunc-arctan ) ( \\arg . calcFunc-arg ) ( \\cos . calcFunc-cos ) ( \\cosh . calcFunc-cosh ) ( \\det . calcFunc-det ) ( \\exp . calcFunc-exp ) ( \\gcd . calcFunc-gcd ) ( \\ln . calcFunc-ln ) ( \\log . calcFunc-log10 ) ( \\max . calcFunc-max ) ( \\min . calcFunc-min ) ( \\tan . calcFunc-tan ) ( \\sin . calcFunc-sin ) ( \\sinh . calcFunc-sinh ) ( \\sqrt . calcFunc-sqrt ) ( \\tanh . calcFunc-tanh ) ( \\phi . calcFunc-totient ) ( \\mu . calcFunc-moebius ) )) (put 'tex 'math-variable-table '( ( \\pi . var-pi ) ( \\infty . var-inf ) ( \\infty . var-uinf ) ( \\phi . var-phi ) ( \\gamma . var-gamma ) ( \\sum . (math-parse-tex-sum calcFunc-sum) ) ( \\prod . (math-parse-tex-sum calcFunc-prod) ) )) (put 'tex 'math-complex-format 'i) (defun math-parse-tex-sum (f val) (let (low high save) (or (equal exp-data "_") (throw 'syntax "Expected `_'")) (math-read-token) (setq save exp-old-pos) (setq low (math-read-factor)) (or (eq (car-safe low) 'calcFunc-eq) (progn (setq exp-old-pos (1+ save)) (throw 'syntax "Expected equation"))) (or (equal exp-data "^") (throw 'syntax "Expected `^'")) (math-read-token) (setq high (math-read-factor)) (list (nth 2 f) (math-read-factor) (nth 1 low) (nth 2 low) high)) ) (defun math-tex-input-filter (str) ; allow parsing of 123\,456\,789. (while (string-match "[0-9]\\\\,[0-9]" str) (setq str (concat (substring str 0 (1+ (match-beginning 0))) (substring str (1- (match-end 0)))))) str ) (put 'tex 'math-input-filter 'math-tex-input-filter) (defun calc-eqn-language (n) (interactive "P") (calc-wrapper (calc-set-language 'eqn) (message "Eqn language mode.")) ) (put 'eqn 'math-oper-table '( ( "u+" ident -1 1000 ) ( "u-" neg -1 1000 ) ( "prime" (math-parse-eqn-prime) 950 -1 ) ( "prime" calcFunc-Prime 950 -1 ) ( "dot" calcFunc-dot 950 -1 ) ( "dotdot" calcFunc-dotdot 950 -1 ) ( "hat" calcFunc-hat 950 -1 ) ( "tilde" calcFunc-tilde 950 -1 ) ( "vec" calcFunc-Vec 950 -1 ) ( "dyad" calcFunc-dyad 950 -1 ) ( "bar" calcFunc-bar 950 -1 ) ( "under" calcFunc-under 950 -1 ) ( "sub" calcFunc-subscr 931 930 ) ( "sup" ^ 921 920 ) ( "sqrt" calcFunc-sqrt -1 910 ) ( "over" / 900 901 ) ( "u|" calcFunc-abs -1 0 ) ( "|" closing 0 -1 ) ( "left floor" calcFunc-floor -1 0 ) ( "right floor" closing 0 -1 ) ( "left ceil" calcFunc-ceil -1 0 ) ( "right ceil" closing 0 -1 ) ( "+-" sdev 300 300 ) ( "!" calcFunc-fact 210 -1 ) ( "times" * 191 190 ) ( "*" * 191 190 ) ( "2x" * 191 190 ) ( "/" / 180 181 ) ( "%" % 180 181 ) ( "+" + 170 171 ) ( "-" - 170 171 ) ( "<" calcFunc-lt 160 161 ) ( ">" calcFunc-gt 160 161 ) ( "<=" calcFunc-leq 160 161 ) ( ">=" calcFunc-geq 160 161 ) ( "=" calcFunc-eq 160 161 ) ( "==" calcFunc-eq 160 161 ) ( "!=" calcFunc-neq 160 161 ) ( "u!" calcFunc-lnot -1 121 ) ( "&&" calcFunc-land 110 111 ) ( "||" calcFunc-lor 100 101 ) ( "?" (math-read-if) 91 90 ) ( "!!!" calcFunc-pnot -1 85 ) ( "&&&" calcFunc-pand 80 81 ) ( "|||" calcFunc-por 75 76 ) ( "<-" calcFunc-assign 51 50 ) ( ":=" calcFunc-assign 51 50 ) ( "::" calcFunc-condition 45 46 ) ( "->" calcFunc-evalto 40 41 ) ( "->" calcFunc-evalto 40 -1 ) ( "=>" calcFunc-evalto 40 41 ) ( "=>" calcFunc-evalto 40 -1 ) )) (put 'eqn 'math-function-table '( ( arc\ cos . calcFunc-arccos ) ( arc\ cosh . calcFunc-arccosh ) ( arc\ sin . calcFunc-arcsin ) ( arc\ sinh . calcFunc-arcsinh ) ( arc\ tan . calcFunc-arctan ) ( arc\ tanh . calcFunc-arctanh ) ( GAMMA . calcFunc-gamma ) ( phi . calcFunc-totient ) ( mu . calcFunc-moebius ) ( matrix . (math-parse-eqn-matrix) ) )) (put 'eqn 'math-variable-table '( ( inf . var-uinf ) )) (put 'eqn 'math-complex-format 'i) (defun math-parse-eqn-matrix (f sym) (let ((vec nil)) (while (assoc exp-data '(("ccol") ("lcol") ("rcol"))) (math-read-token) (or (equal exp-data calc-function-open) (throw 'syntax "Expected `{'")) (math-read-token) (setq vec (cons (cons 'vec (math-read-expr-list)) vec)) (or (equal exp-data calc-function-close) (throw 'syntax "Expected `}'")) (math-read-token)) (or (equal exp-data calc-function-close) (throw 'syntax "Expected `}'")) (math-read-token) (math-transpose (cons 'vec (nreverse vec)))) ) (defun math-parse-eqn-prime (x sym) (if (eq (car-safe x) 'var) (if (equal exp-data calc-function-open) (progn (math-read-token) (let ((args (if (or (equal exp-data calc-function-close) (eq exp-token 'end)) nil (math-read-expr-list)))) (if (not (or (equal exp-data calc-function-close) (eq exp-token 'end))) (throw 'syntax "Expected `)'")) (math-read-token) (cons (intern (format "calcFunc-%s'" (nth 1 x))) args))) (list 'var (intern (concat (symbol-name (nth 1 x)) "'")) (intern (concat (symbol-name (nth 2 x)) "'")))) (list 'calcFunc-Prime x)) ) (defun calc-mathematica-language () (interactive) (calc-wrapper (calc-set-language 'math) (message "Mathematica language mode.")) ) (put 'math 'math-oper-table '( ( "[[" (math-read-math-subscr) 250 -1 ) ( "!" calcFunc-fact 210 -1 ) ( "!!" calcFunc-dfact 210 -1 ) ( "^" ^ 201 200 ) ( "u+" ident -1 197 ) ( "u-" neg -1 197 ) ( "/" / 195 196 ) ( "*" * 190 191 ) ( "2x" * 190 191 ) ( "+" + 180 181 ) ( "-" - 180 181 ) ( "<" calcFunc-lt 160 161 ) ( ">" calcFunc-gt 160 161 ) ( "<=" calcFunc-leq 160 161 ) ( ">=" calcFunc-geq 160 161 ) ( "==" calcFunc-eq 150 151 ) ( "!=" calcFunc-neq 150 151 ) ( "u!" calcFunc-lnot -1 121 ) ( "&&" calcFunc-land 110 111 ) ( "||" calcFunc-lor 100 101 ) ( "!!!" calcFunc-pnot -1 85 ) ( "&&&" calcFunc-pand 80 81 ) ( "|||" calcFunc-por 75 76 ) ( ":=" calcFunc-assign 51 50 ) ( "=" calcFunc-assign 51 50 ) ( "->" calcFunc-assign 51 50 ) ( ":>" calcFunc-assign 51 50 ) ( "::" calcFunc-condition 45 46 ) )) (put 'math 'math-function-table '( ( Abs . calcFunc-abs ) ( ArcCos . calcFunc-arccos ) ( ArcCosh . calcFunc-arccosh ) ( ArcSin . calcFunc-arcsin ) ( ArcSinh . calcFunc-arcsinh ) ( ArcTan . calcFunc-arctan ) ( ArcTanh . calcFunc-arctanh ) ( Arg . calcFunc-arg ) ( Binomial . calcFunc-choose ) ( Ceiling . calcFunc-ceil ) ( Conjugate . calcFunc-conj ) ( Cos . calcFunc-cos ) ( Cosh . calcFunc-cosh ) ( D . calcFunc-deriv ) ( Dt . calcFunc-tderiv ) ( Det . calcFunc-det ) ( Exp . calcFunc-exp ) ( EulerPhi . calcFunc-totient ) ( Floor . calcFunc-floor ) ( Gamma . calcFunc-gamma ) ( GCD . calcFunc-gcd ) ( If . calcFunc-if ) ( Im . calcFunc-im ) ( Inverse . calcFunc-inv ) ( Integrate . calcFunc-integ ) ( Join . calcFunc-vconcat ) ( LCM . calcFunc-lcm ) ( Log . calcFunc-ln ) ( Max . calcFunc-max ) ( Min . calcFunc-min ) ( Mod . calcFunc-mod ) ( MoebiusMu . calcFunc-moebius ) ( Random . calcFunc-random ) ( Round . calcFunc-round ) ( Re . calcFunc-re ) ( Sign . calcFunc-sign ) ( Sin . calcFunc-sin ) ( Sinh . calcFunc-sinh ) ( Sqrt . calcFunc-sqrt ) ( Tan . calcFunc-tan ) ( Tanh . calcFunc-tanh ) ( Transpose . calcFunc-trn ) ( Length . calcFunc-vlen ) )) (put 'math 'math-variable-table '( ( I . var-i ) ( Pi . var-pi ) ( E . var-e ) ( GoldenRatio . var-phi ) ( EulerGamma . var-gamma ) ( Infinity . var-inf ) ( ComplexInfinity . var-uinf ) ( Indeterminate . var-nan ) )) (put 'math 'math-vector-brackets "{}") (put 'math 'math-complex-format 'I) (put 'math 'math-function-open "[") (put 'math 'math-function-close "]") (put 'math 'math-radix-formatter (function (lambda (r s) (format "%d^^%s" r s)))) (defun math-read-math-subscr (x op) (let ((idx (math-read-expr-level 0))) (or (and (equal exp-data "]") (progn (math-read-token) (equal exp-data "]"))) (throw 'syntax "Expected ']]'")) (math-read-token) (list 'calcFunc-subscr x idx)) ) (defun calc-maple-language () (interactive) (calc-wrapper (calc-set-language 'maple) (message "Maple language mode.")) ) (put 'maple 'math-oper-table '( ( "matrix" ident -1 300 ) ( "MATRIX" ident -1 300 ) ( "!" calcFunc-fact 210 -1 ) ( "^" ^ 201 200 ) ( "**" ^ 201 200 ) ( "u+" ident -1 197 ) ( "u-" neg -1 197 ) ( "/" / 191 192 ) ( "*" * 191 192 ) ( "intersect" calcFunc-vint 191 192 ) ( "+" + 180 181 ) ( "-" - 180 181 ) ( "union" calcFunc-vunion 180 181 ) ( "minus" calcFunc-vdiff 180 181 ) ( "mod" % 170 170 ) ( ".." (math-read-maple-dots) 165 165 ) ( "\\dots" (math-read-maple-dots) 165 165 ) ( "<" calcFunc-lt 160 160 ) ( ">" calcFunc-gt 160 160 ) ( "<=" calcFunc-leq 160 160 ) ( ">=" calcFunc-geq 160 160 ) ( "=" calcFunc-eq 160 160 ) ( "<>" calcFunc-neq 160 160 ) ( "not" calcFunc-lnot -1 121 ) ( "and" calcFunc-land 110 111 ) ( "or" calcFunc-lor 100 101 ) ( "!!!" calcFunc-pnot -1 85 ) ( "&&&" calcFunc-pand 80 81 ) ( "|||" calcFunc-por 75 76 ) ( ":=" calcFunc-assign 51 50 ) ( "::" calcFunc-condition 45 46 ) )) (put 'maple 'math-function-table '( ( bernoulli . calcFunc-bern ) ( binomial . calcFunc-choose ) ( diff . calcFunc-deriv ) ( GAMMA . calcFunc-gamma ) ( ifactor . calcFunc-prfac ) ( igcd . calcFunc-gcd ) ( ilcm . calcFunc-lcm ) ( int . calcFunc-integ ) ( modp . % ) ( irem . % ) ( iquo . calcFunc-idiv ) ( isprime . calcFunc-prime ) ( length . calcFunc-vlen ) ( member . calcFunc-in ) ( crossprod . calcFunc-cross ) ( inverse . calcFunc-inv ) ( trace . calcFunc-tr ) ( transpose . calcFunc-trn ) ( vectdim . calcFunc-vlen ) )) (put 'maple 'math-variable-table '( ( I . var-i ) ( Pi . var-pi ) ( E . var-e ) ( infinity . var-inf ) ( infinity . var-uinf ) ( infinity . var-nan ) )) (put 'maple 'math-complex-format 'I) (defun math-read-maple-dots (x op) (list 'intv 3 x (math-read-expr-level (nth 3 op))) ) (defun math-read-big-rec (h1 v1 h2 v2 &optional baseline prec short) (or prec (setq prec 0)) ;; Clip whitespace above or below. (while (and (< v1 v2) (math-read-big-emptyp h1 v1 h2 (1+ v1))) (setq v1 (1+ v1))) (while (and (< v1 v2) (math-read-big-emptyp h1 (1- v2) h2 v2)) (setq v2 (1- v2))) ;; If formula is a single line high, normal parser can handle it. (if (<= v2 (1+ v1)) (if (or (<= v2 v1) (> h1 (length (setq v2 (nth v1 lines))))) (math-read-big-error h1 v1) (setq the-baseline v1 the-h2 h2 v2 (nth v1 lines) h2 (math-read-expr (substring v2 h1 (min h2 (length v2))))) (if (eq (car-safe h2) 'error) (math-read-big-error (+ h1 (nth 1 h2)) v1 (nth 2 h2)) h2)) ;; Clip whitespace at left or right. (while (and (< h1 h2) (math-read-big-emptyp h1 v1 (1+ h1) v2)) (setq h1 (1+ h1))) (while (and (< h1 h2) (math-read-big-emptyp (1- h2) v1 h2 v2)) (setq h2 (1- h2))) ;; Scan to find widest left-justified "----" in the region. (let* ((widest nil) (widest-h2 0) (lines-v1 (nthcdr v1 lines)) (p lines-v1) (v v1) (other-v nil) other-char line len h) (while (< v v2) (setq line (car p) len (min h2 (length line))) (and (< h1 len) (/= (aref line h1) ?\ ) (if (and (= (aref line h1) ?\-) ;; Make sure it's not a minus sign. (or (and (< (1+ h1) len) (= (aref line (1+ h1)) ?\-)) (/= (math-read-big-char h1 (1- v)) ?\ ) (/= (math-read-big-char h1 (1+ v)) ?\ ))) (progn (setq h h1) (while (and (< (setq h (1+ h)) len) (= (aref line h) ?\-))) (if (> h widest-h2) (setq widest v widest-h2 h))) (or other-v (setq other-v v other-char (aref line h1))))) (setq v (1+ v) p (cdr p))) (cond ((not (setq v other-v)) (math-read-big-error h1 v1)) ; Should never happen! ;; Quotient. (widest (setq h widest-h2 v widest) (let ((num (math-read-big-rec h1 v1 h v)) (den (math-read-big-rec h1 (1+ v) h v2))) (setq p (if (and (math-integerp num) (math-integerp den)) (math-make-frac num den) (list '/ num den))))) ;; Big radical sign. ((= other-char ?\\) (or (= (math-read-big-char (1+ h1) v) ?\|) (math-read-big-error (1+ h1) v "Malformed root sign")) (math-read-big-emptyp h1 v1 (1+ h1) v nil t) (while (= (math-read-big-char (1+ h1) (setq v (1- v))) ?\|)) (or (= (math-read-big-char (setq h (+ h1 2)) v) ?\_) (math-read-big-error h v "Malformed root sign")) (while (= (math-read-big-char (setq h (1+ h)) v) ?\_)) (math-read-big-emptyp h1 v1 (1+ h1) v nil t) (math-read-big-emptyp h1 (1+ other-v) h v2 nil t) (setq p (list 'calcFunc-sqrt (math-read-big-rec (+ h1 2) (1+ v) h (1+ other-v) baseline)) v the-baseline)) ;; Small radical sign. ((and (= other-char ?V) (= (math-read-big-char (1+ h1) (1- v)) ?\_)) (setq h (1+ h1)) (math-read-big-emptyp h1 v1 h (1- v) nil t) (math-read-big-emptyp h1 (1+ v) h v2 nil t) (math-read-big-emptyp h1 v1 (1+ h1) v nil t) (while (= (math-read-big-char (setq h (1+ h)) (1- v)) ?\_)) (setq p (list 'calcFunc-sqrt (math-read-big-rec (1+ h1) v h (1+ v) t)) v the-baseline)) ;; Binomial coefficient. ((and (= other-char ?\() (= (math-read-big-char (1+ h1) v) ?\ ) (= (string-match "( *)" (nth v lines) h1) h1)) (setq h (match-end 0)) (math-read-big-emptyp h1 v1 (1+ h1) v nil t) (math-read-big-emptyp h1 (1+ v) (1+ h1) v2 nil t) (math-read-big-emptyp (1- h) v1 h v nil t) (math-read-big-emptyp (1- h) (1+ v) h v2 nil t) (setq p (list 'calcFunc-choose (math-read-big-rec (1+ h1) v1 (1- h) v) (math-read-big-rec (1+ h1) (1+ v) (1- h) v2)))) ;; Minus sign. ((= other-char ?\-) (setq p (list 'neg (math-read-big-rec (1+ h1) v1 h2 v2 v 250 t)) v the-baseline h the-h2)) ;; Parentheses. ((= other-char ?\() (math-read-big-emptyp h1 v1 (1+ h1) v nil t) (math-read-big-emptyp h1 (1+ v) (1+ h1) v2 nil t) (setq h (math-read-big-balance (1+ h1) v "(" t)) (math-read-big-emptyp (1- h) v1 h v nil t) (math-read-big-emptyp (1- h) (1+ v) h v2 nil t) (let ((sep (math-read-big-char (1- h) v)) hmid) (if (= sep ?\.) (setq h (1+ h))) (if (= sep ?\]) (math-read-big-error (1- h) v "Expected `)'")) (if (= sep ?\)) (setq p (math-read-big-rec (1+ h1) v1 (1- h) v2 v)) (setq hmid (math-read-big-balance h v "(") p (list p (math-read-big-rec h v1 (1- hmid) v2 v)) h hmid) (cond ((= sep ?\.) (setq p (cons 'intv (cons (if (= (math-read-big-char (1- h) v) ?\)) 0 1) p)))) ((= (math-read-big-char (1- h) v) ?\]) (math-read-big-error (1- h) v "Expected `)'")) ((= sep ?\,) (or (and (math-realp (car p)) (math-realp (nth 1 p))) (math-read-big-error h1 v "Complex components must be real")) (setq p (cons 'cplx p))) ((= sep ?\;) (or (and (math-realp (car p)) (math-anglep (nth 1 p))) (math-read-big-error h1 v "Complex components must be real")) (setq p (cons 'polar p))))))) ;; Matrix. ((and (= other-char ?\[) (or (= (math-read-big-char (setq h h1) (1+ v)) ?\[) (= (math-read-big-char (setq h (1+ h)) v) ?\[) (and (= (math-read-big-char h v) ?\ ) (= (math-read-big-char (setq h (1+ h)) v) ?\[))) (= (math-read-big-char h (1+ v)) ?\[)) (math-read-big-emptyp h1 v1 h v nil t) (let ((vtop v) (hleft h) (hright nil)) (setq p nil) (while (progn (setq h (math-read-big-balance (1+ hleft) v "[")) (if hright (or (= h hright) (math-read-big-error hright v "Expected `]'")) (setq hright h)) (setq p (cons (math-read-big-rec hleft v h (1+ v)) p)) (and (memq (math-read-big-char h v) '(?\ ?\,)) (= (math-read-big-char hleft (1+ v)) ?\[))) (setq v (1+ v))) (or (= hleft h1) (progn (if (= (math-read-big-char h v) ?\ ) (setq h (1+ h))) (and (= (math-read-big-char h v) ?\]) (setq h (1+ h)))) (math-read-big-error (1- h) v "Expected `]'")) (if (= (math-read-big-char h vtop) ?\,) (setq h (1+ h))) (math-read-big-emptyp h1 (1+ v) (1- h) v2 nil t) (setq v (+ vtop (/ (- v vtop) 2)) p (cons 'vec (nreverse p))))) ;; Square brackets. ((= other-char ?\[) (math-read-big-emptyp h1 v1 (1+ h1) v nil t) (math-read-big-emptyp h1 (1+ v) (1+ h1) v2 nil t) (setq p nil h (1+ h1)) (while (progn (setq widest (math-read-big-balance h v "[" t)) (math-read-big-emptyp (1- h) v1 h v nil t) (math-read-big-emptyp (1- h) (1+ v) h v2 nil t) (setq p (cons (math-read-big-rec h v1 (1- widest) v2 v) p) h widest) (= (math-read-big-char (1- h) v) ?\,))) (setq widest (math-read-big-char (1- h) v)) (if (or (memq widest '(?\; ?\))) (and (eq widest ?\.) (cdr p))) (math-read-big-error (1- h) v "Expected `]'")) (if (= widest ?\.) (setq h (1+ h) widest (math-read-big-balance h v "[") p (nconc p (list (math-read-big-big-rec h v1 (1- widest) v2 v))) h widest p (cons 'intv (cons (if (= (math-read-big-char (1- h) v) ?\]) 3 2) p))) (setq p (cons 'vec (nreverse p))))) ;; Date form. ((= other-char ?\<) (setq line (nth v lines)) (string-match ">" line h1) (setq h (match-end 0)) (math-read-big-emptyp h1 v1 h v nil t) (math-read-big-emptyp h1 (1+ v) h v2 nil t) (setq p (math-read-big-rec h1 v h (1+ v) v))) ;; Variable name or function call. ((or (and (>= other-char ?a) (<= other-char ?z)) (and (>= other-char ?A) (<= other-char ?Z))) (setq line (nth v lines)) (string-match "\\([a-zA-Z'_]+\\) *" line h1) (setq h (match-end 1) widest (match-end 0) p (math-match-substring line 1)) (math-read-big-emptyp h1 v1 h v nil t) (math-read-big-emptyp h1 (1+ v) h v2 nil t) (if (= (math-read-big-char widest v) ?\() (progn (setq line (if (string-match "-" p) (intern p) (intern (concat "calcFunc-" p))) h (1+ widest) p nil) (math-read-big-emptyp widest v1 h v nil t) (math-read-big-emptyp widest (1+ v) h v2 nil t) (while (progn (setq widest (math-read-big-balance h v "(" t)) (math-read-big-emptyp (1- h) v1 h v nil t) (math-read-big-emptyp (1- h) (1+ v) h v2 nil t) (setq p (cons (math-read-big-rec h v1 (1- widest) v2 v) p) h widest) (= (math-read-big-char (1- h) v) ?\,))) (or (= (math-read-big-char (1- h) v) ?\)) (math-read-big-error (1- h) v "Expected `)'")) (setq p (cons line (nreverse p)))) (setq p (list 'var (intern (math-remove-dashes p)) (if (string-match "-" p) (intern p) (intern (concat "var-" p))))))) ;; Number. (t (setq line (nth v lines)) (or (= (string-match "_?\\([0-9]+.?0*@ *\\)?\\([0-9]+.?0*' *\\)?\\([0-9]+\\(#\\|\\^\\^\\)[0-9a-zA-Z:]+\\|[0-9]+:[0-9:]+\\|[0-9.]+\\([eE][-+_]?[0-9]+\\)?\"?\\)?" line h1) h1) (math-read-big-error h v "Expected a number")) (setq h (match-end 0) p (math-read-number (math-match-substring line 0))) (math-read-big-emptyp h1 v1 h v nil t) (math-read-big-emptyp h1 (1+ v) h v2 nil t))) ;; Now left term is bounded by h1, v1, h, v2; baseline = v. (if baseline (or (= v baseline) (math-read-big-error h1 v "Inconsistent baseline in formula")) (setq baseline v)) ;; Look for superscripts or subscripts. (setq line (nth baseline lines) len (min h2 (length line)) widest h) (while (and (< widest len) (= (aref line widest) ?\ )) (setq widest (1+ widest))) (and (>= widest len) (setq widest h2)) (if (math-read-big-emptyp h v widest v2) (if (math-read-big-emptyp h v1 widest v) (setq h widest) (setq p (list '^ p (math-read-big-rec h v1 widest v)) h widest)) (if (math-read-big-emptyp h v1 widest v) (setq p (list 'calcFunc-subscr p (math-read-big-rec h v widest v2)) h widest))) ;; Look for an operator name and grab additional terms. (while (and (< h len) (if (setq widest (and (math-read-big-emptyp h v1 (1+ h) v) (math-read-big-emptyp h (1+ v) (1+ h) v2) (string-match "<=\\|>=\\|\\+/-\\|!=\\|&&\\|||\\|:=\\|=>\\|." line h) (assoc (math-match-substring line 0) math-standard-opers))) (and (>= (nth 2 widest) prec) (setq h (match-end 0))) (and (not (eq (string-match ",\\|;\\|\\.\\.\\|)\\|\\]\\|:" line h) h)) (setq widest '("2x" * 196 195))))) (cond ((eq (nth 3 widest) -1) (setq p (list (nth 1 widest) p))) ((equal (car widest) "?") (let ((y (math-read-big-rec h v1 h2 v2 baseline nil t))) (or (= (math-read-big-char the-h2 baseline) ?\:) (math-read-big-error the-h2 baseline "Expected `:'")) (setq p (list (nth 1 widest) p y (math-read-big-rec (1+ the-h2) v1 h2 v2 baseline (nth 3 widest) t)) h the-h2))) (t (setq p (list (nth 1 widest) p (math-read-big-rec h v1 h2 v2 baseline (nth 3 widest) t)) h the-h2)))) ;; Return all relevant information to caller. (setq the-baseline baseline the-h2 h) (or short (= the-h2 h2) (math-read-big-error h baseline)) p)) ) (defun math-read-big-char (h v) (or (and (>= h h1) (< h h2) (>= v v1) (< v v2) (let ((line (nth v lines))) (and line (< h (length line)) (aref line h)))) ?\ ) ) (defun math-read-big-emptyp (eh1 ev1 eh2 ev2 &optional what error) (and (< ev1 v1) (setq ev1 v1)) (and (< eh1 h1) (setq eh1 h1)) (and (> ev2 v2) (setq ev2 v2)) (and (> eh2 h2) (setq eh2 h2)) (or what (setq what ?\ )) (let ((p (nthcdr ev1 lines)) h) (while (and (< ev1 ev2) (progn (setq h (min eh2 (length (car p)))) (while (and (>= (setq h (1- h)) eh1) (= (aref (car p) h) what))) (and error (>= h eh1) (math-read-big-error h ev1 (if (stringp error) error "Whitespace expected"))) (< h eh1))) (setq ev1 (1+ ev1) p (cdr p))) (>= ev1 ev2)) ) (defun math-read-big-error (h v &optional msg) (let ((pos 0) (p lines)) (while (> v 0) (setq pos (+ pos 1 (length (car p))) p (cdr p) v (1- v))) (setq h (+ pos (min h (length (car p)))) err-msg (list 'error h (or msg "Syntax error"))) (throw 'syntax nil)) ) (defun math-read-big-balance (h v what &optional commas) (let* ((line (nth v lines)) (len (min h2 (length line))) (count 1)) (while (> count 0) (if (>= h len) (if what (math-read-big-error h1 v (format "Unmatched `%s'" what)) (setq count 0)) (if (memq (aref line h) '(?\( ?\[)) (setq count (1+ count)) (if (if (and commas (= count 1)) (or (memq (aref line h) '(?\) ?\] ?\, ?\;)) (and (eq (aref line h) ?\.) (< (1+ h) len) (eq (aref line (1+ h)) ?\.))) (memq (aref line h) '(?\) ?\]))) (setq count (1- count)))) (setq h (1+ h)))) h) ) calc-2.02c/calc-graph.el100644 22403 13 134576 5547406475 13441 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-graph.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-graph () nil) ;;; Graphics ;;; Note that some of the following initial values also occur in calc.el. (defvar calc-gnuplot-tempfile "/tmp/calc") (defvar calc-gnuplot-default-device "default") (defvar calc-gnuplot-default-output "STDOUT") (defvar calc-gnuplot-print-device "postscript") (defvar calc-gnuplot-print-output "auto") (defvar calc-gnuplot-keep-outfile nil) (defvar calc-gnuplot-version nil) (defvar calc-gnuplot-display (getenv "DISPLAY")) (defvar calc-gnuplot-geometry nil) (defvar calc-graph-default-resolution 15) (defvar calc-graph-default-resolution-3d 5) (defvar calc-graph-default-precision 5) (defvar calc-gnuplot-buffer nil) (defvar calc-gnuplot-input nil) (defvar calc-gnuplot-last-error-pos 1) (defvar calc-graph-last-device nil) (defvar calc-graph-last-output nil) (defvar calc-graph-file-cache nil) (defvar calc-graph-var-cache nil) (defvar calc-graph-data-cache nil) (defvar calc-graph-data-cache-limit 10) (defun calc-graph-fast (many) (interactive "P") (let ((calc-graph-no-auto-view t)) (calc-graph-delete t) (calc-graph-add many) (calc-graph-plot nil)) ) (defun calc-graph-fast-3d (many) (interactive "P") (let ((calc-graph-no-auto-view t)) (calc-graph-delete t) (calc-graph-add-3d many) (calc-graph-plot nil)) ) (defun calc-graph-delete (all) (interactive "P") (calc-wrapper (calc-graph-init) (save-excursion (set-buffer calc-gnuplot-input) (and (calc-graph-find-plot t all) (progn (if (looking-at "s?plot") (progn (setq calc-graph-var-cache nil) (delete-region (point) (point-max))) (delete-region (point) (1- (point-max))))))) (calc-graph-view-commands)) ) (defun calc-graph-find-plot (&optional before all) (goto-char (point-min)) (and (re-search-forward "^s?plot[ \t]+" nil t) (let ((beg (point))) (goto-char (point-max)) (if (or all (not (search-backward "," nil t)) (< (point) beg)) (progn (goto-char beg) (if before (beginning-of-line))) (or before (re-search-forward ",[ \t]+"))) t)) ) (defun calc-graph-add (many) (interactive "P") (calc-wrapper (calc-graph-init) (cond ((null many) (calc-graph-add-curve (calc-graph-lookup (calc-top-n 2)) (calc-graph-lookup (calc-top-n 1)))) ((or (consp many) (eq many 0)) (let ((xdata (calc-graph-lookup (calc-top-n 2))) (ylist (calc-top-n 1))) (or (eq (car-safe ylist) 'vec) (error "Y argument must be a vector")) (while (setq ylist (cdr ylist)) (calc-graph-add-curve xdata (calc-graph-lookup (car ylist)))))) ((> (setq many (prefix-numeric-value many)) 0) (let ((xdata (calc-graph-lookup (calc-top-n (1+ many))))) (while (> many 0) (calc-graph-add-curve xdata (calc-graph-lookup (calc-top-n many))) (setq many (1- many))))) (t (let (pair) (setq many (- many)) (while (> many 0) (setq pair (calc-top-n many)) (or (and (eq (car-safe pair) 'vec) (= (length pair) 3)) (error "Argument must be an [x,y] vector")) (calc-graph-add-curve (calc-graph-lookup (nth 1 pair)) (calc-graph-lookup (nth 2 pair))) (setq many (1- many)))))) (calc-graph-view-commands)) ) (defun calc-graph-add-3d (many) (interactive "P") (calc-wrapper (calc-graph-init) (cond ((null many) (calc-graph-add-curve (calc-graph-lookup (calc-top-n 3)) (calc-graph-lookup (calc-top-n 2)) (calc-graph-lookup (calc-top-n 1)))) ((or (consp many) (eq many 0)) (let ((xdata (calc-graph-lookup (calc-top-n 3))) (ydata (calc-graph-lookup (calc-top-n 2))) (zlist (calc-top-n 1))) (or (eq (car-safe zlist) 'vec) (error "Z argument must be a vector")) (while (setq zlist (cdr zlist)) (calc-graph-add-curve xdata ydata (calc-graph-lookup (car zlist)))))) ((> (setq many (prefix-numeric-value many)) 0) (let ((xdata (calc-graph-lookup (calc-top-n (+ many 2)))) (ydata (calc-graph-lookup (calc-top-n (+ many 1))))) (while (> many 0) (calc-graph-add-curve xdata ydata (calc-graph-lookup (calc-top-n many))) (setq many (1- many))))) (t (let (curve) (setq many (- many)) (while (> many 0) (setq curve (calc-top-n many)) (or (and (eq (car-safe curve) 'vec) (= (length curve) 4)) (error "Argument must be an [x,y,z] vector")) (calc-graph-add-curve (calc-graph-lookup (nth 1 curve)) (calc-graph-lookup (nth 2 curve)) (calc-graph-lookup (nth 3 curve))) (setq many (1- many)))))) (calc-graph-view-commands)) ) (defun calc-graph-add-curve (xdata ydata &optional zdata) (let ((num (calc-graph-count-curves)) (pstyle (calc-var-value 'var-PointStyles)) (lstyle (calc-var-value 'var-LineStyles))) (save-excursion (set-buffer calc-gnuplot-input) (goto-char (point-min)) (if (re-search-forward (if zdata "^plot[ \t]" "^splot[ \t]") nil t) (error "Can't mix 2d and 3d curves on one graph")) (if (re-search-forward "^s?plot[ \t]" nil t) (progn (end-of-line) (insert ", ")) (goto-char (point-max)) (or (eq (preceding-char) ?\n) (insert "\n")) (insert (if zdata "splot" "plot") " \n") (forward-char -1)) (insert "{" (symbol-name (nth 1 xdata)) ":" (symbol-name (nth 1 ydata))) (if zdata (insert ":" (symbol-name (nth 1 zdata)))) (insert "} " "title \"" (symbol-name (nth 1 ydata)) "\" " "with dots") (setq pstyle (and (eq (car-safe pstyle) 'vec) (nth (1+ num) pstyle))) (setq lstyle (and (eq (car-safe lstyle) 'vec) (nth (1+ num) lstyle))) (calc-graph-set-styles (or (and (Math-num-integerp lstyle) (math-trunc lstyle)) 0) (or (and (Math-num-integerp pstyle) (math-trunc pstyle)) (if (eq (car-safe (calc-var-value (nth 2 ydata))) 'vec) 0 -1))))) ) (defun calc-graph-lookup (thing) (if (and (eq (car-safe thing) 'var) (calc-var-value (nth 2 thing))) thing (let ((found (assoc thing calc-graph-var-cache))) (or found (progn (setq varname (concat "PlotData" (int-to-string (1+ (length calc-graph-var-cache)))) var (list 'var (intern varname) (intern (concat "var-" varname))) found (cons thing var) calc-graph-var-cache (cons found calc-graph-var-cache)) (set (nth 2 var) thing))) (cdr found))) ) (defun calc-graph-juggle (arg) (interactive "p") (calc-graph-init) (save-excursion (set-buffer calc-gnuplot-input) (if (< arg 0) (let ((num (calc-graph-count-curves))) (if (> num 0) (while (< arg 0) (setq arg (+ arg num)))))) (while (>= (setq arg (1- arg)) 0) (calc-graph-do-juggle))) ) (defun calc-graph-count-curves () (save-excursion (set-buffer calc-gnuplot-input) (if (re-search-forward "^s?plot[ \t]" nil t) (let ((num 1)) (goto-char (point-min)) (while (search-forward "," nil t) (setq num (1+ num))) num) 0)) ) (defun calc-graph-do-juggle () (let (base) (and (calc-graph-find-plot t t) (progn (setq base (point)) (calc-graph-find-plot t nil) (or (eq base (point)) (let ((str (buffer-substring (+ (point) 2) (1- (point-max))))) (delete-region (point) (1- (point-max))) (goto-char (+ base 5)) (insert str ", ")))))) ) (defun calc-graph-print (flag) (interactive "P") (calc-graph-plot flag t) ) (defun calc-graph-plot (flag &optional printing) (interactive "P") (calc-slow-wrapper (let ((calcbuf (current-buffer)) (tempbuf (get-buffer-create "*Gnuplot Temp-2*")) (tempbuftop 1) (tempoutfile nil) (curve-num 0) (refine (and flag (> (prefix-numeric-value flag) 0))) (recompute (and flag (< (prefix-numeric-value flag) 0))) (surprise-splot nil) (tty-output nil) cache-env is-splot device output resolution precision samples-pos) (or (boundp 'calc-graph-prev-kill-hook) (if calc-emacs-type-19 (progn (setq calc-graph-prev-kill-hook nil) (add-hook 'kill-emacs-hook 'calc-graph-kill-hook)) (setq calc-graph-prev-kill-hook kill-emacs-hook) (setq kill-emacs-hook 'calc-graph-kill-hook))) (save-excursion (calc-graph-init) (set-buffer tempbuf) (erase-buffer) (set-buffer calc-gnuplot-input) (goto-char (point-min)) (setq is-splot (re-search-forward "^splot[ \t]" nil t)) (let ((str (buffer-string)) (ver calc-gnuplot-version)) (set-buffer (get-buffer-create "*Gnuplot Temp*")) (erase-buffer) (insert "# (Note: This is a temporary copy---do not edit!)\n") (if (>= ver 2) (insert "set noarrow\nset nolabel\n" "set autoscale xy\nset nologscale xy\n" "set xlabel\nset ylabel\nset title\n" "set noclip points\nset clip one\nset clip two\n" "set format \"%g\"\nset tics\nset xtics\nset ytics\n" "set data style linespoints\n" "set nogrid\nset nokey\nset nopolar\n")) (if (>= ver 3) (insert "set surface\nset nocontour\n" "set " (if is-splot "" "no") "parametric\n" "set notime\nset border\nset ztics\nset zeroaxis\n" "set view 60,30,1,1\nset offsets 0,0,0,0\n")) (setq samples-pos (point)) (insert "\n\n" str)) (goto-char (point-min)) (if is-splot (if refine (error "This option works only for 2d plots") (setq recompute t))) (let ((calc-gnuplot-input (current-buffer)) (calc-graph-no-auto-view t)) (if printing (setq device calc-gnuplot-print-device output calc-gnuplot-print-output) (setq device (calc-graph-find-command "terminal") output (calc-graph-find-command "output")) (or device (setq device calc-gnuplot-default-device)) (if output (setq output (car (read-from-string output))) (setq output calc-gnuplot-default-output))) (if (or (equal device "") (equal device "default")) (setq device (if printing "postscript" (if (or (eq window-system 'x) (getenv "DISPLAY")) "x11" (if (>= calc-gnuplot-version 3) "dumb" "postscript"))))) (if (equal device "dumb") (setq device (format "dumb %d %d" (1- (screen-width)) (1- (screen-height))))) (if (equal device "big") (setq device (format "dumb %d %d" (* 4 (- (screen-width) 3)) (* 4 (- (screen-height) 3))))) (if (stringp output) (if (or (equal output "auto") (and (equal output "tty") (setq tty-output t))) (setq tempoutfile (calc-temp-file-name -1) output tempoutfile)) (setq output (eval output))) (or (equal device calc-graph-last-device) (progn (setq calc-graph-last-device device) (calc-gnuplot-command "set terminal" device))) (or (equal output calc-graph-last-output) (progn (setq calc-graph-last-output output) (calc-gnuplot-command "set output" (if (equal output "STDOUT") "" (prin1-to-string output))))) (setq resolution (calc-graph-find-command "samples")) (if resolution (setq resolution (string-to-int resolution)) (setq resolution (if is-splot calc-graph-default-resolution-3d calc-graph-default-resolution))) (setq precision (calc-graph-find-command "precision")) (if precision (setq precision (string-to-int precision)) (setq precision calc-graph-default-precision)) (calc-graph-set-command "terminal") (calc-graph-set-command "output") (calc-graph-set-command "samples") (calc-graph-set-command "precision")) (goto-char samples-pos) (insert "set samples " (int-to-string (max (if is-splot 20 200) (+ 5 resolution))) "\n") (while (re-search-forward "{\\*[^}]+}[^,\n]*" nil t) (delete-region (match-beginning 0) (match-end 0)) (if (looking-at ",") (delete-char 1) (while (memq (preceding-char) '(?\ ?\t)) (forward-char -1)) (if (eq (preceding-char) ?\,) (delete-backward-char 1)))) (save-excursion (set-buffer calcbuf) (setq cache-env (list calc-angle-mode calc-complex-mode calc-simplify-mode calc-infinite-mode calc-word-size precision is-splot)) (if (and (not recompute) (equal (cdr (car calc-graph-data-cache)) cache-env)) (while (> (length calc-graph-data-cache) calc-graph-data-cache-limit) (setcdr calc-graph-data-cache (cdr (cdr calc-graph-data-cache)))) (setq calc-graph-data-cache (list (cons nil cache-env))))) (calc-graph-find-plot t t) (while (re-search-forward (if is-splot "{\\([^{}:\n]+\\):\\([^{}:\n]+\\):\\([^{}:\n]+\\)}" "{\\([^{}:\n]+\\)\\(:\\)\\([^{}:\n]+\\)}") nil t) (setq curve-num (1+ curve-num)) (let* ((xname (buffer-substring (match-beginning 1) (match-end 1))) (xvar (intern (concat "var-" xname))) (xvalue (math-evaluate-expr (calc-var-value xvar))) (y3name (and is-splot (buffer-substring (match-beginning 2) (match-end 2)))) (y3var (and is-splot (intern (concat "var-" y3name)))) (y3value (and is-splot (calc-var-value y3var))) (yname (buffer-substring (match-beginning 3) (match-end 3))) (yvar (intern (concat "var-" yname))) (yvalue (calc-var-value yvar)) filename) (delete-region (match-beginning 0) (match-end 0)) (setq filename (calc-temp-file-name curve-num)) (save-excursion (set-buffer calcbuf) (let (tempbuftop (xp xvalue) (yp yvalue) (zp nil) (xlow nil) (xhigh nil) (y3low nil) (y3high nil) xvec xval xstep var-DUMMY y3vec y3val y3step var-DUMMY2 (zval nil) yvec yval ycache ycacheptr yvector numsteps numsteps3 (keep-file (and (not is-splot) (file-exists-p filename))) (stepcount 0) (calc-symbolic-mode nil) (calc-prefer-frac nil) (calc-internal-prec (max 3 precision)) (calc-simplify-mode (and (not (memq calc-simplify-mode '(none num))) calc-simplify-mode)) (blank t) (non-blank nil) (math-working-step 0) (math-working-step-2 nil)) (save-excursion (if is-splot (calc-graph-compute-3d) (calc-graph-compute-2d)) (set-buffer tempbuf) (goto-char (point-max)) (insert "\n" xname) (if is-splot (insert ":" y3name)) (insert ":" yname "\n\n") (setq tempbuftop (point)) (let ((calc-group-digits nil) (calc-leading-zeros nil) (calc-number-radix 10) (entry (and (not is-splot) (list xp yp xhigh numsteps)))) (or (equal entry (nth 1 (nth (1+ curve-num) calc-graph-file-cache))) (setq keep-file nil)) (setcar (cdr (nth (1+ curve-num) calc-graph-file-cache)) entry) (or keep-file (calc-graph-format-data))) (or keep-file (progn (or non-blank (error "No valid data points for %s:%s" xname yname)) (write-region tempbuftop (point-max) filename nil 'quiet)))))) (insert (prin1-to-string filename)))) (if surprise-splot (setcdr cache-env nil)) (if (= curve-num 0) (progn (calc-gnuplot-command "clear") (calc-clear-command-flag 'clear-message) (message "No data to plot!")) (setq calc-graph-data-cache-limit (max curve-num calc-graph-data-cache-limit) filename (calc-temp-file-name 0)) (write-region (point-min) (point-max) filename nil 'quiet) (calc-gnuplot-command "load" (prin1-to-string filename)) (or (equal output "STDOUT") calc-gnuplot-keep-outfile (progn ; need to close the output file before printing/plotting (setq calc-graph-last-output "STDOUT") (calc-gnuplot-command "set output"))) (let ((command (if printing calc-gnuplot-print-command (or calc-gnuplot-plot-command (and (string-match "^dumb" device) 'calc-graph-show-dumb) (and tty-output 'calc-graph-show-tty))))) (if command (if (stringp command) (calc-gnuplot-command "!" (format command (or tempoutfile calc-gnuplot-print-output))) (if (symbolp command) (funcall command output) (eval command))))))))) ) (defun calc-graph-compute-2d () (if (setq yvec (eq (car-safe yvalue) 'vec)) (if (= (setq numsteps (1- (length yvalue))) 0) (error "Can't plot an empty vector") (if (setq xvec (eq (car-safe xvalue) 'vec)) (or (= (1- (length xvalue)) numsteps) (error "%s and %s have different lengths" xname yname)) (if (and (eq (car-safe xvalue) 'intv) (math-constp xvalue)) (setq xstep (math-div (math-sub (nth 3 xvalue) (nth 2 xvalue)) (1- numsteps)) xvalue (nth 2 xvalue)) (if (math-realp xvalue) (setq xstep 1) (error "%s is not a suitable basis for %s" xname yname))))) (or (math-realp yvalue) (let ((arglist nil)) (setq yvalue (math-evaluate-expr yvalue)) (calc-default-formula-arglist yvalue) (or arglist (error "%s does not contain any unassigned variables" yname)) (and (cdr arglist) (error "%s contains more than one variable: %s" yname arglist)) (setq yvalue (math-expr-subst yvalue (math-build-var-name (car arglist)) '(var DUMMY var-DUMMY))))) (setq ycache (assoc yvalue calc-graph-data-cache)) (delq ycache calc-graph-data-cache) (nconc calc-graph-data-cache (list (or ycache (setq ycache (list yvalue))))) (if (and (not (setq xvec (eq (car-safe xvalue) 'vec))) refine (cdr (cdr ycache))) (calc-graph-refine-2d) (calc-graph-recompute-2d))) ) (defun calc-graph-refine-2d () (setq keep-file nil ycacheptr (cdr ycache)) (if (and (setq xval (calc-graph-find-command "xrange")) (string-match "\\`\\[\\([0-9.eE+-]*\\):\\([0-9.eE+-]*\\)\\]\\'" xval)) (let ((b2 (match-beginning 2)) (e2 (match-end 2))) (setq xlow (math-read-number (substring xval (match-beginning 1) (match-end 1))) xhigh (math-read-number (substring xval b2 e2)))) (if xlow (while (and (cdr ycacheptr) (Math-lessp (car (nth 1 ycacheptr)) xlow)) (setq ycacheptr (cdr ycacheptr))))) (setq math-working-step-2 (1- (length ycacheptr))) (while (and (cdr ycacheptr) (or (not xhigh) (Math-lessp (car (car ycacheptr)) xhigh))) (setq var-DUMMY (math-div (math-add (car (car ycacheptr)) (car (nth 1 ycacheptr))) 2) math-working-step (1+ math-working-step) yval (math-evaluate-expr yvalue)) (setcdr ycacheptr (cons (cons var-DUMMY yval) (cdr ycacheptr))) (setq ycacheptr (cdr (cdr ycacheptr)))) (setq yp ycache numsteps 1000000) ) (defun calc-graph-recompute-2d () (setq ycacheptr ycache) (if xvec (setq numsteps (1- (length xvalue)) yvector nil) (if (and (eq (car-safe xvalue) 'intv) (math-constp xvalue)) (setq numsteps resolution yp nil xlow (nth 2 xvalue) xhigh (nth 3 xvalue) xstep (math-div (math-sub xhigh xlow) (1- numsteps)) xvalue (nth 2 xvalue)) (error "%s is not a suitable basis for %s" xname yname))) (setq math-working-step-2 numsteps) (while (>= (setq numsteps (1- numsteps)) 0) (setq math-working-step (1+ math-working-step)) (if xvec (progn (setq xp (cdr xp) xval (car xp)) (and (not (eq ycacheptr ycache)) (consp (car ycacheptr)) (not (Math-lessp (car (car ycacheptr)) xval)) (setq ycacheptr ycache))) (if (= numsteps 0) (setq xval xhigh) ; avoid cumulative roundoff (setq xval xvalue xvalue (math-add xvalue xstep)))) (while (and (cdr ycacheptr) (Math-lessp (car (nth 1 ycacheptr)) xval)) (setq ycacheptr (cdr ycacheptr))) (or (and (cdr ycacheptr) (Math-equal (car (nth 1 ycacheptr)) xval)) (progn (setq keep-file nil var-DUMMY xval) (setcdr ycacheptr (cons (cons xval (math-evaluate-expr yvalue)) (cdr ycacheptr))))) (setq ycacheptr (cdr ycacheptr)) (if xvec (setq yvector (cons (cdr (car ycacheptr)) yvector)) (or yp (setq yp ycacheptr)))) (if xvec (setq xp xvalue yvec t yp (cons 'vec (nreverse yvector)) numsteps (1- (length xp))) (setq numsteps 1000000)) ) (defun calc-graph-compute-3d () (if (setq yvec (eq (car-safe yvalue) 'vec)) (if (math-matrixp yvalue) (progn (setq numsteps (1- (length yvalue)) numsteps3 (1- (length (nth 1 yvalue)))) (if (eq (car-safe xvalue) 'vec) (or (= (1- (length xvalue)) numsteps) (error "%s has wrong length" xname)) (if (and (eq (car-safe xvalue) 'intv) (math-constp xvalue)) (setq xvalue (calcFunc-index numsteps (nth 2 xvalue) (math-div (math-sub (nth 3 xvalue) (nth 2 xvalue)) (1- numsteps)))) (if (math-realp xvalue) (setq xvalue (calcFunc-index numsteps xvalue 1)) (error "%s is not a suitable basis for %s" xname yname)))) (if (eq (car-safe y3value) 'vec) (or (= (1- (length y3value)) numsteps3) (error "%s has wrong length" y3name)) (if (and (eq (car-safe y3value) 'intv) (math-constp y3value)) (setq y3value (calcFunc-index numsteps3 (nth 2 y3value) (math-div (math-sub (nth 3 y3value) (nth 2 y3value)) (1- numsteps3)))) (if (math-realp y3value) (setq y3value (calcFunc-index numsteps3 y3value 1)) (error "%s is not a suitable basis for %s" y3name yname)))) (setq xp nil yp nil zp nil xvec t) (while (setq xvalue (cdr xvalue) yvalue (cdr yvalue)) (setq xp (nconc xp (make-list (1+ numsteps3) (car xvalue))) yp (nconc yp (cons 0 (copy-sequence (cdr y3value)))) zp (nconc zp (cons '(skip) (copy-sequence (cdr (car yvalue))))))) (setq numsteps (1- (* numsteps (1+ numsteps3))))) (if (= (setq numsteps (1- (length yvalue))) 0) (error "Can't plot an empty vector")) (or (and (eq (car-safe xvalue) 'vec) (= (1- (length xvalue)) numsteps)) (error "%s is not a suitable basis for %s" xname yname)) (or (and (eq (car-safe y3value) 'vec) (= (1- (length y3value)) numsteps)) (error "%s is not a suitable basis for %s" y3name yname)) (setq xp xvalue yp y3value zp yvalue xvec t)) (or (math-realp yvalue) (let ((arglist nil)) (setq yvalue (math-evaluate-expr yvalue)) (calc-default-formula-arglist yvalue) (setq arglist (sort arglist 'string-lessp)) (or (cdr arglist) (error "%s does not contain enough unassigned variables" yname)) (and (cdr (cdr arglist)) (error "%s contains too many variables: %s" yname arglist)) (setq yvalue (math-multi-subst yvalue (mapcar 'math-build-var-name arglist) '((var DUMMY var-DUMMY) (var DUMMY2 var-DUMMY2)))))) (if (setq xvec (eq (car-safe xvalue) 'vec)) (setq numsteps (1- (length xvalue))) (if (and (eq (car-safe xvalue) 'intv) (math-constp xvalue)) (setq numsteps resolution xvalue (calcFunc-index numsteps (nth 2 xvalue) (math-div (math-sub (nth 3 xvalue) (nth 2 xvalue)) (1- numsteps)))) (error "%s is not a suitable basis for %s" xname yname))) (if (setq y3vec (eq (car-safe y3value) 'vec)) (setq numsteps3 (1- (length y3value))) (if (and (eq (car-safe y3value) 'intv) (math-constp y3value)) (setq numsteps3 resolution y3value (calcFunc-index numsteps3 (nth 2 y3value) (math-div (math-sub (nth 3 y3value) (nth 2 y3value)) (1- numsteps3)))) (error "%s is not a suitable basis for %s" y3name yname))) (setq xp nil yp nil zp nil xvec t) (setq math-working-step 0) (while (setq xvalue (cdr xvalue)) (setq xp (nconc xp (make-list (1+ numsteps3) (car xvalue))) yp (nconc yp (cons 0 (copy-sequence (cdr y3value)))) zp (cons '(skip) zp) y3step y3value var-DUMMY (car xvalue) math-working-step-2 0 math-working-step (1+ math-working-step)) (while (setq y3step (cdr y3step)) (setq math-working-step-2 (1+ math-working-step-2) var-DUMMY2 (car y3step) zp (cons (math-evaluate-expr yvalue) zp)))) (setq zp (nreverse zp) numsteps (1- (* numsteps (1+ numsteps3))))) ) (defun calc-graph-format-data () (while (<= (setq stepcount (1+ stepcount)) numsteps) (if xvec (setq xp (cdr xp) xval (car xp) yp (cdr yp) yval (car yp) zp (cdr zp) zval (car zp)) (if yvec (setq xval xvalue xvalue (math-add xvalue xstep) yp (cdr yp) yval (car yp)) (setq xval (car (car yp)) yval (cdr (car yp)) yp (cdr yp)) (if (or (not yp) (and xhigh (equal xval xhigh))) (setq numsteps 0)))) (if is-splot (if (and (eq (car-safe zval) 'calcFunc-xyz) (= (length zval) 4)) (setq xval (nth 1 zval) yval (nth 2 zval) zval (nth 3 zval))) (if (and (eq (car-safe yval) 'calcFunc-xyz) (= (length yval) 4)) (progn (or surprise-splot (save-excursion (set-buffer (get-buffer-create "*Gnuplot Temp*")) (save-excursion (goto-char (point-max)) (re-search-backward "^plot[ \t]") (insert "set parametric\ns") (setq surprise-splot t)))) (setq xval (nth 1 yval) zval (nth 3 yval) yval (nth 2 yval))) (if (and (eq (car-safe yval) 'calcFunc-xy) (= (length yval) 3)) (setq xval (nth 1 yval) yval (nth 2 yval))))) (if (and (Math-realp xval) (Math-realp yval) (or (not zval) (Math-realp zval))) (progn (setq blank nil non-blank t) (if (Math-integerp xval) (insert (math-format-number xval)) (if (eq (car xval) 'frac) (setq xval (math-float xval))) (insert (math-format-number (nth 1 xval)) "e" (int-to-string (nth 2 xval)))) (insert " ") (if (Math-integerp yval) (insert (math-format-number yval)) (if (eq (car yval) 'frac) (setq yval (math-float yval))) (insert (math-format-number (nth 1 yval)) "e" (int-to-string (nth 2 yval)))) (if zval (progn (insert " ") (if (Math-integerp zval) (insert (math-format-number zval)) (if (eq (car zval) 'frac) (setq zval (math-float zval))) (insert (math-format-number (nth 1 zval)) "e" (int-to-string (nth 2 zval)))))) (insert "\n")) (and (not (equal zval '(skip))) (boundp 'var-PlotRejects) (eq (car-safe var-PlotRejects) 'vec) (nconc var-PlotRejects (list (list 'vec curve-num stepcount xval yval))) (calc-refresh-evaltos 'var-PlotRejects)) (or blank (progn (insert "\n") (setq blank t))))) ) (defun calc-temp-file-name (num) (while (<= (length calc-graph-file-cache) (1+ num)) (setq calc-graph-file-cache (nconc calc-graph-file-cache (list nil)))) (car (or (nth (1+ num) calc-graph-file-cache) (setcar (nthcdr (1+ num) calc-graph-file-cache) (list (make-temp-name (concat calc-gnuplot-tempfile (if (<= num 0) (char-to-string (- ?A num)) (int-to-string num)))) nil)))) ) (defun calc-graph-delete-temps () (while calc-graph-file-cache (and (car calc-graph-file-cache) (file-exists-p (car (car calc-graph-file-cache))) (condition-case err (delete-file (car (car calc-graph-file-cache))) (error nil))) (setq calc-graph-file-cache (cdr calc-graph-file-cache))) ) (defun calc-graph-kill-hook () (calc-graph-delete-temps) (if calc-graph-prev-kill-hook (funcall calc-graph-prev-kill-hook)) ) (defun calc-graph-show-tty (output) "Default calc-gnuplot-plot-command for \"tty\" output mode. This is useful for tek40xx and other graphics-terminal types." (call-process-region 1 1 shell-file-name nil calc-gnuplot-buffer nil "-c" (format "cat %s >/dev/tty; rm %s" output output)) ) (defun calc-graph-show-dumb (&optional output) "Default calc-gnuplot-plot-command for Pinard's \"dumb\" terminal type. This \"dumb\" driver will be present in Gnuplot 3.0." (interactive) (save-window-excursion (switch-to-buffer calc-gnuplot-buffer) (delete-other-windows) (goto-char calc-gnuplot-trail-mark) (or (search-forward "\f" nil t) (sleep-for 1)) (goto-char (point-max)) (re-search-backward "\f\\|^[ \t]+\\^$\\|G N U P L O T") (setq found-pt (point)) (if (looking-at "\f") (progn (forward-char 1) (if (eolp) (forward-line 1)) (or (calc-graph-find-command "time") (calc-graph-find-command "title") (calc-graph-find-command "ylabel") (let ((pt (point))) (insert-before-markers (format "(%s)" (current-time-string))) (goto-char pt))) (set-window-start (selected-window) (point)) (goto-char (point-max))) (end-of-line) (backward-char 1) (recenter '(4))) (or (boundp 'calc-dumb-map) (progn (setq calc-dumb-map (make-sparse-keymap)) (define-key calc-dumb-map "\n" 'scroll-up) (define-key calc-dumb-map " " 'scroll-up) (define-key calc-dumb-map "\177" 'scroll-down) (define-key calc-dumb-map "<" 'scroll-left) (define-key calc-dumb-map ">" 'scroll-right) (define-key calc-dumb-map "{" 'scroll-down) (define-key calc-dumb-map "}" 'scroll-up) (define-key calc-dumb-map "q" 'exit-recursive-edit) (define-key calc-dumb-map "\C-c\C-c" 'exit-recursive-edit))) (use-local-map calc-dumb-map) (setq truncate-lines t) (message "Type `q'%s to return to Calc." (if (eq (lookup-key (current-global-map) "\e#") 'calc-dispatch) " or `M-# M-#'" "")) (recursive-edit) (bury-buffer "*Gnuplot Trail*")) ) (defun calc-graph-clear () (interactive) (if calc-graph-last-device (if (or (equal calc-graph-last-device "x11") (equal calc-graph-last-device "X11")) (calc-gnuplot-command "set output" (if (equal calc-graph-last-output "STDOUT") "" (prin1-to-string calc-graph-last-output))) (calc-gnuplot-command "clear"))) ) (defun calc-graph-title-x (title) (interactive "sX axis title: ") (calc-graph-set-command "xlabel" (if (not (equal title "")) (prin1-to-string title))) ) (defun calc-graph-title-y (title) (interactive "sY axis title: ") (calc-graph-set-command "ylabel" (if (not (equal title "")) (prin1-to-string title))) ) (defun calc-graph-title-z (title) (interactive "sZ axis title: ") (calc-graph-set-command "zlabel" (if (not (equal title "")) (prin1-to-string title))) ) (defun calc-graph-range-x (range) (interactive "sX axis range: ") (calc-graph-set-range "xrange" range) ) (defun calc-graph-range-y (range) (interactive "sY axis range: ") (calc-graph-set-range "yrange" range) ) (defun calc-graph-range-z (range) (interactive "sZ axis range: ") (calc-graph-set-range "zrange" range) ) (defun calc-graph-set-range (cmd range) (if (equal range "$") (calc-wrapper (let ((val (calc-top-n 1))) (if (and (eq (car-safe val) 'intv) (math-constp val)) (setq range (concat (math-format-number (math-float (nth 2 val))) ":" (math-format-number (math-float (nth 3 val))))) (if (and (eq (car-safe val) 'vec) (= (length val) 3)) (setq range (concat (math-format-number (math-float (nth 1 val))) ":" (math-format-number (math-float (nth 2 val))))) (error "Range specification must be an interval or 2-vector"))) (calc-pop-stack 1)))) (if (string-match "\\[.+\\]" range) (setq range (substring range 1 -1))) (if (and (not (string-match ":" range)) (or (string-match "," range) (string-match " " range))) (aset range (match-beginning 0) ?\:)) (calc-graph-set-command cmd (if (not (equal range "")) (concat "[" range "]"))) ) (defun calc-graph-log-x (flag) (interactive "P") (calc-graph-set-log flag 0 0) ) (defun calc-graph-log-y (flag) (interactive "P") (calc-graph-set-log 0 flag 0) ) (defun calc-graph-log-z (flag) (interactive "P") (calc-graph-set-log 0 0 flag) ) (defun calc-graph-set-log (xflag yflag zflag) (let* ((old (or (calc-graph-find-command "logscale") "")) (xold (string-match "x" old)) (yold (string-match "y" old)) (zold (string-match "z" old)) str) (setq str (concat (if (if xflag (if (eq xflag 0) xold (> (prefix-numeric-value xflag) 0)) (not xold)) "x" "") (if (if yflag (if (eq yflag 0) yold (> (prefix-numeric-value yflag) 0)) (not yold)) "y" "") (if (if zflag (if (eq zflag 0) zold (> (prefix-numeric-value zflag) 0)) (not zold)) "z" ""))) (calc-graph-set-command "logscale" (if (not (equal str "")) str))) ) (defun calc-graph-line-style (style) (interactive "P") (calc-graph-set-styles (and style (prefix-numeric-value style)) t) ) (defun calc-graph-point-style (style) (interactive "P") (calc-graph-set-styles t (and style (prefix-numeric-value style))) ) (defun calc-graph-set-styles (lines points) (calc-graph-init) (save-excursion (set-buffer calc-gnuplot-input) (or (calc-graph-find-plot nil nil) (error "No data points have been set!")) (let ((base (point)) (mode nil) (lstyle nil) (pstyle nil) start end lenbl penbl) (re-search-forward "[,\n]") (forward-char -1) (setq end (point) start end) (goto-char base) (if (looking-at "[^,\n]*[^,\n \t]\\([ \t]+with\\)") (progn (setq start (match-beginning 1)) (goto-char (match-end 0)) (if (looking-at "[ \t]+\\([a-z]+\\)") (setq mode (buffer-substring (match-beginning 1) (match-end 1)))) (if (looking-at "[ \ta-z]+\\([0-9]+\\)") (setq lstyle (string-to-int (buffer-substring (match-beginning 1) (match-end 1))))) (if (looking-at "[ \ta-z]+[0-9]+[ \t]+\\([0-9]+\\)") (setq pstyle (string-to-int (buffer-substring (match-beginning 1) (match-end 1))))))) (setq lenbl (or (equal mode "lines") (equal mode "linespoints")) penbl (or (equal mode "points") (equal mode "linespoints"))) (if lines (or (eq lines t) (setq lstyle lines lenbl (>= lines 0))) (setq lenbl (not lenbl))) (if points (or (eq points t) (setq pstyle points penbl (>= points 0))) (setq penbl (not penbl))) (delete-region start end) (goto-char start) (insert " with " (if lenbl (if penbl "linespoints" "lines") (if penbl "points" "dots"))) (if (and pstyle (> pstyle 0)) (insert " " (if (and lstyle (> lstyle 0)) (int-to-string lstyle) "1") " " (int-to-string pstyle)) (if (and lstyle (> lstyle 0)) (insert " " (int-to-string lstyle)))))) (calc-graph-view-commands) ) (defun calc-graph-zero-x (flag) (interactive "P") (calc-graph-set-command "noxzeroaxis" (and (if flag (<= (prefix-numeric-value flag) 0) (not (calc-graph-find-command "noxzeroaxis"))) " ")) ) (defun calc-graph-zero-y (flag) (interactive "P") (calc-graph-set-command "noyzeroaxis" (and (if flag (<= (prefix-numeric-value flag) 0) (not (calc-graph-find-command "noyzeroaxis"))) " ")) ) (defun calc-graph-name (name) (interactive "sTitle for current curve: ") (calc-graph-init) (save-excursion (set-buffer calc-gnuplot-input) (or (calc-graph-find-plot nil nil) (error "No data points have been set!")) (let ((base (point)) start) (re-search-forward "[,\n]\\|[ \t]+with") (setq end (match-beginning 0)) (goto-char base) (if (looking-at "[^,\n]*[^,\n \t]\\([ \t]+title\\)") (progn (goto-char (match-beginning 1)) (delete-region (point) end)) (goto-char end)) (insert " title " (prin1-to-string name)))) (calc-graph-view-commands) ) (defun calc-graph-hide (flag) (interactive "P") (calc-graph-init) (and (calc-graph-find-plot nil nil) (progn (or (looking-at "{") (error "Can't hide this curve (wrong format)")) (forward-char 1) (if (looking-at "*") (if (or (null flag) (<= (prefix-numeric-value flag) 0)) (delete-char 1)) (if (or (null flag) (> (prefix-numeric-value flag) 0)) (insert "*"))))) ) (defun calc-graph-header (title) (interactive "sTitle for entire graph: ") (calc-graph-set-command "title" (if (not (equal title "")) (prin1-to-string title))) ) (defun calc-graph-border (flag) (interactive "P") (calc-graph-set-command "noborder" (and (if flag (<= (prefix-numeric-value flag) 0) (not (calc-graph-find-command "noborder"))) " ")) ) (defun calc-graph-grid (flag) (interactive "P") (calc-graph-set-command "grid" (and (if flag (> (prefix-numeric-value flag) 0) (not (calc-graph-find-command "grid"))) " ")) ) (defun calc-graph-key (flag) (interactive "P") (calc-graph-set-command "key" (and (if flag (> (prefix-numeric-value flag) 0) (not (calc-graph-find-command "key"))) " ")) ) (defun calc-graph-num-points (res flag) (interactive "sNumber of data points: \nP") (if flag (if (> (prefix-numeric-value flag) 0) (if (equal res "") (message "Default resolution is %d." calc-graph-default-resolution) (setq calc-graph-default-resolution (string-to-int res))) (if (equal res "") (message "Default 3D resolution is %d." calc-graph-default-resolution-3d) (setq calc-graph-default-resolution-3d (string-to-int res)))) (calc-graph-set-command "samples" (if (not (equal res "")) res))) ) (defun calc-graph-device (name flag) (interactive "sDevice name: \nP") (if (equal name "?") (progn (calc-gnuplot-command "set terminal") (calc-graph-view-trail)) (if flag (if (> (prefix-numeric-value flag) 0) (if (equal name "") (message "Default GNUPLOT device is \"%s\"." calc-gnuplot-default-device) (setq calc-gnuplot-default-device name)) (if (equal name "") (message "GNUPLOT device for Print command is \"%s\"." calc-gnuplot-print-device) (setq calc-gnuplot-print-device name))) (calc-graph-set-command "terminal" (if (not (equal name "")) name)))) ) (defun calc-graph-output (name flag) (interactive "FOutput file name: \np") (cond ((string-match "\\<[aA][uU][tT][oO]$" name) (setq name "auto")) ((string-match "\\<[tT][tT][yY]$" name) (setq name "tty")) ((string-match "\\<[sS][tT][dD][oO][uU][tT]$" name) (setq name "STDOUT")) ((equal (file-name-nondirectory name) "") (setq name "")) (t (setq name (expand-file-name name)))) (if flag (if (> (prefix-numeric-value flag) 0) (if (equal name "") (message "Default GNUPLOT output file is \"%s\"." calc-gnuplot-default-output) (setq calc-gnuplot-default-output name)) (if (equal name "") (message "GNUPLOT output file for Print command is \"%s\"." calc-gnuplot-print-output) (setq calc-gnuplot-print-output name))) (calc-graph-set-command "output" (if (not (equal name "")) (prin1-to-string name)))) ) (defun calc-graph-display (name) (interactive "sX display name: ") (if (equal name "") (message "Current X display is \"%s\"." (or calc-gnuplot-display "")) (setq calc-gnuplot-display name) (if (calc-gnuplot-alive) (calc-gnuplot-command "exit"))) ) (defun calc-graph-geometry (name) (interactive "sX geometry spec (or \"default\"): ") (if (equal name "") (message "Current X geometry is \"%s\"." (or calc-gnuplot-geometry "default")) (setq calc-gnuplot-geometry (and (not (equal name "default")) name)) (if (calc-gnuplot-alive) (calc-gnuplot-command "exit"))) ) (defun calc-graph-find-command (cmd) (calc-graph-init) (save-excursion (set-buffer calc-gnuplot-input) (goto-char (point-min)) (if (re-search-forward (concat "^set[ \t]+" cmd "[ \t]*\\(.*\\)$") nil t) (buffer-substring (match-beginning 1) (match-end 1)))) ) (defun calc-graph-set-command (cmd &rest args) (calc-graph-init) (save-excursion (set-buffer calc-gnuplot-input) (goto-char (point-min)) (if (re-search-forward (concat "^set[ \t]+" cmd "[ \t\n]") nil t) (progn (forward-char -1) (end-of-line) (let ((end (point))) (beginning-of-line) (delete-region (point) (1+ end)))) (if (calc-graph-find-plot t t) (if (eq (preceding-char) ?\n) (forward-char -1)) (goto-char (1- (point-max))))) (if (and args (car args)) (progn (or (bolp) (insert "\n")) (insert "set " (mapconcat 'identity (cons cmd args) " ") "\n")))) (calc-graph-view-commands) ) (defun calc-graph-command (cmd) (interactive "sGNUPLOT command: ") (calc-wrapper (calc-graph-init) (calc-graph-view-trail) (calc-gnuplot-command cmd) (accept-process-output) (calc-graph-view-trail)) ) (defun calc-graph-kill (&optional no-view) (interactive) (calc-graph-delete-temps) (if (calc-gnuplot-alive) (calc-wrapper (or no-view (calc-graph-view-trail)) (let ((calc-graph-no-wait t)) (calc-gnuplot-command "exit")) (sit-for 1) (if (process-status calc-gnuplot-process) (delete-process calc-gnuplot-process)) (setq calc-gnuplot-process nil))) ) (defun calc-graph-quit () (interactive) (if (get-buffer-window calc-gnuplot-input) (calc-graph-view-commands t)) (if (get-buffer-window calc-gnuplot-buffer) (calc-graph-view-trail t)) (calc-graph-kill t) ) (defun calc-graph-view-commands (&optional no-need) (interactive "p") (or calc-graph-no-auto-view (calc-graph-init-buffers)) (calc-graph-view calc-gnuplot-input calc-gnuplot-buffer (null no-need)) ) (defun calc-graph-view-trail (&optional no-need) (interactive "p") (or calc-graph-no-auto-view (calc-graph-init-buffers)) (calc-graph-view calc-gnuplot-buffer calc-gnuplot-input (null no-need)) ) (defun calc-graph-view (buf other-buf need) (let (win) (or calc-graph-no-auto-view (if (setq win (get-buffer-window buf)) (or need (and (eq buf calc-gnuplot-buffer) (save-excursion (set-buffer buf) (not (pos-visible-in-window-p (point-max) win)))) (progn (bury-buffer buf) (bury-buffer other-buf) (let ((curwin (selected-window))) (select-window win) (switch-to-buffer nil) (select-window curwin)))) (if (setq win (get-buffer-window other-buf)) (set-window-buffer win buf) (if (eq major-mode 'calc-mode) (if (or need (< (window-height) (1- (screen-height)))) (display-buffer buf)) (switch-to-buffer buf))))) (save-excursion (set-buffer buf) (if (and (eq buf calc-gnuplot-buffer) (setq win (get-buffer-window buf)) (not (pos-visible-in-window-p (point-max) win))) (progn (goto-char (point-max)) (vertical-motion (- 6 (window-height win))) (set-window-start win (point)) (goto-char (point-max))))) (or calc-graph-no-auto-view (sit-for 0))) ) (setq calc-graph-no-auto-view nil) (defun calc-gnuplot-check-for-errors () (if (save-excursion (prog2 (progn (set-buffer calc-gnuplot-buffer) (goto-char calc-gnuplot-last-error-pos)) (re-search-forward "^[ \t]+\\^$" nil t) (goto-char (point-max)) (setq calc-gnuplot-last-error-pos (point-max)))) (calc-graph-view-trail)) ) (defun calc-gnuplot-command (&rest args) (calc-graph-init) (let ((cmd (concat (mapconcat 'identity args " ") "\n"))) (accept-process-output) (save-excursion (set-buffer calc-gnuplot-buffer) (calc-gnuplot-check-for-errors) (goto-char (point-max)) (setq calc-gnuplot-trail-mark (point)) (or (>= calc-gnuplot-version 3) (insert cmd)) (set-marker (process-mark calc-gnuplot-process) (point)) (process-send-string calc-gnuplot-process cmd) (if (get-buffer-window calc-gnuplot-buffer) (calc-graph-view-trail)) (accept-process-output (and (not calc-graph-no-wait) calc-gnuplot-process)) (calc-gnuplot-check-for-errors) (if (get-buffer-window calc-gnuplot-buffer) (calc-graph-view-trail)))) ) (setq calc-graph-no-wait nil) (defun calc-graph-init-buffers () (or (and calc-gnuplot-buffer (buffer-name calc-gnuplot-buffer)) (setq calc-gnuplot-buffer (get-buffer-create "*Gnuplot Trail*"))) (or (and calc-gnuplot-input (buffer-name calc-gnuplot-input)) (setq calc-gnuplot-input (get-buffer-create "*Gnuplot Commands*"))) ) (defun calc-graph-init () (or (calc-gnuplot-alive) (let ((process-connection-type t) origin) (if calc-gnuplot-process (progn (delete-process calc-gnuplot-process) (setq calc-gnuplot-process nil))) (calc-graph-init-buffers) (save-excursion (set-buffer calc-gnuplot-buffer) (insert "\nStarting gnuplot...\n") (setq origin (point))) (setq calc-graph-last-device nil) (setq calc-graph-last-output nil) (condition-case err (let ((args (append (and calc-gnuplot-display (not (equal calc-gnuplot-display (getenv "DISPLAY"))) (list "-display" calc-gnuplot-display)) (and calc-gnuplot-geometry (list "-geometry" calc-gnuplot-geometry))))) (setq calc-gnuplot-process (apply 'start-process "gnuplot" calc-gnuplot-buffer calc-gnuplot-name args)) (process-kill-without-query calc-gnuplot-process)) (file-error (error "Sorry, can't find \"%s\" on your system." calc-gnuplot-name))) (save-excursion (set-buffer calc-gnuplot-buffer) (while (and (not (save-excursion (goto-char origin) (search-forward "gnuplot> " nil t))) (memq (process-status calc-gnuplot-process) '(run stop))) (accept-process-output calc-gnuplot-process)) (or (memq (process-status calc-gnuplot-process) '(run stop)) (error "Unable to start GNUPLOT process.")) (if (save-excursion (goto-char origin) (re-search-forward "G N U P L O T.*\n.*version \\([0-9]+\\)\\." nil t)) (setq calc-gnuplot-version (string-to-int (buffer-substring (match-beginning 1) (match-end 1)))) (setq calc-gnuplot-version 1)) (goto-char (point-max))))) (save-excursion (set-buffer calc-gnuplot-input) (if (= (buffer-size) 0) (insert "# Commands for running gnuplot\n\n\n") (or calc-graph-no-auto-view (eq (char-after (1- (point-max))) ?\n) (progn (goto-char (point-max)) (insert "\n"))))) ) calc-2.02c/calc-comb.el100644 22403 13 101302 5402630535 13217 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-comb.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-comb () nil) ;;; Combinatorics (defun calc-gcd (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "gcd" 'calcFunc-gcd arg)) ) (defun calc-lcm (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "lcm" 'calcFunc-lcm arg)) ) (defun calc-extended-gcd () (interactive) (calc-slow-wrapper (calc-enter-result 2 "egcd" (cons 'calcFunc-egcd (calc-top-list-n 2)))) ) (defun calc-factorial (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "fact" 'calcFunc-fact arg)) ) (defun calc-gamma (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "gmma" 'calcFunc-gamma arg)) ) (defun calc-double-factorial (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "dfac" 'calcFunc-dfact arg)) ) (defun calc-choose (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-hyperbolic) (calc-binary-op "perm" 'calcFunc-perm arg) (calc-binary-op "chos" 'calcFunc-choose arg))) ) (defun calc-perm (arg) (interactive "P") (calc-hyperbolic-func) (calc-choose arg) ) (defvar calc-last-random-limit '(float 1 0)) (defun calc-random (n) (interactive "P") (calc-slow-wrapper (if n (calc-enter-result 0 "rand" (list 'calcFunc-random (calc-get-random-limit (prefix-numeric-value n)))) (calc-enter-result 1 "rand" (list 'calcFunc-random (calc-get-random-limit (calc-top-n 1)))))) ) (defun calc-get-random-limit (val) (if (eq val 0) calc-last-random-limit (setq calc-last-random-limit val)) ) (defun calc-rrandom () (interactive) (calc-slow-wrapper (setq calc-last-random-limit '(float 1 0)) (calc-enter-result 0 "rand" (list 'calcFunc-random '(float 1 0)))) ) (defun calc-random-again (arg) (interactive "p") (calc-slow-wrapper (while (>= (setq arg (1- arg)) 0) (calc-enter-result 0 "rand" (list 'calcFunc-random calc-last-random-limit)))) ) (defun calc-shuffle (n) (interactive "P") (calc-slow-wrapper (if n (calc-enter-result 1 "shuf" (list 'calcFunc-shuffle (prefix-numeric-value n) (calc-get-random-limit (calc-top-n 1)))) (calc-enter-result 2 "shuf" (list 'calcFunc-shuffle (calc-top-n 1) (calc-get-random-limit (calc-top-n 2)))))) ) (defun calc-report-prime-test (res) (cond ((eq (car res) t) (calc-record-message "prim" "Prime (guaranteed)")) ((eq (car res) nil) (if (cdr res) (if (eq (nth 1 res) 'unknown) (calc-record-message "prim" "Non-prime (factors unknown)") (calc-record-message "prim" "Non-prime (%s is a factor)" (math-format-number (nth 1 res)))) (calc-record-message "prim" "Non-prime"))) (t (calc-record-message "prim" "Probably prime (%d iters; %s%% chance of error)" (nth 1 res) (let ((calc-float-format '(fix 2))) (math-format-number (nth 2 res)))))) ) (defun calc-prime-test (iters) (interactive "p") (calc-slow-wrapper (let* ((n (calc-top-n 1)) (res (math-prime-test n iters))) (calc-report-prime-test res))) ) (defun calc-next-prime (iters) (interactive "p") (calc-slow-wrapper (let ((calc-verbose-nextprime t)) (if (calc-is-inverse) (calc-enter-result 1 "prvp" (list 'calcFunc-prevprime (calc-top-n 1) (math-abs iters))) (calc-enter-result 1 "nxtp" (list 'calcFunc-nextprime (calc-top-n 1) (math-abs iters)))))) ) (defun calc-prev-prime (iters) (interactive "p") (calc-invert-func) (calc-next-prime iters) ) (defun calc-prime-factors (iters) (interactive "p") (calc-slow-wrapper (let ((res (calcFunc-prfac (calc-top-n 1)))) (if (not math-prime-factors-finished) (calc-record-message "pfac" "Warning: May not be fully factored")) (calc-enter-result 1 "pfac" res))) ) (defun calc-totient (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "phi" 'calcFunc-totient arg)) ) (defun calc-moebius (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "mu" 'calcFunc-moebius arg)) ) (defun calcFunc-gcd (a b) (if (Math-messy-integerp a) (setq a (math-trunc a))) (if (Math-messy-integerp b) (setq b (math-trunc b))) (cond ((and (Math-integerp a) (Math-integerp b)) (math-gcd a b)) ((Math-looks-negp a) (calcFunc-gcd (math-neg a) b)) ((Math-looks-negp b) (calcFunc-gcd a (math-neg b))) ((Math-zerop a) b) ((Math-zerop b) a) ((and (Math-ratp a) (Math-ratp b)) (math-make-frac (math-gcd (if (eq (car-safe a) 'frac) (nth 1 a) a) (if (eq (car-safe b) 'frac) (nth 1 b) b)) (calcFunc-lcm (if (eq (car-safe a) 'frac) (nth 2 a) 1) (if (eq (car-safe b) 'frac) (nth 2 b) 1)))) ((not (Math-integerp a)) (calc-record-why 'integerp a) (list 'calcFunc-gcd a b)) (t (calc-record-why 'integerp b) (list 'calcFunc-gcd a b))) ) (defun calcFunc-lcm (a b) (let ((g (calcFunc-gcd a b))) (if (Math-numberp g) (math-div (math-mul a b) g) (list 'calcFunc-lcm a b))) ) (defun calcFunc-egcd (a b) ; Knuth section 4.5.2 (cond ((not (Math-integerp a)) (if (Math-messy-integerp a) (calcFunc-egcd (math-trunc a) b) (calc-record-why 'integerp a) (list 'calcFunc-egcd a b))) ((not (Math-integerp b)) (if (Math-messy-integerp b) (calcFunc-egcd a (math-trunc b)) (calc-record-why 'integerp b) (list 'calcFunc-egcd a b))) (t (let ((u1 1) (u2 0) (u3 a) (v1 0) (v2 1) (v3 b) t1 t2 q) (while (not (eq v3 0)) (setq q (math-idivmod u3 v3) t1 (math-sub u1 (math-mul v1 (car q))) t2 (math-sub u2 (math-mul v2 (car q))) u1 v1 u2 v2 u3 v3 v1 t1 v2 t2 v3 (cdr q))) (list 'vec u3 u1 u2)))) ) ;;; Factorial and related functions. (defun calcFunc-fact (n) ; [I I] [F F] [Public] (let (temp) (cond ((Math-integer-negp n) (if calc-infinite-mode '(var uinf var-uinf) (math-reject-arg n 'range))) ((integerp n) (if (<= n 20) (aref '[1 1 2 6 24 120 720 5040 40320 362880 (bigpos 800 628 3) (bigpos 800 916 39) (bigpos 600 1 479) (bigpos 800 20 227 6) (bigpos 200 291 178 87) (bigpos 0 368 674 307 1) (bigpos 0 888 789 922 20) (bigpos 0 96 428 687 355) (bigpos 0 728 705 373 402 6) (bigpos 0 832 408 100 645 121) (bigpos 0 640 176 8 902 432 2)] n) (math-factorial-iter (1- n) 2 1))) ((and (math-messy-integerp n) (Math-lessp n 100)) (math-inexact-result) (setq temp (math-trunc n)) (if (>= temp 0) (if (<= temp 20) (math-float (calcFunc-fact temp)) (math-with-extra-prec 1 (math-factorial-iter (1- temp) 2 '(float 1 0)))) (math-reject-arg n 'range))) ((math-numberp n) (let* ((q (math-quarter-integer n)) (tn (and q (Math-lessp n 1000) (Math-lessp -1000 n) (1+ (math-floor n))))) (cond ((and tn (= q 2) (or calc-symbolic-mode (< (math-abs tn) 20))) (let ((q (if (< tn 0) (math-div (math-pow -2 (- tn)) (math-double-factorial-iter (* -2 tn) 3 1 2)) (math-div (math-double-factorial-iter (* 2 tn) 3 1 2) (math-pow 2 tn))))) (math-mul q (if calc-symbolic-mode (list 'calcFunc-sqrt '(var pi var-pi)) (math-sqrt-pi))))) ((and tn (>= tn 0) (< tn 20) (memq q '(1 3))) (math-inexact-result) (math-div (math-mul (math-double-factorial-iter (* 4 tn) q 1 4) (if (= q 1) (math-gamma-1q) (math-gamma-3q))) (math-pow 4 tn))) (t (math-inexact-result) (math-with-extra-prec 3 (math-gammap1-raw (math-float n))))))) ((equal n '(var inf var-inf)) n) (t (calc-record-why 'numberp n) (list 'calcFunc-fact n)))) ) (math-defcache math-gamma-1q nil (math-with-extra-prec 3 (math-gammap1-raw '(float -75 -2)))) (math-defcache math-gamma-3q nil (math-with-extra-prec 3 (math-gammap1-raw '(float -25 -2)))) (defun math-factorial-iter (count n f) (if (= (% n 5) 1) (math-working (format "factorial(%d)" (1- n)) f)) (if (> count 0) (math-factorial-iter (1- count) (1+ n) (math-mul n f)) f) ) (defun calcFunc-dfact (n) ; [I I] [F F] [Public] (cond ((Math-integer-negp n) (if (math-oddp n) (if (eq n -1) 1 (math-div (if (eq (math-mod n 4) 3) 1 -1) (calcFunc-dfact (math-sub -2 n)))) (list 'calcFunc-dfact n))) ((Math-zerop n) 1) ((integerp n) (math-double-factorial-iter n (+ 2 (% n 2)) 1 2)) ((math-messy-integerp n) (let ((temp (math-trunc n))) (math-inexact-result) (if (natnump temp) (if (Math-lessp temp 200) (math-with-extra-prec 1 (math-double-factorial-iter temp (+ 2 (% temp 2)) '(float 1 0) 2)) (let* ((half (math-div2 temp)) (even (math-mul (math-pow 2 half) (calcFunc-fact (math-float half))))) (if (math-evenp temp) even (math-div (calcFunc-fact n) even)))) (list 'calcFunc-dfact max)))) ((equal n '(var inf var-inf)) n) (t (calc-record-why 'natnump n) (list 'calcFunc-dfact n))) ) (defun math-double-factorial-iter (max n f step) (if (< (% n 12) step) (math-working (format "dfact(%d)" (- n step)) f)) (if (<= n max) (math-double-factorial-iter max (+ n step) (math-mul n f) step) f) ) (defun calcFunc-perm (n m) ; [I I I] [F F F] [Public] (cond ((and (integerp n) (integerp m) (<= m n) (>= m 0)) (math-factorial-iter m (1+ (- n m)) 1)) ((or (not (math-num-integerp n)) (and (math-messy-integerp n) (Math-lessp 100 n)) (not (math-num-integerp m)) (and (math-messy-integerp m) (Math-lessp 100 m))) (or (math-realp n) (equal n '(var inf var-inf)) (math-reject-arg n 'realp)) (or (math-realp m) (equal m '(var inf var-inf)) (math-reject-arg m 'realp)) (and (math-num-integerp n) (math-negp n) (math-reject-arg n 'range)) (and (math-num-integerp m) (math-negp m) (math-reject-arg m 'range)) (math-div (calcFunc-fact n) (calcFunc-fact (math-sub n m)))) (t (let ((tn (math-trunc n)) (tm (math-trunc m))) (math-inexact-result) (or (integerp tn) (math-reject-arg tn 'fixnump)) (or (integerp tm) (math-reject-arg tm 'fixnump)) (or (and (<= tm tn) (>= tm 0)) (math-reject-arg tm 'range)) (math-with-extra-prec 1 (math-factorial-iter tm (1+ (- tn tm)) '(float 1 0)))))) ) (defun calcFunc-choose (n m) ; [I I I] [F F F] [Public] (cond ((and (integerp n) (integerp m) (<= m n) (>= m 0)) (if (> m (/ n 2)) (math-choose-iter (- n m) n 1 1) (math-choose-iter m n 1 1))) ((not (math-realp n)) (math-reject-arg n 'realp)) ((not (math-realp m)) (math-reject-arg m 'realp)) ((not (math-num-integerp m)) (if (and (math-num-integerp n) (math-negp n)) (list 'calcFunc-choose n m) (math-div (calcFunc-fact (math-float n)) (math-mul (calcFunc-fact m) (calcFunc-fact (math-sub n m)))))) ((math-negp m) 0) ((math-negp n) (let ((val (calcFunc-choose (math-add (math-add n m) -1) m))) (if (math-evenp (math-trunc m)) val (math-neg val)))) ((and (math-num-integerp n) (Math-lessp n m)) 0) (t (math-inexact-result) (let ((tm (math-trunc m))) (or (integerp tm) (math-reject-arg tm 'fixnump)) (if (> tm 100) (math-div (calcFunc-fact (math-float n)) (math-mul (calcFunc-fact (math-float m)) (calcFunc-fact (math-float (math-sub n m))))) (math-with-extra-prec 1 (math-choose-float-iter tm n 1 1)))))) ) (defun math-choose-iter (m n i c) (if (and (= (% i 5) 1) (> i 5)) (math-working (format "choose(%d)" (1- i)) c)) (if (<= i m) (math-choose-iter m (1- n) (1+ i) (math-quotient (math-mul c n) i)) c) ) (defun math-choose-float-iter (count n i c) (if (= (% i 5) 1) (math-working (format "choose(%d)" (1- i)) c)) (if (> count 0) (math-choose-float-iter (1- count) (math-sub n 1) (1+ i) (math-div (math-mul c n) i)) c) ) ;;; Stirling numbers. (defun calcFunc-stir1 (n m) (math-stirling-number n m 1) ) (defun calcFunc-stir2 (n m) (math-stirling-number n m 0) ) (defun math-stirling-number (n m k) (or (math-num-natnump n) (math-reject-arg n 'natnump)) (or (math-num-natnump m) (math-reject-arg m 'natnump)) (if (consp n) (setq n (math-trunc n))) (or (integerp n) (math-reject-arg n 'fixnump)) (if (consp m) (setq m (math-trunc m))) (or (integerp m) (math-reject-arg m 'fixnump)) (if (< n m) 0 (let ((cache (aref math-stirling-cache k))) (while (<= (length cache) n) (let ((i (1- (length cache))) row) (setq cache (vconcat cache (make-vector (length cache) nil))) (aset math-stirling-cache k cache) (while (< (setq i (1+ i)) (length cache)) (aset cache i (setq row (make-vector (1+ i) nil))) (aset row 0 0) (aset row i 1)))) (if (= k 1) (math-stirling-1 n m) (math-stirling-2 n m)))) ) (setq math-stirling-cache (vector [[1]] [[1]])) (defun math-stirling-1 (n m) (or (aref (aref cache n) m) (aset (aref cache n) m (math-add (math-stirling-1 (1- n) (1- m)) (math-mul (- 1 n) (math-stirling-1 (1- n) m))))) ) (defun math-stirling-2 (n m) (or (aref (aref cache n) m) (aset (aref cache n) m (math-add (math-stirling-2 (1- n) (1- m)) (math-mul m (math-stirling-2 (1- n) m))))) ) ;;; Produce a random 10-bit integer, with (random) if no seed provided, ;;; or else with Numerical Recipes algorithm ran3 / Knuth 3.2.2-A. (defun math-init-random-base () (if (and (boundp 'var-RandSeed) var-RandSeed) (if (eq (car-safe var-RandSeed) 'vec) nil (if (Math-integerp var-RandSeed) (let* ((seed (math-sub 161803 var-RandSeed)) (mj (1+ (math-mod seed '(bigpos 0 0 1)))) (mk (1+ (math-mod (math-quotient seed '(bigpos 0 0 1)) '(bigpos 0 0 1)))) (i 0)) (setq math-random-table (cons 'vec (make-list 55 mj))) (while (<= (setq i (1+ i)) 54) (let* ((ii (% (* i 21) 55)) (p (nthcdr ii math-random-table))) (setcar p mk) (setq mk (- mj mk) mj (car p))))) (math-reject-arg var-RandSeed "*RandSeed must be an integer")) (setq var-RandSeed (list 'vec var-RandSeed) math-random-ptr1 math-random-table math-random-cache nil math-random-ptr2 (nthcdr 31 math-random-table)) (let ((i 200)) (while (> (setq i (1- i)) 0) (math-random-base)))) (random t) (setq var-RandSeed nil math-random-cache nil i 0 math-random-shift -4) ; assume RAND_MAX >= 16383 ;; This exercises the random number generator and also helps ;; deduce a better value for RAND_MAX. (while (< (setq i (1+ i)) 30) (if (> (lsh (math-abs (random)) math-random-shift) 4095) (setq math-random-shift (1- math-random-shift))))) (setq math-last-RandSeed var-RandSeed math-gaussian-cache nil) ) (defun math-random-base () (if var-RandSeed (progn (setq math-random-ptr1 (or (cdr math-random-ptr1) (cdr math-random-table)) math-random-ptr2 (or (cdr math-random-ptr2) (cdr math-random-table))) (logand (lsh (setcar math-random-ptr1 (logand (- (car math-random-ptr1) (car math-random-ptr2)) 524287)) -6) 1023)) (logand (lsh (random) math-random-shift) 1023)) ) (setq math-random-table nil) (setq math-last-RandSeed nil) (setq math-random-ptr1 nil) (setq math-random-ptr2 nil) (setq math-random-shift nil) ;;; Produce a random digit in the range 0..999. ;;; Avoid various pitfalls that may lurk in the built-in (random) function! ;;; Shuffling algorithm from Numerical Recipes, section 7.1. (defun math-random-digit () (let (i) (or (and (boundp 'var-RandSeed) (eq var-RandSeed math-last-RandSeed)) (math-init-random-base)) (or math-random-cache (progn (setq math-random-last (math-random-base) math-random-cache (make-vector 13 nil) i -1) (while (< (setq i (1+ i)) 13) (aset math-random-cache i (math-random-base))))) (while (progn (setq i (/ math-random-last 79) ; 0 <= i < 13 math-random-last (aref math-random-cache i)) (aset math-random-cache i (math-random-base)) (>= math-random-last 1000))) math-random-last) ) (setq math-random-cache nil) ;;; Produce an N-digit random integer. (defun math-random-digits (n) (cond ((<= n 6) (math-scale-right (+ (* (math-random-digit) 1000) (math-random-digit)) (- 6 n))) (t (let* ((slop (% (- 900003 n) 3)) (i (/ (+ n slop) 3)) (digs nil)) (while (> i 0) (setq digs (cons (math-random-digit) digs) i (1- i))) (math-normalize (math-scale-right (cons 'bigpos digs) slop))))) ) ;;; Produce a uniformly-distributed random float 0 <= N < 1. (defun math-random-float () (math-make-float (math-random-digits calc-internal-prec) (- calc-internal-prec)) ) ;;; Produce a Gaussian-distributed random float with mean=0, sigma=1. (defun math-gaussian-float () (math-with-extra-prec 2 (if (and math-gaussian-cache (= (car math-gaussian-cache) calc-internal-prec)) (prog1 (cdr math-gaussian-cache) (setq math-gaussian-cache nil)) (let* ((v1 (math-add (math-mul (math-random-float) 2) -1)) (v2 (math-add (math-mul (math-random-float) 2) -1)) (r (math-add (math-sqr v1) (math-sqr v2)))) (while (or (not (Math-lessp r 1)) (math-zerop r)) (setq v1 (math-add (math-mul (math-random-float) 2) -1) v2 (math-add (math-mul (math-random-float) 2) -1) r (math-add (math-sqr v1) (math-sqr v2)))) (let ((fac (math-sqrt (math-mul (math-div (calcFunc-ln r) r) -2)))) (setq math-gaussian-cache (cons calc-internal-prec (math-mul v1 fac))) (math-mul v2 fac))))) ) (setq math-gaussian-cache nil) ;;; Produce a random integer or real 0 <= N < MAX. (defun calcFunc-random (max) (cond ((Math-zerop max) (math-gaussian-float)) ((Math-integerp max) (let* ((digs (math-numdigs max)) (r (math-random-digits (+ digs 3)))) (math-mod r max))) ((Math-realp max) (math-mul (math-random-float) max)) ((and (eq (car max) 'intv) (math-constp max) (Math-lessp (nth 2 max) (nth 3 max))) (if (math-floatp max) (let ((val (math-add (math-mul (math-random-float) (math-sub (nth 3 max) (nth 2 max))) (nth 2 max)))) (if (or (and (memq (nth 1 max) '(0 1)) ; almost not worth (Math-equal val (nth 2 max))) ; checking! (and (memq (nth 1 max) '(0 2)) (Math-equal val (nth 3 max)))) (calcFunc-random max) val)) (let ((lo (if (memq (nth 1 max) '(0 1)) (math-add (nth 2 max) 1) (nth 2 max))) (hi (if (memq (nth 1 max) '(1 3)) (math-add (nth 3 max) 1) (nth 3 max)))) (if (Math-lessp lo hi) (math-add (calcFunc-random (math-sub hi lo)) lo) (math-reject-arg max "*Empty interval"))))) ((eq (car max) 'vec) (if (cdr max) (nth (1+ (calcFunc-random (1- (length max)))) max) (math-reject-arg max "*Empty list"))) ((and (eq (car max) 'sdev) (math-constp max) (Math-realp (nth 1 max))) (math-add (math-mul (math-gaussian-float) (nth 2 max)) (nth 1 max))) (t (math-reject-arg max 'realp))) ) ;;; Choose N objects at random from the set MAX without duplicates. (defun calcFunc-shuffle (n &optional max) (or max (setq max n n -1)) (or (and (Math-num-integerp n) (or (natnump (setq n (math-trunc n))) (eq n -1))) (math-reject-arg n 'integerp)) (cond ((or (math-zerop max) (math-floatp max) (eq (car-safe max) 'sdev)) (if (< n 0) (math-reject-arg n 'natnump) (math-simple-shuffle n max))) ((and (<= n 1) (>= n 0)) (math-simple-shuffle n max)) ((and (eq (car-safe max) 'intv) (math-constp max)) (let ((num (math-add (math-sub (nth 3 max) (nth 2 max)) (cdr (assq (nth 1 max) '((0 . -1) (1 . 0) (2 . 0) (3 . 1)))))) (min (math-add (nth 2 max) (if (memq (nth 1 max) '(0 1)) 1 0)))) (if (< n 0) (setq n num)) (or (math-posp num) (math-reject-arg max 'range)) (and (Math-lessp num n) (math-reject-arg n 'range)) (if (Math-lessp n (math-quotient num 3)) (math-simple-shuffle n max) (if (> (* n 4) (* num 3)) (math-add (math-sub min 1) (math-shuffle-list n num (calcFunc-index num))) (let ((tot 0) (m 0) (vec nil)) (while (< m n) (if (< (calcFunc-random (- num tot)) (- n m)) (setq vec (cons (math-add min tot) vec) m (1+ m))) (setq tot (1+ tot))) (math-shuffle-list n n (cons 'vec vec))))))) ((eq (car-safe max) 'vec) (let ((size (1- (length max)))) (if (< n 0) (setq n size)) (if (and (> n (/ size 2)) (<= n size)) (math-shuffle-list n size (copy-sequence max)) (let* ((vals (calcFunc-shuffle n (list 'intv 3 1 (1- (length max))))) (p vals)) (while (setq p (cdr p)) (setcar p (nth (car p) max))) vals)))) ((math-integerp max) (if (math-posp max) (calcFunc-shuffle n (list 'intv 2 0 max)) (calcFunc-shuffle n (list 'intv 1 max 0)))) (t (math-reject-arg max 'realp))) ) (defun math-simple-shuffle (n max) (let ((vec nil) val) (while (>= (setq n (1- n)) 0) (while (math-member (setq val (calcFunc-random max)) vec)) (setq vec (cons val vec))) (cons 'vec vec)) ) (defun math-shuffle-list (n size vec) (let ((j size) k temp (p vec)) (while (cdr (setq p (cdr p))) (setq k (calcFunc-random j) j (1- j) temp (nth k p)) (setcar (nthcdr k p) (car p)) (setcar p temp)) (cons 'vec (nthcdr (- size n -1) vec))) ) (defun math-member (x list) (while (and list (not (equal x (car list)))) (setq list (cdr list))) list ) ;;; Check if the integer N is prime. [X I] ;;; Return (nil) if non-prime, ;;; (nil N) if non-prime with known factor N, ;;; (nil unknown) if non-prime with no known factors, ;;; (t) if prime, ;;; (maybe N P) if probably prime (after N iters with probability P%) (defun math-prime-test (n iters) (if (and (Math-vectorp n) (cdr n)) (setq n (nth (1- (length n)) n))) (if (Math-messy-integerp n) (setq n (math-trunc n))) (let ((res)) (while (> iters 0) (setq res (cond ((and (integerp n) (<= n 5003)) (list (= (math-next-small-prime n) n))) ((not (Math-integerp n)) (error "Argument must be an integer")) ((Math-integer-negp n) '(nil)) ((Math-natnum-lessp n '(bigpos 0 0 8)) (setq n (math-fixnum n)) (let ((i -1) v) (while (and (> (% n (setq v (aref math-primes-table (setq i (1+ i))))) 0) (< (* v v) n))) (if (= (% n v) 0) (list nil v) '(t)))) ((not (equal n (car math-prime-test-cache))) (cond ((= (% (nth 1 n) 2) 0) '(nil 2)) ((= (% (nth 1 n) 5) 0) '(nil 5)) (t (let ((dig (cdr n)) (sum 0)) (while dig (if (cdr dig) (setq sum (% (+ (+ sum (car dig)) (* (nth 1 dig) 1000)) 111111) dig (cdr (cdr dig))) (setq sum (% (+ sum (car dig)) 111111) dig nil))) (cond ((= (% sum 3) 0) '(nil 3)) ((= (% sum 7) 0) '(nil 7)) ((= (% sum 11) 0) '(nil 11)) ((= (% sum 13) 0) '(nil 13)) ((= (% sum 37) 0) '(nil 37)) (t (setq math-prime-test-cache-k 1 math-prime-test-cache-q (math-div2 n) math-prime-test-cache-nm1 (math-add n -1)) (while (math-evenp math-prime-test-cache-q) (setq math-prime-test-cache-k (1+ math-prime-test-cache-k) math-prime-test-cache-q (math-div2 math-prime-test-cache-q))) (setq iters (1+ iters)) (list 'maybe 0 (math-sub 100 (math-div '(float 232 0) (math-numdigs n)))))))))) ((not (eq (car (nth 1 math-prime-test-cache)) 'maybe)) (nth 1 math-prime-test-cache)) (t ; Fermat step (let* ((x (math-add (calcFunc-random (math-add n -2)) 2)) (y (math-pow-mod x math-prime-test-cache-q n)) (j 0)) (while (and (not (eq y 1)) (not (equal y math-prime-test-cache-nm1)) (< (setq j (1+ j)) math-prime-test-cache-k)) (setq y (math-mod (math-mul y y) n))) (if (or (equal y math-prime-test-cache-nm1) (and (eq y 1) (eq j 0))) (list 'maybe (1+ (nth 1 (nth 1 math-prime-test-cache))) (math-mul (nth 2 (nth 1 math-prime-test-cache)) '(float 25 -2))) '(nil unknown)))))) (setq math-prime-test-cache (list n res) iters (if (eq (car res) 'maybe) (1- iters) 0))) res) ) (defvar math-prime-test-cache '(-1)) (defun calcFunc-prime (n &optional iters) (or (math-num-integerp n) (math-reject-arg n 'integerp)) (or (not iters) (math-num-integerp iters) (math-reject-arg iters 'integerp)) (if (car (math-prime-test (math-trunc n) (math-trunc (or iters 1)))) 1 0) ) ;;; Theory: summing base-10^6 digits modulo 111111 is "casting out 999999s". ;;; Initial probability that N is prime is 1/ln(N) = log10(e)/log10(N). ;;; After culling [2,3,5,7,11,13,37], probability of primality is 5.36 x more. ;;; Initial reported probability of non-primality is thus 100% - this. ;;; Each Fermat step multiplies this probability by 25%. ;;; The Fermat step is algorithm P from Knuth section 4.5.4. (defun calcFunc-prfac (n) (setq math-prime-factors-finished t) (if (Math-messy-integerp n) (setq n (math-trunc n))) (if (Math-natnump n) (if (Math-natnum-lessp 2 n) (let (factors res p (i 0)) (while (and (not (eq n 1)) (< i (length math-primes-table))) (setq p (aref math-primes-table i)) (while (eq (cdr (setq res (cond ((eq n p) (cons 1 0)) ((eq n 1) (cons 0 1)) ((consp n) (math-idivmod n p)) (t (cons (/ n p) (% n p)))))) 0) (math-working "factor" p) (setq factors (nconc factors (list p)) n (car res))) (or (eq n 1) (Math-natnum-lessp p (car res)) (setq factors (nconc factors (list n)) n 1)) (setq i (1+ i))) (or (setq math-prime-factors-finished (eq n 1)) (setq factors (nconc factors (list n)))) (cons 'vec factors)) (list 'vec n)) (if (Math-integerp n) (if (eq n -1) (list 'vec n) (cons 'vec (cons -1 (cdr (calcFunc-prfac (math-neg n)))))) (calc-record-why 'integerp n) (list 'calcFunc-prfac n))) ) (defun calcFunc-totient (n) (if (Math-messy-integerp n) (setq n (math-trunc n))) (if (Math-natnump n) (if (Math-natnum-lessp n 2) (if (Math-negp n) (calcFunc-totient (math-abs n)) n) (let ((factors (cdr (calcFunc-prfac n))) p) (if math-prime-factors-finished (progn (while factors (setq p (car factors) n (math-mul (math-div n p) (math-add p -1))) (while (equal p (car factors)) (setq factors (cdr factors)))) n) (calc-record-why "*Number too big to factor" n) (list 'calcFunc-totient n)))) (calc-record-why 'natnump n) (list 'calcFunc-totient n)) ) (defun calcFunc-moebius (n) (if (Math-messy-integerp n) (setq n (math-trunc n))) (if (and (Math-natnump n) (not (eq n 0))) (if (Math-natnum-lessp n 2) (if (Math-negp n) (calcFunc-moebius (math-abs n)) 1) (let ((factors (cdr (calcFunc-prfac n))) (mu 1)) (if math-prime-factors-finished (progn (while factors (setq mu (if (equal (car factors) (nth 1 factors)) 0 (math-neg mu)) factors (cdr factors))) mu) (calc-record-why "Number too big to factor" n) (list 'calcFunc-moebius n)))) (calc-record-why 'posintp n) (list 'calcFunc-moebius n)) ) (defun calcFunc-nextprime (n &optional iters) (if (Math-integerp n) (if (Math-integer-negp n) 2 (if (and (integerp n) (< n 5003)) (math-next-small-prime (1+ n)) (if (math-evenp n) (setq n (math-add n -1))) (let (res) (while (not (car (setq res (math-prime-test (setq n (math-add n 2)) (or iters 1)))))) (if (and calc-verbose-nextprime (eq (car res) 'maybe)) (calc-report-prime-test res))) n)) (if (Math-realp n) (calcFunc-nextprime (math-trunc n) iters) (math-reject-arg n 'integerp))) ) (setq calc-verbose-nextprime nil) (defun calcFunc-prevprime (n &optional iters) (if (Math-integerp n) (if (Math-lessp n 4) 2 (if (math-evenp n) (setq n (math-add n 1))) (let (res) (while (not (car (setq res (math-prime-test (setq n (math-add n -2)) (or iters 1)))))) (if (and calc-verbose-nextprime (eq (car res) 'maybe)) (calc-report-prime-test res))) n) (if (Math-realp n) (calcFunc-prevprime (math-ceiling n) iters) (math-reject-arg n 'integerp))) ) (defun math-next-small-prime (n) (if (and (integerp n) (> n 2)) (let ((lo -1) (hi (length math-primes-table)) mid) (while (> (- hi lo) 1) (if (> n (aref math-primes-table (setq mid (ash (+ lo hi) -1)))) (setq lo mid) (setq hi mid))) (aref math-primes-table hi)) 2) ) (defconst math-primes-table [2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541 547 557 563 569 571 577 587 593 599 601 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691 701 709 719 727 733 739 743 751 757 761 769 773 787 797 809 811 821 823 827 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941 947 953 967 971 977 983 991 997 1009 1013 1019 1021 1031 1033 1039 1049 1051 1061 1063 1069 1087 1091 1093 1097 1103 1109 1117 1123 1129 1151 1153 1163 1171 1181 1187 1193 1201 1213 1217 1223 1229 1231 1237 1249 1259 1277 1279 1283 1289 1291 1297 1301 1303 1307 1319 1321 1327 1361 1367 1373 1381 1399 1409 1423 1427 1429 1433 1439 1447 1451 1453 1459 1471 1481 1483 1487 1489 1493 1499 1511 1523 1531 1543 1549 1553 1559 1567 1571 1579 1583 1597 1601 1607 1609 1613 1619 1621 1627 1637 1657 1663 1667 1669 1693 1697 1699 1709 1721 1723 1733 1741 1747 1753 1759 1777 1783 1787 1789 1801 1811 1823 1831 1847 1861 1867 1871 1873 1877 1879 1889 1901 1907 1913 1931 1933 1949 1951 1973 1979 1987 1993 1997 1999 2003 2011 2017 2027 2029 2039 2053 2063 2069 2081 2083 2087 2089 2099 2111 2113 2129 2131 2137 2141 2143 2153 2161 2179 2203 2207 2213 2221 2237 2239 2243 2251 2267 2269 2273 2281 2287 2293 2297 2309 2311 2333 2339 2341 2347 2351 2357 2371 2377 2381 2383 2389 2393 2399 2411 2417 2423 2437 2441 2447 2459 2467 2473 2477 2503 2521 2531 2539 2543 2549 2551 2557 2579 2591 2593 2609 2617 2621 2633 2647 2657 2659 2663 2671 2677 2683 2687 2689 2693 2699 2707 2711 2713 2719 2729 2731 2741 2749 2753 2767 2777 2789 2791 2797 2801 2803 2819 2833 2837 2843 2851 2857 2861 2879 2887 2897 2903 2909 2917 2927 2939 2953 2957 2963 2969 2971 2999 3001 3011 3019 3023 3037 3041 3049 3061 3067 3079 3083 3089 3109 3119 3121 3137 3163 3167 3169 3181 3187 3191 3203 3209 3217 3221 3229 3251 3253 3257 3259 3271 3299 3301 3307 3313 3319 3323 3329 3331 3343 3347 3359 3361 3371 3373 3389 3391 3407 3413 3433 3449 3457 3461 3463 3467 3469 3491 3499 3511 3517 3527 3529 3533 3539 3541 3547 3557 3559 3571 3581 3583 3593 3607 3613 3617 3623 3631 3637 3643 3659 3671 3673 3677 3691 3697 3701 3709 3719 3727 3733 3739 3761 3767 3769 3779 3793 3797 3803 3821 3823 3833 3847 3851 3853 3863 3877 3881 3889 3907 3911 3917 3919 3923 3929 3931 3943 3947 3967 3989 4001 4003 4007 4013 4019 4021 4027 4049 4051 4057 4073 4079 4091 4093 4099 4111 4127 4129 4133 4139 4153 4157 4159 4177 4201 4211 4217 4219 4229 4231 4241 4243 4253 4259 4261 4271 4273 4283 4289 4297 4327 4337 4339 4349 4357 4363 4373 4391 4397 4409 4421 4423 4441 4447 4451 4457 4463 4481 4483 4493 4507 4513 4517 4519 4523 4547 4549 4561 4567 4583 4591 4597 4603 4621 4637 4639 4643 4649 4651 4657 4663 4673 4679 4691 4703 4721 4723 4729 4733 4751 4759 4783 4787 4789 4793 4799 4801 4813 4817 4831 4861 4871 4877 4889 4903 4909 4919 4931 4933 4937 4943 4951 4957 4967 4969 4973 4987 4993 4999 5003]) calc-2.02c/calc-trail.el100644 22403 13 11365 5547406516 13415 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-trail.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-trail () nil) ;;; Trail commands. (defun calc-trail-in () (interactive) (let ((win (get-buffer-window (calc-trail-display t)))) (and win (select-window win))) ) (defun calc-trail-out () (interactive) (calc-select-buffer) (let ((win (get-buffer-window (current-buffer)))) (if win (progn (select-window win) (calc-align-stack-window)) (calc))) ) (defun calc-trail-next (n) (interactive "p") (calc-with-trail-buffer (forward-line n) (calc-trail-here)) ) (defun calc-trail-previous (n) (interactive "p") (calc-with-trail-buffer (forward-line (- n)) (calc-trail-here)) ) (defun calc-trail-first (n) (interactive "p") (calc-with-trail-buffer (goto-char (point-min)) (forward-line n) (calc-trail-here)) ) (defun calc-trail-last (n) (interactive "p") (calc-with-trail-buffer (goto-char (point-max)) (forward-line (- n)) (calc-trail-here)) ) (defun calc-trail-scroll-left (n) (interactive "P") (let ((curwin (selected-window))) (calc-with-trail-buffer (unwind-protect (progn (select-window (get-buffer-window (current-buffer))) (calc-scroll-left n)) (select-window curwin)))) ) (defun calc-trail-scroll-right (n) (interactive "P") (let ((curwin (selected-window))) (calc-with-trail-buffer (unwind-protect (progn (select-window (get-buffer-window (current-buffer))) (calc-scroll-right n)) (select-window curwin)))) ) (defun calc-trail-forward (n) (interactive "p") (calc-with-trail-buffer (forward-line (* n (1- (window-height)))) (calc-trail-here)) ) (defun calc-trail-backward (n) (interactive "p") (calc-with-trail-buffer (forward-line (- (* n (1- (window-height))))) (calc-trail-here)) ) (defun calc-trail-isearch-forward () (interactive) (calc-with-trail-buffer (save-window-excursion (select-window (get-buffer-window (current-buffer))) (let ((search-exit-char ?\r)) (isearch-forward))) (calc-trail-here)) ) (defun calc-trail-isearch-backward () (interactive) (calc-with-trail-buffer (save-window-excursion (select-window (get-buffer-window (current-buffer))) (let ((search-exit-char ?\r)) (isearch-backward))) (calc-trail-here)) ) (defun calc-trail-yank (arg) (interactive "P") (calc-wrapper (or arg (calc-set-command-flag 'hold-trail)) (calc-enter-result 0 "yank" (calc-with-trail-buffer (if arg (forward-line (- (prefix-numeric-value arg)))) (if (or (looking-at "Emacs Calc") (looking-at "----") (looking-at " ? ? ?[^ \n]* *$") (looking-at "..?.?$")) (error "Can't yank that line")) (if (looking-at ".*, \\.\\.\\., ") (error "Can't yank (vector was abbreviated)")) (forward-char 4) (search-forward " ") (let* ((next (save-excursion (forward-line 1) (point))) (str (buffer-substring (point) (1- next))) (val (save-excursion (set-buffer save-buf) (math-read-plain-expr str)))) (if (eq (car-safe val) 'error) (error "Can't yank that line: %s" (nth 2 val)) val))))) ) (defun calc-trail-marker (str) (interactive "sText to insert in trail: ") (calc-with-trail-buffer (forward-line 1) (let ((buffer-read-only nil)) (insert "---- " str "\n")) (forward-line -1) (calc-trail-here)) ) (defun calc-trail-kill (n) (interactive "p") (calc-with-trail-buffer (let ((buffer-read-only nil)) (save-restriction (narrow-to-region ; don't delete "Emacs Trail" header (save-excursion (goto-char (point-min)) (forward-line 1) (point)) (point-max)) (kill-line n))) (calc-trail-here)) ) calc-2.02c/calc-units.el100644 22403 13 123410 5402631003 13434 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-units.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-units () nil) ;;; Units commands. (defun calc-base-units () (interactive) (calc-slow-wrapper (let ((calc-autorange-units nil)) (calc-enter-result 1 "bsun" (math-simplify-units (math-to-standard-units (calc-top-n 1) nil))))) ) (defun calc-quick-units () (interactive) (calc-slow-wrapper (let* ((num (- last-command-char ?0)) (pos (if (= num 0) 10 num)) (units (calc-var-value 'var-Units)) (expr (calc-top-n 1))) (or (and (>= num 0) (<= num 9)) (error "Bad unit number")) (or (math-vectorp units) (error "No \"quick units\" are defined")) (or (< pos (length units)) (error "Unit number %d not defined" pos)) (if (math-units-in-expr-p expr nil) (calc-enter-result 1 (format "cun%d" num) (math-convert-units expr (nth pos units))) (calc-enter-result 1 (format "*un%d" num) (math-simplify-units (math-mul expr (nth pos units))))))) ) (defun calc-convert-units (&optional old-units new-units) (interactive) (calc-slow-wrapper (let ((expr (calc-top-n 1)) (uoldname nil) unew) (or (math-units-in-expr-p expr t) (let ((uold (or old-units (progn (setq uoldname (read-string "Old units: ")) (if (equal uoldname "") (progn (setq uoldname "1") 1) (if (string-match "\\` */" uoldname) (setq uoldname (concat "1" uoldname))) (math-read-expr uoldname)))))) (if (eq (car-safe uold) 'error) (error "Bad format in units expression: %s" (nth 1 uold))) (setq expr (math-mul expr uold)))) (or new-units (setq new-units (read-string (if uoldname (concat "Old units: " uoldname ", new units: ") "New units: ")))) (if (string-match "\\` */" new-units) (setq new-units (concat "1" new-units))) (setq units (math-read-expr new-units)) (if (eq (car-safe units) 'error) (error "Bad format in units expression: %s" (nth 2 units))) (let ((unew (math-units-in-expr-p units t)) (std (and (eq (car-safe units) 'var) (assq (nth 1 units) math-standard-units-systems)))) (if std (calc-enter-result 1 "cvun" (math-simplify-units (math-to-standard-units expr (nth 1 std)))) (or unew (error "No units specified")) (calc-enter-result 1 "cvun" (math-convert-units expr units (and uoldname (not (equal uoldname "1"))))))))) ) (defun calc-autorange-units (arg) (interactive "P") (calc-wrapper (calc-change-mode 'calc-autorange-units arg nil t) (message (if calc-autorange-units "Adjusting target unit prefix automatically." "Using target units exactly."))) ) (defun calc-convert-temperature (&optional old-units new-units) (interactive) (calc-slow-wrapper (let ((expr (calc-top-n 1)) (uold nil) (uoldname nil) unew) (setq uold (or old-units (let ((units (math-single-units-in-expr-p expr))) (if units (if (consp units) (list 'var (car units) (intern (concat "var-" (symbol-name (car units))))) (error "Not a pure temperature expression")) (math-read-expr (setq uoldname (read-string "Old temperature units: "))))))) (if (eq (car-safe uold) 'error) (error "Bad format in units expression: %s" (nth 2 uold))) (or (math-units-in-expr-p expr nil) (setq expr (math-mul expr uold))) (setq unew (or new-units (math-read-expr (read-string (if uoldname (concat "Old temperature units: " uoldname ", new units: ") "New temperature units: "))))) (if (eq (car-safe unew) 'error) (error "Bad format in units expression: %s" (nth 2 unew))) (calc-enter-result 1 "cvtm" (math-simplify-units (math-convert-temperature expr uold unew uoldname))))) ) (defun calc-remove-units () (interactive) (calc-slow-wrapper (calc-enter-result 1 "rmun" (math-simplify-units (math-remove-units (calc-top-n 1))))) ) (defun calc-extract-units () (interactive) (calc-slow-wrapper (calc-enter-result 1 "rmun" (math-simplify-units (math-extract-units (calc-top-n 1))))) ) (defun calc-explain-units () (interactive) (calc-wrapper (let ((num-units nil) (den-units nil)) (calc-explain-units-rec (calc-top-n 1) 1) (and den-units (string-match "^[^(].* .*[^)]$" den-units) (setq den-units (concat "(" den-units ")"))) (if num-units (if den-units (message "%s per %s" num-units den-units) (message "%s" num-units)) (if den-units (message "1 per %s" den-units) (message "No units in expression"))))) ) (defun calc-explain-units-rec (expr pow) (let ((u (math-check-unit-name expr)) pos) (if (and u (not (math-zerop pow))) (let ((name (or (nth 2 u) (symbol-name (car u))))) (if (eq (aref name 0) ?\*) (setq name (substring name 1))) (if (string-match "[^a-zA-Z0-9']" name) (if (string-match "^[a-zA-Z0-9' ()]*$" name) (while (setq pos (string-match "[ ()]" name)) (setq name (concat (substring name 0 pos) (if (eq (aref name pos) 32) "-" "") (substring name (1+ pos))))) (setq name (concat "(" name ")")))) (or (eq (nth 1 expr) (car u)) (setq name (concat (nth 2 (assq (aref (symbol-name (nth 1 expr)) 0) math-unit-prefixes)) (if (and (string-match "[^a-zA-Z0-9']" name) (not (memq (car u) '(mHg gf)))) (concat "-" name) (downcase name))))) (cond ((or (math-equal-int pow 1) (math-equal-int pow -1))) ((or (math-equal-int pow 2) (math-equal-int pow -2)) (if (equal (nth 4 u) '((m . 1))) (setq name (concat "Square-" name)) (setq name (concat name "-squared")))) ((or (math-equal-int pow 3) (math-equal-int pow -3)) (if (equal (nth 4 u) '((m . 1))) (setq name (concat "Cubic-" name)) (setq name (concat name "-cubed")))) (t (setq name (concat name "^" (math-format-number (math-abs pow)))))) (if (math-posp pow) (setq num-units (if num-units (concat num-units " " name) name)) (setq den-units (if den-units (concat den-units " " name) name)))) (cond ((eq (car-safe expr) '*) (calc-explain-units-rec (nth 1 expr) pow) (calc-explain-units-rec (nth 2 expr) pow)) ((eq (car-safe expr) '/) (calc-explain-units-rec (nth 1 expr) pow) (calc-explain-units-rec (nth 2 expr) (- pow))) ((memq (car-safe expr) '(neg + -)) (calc-explain-units-rec (nth 1 expr) pow)) ((and (eq (car-safe expr) '^) (math-realp (nth 2 expr))) (calc-explain-units-rec (nth 1 expr) (math-mul pow (nth 2 expr))))))) ) (defun calc-simplify-units () (interactive) (calc-slow-wrapper (calc-with-default-simplification (calc-enter-result 1 "smun" (math-simplify-units (calc-top-n 1))))) ) (defun calc-view-units-table (n) (interactive "P") (and n (setq math-units-table-buffer-valid nil)) (let ((win (get-buffer-window "*Units Table*"))) (if (and win math-units-table math-units-table-buffer-valid) (progn (bury-buffer (window-buffer win)) (let ((curwin (selected-window))) (select-window win) (switch-to-buffer nil) (select-window curwin))) (math-build-units-table-buffer nil))) ) (defun calc-enter-units-table (n) (interactive "P") (and n (setq math-units-table-buffer-valid nil)) (math-build-units-table-buffer t) (message (substitute-command-keys "Type \\[calc] to return to the Calculator.")) ) (defun calc-define-unit (uname desc) (interactive "SDefine unit name: \nsDescription: ") (calc-wrapper (let ((form (calc-top-n 1)) (unit (assq uname math-additional-units))) (or unit (setq math-additional-units (cons (setq unit (list uname nil nil)) math-additional-units) math-units-table nil)) (setcar (cdr unit) (and (not (and (eq (car-safe form) 'var) (eq (nth 1 form) uname))) (not (math-equal-int form 1)) (math-format-flat-expr form 0))) (setcar (cdr (cdr unit)) (and (not (equal desc "")) desc)))) (calc-invalidate-units-table) ) (defun calc-undefine-unit (uname) (interactive "SUndefine unit name: ") (calc-wrapper (let ((unit (assq uname math-additional-units))) (or unit (if (assq uname math-standard-units) (error "\"%s\" is a predefined unit name" uname) (error "Unit name \"%s\" not found" uname))) (setq math-additional-units (delq unit math-additional-units) math-units-table nil))) (calc-invalidate-units-table) ) (defun calc-invalidate-units-table () (setq math-units-table nil) (let ((buf (get-buffer "*Units Table*"))) (and buf (save-excursion (set-buffer buf) (save-excursion (goto-char (point-min)) (if (looking-at "Calculator Units Table") (let ((buffer-read-only nil)) (insert "(Obsolete) "))))))) ) (defun calc-get-unit-definition (uname) (interactive "SGet definition for unit: ") (calc-wrapper (math-build-units-table) (let ((unit (assq uname math-units-table))) (or unit (error "Unit name \"%s\" not found" uname)) (let ((msg (nth 2 unit))) (if (stringp msg) (if (string-match "^\\*" msg) (setq msg (substring msg 1))) (setq msg (symbol-name uname))) (if (nth 1 unit) (progn (calc-enter-result 0 "ugdf" (nth 1 unit)) (message "Derived unit: %s" msg)) (calc-enter-result 0 "ugdf" (list 'var uname (intern (concat "var-" (symbol-name uname))))) (message "Base unit: %s" msg))))) ) (defun calc-permanent-units () (interactive) (calc-wrapper (let (pos) (set-buffer (find-file-noselect (substitute-in-file-name calc-settings-file))) (goto-char (point-min)) (if (and (search-forward ";;; Custom units stored by Calc" nil t) (progn (beginning-of-line) (setq pos (point)) (search-forward "\n;;; End of custom units" nil t))) (progn (beginning-of-line) (forward-line 1) (delete-region pos (point))) (goto-char (point-max)) (insert "\n\n") (forward-char -1)) (insert ";;; Custom units stored by Calc on " (current-time-string) "\n") (if math-additional-units (progn (insert "(setq math-additional-units '(\n") (let ((list math-additional-units)) (while list (insert " (" (symbol-name (car (car list))) " " (if (nth 1 (car list)) (if (stringp (nth 1 (car list))) (prin1-to-string (nth 1 (car list))) (prin1-to-string (math-format-flat-expr (nth 1 (car list)) 0))) "nil") " " (prin1-to-string (nth 2 (car list))) ")\n") (setq list (cdr list)))) (insert "))\n")) (insert ";;; (no custom units defined)\n")) (insert ";;; End of custom units\n") (save-buffer))) ) ;;; Units operations. ;;; Units table last updated 9-Jan-91 by Ulrich Mueller (ulm@vsnhd1.cern.ch) ;;; with some additions by Przemek Klosowski (przemek@rrdstrad.nist.gov) (defvar math-standard-units '( ;; Length ( m nil "*Meter" ) ( in "2.54 cm" "Inch" ) ( ft "12 in" "Foot" ) ( yd "3 ft" "Yard" ) ( mi "5280 ft" "Mile" ) ( au "1.495979e11 m" "Astronomical Unit" ) ( lyr "9460536207068016 m" "Light Year" ) ( pc "206264.80625 au" "Parsec" ) ( nmi "1852 m" "Nautical Mile" ) ( fath "6 ft" "Fathom" ) ( u "1 um" "Micron" ) ( mil "in/1000" "Mil" ) ( point "in/72" "Point (1/72 inch)" ) ( tpt "in/72.27" "Point (TeX conventions)" ) ( Ang "1e-10 m" "Angstrom" ) ( mfi "mi+ft+in" "Miles + feet + inches" ) ;; Area ( hect "10000 m^2" "*Hectare" ) ( acre "mi^2 / 640" "Acre" ) ( b "1e-28 m^2" "Barn" ) ;; Volume ( l "1e-3 m^3" "*Liter" ) ( L "1e-3 m^3" "Liter" ) ( gal "4 qt" "US Gallon" ) ( qt "2 pt" "Quart" ) ( pt "2 cup" "Pint" ) ( cup "8 ozfl" "Cup" ) ( ozfl "2 tbsp" "Fluid Ounce" ) ( floz "2 tbsp" "Fluid Ounce" ) ( tbsp "3 tsp" "Tablespoon" ) ( tsp "4.92892159375 ml" "Teaspoon" ) ( vol "tsp+tbsp+ozfl+cup+pt+qt+gal" "Gallons + ... + teaspoons" ) ( galC "4.54609 l" "Canadian Gallon" ) ( galUK "4.546092 l" "UK Gallon" ) ;; Time ( s nil "*Second" ) ( sec "s" "Second" ) ( min "60 s" "Minute" ) ( hr "60 min" "Hour" ) ( day "24 hr" "Day" ) ( wk "7 day" "Week" ) ( hms "wk+day+hr+min+s" "Hours, minutes, seconds" ) ( yr "365.25 day" "Year" ) ( Hz "1/s" "Hertz" ) ;; Speed ( mph "mi/hr" "*Miles per hour" ) ( kph "km/hr" "Kilometers per hour" ) ( knot "nmi/hr" "Knot" ) ( c "2.99792458e8 m/s" "Speed of light" ) ;; Acceleration ( ga "9.80665 m/s^2" "*\"g\" acceleration" ) ;; Mass ( g nil "*Gram" ) ( lb "16 oz" "Pound (mass)" ) ( oz "28.349523125 g" "Ounce (mass)" ) ( ton "2000 lb" "Ton" ) ( tpo "ton+lb+oz" "Tons + pounds + ounces (mass)" ) ( t "1000 kg" "Metric ton" ) ( tonUK "1016.0469088 kg" "UK ton" ) ( lbt "12 ozt" "Troy pound" ) ( ozt "31.103475 g" "Troy ounce" ) ( ct ".2 g" "Carat" ) ( amu "1.6605402e-24 g" "Unified atomic mass" ) ;; Force ( N "m kg/s^2" "*Newton" ) ( dyn "1e-5 N" "Dyne" ) ( gf "ga g" "Gram (force)" ) ( lbf "4.44822161526 N" "Pound (force)" ) ( kip "1000 lbf" "Kilopound (force)" ) ( pdl "0.138255 N" "Poundal" ) ;; Energy ( J "N m" "*Joule" ) ( erg "1e-7 J" "Erg" ) ( cal "4.1868 J" "International Table Calorie" ) ( Btu "1055.05585262 J" "International Table Btu" ) ( eV "ech V" "Electron volt" ) ( ev "eV" "Electron volt" ) ( therm "105506000 J" "EEC therm" ) ( invcm "h c/cm" "Energy in inverse centimeters" ) ( Kayser "invcm" "Kayser (inverse centimeter energy)" ) ( men "100/invcm" "Inverse energy in meters" ) ( Hzen "h Hz" "Energy in Hertz") ( Ken "k K" "Energy in Kelvins") ;; ( invcm "eV / 8065.47835185" "Energy in inverse centimeters" ) ;; ( Hzen "eV / 2.41796958004e14" "Energy in Hertz") ;; ( Ken "eV / 11604.7967327" "Energy in Kelvins") ;; Power ( W "J/s" "*Watt" ) ( hp "745.7 W" "Horsepower" ) ;; Temperature ( K nil "*Degree Kelvin" K ) ( dK "K" "Degree Kelvin" K ) ( degK "K" "Degree Kelvin" K ) ( dC "K" "Degree Celsius" C ) ( degC "K" "Degree Celsius" C ) ( dF "(5/9) K" "Degree Fahrenheit" F ) ( degF "(5/9) K" "Degree Fahrenheit" F ) ;; Pressure ( Pa "N/m^2" "*Pascal" ) ( bar "1e5 Pa" "Bar" ) ( atm "101325 Pa" "Standard atmosphere" ) ( torr "atm/760" "Torr" ) ( mHg "1000 torr" "Meter of mercury" ) ( inHg "25.4 mmHg" "Inch of mercury" ) ( inH2O "248.84 Pa" "Inch of water" ) ( psi "6894.75729317 Pa" "Pound per square inch" ) ;; Viscosity ( P "0.1 Pa s" "*Poise" ) ( St "1e-4 m^2/s" "Stokes" ) ;; Electromagnetism ( A nil "*Ampere" ) ( C "A s" "Coulomb" ) ( Fdy "ech Nav" "Faraday" ) ( e "1.60217733e-19 C" "Elementary charge" ) ( ech "1.60217733e-19 C" "Elementary charge" ) ( V "W/A" "Volt" ) ( ohm "V/A" "Ohm" ) ( mho "A/V" "Mho" ) ( S "A/V" "Siemens" ) ( F "C/V" "Farad" ) ( H "Wb/A" "Henry" ) ( T "Wb/m^2" "Tesla" ) ( G "1e-4 T" "Gauss" ) ( Wb "V s" "Weber" ) ;; Luminous intensity ( cd nil "*Candela" ) ( sb "1e4 cd/m^2" "Stilb" ) ( lm "cd sr" "Lumen" ) ( lx "lm/m^2" "Lux" ) ( ph "1e4 lx" "Phot" ) ( fc "10.76 lx" "Footcandle" ) ( lam "1e4 lm/m^2" "Lambert" ) ( flam "1.07639104e-3 lam" "Footlambert" ) ;; Radioactivity ( Bq "1/s" "*Becquerel" ) ( Ci "3.7e10 Bq" "Curie" ) ( Gy "J/kg" "Gray" ) ( Sv "Gy" "Sievert" ) ( R "2.58e-4 C/kg" "Roentgen" ) ( rd ".01 Gy" "Rad" ) ( rem "rd" "Rem" ) ;; Amount of substance ( mol nil "*Mole" ) ;; Plane angle ( rad nil "*Radian" ) ( circ "2 pi rad" "Full circle" ) ( rev "circ" "Full revolution" ) ( deg "circ/360" "Degree" ) ( arcmin "deg/60" "Arc minute" ) ( arcsec "arcmin/60" "Arc second" ) ( grad "circ/400" "Grade" ) ( rpm "rev/min" "Revolutions per minute" ) ;; Solid angle ( sr nil "*Steradian" ) ;; Other physical quantities (Physics Letters B239, 1 (1990)) ( h "6.6260755e-34 J s" "*Planck's constant" ) ( hbar "h / 2 pi" "Planck's constant" ) ( mu0 "4 pi 1e-7 H/m" "Permeability of vacuum" ) ( Grav "6.67259e-11 N m^2/kg^2" "Gravitational constant" ) ( Nav "6.0221367e23 / mol" "Avagadro's constant" ) ( me "0.51099906 MeV/c^2" "Electron rest mass" ) ( mp "1.007276470 amu" "Proton rest mass" ) ( mn "1.008664904 amu" "Neutron rest mass" ) ( mu "0.113428913 amu" "Muon rest mass" ) ( Ryd "1.0973731571e5 invcm" "Rydberg's constant" ) ( k "1.3806513e-23 J/K" "Boltzmann's constant" ) ( fsc "1 / 137.0359895" "Fine structure constant" ) ( muB "5.78838263e-11 MeV/T" "Bohr magneton" ) ( muN "3.15245166e-14 MeV/T" "Nuclear magneton" ) ( mue "1.001159652193 muB" "Electron magnetic moment" ) ( mup "2.792847386 muN" "Proton magnetic moment" ) ( R0 "Nav k" "Molar gas constant" ) ( V0 "22.413992 L/mol" "Standard volume of ideal gas" ) )) (defvar math-additional-units nil "*Additional units table for user-defined units. Must be formatted like math-standard-units. If this is changed, be sure to set math-units-table to nil to ensure that the combined units table will be rebuilt.") (defvar math-unit-prefixes '( ( ?E (float 1 18) "Exa" ) ( ?P (float 1 15) "Peta" ) ( ?T (float 1 12) "Tera" ) ( ?G (float 1 9) "Giga" ) ( ?M (float 1 6) "Mega" ) ( ?k (float 1 3) "Kilo" ) ( ?K (float 1 3) "Kilo" ) ( ?h (float 1 2) "Hecto" ) ( ?H (float 1 2) "Hecto" ) ( ?D (float 1 1) "Deka" ) ( 0 (float 1 0) nil ) ( ?d (float 1 -1) "Deci" ) ( ?c (float 1 -2) "Centi" ) ( ?m (float 1 -3) "Milli" ) ( ?u (float 1 -6) "Micro" ) ( ?n (float 1 -9) "Nano" ) ( ?p (float 1 -12) "Pico" ) ( ?f (float 1 -15) "Femto" ) ( ?a (float 1 -18) "Atto" ) )) (defvar math-standard-units-systems '( ( base nil ) ( si ( ( g '(* (var kg var-kg) (float 1 -3)) ) ) ) ( mks ( ( g '(* (var kg var-kg) (float 1 -3)) ) ) ) ( cgs ( ( m '(* (var cm var-cm) 100 ) ) ) ) )) (defvar math-units-table nil "Internal units table derived from math-defined-units. Entries are (SYMBOL EXPR DOC-STRING TEMP-TYPE BASE-UNITS).") (defvar math-units-table-buffer-valid nil) (defun math-build-units-table () (or math-units-table (let* ((combined-units (append math-additional-units math-standard-units)) (unit-list (mapcar 'car combined-units)) tab) (message "Building units table...") (setq math-units-table-buffer-valid nil) (setq tab (mapcar (function (lambda (x) (list (car x) (and (nth 1 x) (if (stringp (nth 1 x)) (let ((exp (math-read-plain-expr (nth 1 x)))) (if (eq (car-safe exp) 'error) (error "Format error in definition of %s in units table: %s" (car x) (nth 2 exp)) exp)) (nth 1 x))) (nth 2 x) (nth 3 x) (and (not (nth 1 x)) (list (cons (car x) 1)))))) combined-units)) (let ((math-units-table tab)) (mapcar 'math-find-base-units tab)) (message "Building units table...done") (setq math-units-table tab))) ) (defun math-find-base-units (entry) (if (eq (nth 4 entry) 'boom) (error "Circular definition involving unit %s" (car entry))) (or (nth 4 entry) (let (base) (setcar (nthcdr 4 entry) 'boom) (math-find-base-units-rec (nth 1 entry) 1) '(or base (error "Dimensionless definition for unit %s" (car entry))) (while (eq (cdr (car base)) 0) (setq base (cdr base))) (let ((b base)) (while (cdr b) (if (eq (cdr (car (cdr b))) 0) (setcdr b (cdr (cdr b))) (setq b (cdr b))))) (setq base (sort base 'math-compare-unit-names)) (setcar (nthcdr 4 entry) base) base)) ) (defun math-compare-unit-names (a b) (memq (car b) (cdr (memq (car a) unit-list))) ) (defun math-find-base-units-rec (expr pow) (let ((u (math-check-unit-name expr))) (cond (u (let ((ulist (math-find-base-units u))) (while ulist (let ((p (* (cdr (car ulist)) pow)) (old (assq (car (car ulist)) base))) (if old (setcdr old (+ (cdr old) p)) (setq base (cons (cons (car (car ulist)) p) base)))) (setq ulist (cdr ulist))))) ((math-scalarp expr)) ((and (eq (car expr) '^) (integerp (nth 2 expr))) (math-find-base-units-rec (nth 1 expr) (* pow (nth 2 expr)))) ((eq (car expr) '*) (math-find-base-units-rec (nth 1 expr) pow) (math-find-base-units-rec (nth 2 expr) pow)) ((eq (car expr) '/) (math-find-base-units-rec (nth 1 expr) pow) (math-find-base-units-rec (nth 2 expr) (- pow))) ((eq (car expr) 'neg) (math-find-base-units-rec (nth 1 expr) pow)) ((eq (car expr) '+) (math-find-base-units-rec (nth 1 expr) pow)) ((eq (car expr) 'var) (or (eq (nth 1 expr) 'pi) (error "Unknown name %s in defining expression for unit %s" (nth 1 expr) (car entry)))) (t (error "Malformed defining expression for unit %s" (car entry))))) ) (defun math-units-in-expr-p (expr sub-exprs) (and (consp expr) (if (eq (car expr) 'var) (math-check-unit-name expr) (and (or sub-exprs (memq (car expr) '(* / ^))) (or (math-units-in-expr-p (nth 1 expr) sub-exprs) (math-units-in-expr-p (nth 2 expr) sub-exprs))))) ) (defun math-only-units-in-expr-p (expr) (and (consp expr) (if (eq (car expr) 'var) (math-check-unit-name expr) (if (memq (car expr) '(* /)) (and (math-only-units-in-expr-p (nth 1 expr)) (math-only-units-in-expr-p (nth 2 expr))) (and (eq (car expr) '^) (and (math-only-units-in-expr-p (nth 1 expr)) (math-realp (nth 2 expr))))))) ) (defun math-single-units-in-expr-p (expr) (cond ((math-scalarp expr) nil) ((eq (car expr) 'var) (math-check-unit-name expr)) ((eq (car expr) '*) (let ((u1 (math-single-units-in-expr-p (nth 1 expr))) (u2 (math-single-units-in-expr-p (nth 2 expr)))) (or (and u1 u2 'wrong) u1 u2))) ((eq (car expr) '/) (if (math-units-in-expr-p (nth 2 expr) nil) 'wrong (math-single-units-in-expr-p (nth 1 expr)))) (t 'wrong)) ) (defun math-check-unit-name (v) (and (eq (car-safe v) 'var) (or (assq (nth 1 v) (or math-units-table (math-build-units-table))) (let ((name (symbol-name (nth 1 v)))) (and (> (length name) 1) (assq (aref name 0) math-unit-prefixes) (or (assq (intern (substring name 1)) math-units-table) (and (eq (aref name 0) ?M) (> (length name) 3) (eq (aref name 1) ?e) (eq (aref name 2) ?g) (assq (intern (substring name 3)) math-units-table))))))) ) (defun math-to-standard-units (expr which-standard) (math-to-standard-rec expr) ) (defun math-to-standard-rec (expr) (if (eq (car-safe expr) 'var) (let ((u (math-check-unit-name expr)) (base (nth 1 expr))) (if u (progn (if (nth 1 u) (setq expr (math-to-standard-rec (nth 1 u))) (let ((st (assq (car u) which-standard))) (if st (setq expr (nth 1 st)) (setq expr (list 'var (car u) (intern (concat "var-" (symbol-name (car u))))))))) (or (null u) (eq base (car u)) (setq expr (list '* (nth 1 (assq (aref (symbol-name base) 0) math-unit-prefixes)) expr))) expr) (if (eq base 'pi) (math-pi) expr))) (if (Math-primp expr) expr (cons (car expr) (mapcar 'math-to-standard-rec (cdr expr))))) ) (defun math-apply-units (expr units ulist &optional pure) (if ulist (let ((new 0) value) (setq expr (math-simplify-units expr)) (or (math-numberp expr) (error "Incompatible units")) (while (cdr ulist) (setq value (math-div expr (nth 1 (car ulist))) value (math-floor (let ((calc-internal-prec (1- calc-internal-prec))) (math-normalize value))) new (math-add new (math-mul value (car (car ulist)))) expr (math-sub expr (math-mul value (nth 1 (car ulist)))) ulist (cdr ulist))) (math-add new (math-mul (math-div expr (nth 1 (car ulist))) (car (car ulist))))) (math-simplify-units (if pure expr (list '* expr units)))) ) (defun math-decompose-units (units) (let ((u (math-check-unit-name units))) (and u (eq (car-safe (nth 1 u)) '+) (setq units (nth 1 u)))) (setq units (calcFunc-expand units)) (and (eq (car-safe units) '+) (let ((entry (list units calc-internal-prec calc-prefer-frac))) (or (equal entry (car math-decompose-units-cache)) (let ((ulist nil) (utemp units) qty unit) (while (eq (car-safe utemp) '+) (setq ulist (cons (math-decompose-unit-part (nth 2 utemp)) ulist) utemp (nth 1 utemp))) (setq ulist (cons (math-decompose-unit-part utemp) ulist) utemp ulist) (while (setq utemp (cdr utemp)) (or (equal (nth 2 (car utemp)) (nth 2 (car ulist))) (error "Inconsistent units in sum"))) (setq math-decompose-units-cache (cons entry (sort ulist (function (lambda (x y) (not (Math-lessp (nth 1 x) (nth 1 y)))))))))) (cdr math-decompose-units-cache))) ) (setq math-decompose-units-cache nil) (defun math-decompose-unit-part (unit) (cons unit (math-is-multiple (math-simplify-units (math-to-standard-units unit nil)) t)) ) (defun math-find-compatible-unit (expr unit) (let ((u (math-check-unit-name unit))) (if u (math-find-compatible-unit-rec expr 1))) ) (defun math-find-compatible-unit-rec (expr pow) (cond ((eq (car-safe expr) '*) (or (math-find-compatible-unit-rec (nth 1 expr) pow) (math-find-compatible-unit-rec (nth 2 expr) pow))) ((eq (car-safe expr) '/) (or (math-find-compatible-unit-rec (nth 1 expr) pow) (math-find-compatible-unit-rec (nth 2 expr) (- pow)))) ((and (eq (car-safe expr) '^) (integerp (nth 2 expr))) (math-find-compatible-unit-rec (nth 1 expr) (* pow (nth 2 expr)))) (t (let ((u2 (math-check-unit-name expr))) (if (equal (nth 4 u) (nth 4 u2)) (cons expr pow))))) ) (defun math-convert-units (expr new-units &optional pure) (math-with-extra-prec 2 (let ((compat (and (not pure) (math-find-compatible-unit expr new-units))) (unit-list nil) (math-combining-units nil)) (if compat (math-simplify-units (math-mul (math-mul (math-simplify-units (math-div expr (math-pow (car compat) (cdr compat)))) (math-pow new-units (cdr compat))) (math-simplify-units (math-to-standard-units (math-pow (math-div (car compat) new-units) (cdr compat)) nil)))) (if (setq unit-list (math-decompose-units new-units)) (setq new-units (nth 2 (car unit-list)))) (if (eq (car-safe expr) '+) (setq expr (math-simplify-units expr))) (if (math-units-in-expr-p expr t) (math-convert-units-rec expr) (math-apply-units (math-to-standard-units (list '/ expr new-units) nil) new-units unit-list pure))))) ) (defun math-convert-units-rec (expr) (if (math-units-in-expr-p expr nil) (math-apply-units (math-to-standard-units (list '/ expr new-units) nil) new-units unit-list pure) (if (Math-primp expr) expr (cons (car expr) (mapcar 'math-convert-units-rec (cdr expr))))) ) (defun math-convert-temperature (expr old new &optional pure) (let* ((units (math-single-units-in-expr-p expr)) (uold (if old (if (or (null units) (equal (nth 1 old) (car units))) (math-check-unit-name old) (error "Inconsistent temperature units")) units)) (unew (math-check-unit-name new))) (or (and (consp unew) (nth 3 unew)) (error "Not a valid temperature unit")) (or (and (consp uold) (nth 3 uold)) (error "Not a pure temperature expression")) (let ((v (car uold))) (setq expr (list '/ expr (list 'var v (intern (concat "var-" (symbol-name v))))))) (or (eq (nth 3 uold) (nth 3 unew)) (cond ((eq (nth 3 uold) 'K) (setq expr (list '- expr '(float 27315 -2))) (if (eq (nth 3 unew) 'F) (setq expr (list '+ (list '* expr '(frac 9 5)) 32)))) ((eq (nth 3 uold) 'C) (if (eq (nth 3 unew) 'F) (setq expr (list '+ (list '* expr '(frac 9 5)) 32)) (setq expr (list '+ expr '(float 27315 -2))))) (t (setq expr (list '* (list '- expr 32) '(frac 5 9))) (if (eq (nth 3 unew) 'K) (setq expr (list '+ expr '(float 27315 -2))))))) (if pure expr (list '* expr new))) ) (defun math-simplify-units (a) (let ((math-simplifying-units t) (calc-matrix-mode 'scalar)) (math-simplify a)) ) (fset 'calcFunc-usimplify (symbol-function 'math-simplify-units)) (math-defsimplify (+ -) (and math-simplifying-units (math-units-in-expr-p (nth 1 expr) nil) (let* ((units (math-extract-units (nth 1 expr))) (ratio (math-simplify (math-to-standard-units (list '/ (nth 2 expr) units) nil)))) (if (math-units-in-expr-p ratio nil) (progn (calc-record-why "*Inconsistent units" expr) expr) (list '* (math-add (math-remove-units (nth 1 expr)) (if (eq (car expr) '-) (math-neg ratio) ratio)) units)))) ) (math-defsimplify * (math-simplify-units-prod) ) (defun math-simplify-units-prod () (and math-simplifying-units calc-autorange-units (Math-realp (nth 1 expr)) (let* ((num (math-float (nth 1 expr))) (xpon (calcFunc-xpon num)) (unitp (cdr (cdr expr))) (unit (car unitp)) (pow (if (eq (car expr) '*) 1 -1)) u) (and (eq (car-safe unit) '*) (setq unitp (cdr unit) unit (car unitp))) (and (eq (car-safe unit) '^) (integerp (nth 2 unit)) (setq pow (* pow (nth 2 unit)) unitp (cdr unit) unit (car unitp))) (and (setq u (math-check-unit-name unit)) (integerp xpon) (or (< xpon 0) (>= xpon (if (eq (car u) 'm) 1 3))) (let* ((uxpon 0) (pref (if (< pow 0) (reverse math-unit-prefixes) math-unit-prefixes)) (p pref) pxpon pname) (or (eq (car u) (nth 1 unit)) (setq uxpon (* pow (nth 2 (nth 1 (assq (aref (symbol-name (nth 1 unit)) 0) math-unit-prefixes)))))) (setq xpon (+ xpon uxpon)) (while (and p (or (memq (car (car p)) '(?d ?D ?h ?H)) (and (eq (car (car p)) ?c) (not (eq (car u) 'm))) (< xpon (setq pxpon (* (nth 2 (nth 1 (car p))) pow))) (progn (setq pname (math-build-var-name (if (eq (car (car p)) 0) (car u) (concat (char-to-string (car (car p))) (symbol-name (car u)))))) (and (/= (car (car p)) 0) (assq (nth 1 pname) math-units-table))))) (setq p (cdr p))) (and p (/= pxpon uxpon) (or (not (eq p pref)) (< xpon (+ pxpon (* (math-abs pow) 3)))) (progn (setcar (cdr expr) (let ((calc-prefer-frac nil)) (calcFunc-scf (nth 1 expr) (- uxpon pxpon)))) (setcar unitp pname) expr)))))) ) (math-defsimplify / (and math-simplifying-units (let ((np (cdr expr)) (try-cancel-units 0) n nn) (setq n (if (eq (car-safe (nth 2 expr)) '*) (cdr (nth 2 expr)) (nthcdr 2 expr))) (if (math-realp (car n)) (progn (setcar (cdr expr) (math-mul (nth 1 expr) (let ((calc-prefer-frac nil)) (math-div 1 (car n))))) (setcar n 1))) (while (eq (car-safe (setq n (car np))) '*) (math-simplify-units-divisor (cdr n) (cdr (cdr expr))) (setq np (cdr (cdr n)))) (math-simplify-units-divisor np (cdr (cdr expr))) (if (eq try-cancel-units 0) (let* ((math-simplifying-units nil) (base (math-simplify (math-to-standard-units expr nil)))) (if (Math-numberp base) (setq expr base)))) (if (eq (car-safe expr) '/) (math-simplify-units-prod)) expr)) ) (defun math-simplify-units-divisor (np dp) (let ((n (car np)) d dd temp) (while (eq (car-safe (setq d (car dp))) '*) (if (setq temp (math-simplify-units-quotient n (nth 1 d))) (progn (setcar np (setq n temp)) (setcar (cdr d) 1))) (setq dp (cdr (cdr d)))) (if (setq temp (math-simplify-units-quotient n d)) (progn (setcar np (setq n temp)) (setcar dp 1)))) ) ;; Simplify, e.g., "in / cm" to "2.54" in a units expression. (defun math-simplify-units-quotient (n d) (let ((pow1 1) (pow2 1)) (and (eq (car-safe n) '^) (integerp (nth 2 n)) (setq pow1 (nth 2 n) n (nth 1 n))) (and (eq (car-safe d) '^) (integerp (nth 2 d)) (setq pow2 (nth 2 d) d (nth 1 d))) (let ((un (math-check-unit-name n)) (ud (math-check-unit-name d))) (and un ud (if (and (equal (nth 4 un) (nth 4 ud)) (eq pow1 pow2)) (math-to-standard-units (list '/ n d) nil) (let (ud1) (setq un (nth 4 un) ud (nth 4 ud)) (while un (setq ud1 ud) (while ud1 (and (eq (car (car un)) (car (car ud1))) (setq try-cancel-units (+ try-cancel-units (- (* (cdr (car un)) pow1) (* (cdr (car ud)) pow2))))) (setq ud1 (cdr ud1))) (setq un (cdr un))) nil))))) ) (math-defsimplify ^ (and math-simplifying-units (math-realp (nth 2 expr)) (if (memq (car-safe (nth 1 expr)) '(* /)) (list (car (nth 1 expr)) (list '^ (nth 1 (nth 1 expr)) (nth 2 expr)) (list '^ (nth 2 (nth 1 expr)) (nth 2 expr))) (math-simplify-units-pow (nth 1 expr) (nth 2 expr)))) ) (math-defsimplify calcFunc-sqrt (and math-simplifying-units (if (memq (car-safe (nth 1 expr)) '(* /)) (list (car (nth 1 expr)) (list 'calcFunc-sqrt (nth 1 (nth 1 expr))) (list 'calcFunc-sqrt (nth 2 (nth 1 expr)))) (math-simplify-units-pow (nth 1 expr) '(frac 1 2)))) ) (math-defsimplify (calcFunc-floor calcFunc-ceil calcFunc-round calcFunc-rounde calcFunc-roundu calcFunc-trunc calcFunc-float calcFunc-frac calcFunc-abs calcFunc-clean) (and math-simplifying-units (= (length expr) 2) (if (math-only-units-in-expr-p (nth 1 expr)) (nth 1 expr) (if (and (memq (car-safe (nth 1 expr)) '(* /)) (or (math-only-units-in-expr-p (nth 1 (nth 1 expr))) (math-only-units-in-expr-p (nth 2 (nth 1 expr))))) (list (car (nth 1 expr)) (cons (car expr) (cons (nth 1 (nth 1 expr)) (cdr (cdr expr)))) (cons (car expr) (cons (nth 2 (nth 1 expr)) (cdr (cdr expr))))))))) (defun math-simplify-units-pow (a pow) (if (and (eq (car-safe a) '^) (math-check-unit-name (nth 1 a)) (math-realp (nth 2 a))) (list '^ (nth 1 a) (math-mul pow (nth 2 a))) (let* ((u (math-check-unit-name a)) (pf (math-to-simple-fraction pow)) (d (and (eq (car-safe pf) 'frac) (nth 2 pf)))) (and u d (math-units-are-multiple u d) (list '^ (math-to-standard-units a nil) pow)))) ) (defun math-units-are-multiple (u n) (setq u (nth 4 u)) (while (and u (= (% (cdr (car u)) n) 0)) (setq u (cdr u))) (null u) ) (math-defsimplify calcFunc-sin (and math-simplifying-units (math-units-in-expr-p (nth 1 expr) nil) (let ((rad (math-simplify-units (math-evaluate-expr (math-to-standard-units (nth 1 expr) nil)))) (calc-angle-mode 'rad)) (and (eq (car-safe rad) '*) (math-realp (nth 1 rad)) (eq (car-safe (nth 2 rad)) 'var) (eq (nth 1 (nth 2 rad)) 'rad) (list 'calcFunc-sin (nth 1 rad))))) ) (math-defsimplify calcFunc-cos (and math-simplifying-units (math-units-in-expr-p (nth 1 expr) nil) (let ((rad (math-simplify-units (math-evaluate-expr (math-to-standard-units (nth 1 expr) nil)))) (calc-angle-mode 'rad)) (and (eq (car-safe rad) '*) (math-realp (nth 1 rad)) (eq (car-safe (nth 2 rad)) 'var) (eq (nth 1 (nth 2 rad)) 'rad) (list 'calcFunc-cos (nth 1 rad))))) ) (math-defsimplify calcFunc-tan (and math-simplifying-units (math-units-in-expr-p (nth 1 expr) nil) (let ((rad (math-simplify-units (math-evaluate-expr (math-to-standard-units (nth 1 expr) nil)))) (calc-angle-mode 'rad)) (and (eq (car-safe rad) '*) (math-realp (nth 1 rad)) (eq (car-safe (nth 2 rad)) 'var) (eq (nth 1 (nth 2 rad)) 'rad) (list 'calcFunc-tan (nth 1 rad))))) ) (defun math-remove-units (expr) (if (math-check-unit-name expr) 1 (if (Math-primp expr) expr (cons (car expr) (mapcar 'math-remove-units (cdr expr))))) ) (defun math-extract-units (expr) (if (memq (car-safe expr) '(* /)) (cons (car expr) (mapcar 'math-extract-units (cdr expr))) (if (math-check-unit-name expr) expr 1)) ) (defun math-build-units-table-buffer (enter-buffer) (if (not (and math-units-table math-units-table-buffer-valid (get-buffer "*Units Table*"))) (let ((buf (get-buffer-create "*Units Table*")) (uptr (math-build-units-table)) (calc-language (if (eq calc-language 'big) nil calc-language)) (calc-float-format '(float 0)) (calc-group-digits nil) (calc-number-radix 10) (calc-point-char ".") (std nil) u name shadowed) (save-excursion (message "Formatting units table...") (set-buffer buf) (setq buffer-read-only nil) (erase-buffer) (insert "Calculator Units Table:\n\n") (insert "Unit Type Definition Description\n\n") (while uptr (setq u (car uptr) name (nth 2 u)) (if (eq (car u) 'm) (setq std t)) (setq shadowed (and std (assq (car u) math-additional-units))) (if (and name (> (length name) 1) (eq (aref name 0) ?\*)) (progn (or (eq uptr math-units-table) (insert "\n")) (setq name (substring name 1)))) (insert " ") (and shadowed (insert "(")) (insert (symbol-name (car u))) (and shadowed (insert ")")) (if (nth 3 u) (progn (indent-to 10) (insert (symbol-name (nth 3 u)))) (or std (progn (indent-to 10) (insert "U")))) (indent-to 14) (and shadowed (insert "(")) (if (nth 1 u) (insert (math-format-value (nth 1 u) 80)) (insert (symbol-name (car u)))) (and shadowed (insert ")")) (indent-to 41) (insert " ") (if name (insert name)) (if shadowed (insert " (redefined above)") (or (nth 1 u) (insert " (base unit)"))) (insert "\n") (setq uptr (cdr uptr))) (insert "\n\nUnit Prefix Table:\n\n") (setq uptr math-unit-prefixes) (while uptr (setq u (car uptr)) (insert " " (char-to-string (car u))) (if (equal (nth 1 u) (nth 1 (nth 1 uptr))) (insert " " (char-to-string (car (car (setq uptr (cdr uptr))))) " ") (insert " ")) (insert "10^" (int-to-string (nth 2 (nth 1 u)))) (indent-to 15) (insert " " (nth 2 u) "\n") (while (eq (car (car (setq uptr (cdr uptr)))) 0))) (insert "\n") (setq buffer-read-only t) (message "Formatting units table...done")) (setq math-units-table-buffer-valid t) (let ((oldbuf (current-buffer))) (set-buffer buf) (goto-char (point-min)) (set-buffer oldbuf)) (if enter-buffer (pop-to-buffer buf) (display-buffer buf))) (if enter-buffer (pop-to-buffer (get-buffer "*Units Table*")) (display-buffer (get-buffer "*Units Table*")))) ) calc-2.02c/calc-mat.el100644 22403 13 24211 5402630666 13050 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-mat.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-mat () nil) (defun calc-mdet (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "mdet" 'calcFunc-det arg)) ) (defun calc-mtrace (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "mtr" 'calcFunc-tr arg)) ) (defun calc-mlud (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "mlud" 'calcFunc-lud arg)) ) ;;; Coerce row vector A to be a matrix. [V V] (defun math-row-matrix (a) (if (and (Math-vectorp a) (not (math-matrixp a))) (list 'vec a) a) ) ;;; Coerce column vector A to be a matrix. [V V] (defun math-col-matrix (a) (if (and (Math-vectorp a) (not (math-matrixp a))) (cons 'vec (mapcar (function (lambda (x) (list 'vec x))) (cdr a))) a) ) ;;; Multiply matrices A and B. [V V V] (defun math-mul-mats (a b) (let ((mat nil) (cols (length (nth 1 b))) row col ap bp accum) (while (setq a (cdr a)) (setq col cols row nil) (while (> (setq col (1- col)) 0) (setq ap (cdr (car a)) bp (cdr b) accum (math-mul (car ap) (nth col (car bp)))) (while (setq ap (cdr ap) bp (cdr bp)) (setq accum (math-add accum (math-mul (car ap) (nth col (car bp)))))) (setq row (cons accum row))) (setq mat (cons (cons 'vec row) mat))) (cons 'vec (nreverse mat))) ) (defun math-mul-mat-vec (a b) (cons 'vec (mapcar (function (lambda (row) (math-dot-product row b))) (cdr a))) ) (defun calcFunc-tr (mat) ; [Public] (if (math-square-matrixp mat) (math-matrix-trace-step 2 (1- (length mat)) mat (nth 1 (nth 1 mat))) (math-reject-arg mat 'square-matrixp)) ) (defun math-matrix-trace-step (n size mat sum) (if (<= n size) (math-matrix-trace-step (1+ n) size mat (math-add sum (nth n (nth n mat)))) sum) ) ;;; Matrix inverse and determinant. (defun math-matrix-inv-raw (m) (let ((n (1- (length m)))) (if (<= n 3) (let ((det (math-det-raw m))) (and (not (math-zerop det)) (math-div (cond ((= n 1) 1) ((= n 2) (list 'vec (list 'vec (nth 2 (nth 2 m)) (math-neg (nth 2 (nth 1 m)))) (list 'vec (math-neg (nth 1 (nth 2 m))) (nth 1 (nth 1 m))))) ((= n 3) (list 'vec (list 'vec (math-sub (math-mul (nth 3 (nth 3 m)) (nth 2 (nth 2 m))) (math-mul (nth 3 (nth 2 m)) (nth 2 (nth 3 m)))) (math-sub (math-mul (nth 3 (nth 1 m)) (nth 2 (nth 3 m))) (math-mul (nth 3 (nth 3 m)) (nth 2 (nth 1 m)))) (math-sub (math-mul (nth 3 (nth 2 m)) (nth 2 (nth 1 m))) (math-mul (nth 3 (nth 1 m)) (nth 2 (nth 2 m))))) (list 'vec (math-sub (math-mul (nth 3 (nth 2 m)) (nth 1 (nth 3 m))) (math-mul (nth 3 (nth 3 m)) (nth 1 (nth 2 m)))) (math-sub (math-mul (nth 3 (nth 3 m)) (nth 1 (nth 1 m))) (math-mul (nth 3 (nth 1 m)) (nth 1 (nth 3 m)))) (math-sub (math-mul (nth 3 (nth 1 m)) (nth 1 (nth 2 m))) (math-mul (nth 3 (nth 2 m)) (nth 1 (nth 1 m))))) (list 'vec (math-sub (math-mul (nth 2 (nth 3 m)) (nth 1 (nth 2 m))) (math-mul (nth 2 (nth 2 m)) (nth 1 (nth 3 m)))) (math-sub (math-mul (nth 2 (nth 1 m)) (nth 1 (nth 3 m))) (math-mul (nth 2 (nth 3 m)) (nth 1 (nth 1 m)))) (math-sub (math-mul (nth 2 (nth 2 m)) (nth 1 (nth 1 m))) (math-mul (nth 2 (nth 1 m)) (nth 1 (nth 2 m)))))))) det))) (let ((lud (math-matrix-lud m))) (and lud (math-lud-solve lud (calcFunc-idn 1 n)))))) ) (defun calcFunc-det (m) (if (math-square-matrixp m) (math-with-extra-prec 2 (math-det-raw m)) (if (and (eq (car-safe m) 'calcFunc-idn) (or (math-zerop (nth 1 m)) (math-equal-int (nth 1 m) 1))) (nth 1 m) (math-reject-arg m 'square-matrixp))) ) (defun math-det-raw (m) (let ((n (1- (length m)))) (cond ((= n 1) (nth 1 (nth 1 m))) ((= n 2) (math-sub (math-mul (nth 1 (nth 1 m)) (nth 2 (nth 2 m))) (math-mul (nth 2 (nth 1 m)) (nth 1 (nth 2 m))))) ((= n 3) (math-sub (math-sub (math-sub (math-add (math-add (math-mul (nth 1 (nth 1 m)) (math-mul (nth 2 (nth 2 m)) (nth 3 (nth 3 m)))) (math-mul (nth 2 (nth 1 m)) (math-mul (nth 3 (nth 2 m)) (nth 1 (nth 3 m))))) (math-mul (nth 3 (nth 1 m)) (math-mul (nth 1 (nth 2 m)) (nth 2 (nth 3 m))))) (math-mul (nth 3 (nth 1 m)) (math-mul (nth 2 (nth 2 m)) (nth 1 (nth 3 m))))) (math-mul (nth 1 (nth 1 m)) (math-mul (nth 3 (nth 2 m)) (nth 2 (nth 3 m))))) (math-mul (nth 2 (nth 1 m)) (math-mul (nth 1 (nth 2 m)) (nth 3 (nth 3 m)))))) (t (let ((lud (math-matrix-lud m))) (if lud (let ((lu (car lud))) (math-det-step n (nth 2 lud))) 0))))) ) (defun math-det-step (n prod) (if (> n 0) (math-det-step (1- n) (math-mul prod (nth n (nth n lu)))) prod) ) ;;; This returns a list (LU index d), or NIL if not possible. ;;; Argument M must be a square matrix. (defun math-matrix-lud (m) (let ((old (assoc m math-lud-cache)) (context (list calc-internal-prec calc-prefer-frac))) (if (and old (equal (nth 1 old) context)) (cdr (cdr old)) (let* ((lud (catch 'singular (math-do-matrix-lud m))) (entry (cons context lud))) (if old (setcdr old entry) (setq math-lud-cache (cons (cons m entry) math-lud-cache))) lud))) ) (defvar math-lud-cache nil) ;;; Numerical Recipes section 2.3; implicit pivoting omitted. (defun math-do-matrix-lud (m) (let* ((lu (math-copy-matrix m)) (n (1- (length lu))) i (j 1) k imax sum big (d 1) (index nil)) (while (<= j n) (setq i 1 big 0 imax j) (while (< i j) (math-working "LUD step" (format "%d/%d" j i)) (setq sum (nth j (nth i lu)) k 1) (while (< k i) (setq sum (math-sub sum (math-mul (nth k (nth i lu)) (nth j (nth k lu)))) k (1+ k))) (setcar (nthcdr j (nth i lu)) sum) (setq i (1+ i))) (while (<= i n) (math-working "LUD step" (format "%d/%d" j i)) (setq sum (nth j (nth i lu)) k 1) (while (< k j) (setq sum (math-sub sum (math-mul (nth k (nth i lu)) (nth j (nth k lu)))) k (1+ k))) (setcar (nthcdr j (nth i lu)) sum) (let ((dum (math-abs-approx sum))) (if (Math-lessp big dum) (setq big dum imax i))) (setq i (1+ i))) (if (> imax j) (setq lu (math-swap-rows lu j imax) d (- d))) (setq index (cons imax index)) (let ((pivot (nth j (nth j lu)))) (if (math-zerop pivot) (throw 'singular nil) (setq i j) (while (<= (setq i (1+ i)) n) (setcar (nthcdr j (nth i lu)) (math-div (nth j (nth i lu)) pivot))))) (setq j (1+ j))) (list lu (nreverse index) d)) ) (defun math-swap-rows (m r1 r2) (or (= r1 r2) (let* ((r1prev (nthcdr (1- r1) m)) (row1 (cdr r1prev)) (r2prev (nthcdr (1- r2) m)) (row2 (cdr r2prev)) (r2next (cdr row2))) (setcdr r2prev row1) (setcdr r1prev row2) (setcdr row2 (cdr row1)) (setcdr row1 r2next))) m ) (defun math-lud-solve (lud b &optional need) (if lud (let* ((x (math-copy-matrix b)) (n (1- (length x))) (m (1- (length (nth 1 x)))) (lu (car lud)) (col 1) i j ip ii index sum) (while (<= col m) (math-working "LUD solver step" col) (setq i 1 ii nil index (nth 1 lud)) (while (<= i n) (setq ip (car index) index (cdr index) sum (nth col (nth ip x))) (setcar (nthcdr col (nth ip x)) (nth col (nth i x))) (if (null ii) (or (math-zerop sum) (setq ii i)) (setq j ii) (while (< j i) (setq sum (math-sub sum (math-mul (nth j (nth i lu)) (nth col (nth j x)))) j (1+ j)))) (setcar (nthcdr col (nth i x)) sum) (setq i (1+ i))) (while (>= (setq i (1- i)) 1) (setq sum (nth col (nth i x)) j i) (while (<= (setq j (1+ j)) n) (setq sum (math-sub sum (math-mul (nth j (nth i lu)) (nth col (nth j x)))))) (setcar (nthcdr col (nth i x)) (math-div sum (nth i (nth i lu))))) (setq col (1+ col))) x) (and need (math-reject-arg need "*Singular matrix"))) ) (defun calcFunc-lud (m) (if (math-square-matrixp m) (or (math-with-extra-prec 2 (let ((lud (math-matrix-lud m))) (and lud (let* ((lmat (math-copy-matrix (car lud))) (umat (math-copy-matrix (car lud))) (n (1- (length (car lud)))) (perm (calcFunc-idn 1 n)) i (j 1)) (while (<= j n) (setq i 1) (while (< i j) (setcar (nthcdr j (nth i lmat)) 0) (setq i (1+ i))) (setcar (nthcdr j (nth j lmat)) 1) (while (<= (setq i (1+ i)) n) (setcar (nthcdr j (nth i umat)) 0)) (setq j (1+ j))) (while (>= (setq j (1- j)) 1) (let ((pos (nth (1- j) (nth 1 lud)))) (or (= pos j) (setq perm (math-swap-rows perm j pos))))) (list 'vec perm lmat umat))))) (math-reject-arg m "*Singular matrix")) (math-reject-arg m 'square-matrixp)) ) calc-2.02c/calc-map.el100644 22403 13 115655 5547406505 13104 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-map.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-map () nil) (defun calc-apply (&optional oper) (interactive) (calc-wrapper (let* ((sel-mode nil) (calc-dollar-values (mapcar 'calc-get-stack-element (nthcdr calc-stack-top calc-stack))) (calc-dollar-used 0) (oper (or oper (calc-get-operator "Apply" (if (math-vectorp (calc-top 1)) (1- (length (calc-top 1))) -1)))) (expr (calc-top-n (1+ calc-dollar-used)))) (message "Working...") (calc-set-command-flag 'clear-message) (calc-enter-result (1+ calc-dollar-used) (concat (substring "apl" 0 (- 4 (length (nth 2 oper)))) (nth 2 oper)) (list 'calcFunc-apply (math-calcFunc-to-var (nth 1 oper)) expr)))) ) (defun calc-reduce (&optional oper accum) (interactive) (calc-wrapper (let* ((sel-mode nil) (nest (calc-is-hyperbolic)) (rev (calc-is-inverse)) (nargs (if (and nest (not rev)) 2 1)) (calc-dollar-values (mapcar 'calc-get-stack-element (nthcdr calc-stack-top calc-stack))) (calc-dollar-used 0) (calc-mapping-dir (and (not accum) (not nest) "")) (oper (or oper (calc-get-operator (if nest (concat (if accum "Accumulate " "") (if rev "Fixed Point" "Nest")) (concat (if rev "Inv " "") (if accum "Accumulate" "Reduce"))) (if nest 1 2))))) (message "Working...") (calc-set-command-flag 'clear-message) (calc-enter-result (+ calc-dollar-used nargs) (concat (substring (if nest (if rev "fxp" "nst") (if accum "acc" "red")) 0 (- 4 (length (nth 2 oper)))) (nth 2 oper)) (if nest (cons (if rev (if accum 'calcFunc-afixp 'calcFunc-fixp) (if accum 'calcFunc-anest 'calcFunc-nest)) (cons (math-calcFunc-to-var (nth 1 oper)) (calc-top-list-n nargs (1+ calc-dollar-used)))) (list (if accum (if rev 'calcFunc-raccum 'calcFunc-accum) (intern (concat "calcFunc-" (if rev "r" "") "reduce" calc-mapping-dir))) (math-calcFunc-to-var (nth 1 oper)) (calc-top-n (1+ calc-dollar-used))))))) ) (defun calc-accumulate (&optional oper) (interactive) (calc-reduce oper t) ) (defun calc-map (&optional oper) (interactive) (calc-wrapper (let* ((sel-mode nil) (calc-dollar-values (mapcar 'calc-get-stack-element (nthcdr calc-stack-top calc-stack))) (calc-dollar-used 0) (calc-mapping-dir "") (oper (or oper (calc-get-operator "Map"))) (nargs (car oper))) (message "Working...") (calc-set-command-flag 'clear-message) (calc-enter-result (+ nargs calc-dollar-used) (concat (substring "map" 0 (- 4 (length (nth 2 oper)))) (nth 2 oper)) (cons (intern (concat "calcFunc-map" calc-mapping-dir)) (cons (math-calcFunc-to-var (nth 1 oper)) (calc-top-list-n nargs (1+ calc-dollar-used))))))) ) (defun calc-map-equation (&optional oper) (interactive) (calc-wrapper (let* ((sel-mode nil) (calc-dollar-values (mapcar 'calc-get-stack-element (nthcdr calc-stack-top calc-stack))) (calc-dollar-used 0) (oper (or oper (calc-get-operator "Map-equation"))) (nargs (car oper))) (message "Working...") (calc-set-command-flag 'clear-message) (calc-enter-result (+ nargs calc-dollar-used) (concat (substring "map" 0 (- 4 (length (nth 2 oper)))) (nth 2 oper)) (cons (if (calc-is-inverse) 'calcFunc-mapeqr (if (calc-is-hyperbolic) 'calcFunc-mapeqp 'calcFunc-mapeq)) (cons (math-calcFunc-to-var (nth 1 oper)) (calc-top-list-n nargs (1+ calc-dollar-used))))))) ) (defun calc-map-stack () "This is meant to be called by calc-keypad mode." (interactive) (let ((calc-verify-arglist nil)) (calc-unread-command ?\$) (calc-map)) ) (defun calc-outer-product (&optional oper) (interactive) (calc-wrapper (let* ((sel-mode nil) (calc-dollar-values (mapcar 'calc-get-stack-element (nthcdr calc-stack-top calc-stack))) (calc-dollar-used 0) (oper (or oper (calc-get-operator "Outer" 2)))) (message "Working...") (calc-set-command-flag 'clear-message) (calc-enter-result (+ 2 calc-dollar-used) (concat (substring "out" 0 (- 4 (length (nth 2 oper)))) (nth 2 oper)) (cons 'calcFunc-outer (cons (math-calcFunc-to-var (nth 1 oper)) (calc-top-list-n 2 (1+ calc-dollar-used))))))) ) (defun calc-inner-product (&optional mul-oper add-oper) (interactive) (calc-wrapper (let* ((sel-mode nil) (calc-dollar-values (mapcar 'calc-get-stack-element (nthcdr calc-stack-top calc-stack))) (calc-dollar-used 0) (mul-oper (or mul-oper (calc-get-operator "Inner (Mult)" 2))) (mul-used calc-dollar-used) (calc-dollar-values (if (> mul-used 0) (cdr calc-dollar-values) calc-dollar-values)) (calc-dollar-used 0) (add-oper (or add-oper (calc-get-operator "Inner (Add)" 2)))) (message "Working...") (calc-set-command-flag 'clear-message) (calc-enter-result (+ 2 mul-used calc-dollar-used) (concat "in" (substring (nth 2 mul-oper) 0 1) (substring (nth 2 add-oper) 0 1)) (nconc (list 'calcFunc-inner (math-calcFunc-to-var (nth 1 mul-oper)) (math-calcFunc-to-var (nth 1 add-oper))) (calc-top-list-n 2 (+ 1 mul-used calc-dollar-used)))))) ) ;;; Return a list of the form (nargs func name) (defun calc-get-operator (msg &optional nargs) (setq calc-aborted-prefix nil) (let ((inv nil) (hyp nil) (prefix nil) (forcenargs nil) done key oper (which 0) (msgs '( "(Press ? for help)" "+, -, *, /, ^, %, \\, :, &, !, |, Neg" "SHIFT + Abs, conJ, arG; maX, miN; Floor, Round; sQrt" "SHIFT + Inv, Hyp; Sin, Cos, Tan; Exp, Ln, logB" "Algebra + Simp, Esimp, Deriv, Integ, !, =, etc." "Binary + And, Or, Xor, Diff; l/r/t/L/R shifts; Not, Clip" "Conversions + Deg, Rad, HMS; Float; SHIFT + Fraction" "Functions + Re, Im; Hypot; Mant, Expon, Scale; etc." "Kombinatorics + Dfact, Lcm, Gcd, Choose; Random; etc." "Time/date + newYear, Incmonth, etc." "Vectors + Length, Row, Col, Diag, Mask, etc." "_ = mapr/reducea, : = mapc/reduced, = = reducer" "X or Z = any function by name; ' = alg entry; $ = stack"))) (while (not done) (message "%s%s: %s: %s%s%s" msg (cond ((equal calc-mapping-dir "r") " rows") ((equal calc-mapping-dir "c") " columns") ((equal calc-mapping-dir "a") " across") ((equal calc-mapping-dir "d") " down") (t "")) (if forcenargs (format "(%d arg%s)" forcenargs (if (= forcenargs 1) "" "s")) (nth which msgs)) (if inv "Inv " "") (if hyp "Hyp " "") (if prefix (concat (char-to-string prefix) "-") "")) (setq key (read-char)) (if (>= key 128) (setq key (- key 128))) (cond ((memq key '(?\C-g ?q)) (keyboard-quit)) ((memq key '(?\C-u ?\e))) ((= key ??) (setq which (% (1+ which) (length msgs)))) ((and (= key ?I) (null prefix)) (setq inv (not inv))) ((and (= key ?H) (null prefix)) (setq hyp (not hyp))) ((and (eq key prefix) (not (eq key ?v))) (setq prefix nil)) ((and (memq key '(?a ?b ?c ?f ?k ?s ?t ?u ?v ?V)) (null prefix)) (setq prefix (downcase key))) ((and (eq key ?\=) (null prefix)) (if calc-mapping-dir (setq calc-mapping-dir (if (equal calc-mapping-dir "r") "" "r")) (beep))) ((and (eq key ?\_) (null prefix)) (if calc-mapping-dir (if (string-match "map$" msg) (setq calc-mapping-dir (if (equal calc-mapping-dir "r") "" "r")) (setq calc-mapping-dir (if (equal calc-mapping-dir "a") "" "a"))) (beep))) ((and (eq key ?\:) (null prefix)) (if calc-mapping-dir (if (string-match "map$" msg) (setq calc-mapping-dir (if (equal calc-mapping-dir "c") "" "c")) (setq calc-mapping-dir (if (equal calc-mapping-dir "d") "" "d"))) (beep))) ((and (>= key ?0) (<= key ?9) (null prefix)) (setq forcenargs (if (eq forcenargs (- key ?0)) nil (- key ?0))) (and nargs forcenargs (/= nargs forcenargs) (>= nargs 0) (error "Must be a %d-argument operator" nargs))) ((memq key '(?\$ ?\')) (let* ((arglist nil) (has-args nil) (record-entry nil) (expr (if (eq key ?\$) (progn (setq calc-dollar-used 1) (if calc-dollar-values (car calc-dollar-values) (error "Stack underflow"))) (let* ((calc-dollar-values calc-arg-values) (calc-dollar-used 0) (calc-hashes-used 0) (func (calc-do-alg-entry "" "Function: "))) (setq record-entry t) (or (= (length func) 1) (error "Bad format")) (if (> calc-dollar-used 0) (progn (setq has-args calc-dollar-used arglist (calc-invent-args has-args)) (math-multi-subst (car func) (reverse arglist) arglist)) (if (> calc-hashes-used 0) (setq has-args calc-hashes-used arglist (calc-invent-args has-args))) (car func)))))) (if (eq (car-safe expr) 'calcFunc-lambda) (setq oper (list "$" (- (length expr) 2) expr) done t) (or has-args (progn (calc-default-formula-arglist expr) (setq record-entry t arglist (sort arglist 'string-lessp)) (if calc-verify-arglist (setq arglist (read-from-minibuffer "Function argument list: " (if arglist (prin1-to-string arglist) "()") minibuffer-local-map t))) (setq arglist (mapcar (function (lambda (x) (list 'var x (intern (concat "var-" (symbol-name x)))))) arglist)))) (setq oper (list "$" (length arglist) (append '(calcFunc-lambda) arglist (list expr))) done t)) (if record-entry (calc-record (nth 2 oper) "oper")))) ((setq oper (assq key (nth (if inv (if hyp 3 1) (if hyp 2 0)) (if prefix (symbol-value (intern (format "calc-%c-oper-keys" prefix))) calc-oper-keys)))) (if (eq (nth 1 oper) 'user) (let ((func (intern (completing-read "Function name: " obarray 'fboundp nil "calcFunc-")))) (if (or forcenargs nargs) (setq oper (list "z" (or forcenargs nargs) func) done t) (if (fboundp func) (let* ((defn (symbol-function func))) (and (symbolp defn) (setq defn (symbol-function defn))) (if (eq (car-safe defn) 'lambda) (let ((args (nth 1 defn)) (nargs 0)) (while (not (memq (car args) '(&optional &rest nil))) (setq nargs (1+ nargs) args (cdr args))) (setq oper (list "z" nargs func) done t)) (error "Function is not suitable for this operation"))) (message "Number of arguments: ") (let ((nargs (read-char))) (if (and (>= nargs ?0) (<= nargs ?9)) (setq oper (list "z" (- nargs ?0) func) done t) (beep)))))) (if (or (and (eq prefix ?v) (memq key '(?A ?I ?M ?O ?R ?U))) (and (eq prefix ?a) (eq key ?M))) (let* ((dir (cond ((and (equal calc-mapping-dir "") (string-match "map$" msg)) (setq calc-mapping-dir "r") " rows") ((equal calc-mapping-dir "r") " rows") ((equal calc-mapping-dir "c") " columns") ((equal calc-mapping-dir "a") " across") ((equal calc-mapping-dir "d") " down") (t ""))) (calc-mapping-dir (and (memq (nth 2 oper) '(calcFunc-map calcFunc-reduce calcFunc-rreduce)) "")) (oper2 (calc-get-operator (format "%s%s, %s%s" msg dir (substring (symbol-name (nth 2 oper)) 9) (if (eq key ?I) " (mult)" "")) (cdr (assq (nth 2 oper) '((calcFunc-reduce . 2) (calcFunc-rreduce . 2) (calcFunc-accum . 2) (calcFunc-raccum . 2) (calcFunc-nest . 2) (calcFunc-anest . 2) (calcFunc-fixp . 2) (calcFunc-afixp . 2)))))) (oper3 (if (eq (nth 2 oper) 'calcFunc-inner) (calc-get-operator (format "%s%s, inner (add)" msg dir (substring (symbol-name (nth 2 oper)) 9))) '(0 0 0))) (args nil) (nargs (if (> (nth 1 oper) 0) (nth 1 oper) (car oper2))) (n nargs) (p calc-arg-values)) (while (and p (> n 0)) (or (math-expr-contains (nth 1 oper2) (car p)) (math-expr-contains (nth 1 oper3) (car p)) (setq args (nconc args (list (car p))) n (1- n))) (setq p (cdr p))) (setq oper (list "" nargs (append '(calcFunc-lambda) args (list (math-build-call (intern (concat (symbol-name (nth 2 oper)) calc-mapping-dir)) (cons (math-calcFunc-to-var (nth 1 oper2)) (if (eq key ?I) (cons (math-calcFunc-to-var (nth 1 oper3)) args) args)))))) done t)) (setq done t)))) (t (beep)))) (and nargs (>= nargs 0) (/= nargs (nth 1 oper)) (error "Must be a %d-argument operator" nargs)) (append (if forcenargs (cons forcenargs (cdr (cdr oper))) (cdr oper)) (list (let ((name (concat (if inv "I" "") (if hyp "H" "") (if prefix (char-to-string prefix) "") (char-to-string key)))) (if (> (length name) 3) (substring name 0 3) name))))) ) (setq calc-verify-arglist t) (setq calc-mapping-dir nil) (defconst calc-oper-keys '( ( ( ?+ 2 calcFunc-add ) ( ?- 2 calcFunc-sub ) ( ?* 2 calcFunc-mul ) ( ?/ 2 calcFunc-div ) ( ?^ 2 calcFunc-pow ) ( ?| 2 calcFunc-vconcat ) ( ?% 2 calcFunc-mod ) ( ?\\ 2 calcFunc-idiv ) ( ?! 1 calcFunc-fact ) ( ?& 1 calcFunc-inv ) ( ?n 1 calcFunc-neg ) ( ?x user ) ( ?z user ) ( ?A 1 calcFunc-abs ) ( ?J 1 calcFunc-conj ) ( ?G 1 calcFunc-arg ) ( ?Q 1 calcFunc-sqrt ) ( ?N 2 calcFunc-min ) ( ?X 2 calcFunc-max ) ( ?F 1 calcFunc-floor ) ( ?R 1 calcFunc-round ) ( ?S 1 calcFunc-sin ) ( ?C 1 calcFunc-cos ) ( ?T 1 calcFunc-tan ) ( ?L 1 calcFunc-ln ) ( ?E 1 calcFunc-exp ) ( ?B 2 calcFunc-log ) ) ( ( ?F 1 calcFunc-ceil ) ; inverse ( ?R 1 calcFunc-trunc ) ( ?Q 1 calcFunc-sqr ) ( ?S 1 calcFunc-arcsin ) ( ?C 1 calcFunc-arccos ) ( ?T 1 calcFunc-arctan ) ( ?L 1 calcFunc-exp ) ( ?E 1 calcFunc-ln ) ( ?B 2 calcFunc-alog ) ( ?^ 2 calcFunc-nroot ) ( ?| 2 calcFunc-vconcatrev ) ) ( ( ?F 1 calcFunc-ffloor ) ; hyperbolic ( ?R 1 calcFunc-fround ) ( ?S 1 calcFunc-sinh ) ( ?C 1 calcFunc-cosh ) ( ?T 1 calcFunc-tanh ) ( ?L 1 calcFunc-log10 ) ( ?E 1 calcFunc-exp10 ) ( ?| 2 calcFunc-append ) ) ( ( ?F 1 calcFunc-fceil ) ; inverse-hyperbolic ( ?R 1 calcFunc-ftrunc ) ( ?S 1 calcFunc-arcsinh ) ( ?C 1 calcFunc-arccosh ) ( ?T 1 calcFunc-arctanh ) ( ?L 1 calcFunc-exp10 ) ( ?E 1 calcFunc-log10 ) ( ?| 2 calcFunc-appendrev ) ) )) (defconst calc-a-oper-keys '( ( ( ?a 3 calcFunc-apart ) ( ?b 3 calcFunc-subst ) ( ?c 2 calcFunc-collect ) ( ?d 2 calcFunc-deriv ) ( ?e 1 calcFunc-esimplify ) ( ?f 2 calcFunc-factor ) ( ?g 2 calcFunc-pgcd ) ( ?i 2 calcFunc-integ ) ( ?m 2 calcFunc-match ) ( ?n 1 calcFunc-nrat ) ( ?r 2 calcFunc-rewrite ) ( ?s 1 calcFunc-simplify ) ( ?t 3 calcFunc-taylor ) ( ?x 1 calcFunc-expand ) ( ?M 2 calcFunc-mapeq ) ( ?N 3 calcFunc-minimize ) ( ?P 2 calcFunc-roots ) ( ?R 3 calcFunc-root ) ( ?S 2 calcFunc-solve ) ( ?T 4 calcFunc-table ) ( ?X 3 calcFunc-maximize ) ( ?= 2 calcFunc-eq ) ( ?\# 2 calcFunc-neq ) ( ?< 2 calcFunc-lt ) ( ?> 2 calcFunc-gt ) ( ?\[ 2 calcFunc-leq ) ( ?\] 2 calcFunc-geq ) ( ?{ 2 calcFunc-in ) ( ?! 1 calcFunc-lnot ) ( ?& 2 calcFunc-land ) ( ?\| 2 calcFunc-lor ) ( ?: 3 calcFunc-if ) ( ?. 2 calcFunc-rmeq ) ( ?+ 4 calcFunc-sum ) ( ?- 4 calcFunc-asum ) ( ?* 4 calcFunc-prod ) ( ?_ 2 calcFunc-subscr ) ( ?\\ 2 calcFunc-pdiv ) ( ?% 2 calcFunc-prem ) ( ?/ 2 calcFunc-pdivrem ) ) ( ( ?m 2 calcFunc-matchnot ) ( ?M 2 calcFunc-mapeqr ) ( ?S 2 calcFunc-finv ) ) ( ( ?d 2 calcFunc-tderiv ) ( ?f 2 calcFunc-factors ) ( ?M 2 calcFunc-mapeqp ) ( ?N 3 calcFunc-wminimize ) ( ?R 3 calcFunc-wroot ) ( ?S 2 calcFunc-fsolve ) ( ?X 3 calcFunc-wmaximize ) ( ?/ 2 calcFunc-pdivide ) ) ( ( ?S 2 calcFunc-ffinv ) ) )) (defconst calc-b-oper-keys '( ( ( ?a 2 calcFunc-and ) ( ?o 2 calcFunc-or ) ( ?x 2 calcFunc-xor ) ( ?d 2 calcFunc-diff ) ( ?n 1 calcFunc-not ) ( ?c 1 calcFunc-clip ) ( ?l 2 calcFunc-lsh ) ( ?r 2 calcFunc-rsh ) ( ?L 2 calcFunc-ash ) ( ?R 2 calcFunc-rash ) ( ?t 2 calcFunc-rot ) ( ?p 1 calcFunc-vpack ) ( ?u 1 calcFunc-vunpack ) ( ?D 4 calcFunc-ddb ) ( ?F 3 calcFunc-fv ) ( ?I 1 calcFunc-irr ) ( ?M 3 calcFunc-pmt ) ( ?N 2 calcFunc-npv ) ( ?P 3 calcFunc-pv ) ( ?S 3 calcFunc-sln ) ( ?T 3 calcFunc-rate ) ( ?Y 4 calcFunc-syd ) ( ?\# 3 calcFunc-nper ) ( ?\% 2 calcFunc-relch ) ) ( ( ?F 3 calcFunc-fvb ) ( ?I 1 calcFunc-irrb ) ( ?M 3 calcFunc-pmtb ) ( ?N 2 calcFunc-npvb ) ( ?P 3 calcFunc-pvb ) ( ?T 3 calcFunc-rateb ) ( ?\# 3 calcFunc-nperb ) ) ( ( ?F 3 calcFunc-fvl ) ( ?M 3 calcFunc-pmtl ) ( ?P 3 calcFunc-pvl ) ( ?T 3 calcFunc-ratel ) ( ?\# 3 calcFunc-nperl ) ) )) (defconst calc-c-oper-keys '( ( ( ?d 1 calcFunc-deg ) ( ?r 1 calcFunc-rad ) ( ?h 1 calcFunc-hms ) ( ?f 1 calcFunc-float ) ( ?F 1 calcFunc-frac ) ) )) (defconst calc-f-oper-keys '( ( ( ?b 2 calcFunc-beta ) ( ?e 1 calcFunc-erf ) ( ?g 1 calcFunc-gamma ) ( ?h 2 calcFunc-hypot ) ( ?i 1 calcFunc-im ) ( ?j 2 calcFunc-besJ ) ( ?n 2 calcFunc-min ) ( ?r 1 calcFunc-re ) ( ?s 1 calcFunc-sign ) ( ?x 2 calcFunc-max ) ( ?y 2 calcFunc-besY ) ( ?A 1 calcFunc-abssqr ) ( ?B 3 calcFunc-betaI ) ( ?E 1 calcFunc-expm1 ) ( ?G 2 calcFunc-gammaP ) ( ?I 2 calcFunc-ilog ) ( ?L 1 calcFunc-lnp1 ) ( ?M 1 calcFunc-mant ) ( ?Q 1 calcFunc-isqrt ) ( ?S 1 calcFunc-scf ) ( ?T 2 calcFunc-arctan2 ) ( ?X 1 calcFunc-xpon ) ( ?\[ 2 calcFunc-decr ) ( ?\] 2 calcFunc-incr ) ) ( ( ?e 1 calcFunc-erfc ) ( ?E 1 calcFunc-lnp1 ) ( ?G 2 calcFunc-gammaQ ) ( ?L 1 calcFunc-expm1 ) ) ( ( ?B 3 calcFunc-betaB ) ( ?G 2 calcFunc-gammag) ) ( ( ?G 2 calcFunc-gammaG ) ) )) (defconst calc-k-oper-keys '( ( ( ?b 1 calcFunc-bern ) ( ?c 2 calcFunc-choose ) ( ?d 1 calcFunc-dfact ) ( ?e 1 calcFunc-euler ) ( ?f 1 calcFunc-prfac ) ( ?g 2 calcFunc-gcd ) ( ?h 2 calcFunc-shuffle ) ( ?l 2 calcFunc-lcm ) ( ?m 1 calcFunc-moebius ) ( ?n 1 calcFunc-nextprime ) ( ?r 1 calcFunc-random ) ( ?s 2 calcFunc-stir1 ) ( ?t 1 calcFunc-totient ) ( ?B 3 calcFunc-utpb ) ( ?C 2 calcFunc-utpc ) ( ?F 3 calcFunc-utpf ) ( ?N 3 calcFunc-utpn ) ( ?P 2 calcFunc-utpp ) ( ?T 2 calcFunc-utpt ) ) ( ( ?n 1 calcFunc-prevprime ) ( ?B 3 calcFunc-ltpb ) ( ?C 2 calcFunc-ltpc ) ( ?F 3 calcFunc-ltpf ) ( ?N 3 calcFunc-ltpn ) ( ?P 2 calcFunc-ltpp ) ( ?T 2 calcFunc-ltpt ) ) ( ( ?b 2 calcFunc-bern ) ( ?c 2 calcFunc-perm ) ( ?e 2 calcFunc-euler ) ( ?s 2 calcFunc-stir2 ) ) )) (defconst calc-s-oper-keys '( ( ( ?: 2 calcFunc-assign ) ( ?= 1 calcFunc-evalto ) ) )) (defconst calc-t-oper-keys '( ( ( ?C 3 calcFunc-tzconv ) ( ?D 1 calcFunc-date ) ( ?I 2 calcFunc-incmonth ) ( ?J 1 calcFunc-julian ) ( ?M 1 calcFunc-newmonth ) ( ?W 1 calcFunc-newweek ) ( ?U 1 calcFunc-unixtime ) ( ?Y 1 calcFunc-newyear ) ) )) (defconst calc-u-oper-keys '( ( ( ?C 2 calcFunc-vcov ) ( ?G 1 calcFunc-vgmean ) ( ?M 1 calcFunc-vmean ) ( ?N 1 calcFunc-vmin ) ( ?S 1 calcFunc-vsdev ) ( ?X 1 calcFunc-vmax ) ) ( ( ?C 2 calcFunc-vpcov ) ( ?M 1 calcFunc-vmeane ) ( ?S 1 calcFunc-vpsdev ) ) ( ( ?C 2 calcFunc-vcorr ) ( ?G 1 calcFunc-agmean ) ( ?M 1 calcFunc-vmedian ) ( ?S 1 calcFunc-vvar ) ) ( ( ?M 1 calcFunc-vhmean ) ( ?S 1 calcFunc-vpvar ) ) )) (defconst calc-v-oper-keys '( ( ( ?a 2 calcFunc-arrange ) ( ?b 2 calcFunc-cvec ) ( ?c 2 calcFunc-mcol ) ( ?d 2 calcFunc-diag ) ( ?e 2 calcFunc-vexp ) ( ?f 2 calcFunc-find ) ( ?h 1 calcFunc-head ) ( ?k 2 calcFunc-cons ) ( ?l 1 calcFunc-vlen ) ( ?m 2 calcFunc-vmask ) ( ?n 1 calcFunc-rnorm ) ( ?p 2 calcFunc-pack ) ( ?r 2 calcFunc-mrow ) ( ?s 3 calcFunc-subvec ) ( ?t 1 calcFunc-trn ) ( ?u 1 calcFunc-unpack ) ( ?v 1 calcFunc-rev ) ( ?x 1 calcFunc-index ) ( ?A 1 calcFunc-apply ) ( ?C 1 calcFunc-cross ) ( ?D 1 calcFunc-det ) ( ?E 1 calcFunc-venum ) ( ?F 1 calcFunc-vfloor ) ( ?G 1 calcFunc-grade ) ( ?H 2 calcFunc-histogram ) ( ?I 2 calcFunc-inner ) ( ?L 1 calcFunc-lud ) ( ?M 0 calcFunc-map ) ( ?N 1 calcFunc-cnorm ) ( ?O 2 calcFunc-outer ) ( ?R 1 calcFunc-reduce ) ( ?S 1 calcFunc-sort ) ( ?T 1 calcFunc-tr ) ( ?U 1 calcFunc-accum ) ( ?V 2 calcFunc-vunion ) ( ?X 2 calcFunc-vxor ) ( ?- 2 calcFunc-vdiff ) ( ?^ 2 calcFunc-vint ) ( ?~ 1 calcFunc-vcompl ) ( ?# 1 calcFunc-vcard ) ( ?: 1 calcFunc-vspan ) ( ?+ 1 calcFunc-rdup ) ) ( ( ?h 1 calcFunc-tail ) ( ?s 3 calcFunc-rsubvec ) ( ?G 1 calcFunc-rgrade ) ( ?R 1 calcFunc-rreduce ) ( ?S 1 calcFunc-rsort ) ( ?U 1 calcFunc-raccum ) ) ( ( ?e 3 calcFunc-vexp ) ( ?h 1 calcFunc-rhead ) ( ?k 2 calcFunc-rcons ) ( ?H 3 calcFunc-histogram ) ( ?R 2 calcFunc-nest ) ( ?U 2 calcFunc-anest ) ) ( ( ?h 1 calcFunc-rtail ) ( ?R 1 calcFunc-fixp ) ( ?U 1 calcFunc-afixp ) ) )) ;;; Convert a variable name (as a formula) into a like-looking function name. (defun math-var-to-calcFunc (f) (if (eq (car-safe f) 'var) (if (fboundp (nth 2 f)) (nth 2 f) (intern (concat "calcFunc-" (symbol-name (nth 1 f))))) (if (memq (car-safe f) '(lambda calcFunc-lambda)) f (math-reject-arg f "*Expected a function name"))) ) ;;; Convert a function name into a like-looking variable name formula. (defun math-calcFunc-to-var (f) (if (symbolp f) (let* ((func (or (cdr (assq f '( ( + . calcFunc-add ) ( - . calcFunc-sub ) ( * . calcFunc-mul ) ( / . calcFunc-div ) ( ^ . calcFunc-pow ) ( % . calcFunc-mod ) ( neg . calcFunc-neg ) ( | . calcFunc-vconcat ) ))) f)) (base (if (string-match "\\`calcFunc-\\(.+\\)\\'" (symbol-name func)) (math-match-substring (symbol-name func) 1) (symbol-name func)))) (list 'var (intern base) (intern (concat "var-" base)))) f) ) ;;; Expand a function call using "lambda" notation. (defun math-build-call (f args) (if (eq (car-safe f) 'calcFunc-lambda) (if (= (length args) (- (length f) 2)) (math-multi-subst (nth (1- (length f)) f) (cdr f) args) (calc-record-why "*Wrong number of arguments" f) (cons 'calcFunc-call (cons (math-calcFunc-to-var f) args))) (if (and (eq f 'calcFunc-neg) (= (length args) 1)) (list 'neg (car args)) (let ((func (assq f '( ( calcFunc-add . + ) ( calcFunc-sub . - ) ( calcFunc-mul . * ) ( calcFunc-div . / ) ( calcFunc-pow . ^ ) ( calcFunc-mod . % ) ( calcFunc-vconcat . | ) )))) (if (and func (= (length args) 2)) (cons (cdr func) args) (cons f args))))) ) ;;; Do substitutions in parallel to avoid crosstalk. (defun math-multi-subst (expr olds news) (let ((args nil) temp) (while (and olds news) (setq args (cons (cons (car olds) (car news)) args) olds (cdr olds) news (cdr news))) (math-multi-subst-rec expr)) ) (defun math-multi-subst-rec (expr) (cond ((setq temp (assoc expr args)) (cdr temp)) ((Math-primp expr) expr) ((and (eq (car expr) 'calcFunc-lambda) (> (length expr) 2)) (let ((new (list (car expr))) (args args)) (while (cdr (setq expr (cdr expr))) (setq new (cons (car expr) new)) (if (assoc (car expr) args) (setq args (cons (cons (car expr) (car expr)) args)))) (nreverse (cons (math-multi-subst-rec (car expr)) new)))) (t (cons (car expr) (mapcar 'math-multi-subst-rec (cdr expr))))) ) (defun calcFunc-call (f &rest args) (setq args (math-build-call (math-var-to-calcFunc f) args)) (if (eq (car-safe args) 'calcFunc-call) args (math-normalize args)) ) (defun calcFunc-apply (f args) (or (Math-vectorp args) (math-reject-arg args 'vectorp)) (apply 'calcFunc-call (cons f (cdr args))) ) ;;; Map a function over a vector symbolically. [Public] (defun math-symb-map (f mode args) (let* ((func (math-var-to-calcFunc f)) (nargs (length args)) (ptrs (vconcat args)) (vflags (make-vector nargs nil)) (heads '(vec)) (head nil) (vec nil) (i -1) (math-working-step 0) (math-working-step-2 nil) len cols obj expr) (if (eq mode 'eqn) (setq mode 'elems heads '(calcFunc-eq calcFunc-neq calcFunc-lt calcFunc-gt calcFunc-leq calcFunc-geq)) (while (and (< (setq i (1+ i)) nargs) (not (math-matrixp (aref ptrs i))))) (if (< i nargs) (if (eq mode 'elems) (setq func (list 'lambda '(&rest x) (list 'math-symb-map (list 'quote f) '(quote elems) 'x)) mode 'rows) (if (eq mode 'cols) (while (< i nargs) (if (math-matrixp (aref ptrs i)) (aset ptrs i (math-transpose (aref ptrs i)))) (setq i (1+ i))))) (setq mode 'elems)) (setq i -1)) (while (< (setq i (1+ i)) nargs) (setq obj (aref ptrs i)) (if (and (memq (car-safe obj) heads) (or (eq mode 'elems) (math-matrixp obj))) (progn (aset vflags i t) (if head (if (cdr heads) (setq head (nth (aref (aref [ [0 1 2 3 4 5] [1 1 2 3 2 3] [2 2 2 1 2 1] [3 3 1 3 1 3] [4 2 2 1 4 1] [5 3 1 3 1 5] ] (- 6 (length (memq head heads)))) (- 6 (length (memq (car obj) heads)))) heads))) (setq head (car obj))) (if len (or (= (length obj) len) (math-dimension-error)) (setq len (length obj)))))) (or len (if (= nargs 1) (math-reject-arg (aref ptrs 0) 'vectorp) (math-reject-arg nil "At least one argument must be a vector"))) (setq math-working-step-2 (1- len)) (while (> (setq len (1- len)) 0) (setq expr nil i -1) (while (< (setq i (1+ i)) nargs) (if (aref vflags i) (progn (aset ptrs i (cdr (aref ptrs i))) (setq expr (nconc expr (list (car (aref ptrs i)))))) (setq expr (nconc expr (list (aref ptrs i)))))) (setq math-working-step (1+ math-working-step) vec (cons (math-normalize (math-build-call func expr)) vec))) (setq vec (cons head (nreverse vec))) (if (and (eq mode 'cols) (math-matrixp vec)) (math-transpose vec) vec)) ) (defun calcFunc-map (func &rest args) (math-symb-map func 'elems args) ) (defun calcFunc-mapr (func &rest args) (math-symb-map func 'rows args) ) (defun calcFunc-mapc (func &rest args) (math-symb-map func 'cols args) ) (defun calcFunc-mapa (func arg) (if (math-matrixp arg) (math-symb-map func 'elems (cdr (math-transpose arg))) (math-symb-map func 'elems arg)) ) (defun calcFunc-mapd (func arg) (if (math-matrixp arg) (math-symb-map func 'elems (cdr arg)) (math-symb-map func 'elems arg)) ) (defun calcFunc-mapeq (func &rest args) (if (and (or (equal func '(var mul var-mul)) (equal func '(var div var-div))) (= (length args) 2)) (if (math-negp (car args)) (let ((func (nth 1 (assq (car-safe (nth 1 args)) calc-tweak-eqn-table)))) (and func (setq args (list (car args) (cons func (cdr (nth 1 args))))))) (if (math-negp (nth 1 args)) (let ((func (nth 1 (assq (car-safe (car args)) calc-tweak-eqn-table)))) (and func (setq args (list (cons func (cdr (car args))) (nth 1 args)))))))) (if (or (and (equal func '(var div var-div)) (assq (car-safe (nth 1 args)) calc-tweak-eqn-table)) (equal func '(var neg var-neg)) (equal func '(var inv var-inv))) (apply 'calcFunc-mapeqr func args) (apply 'calcFunc-mapeqp func args)) ) (defun calcFunc-mapeqr (func &rest args) (setq args (mapcar (function (lambda (x) (let ((func (assq (car-safe x) calc-tweak-eqn-table))) (if func (cons (nth 1 func) (cdr x)) x)))) args)) (apply 'calcFunc-mapeqp func args) ) (defun calcFunc-mapeqp (func &rest args) (if (or (and (memq (car-safe (car args)) '(calcFunc-lt calcFunc-leq)) (memq (car-safe (nth 1 args)) '(calcFunc-gt calcFunc-geq))) (and (memq (car-safe (car args)) '(calcFunc-gt calcFunc-geq)) (memq (car-safe (nth 1 args)) '(calcFunc-lt calcFunc-leq)))) (setq args (cons (car args) (cons (list (nth 1 (assq (car (nth 1 args)) calc-tweak-eqn-table)) (nth 2 (nth 1 args)) (nth 1 (nth 1 args))) (cdr (cdr args)))))) (math-symb-map func 'eqn args) ) ;;; Reduce a function over a vector symbolically. [Public] (defun calcFunc-reduce (func vec) (if (math-matrixp vec) (let (expr row) (setq func (math-var-to-calcFunc func)) (while (setq vec (cdr vec)) (setq row (car vec)) (while (setq row (cdr row)) (setq expr (if expr (if (Math-numberp expr) (math-normalize (math-build-call func (list expr (car row)))) (math-build-call func (list expr (car row)))) (car row))))) (math-normalize expr)) (calcFunc-reducer func vec)) ) (defun calcFunc-rreduce (func vec) (if (math-matrixp vec) (let (expr row) (setq func (math-var-to-calcFunc func) vec (reverse (cdr vec))) (while vec (setq row (reverse (cdr (car vec)))) (while row (setq expr (if expr (math-build-call func (list (car row) expr)) (car row)) row (cdr row))) (setq vec (cdr vec))) (math-normalize expr)) (calcFunc-rreducer func vec)) ) (defun calcFunc-reducer (func vec) (setq func (math-var-to-calcFunc func)) (or (math-vectorp vec) (math-reject-arg vec 'vectorp)) (let ((expr (car (setq vec (cdr vec))))) (if expr (progn (condition-case err (and (symbolp func) (let ((lfunc (or (cdr (assq func '( (calcFunc-add . math-add) (calcFunc-sub . math-sub) (calcFunc-mul . math-mul) (calcFunc-div . math-div) (calcFunc-pow . math-pow) (calcFunc-mod . math-mod) (calcFunc-vconcat . math-concat) ))) lfunc))) (while (cdr vec) (setq expr (funcall lfunc expr (nth 1 vec)) vec (cdr vec))))) (error nil)) (while (setq vec (cdr vec)) (setq expr (math-build-call func (list expr (car vec))))) (math-normalize expr)) (or (math-identity-value func) (math-reject-arg vec "*Vector is empty")))) ) (defun math-identity-value (func) (cdr (assq func '( (calcFunc-add . 0) (calcFunc-sub . 0) (calcFunc-mul . 1) (calcFunc-div . 1) (calcFunc-idiv . 1) (calcFunc-fdiv . 1) (calcFunc-min . (var inf var-inf)) (calcFunc-max . (neg (var inf var-inf))) (calcFunc-vconcat . (vec)) (calcFunc-append . (vec)) ))) ) (defun calcFunc-rreducer (func vec) (setq func (math-var-to-calcFunc func)) (or (math-vectorp vec) (math-reject-arg vec 'vectorp)) (if (eq func 'calcFunc-sub) ; do this in a way that looks nicer (let ((expr (car (setq vec (cdr vec))))) (if expr (progn (while (setq vec (cdr vec)) (setq expr (math-build-call func (list expr (car vec))) func (if (eq func 'calcFunc-sub) 'calcFunc-add 'calcFunc-sub))) (math-normalize expr)) 0)) (let ((expr (car (setq vec (reverse (cdr vec)))))) (if expr (progn (while (setq vec (cdr vec)) (setq expr (math-build-call func (list (car vec) expr)))) (math-normalize expr)) (or (math-identity-value func) (math-reject-arg vec "*Vector is empty"))))) ) (defun calcFunc-reducec (func vec) (if (math-matrixp vec) (calcFunc-reducer func (math-transpose vec)) (calcFunc-reducer func vec)) ) (defun calcFunc-rreducec (func vec) (if (math-matrixp vec) (calcFunc-rreducer func (math-transpose vec)) (calcFunc-rreducer func vec)) ) (defun calcFunc-reducea (func vec) (if (math-matrixp vec) (cons 'vec (mapcar (function (lambda (x) (calcFunc-reducer func x))) (cdr vec))) (calcFunc-reducer func vec)) ) (defun calcFunc-rreducea (func vec) (if (math-matrixp vec) (cons 'vec (mapcar (function (lambda (x) (calcFunc-rreducer func x))) (cdr vec))) (calcFunc-rreducer func vec)) ) (defun calcFunc-reduced (func vec) (if (math-matrixp vec) (cons 'vec (mapcar (function (lambda (x) (calcFunc-reducer func x))) (cdr (math-transpose vec)))) (calcFunc-reducer func vec)) ) (defun calcFunc-rreduced (func vec) (if (math-matrixp vec) (cons 'vec (mapcar (function (lambda (x) (calcFunc-rreducer func x))) (cdr (math-transpose vec)))) (calcFunc-rreducer func vec)) ) (defun calcFunc-accum (func vec) (setq func (math-var-to-calcFunc func)) (or (math-vectorp vec) (math-reject-arg vec 'vectorp)) (let* ((expr (car (setq vec (cdr vec)))) (res (list 'vec expr))) (or expr (math-reject-arg vec "*Vector is empty")) (while (setq vec (cdr vec)) (setq expr (math-build-call func (list expr (car vec))) res (nconc res (list expr)))) (math-normalize res)) ) (defun calcFunc-raccum (func vec) (setq func (math-var-to-calcFunc func)) (or (math-vectorp vec) (math-reject-arg vec 'vectorp)) (let* ((expr (car (setq vec (reverse (cdr vec))))) (res (list expr))) (or expr (math-reject-arg vec "*Vector is empty")) (while (setq vec (cdr vec)) (setq expr (math-build-call func (list (car vec) expr)) res (cons (list expr) res))) (math-normalize (cons 'vec res))) ) (defun math-nest-calls (func base iters accum tol) (or (symbolp tol) (if (math-realp tol) (or (math-numberp base) (math-reject-arg base 'numberp)) (math-reject-arg tol 'realp))) (setq func (math-var-to-calcFunc func)) (or (null iters) (if (equal iters '(var inf var-inf)) (setq iters nil) (progn (if (math-messy-integerp iters) (setq iters (math-trunc iters))) (or (integerp iters) (math-reject-arg iters 'fixnump)) (or (not tol) (natnump iters) (math-reject-arg iters 'fixnatnump)) (if (< iters 0) (let* ((dummy '(var DummyArg var-DummyArg)) (dummy2 '(var DummyArg2 var-DummyArg2)) (finv (math-solve-for (math-build-call func (list dummy2)) dummy dummy2 nil))) (or finv (math-reject-arg nil "*Unable to find an inverse")) (if (and (= (length finv) 2) (equal (nth 1 finv) dummy)) (setq func (car finv)) (setq func (list 'calcFunc-lambda dummy finv))) (setq iters (- iters))))))) (math-with-extra-prec 1 (let ((value base) (ovalue nil) (avalues (list base)) (math-working-step 0) (math-working-step-2 iters)) (while (and (or (null iters) (>= (setq iters (1- iters)) 0)) (or (null tol) (null ovalue) (if (eq tol t) (not (if (and (Math-numberp value) (Math-numberp ovalue)) (math-nearly-equal value ovalue) (Math-equal value ovalue))) (if (math-numberp value) (Math-lessp tol (math-abs (math-sub value ovalue))) (math-reject-arg value 'numberp))))) (setq ovalue value math-working-step (1+ math-working-step) value (math-normalize (math-build-call func (list value)))) (if accum (setq avalues (cons value avalues)))) (if accum (cons 'vec (nreverse avalues)) value))) ) (defun calcFunc-nest (func base iters) (math-nest-calls func base iters nil nil) ) (defun calcFunc-anest (func base iters) (math-nest-calls func base iters t nil) ) (defun calcFunc-fixp (func base &optional iters tol) (math-nest-calls func base iters nil (or tol t)) ) (defun calcFunc-afixp (func base &optional iters tol) (math-nest-calls func base iters t (or tol t)) ) (defun calcFunc-outer (func a b) (or (math-vectorp a) (math-reject-arg a 'vectorp)) (or (math-vectorp b) (math-reject-arg b 'vectorp)) (setq func (math-var-to-calcFunc func)) (let ((mat nil)) (while (setq a (cdr a)) (setq mat (cons (cons 'vec (mapcar (function (lambda (x) (math-build-call func (list (car a) x)))) (cdr b))) mat))) (math-normalize (cons 'vec (nreverse mat)))) ) (defun calcFunc-inner (mul-func add-func a b) (or (math-vectorp a) (math-reject-arg a 'vectorp)) (or (math-vectorp b) (math-reject-arg b 'vectorp)) (if (math-matrixp a) (if (math-matrixp b) (if (= (length (nth 1 a)) (length b)) (math-inner-mats a b) (math-dimension-error)) (if (= (length (nth 1 a)) 2) (if (= (length a) (length b)) (math-inner-mats a (list 'vec b)) (math-dimension-error)) (if (= (length (nth 1 a)) (length b)) (math-mat-col (math-inner-mats a (math-col-matrix b)) 1) (math-dimension-error)))) (if (math-matrixp b) (nth 1 (math-inner-mats (list 'vec a) b)) (calcFunc-reduce add-func (calcFunc-map mul-func a b)))) ) (defun math-inner-mats (a b) (let ((mat nil) (cols (length (nth 1 b))) row col ap bp accum) (while (setq a (cdr a)) (setq col cols row nil) (while (> (setq col (1- col)) 0) (setq row (cons (calcFunc-reduce add-func (calcFunc-map mul-func (car a) (math-mat-col b col))) row))) (setq mat (cons (cons 'vec row) mat))) (cons 'vec (nreverse mat))) ) calc-2.02c/calc-stat.el100644 22403 13 43244 5402630753 13246 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-stat.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-stat () nil) ;;; Statistical operations on vectors. (defun calc-vector-count (arg) (interactive "P") (calc-slow-wrapper (calc-vector-op "coun" 'calcFunc-vcount arg)) ) (defun calc-vector-sum (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-hyperbolic) (calc-vector-op "vprd" 'calcFunc-vprod arg) (calc-vector-op "vsum" 'calcFunc-vsum arg))) ) (defun calc-vector-product (arg) (interactive "P") (calc-hyperbolic-func) (calc-vector-sum arg) ) (defun calc-vector-max (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-inverse) (calc-vector-op "vmin" 'calcFunc-vmin arg) (calc-vector-op "vmax" 'calcFunc-vmax arg))) ) (defun calc-vector-min (arg) (interactive "P") (calc-invert-func) (calc-vector-max arg) ) (defun calc-vector-mean (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-hyperbolic) (if (calc-is-inverse) (calc-vector-op "harm" 'calcFunc-vhmean arg) (calc-vector-op "medn" 'calcFunc-vmedian arg)) (if (calc-is-inverse) (calc-vector-op "meae" 'calcFunc-vmeane arg) (calc-vector-op "mean" 'calcFunc-vmean arg)))) ) (defun calc-vector-mean-error (arg) (interactive "P") (calc-invert-func) (calc-vector-mean arg) ) (defun calc-vector-median (arg) (interactive "P") (calc-hyperbolic-func) (calc-vector-mean arg) ) (defun calc-vector-harmonic-mean (arg) (interactive "P") (calc-invert-func) (calc-hyperbolic-func) (calc-vector-mean arg) ) (defun calc-vector-geometric-mean (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-hyperbolic) (calc-binary-op "geom" 'calcFunc-agmean arg) (calc-vector-op "geom" 'calcFunc-vgmean arg))) ) (defun calc-vector-sdev (arg) (interactive "P") (calc-slow-wrapper (if (calc-is-hyperbolic) (if (calc-is-inverse) (calc-vector-op "pvar" 'calcFunc-vpvar arg) (calc-vector-op "var" 'calcFunc-vvar arg)) (if (calc-is-inverse) (calc-vector-op "psdv" 'calcFunc-vpsdev arg) (calc-vector-op "sdev" 'calcFunc-vsdev arg)))) ) (defun calc-vector-pop-sdev (arg) (interactive "P") (calc-invert-func) (calc-vector-sdev arg) ) (defun calc-vector-variance (arg) (interactive "P") (calc-hyperbolic-func) (calc-vector-sdev arg) ) (defun calc-vector-pop-variance (arg) (interactive "P") (calc-invert-func) (calc-hyperbolic-func) (calc-vector-sdev arg) ) (defun calc-vector-covariance (arg) (interactive "P") (calc-slow-wrapper (let ((n (if (eq arg 1) 1 2))) (if (calc-is-hyperbolic) (calc-enter-result n "corr" (cons 'calcFunc-vcorr (calc-top-list-n n))) (if (calc-is-inverse) (calc-enter-result n "pcov" (cons 'calcFunc-vpcov (calc-top-list-n n))) (calc-enter-result n "cov" (cons 'calcFunc-vcov (calc-top-list-n n))))))) ) (defun calc-vector-pop-covariance (arg) (interactive "P") (calc-invert-func) (calc-vector-covariance arg) ) (defun calc-vector-correlation (arg) (interactive "P") (calc-hyperbolic-func) (calc-vector-covariance arg) ) (defun calc-vector-op (name func arg) (setq calc-aborted-prefix name arg (prefix-numeric-value arg)) (if (< arg 0) (error "Negative arguments not allowed")) (calc-enter-result arg name (cons func (calc-top-list-n arg))) ) ;;; Useful statistical functions ;;; Sum, product, etc., of one or more values or vectors. ;;; Each argument must be either a number or a vector. Vectors ;;; are flattened, but variables inside are assumed to represent ;;; non-vectors. (defun calcFunc-vsum (&rest vecs) (math-reduce-many-vecs 'calcFunc-add 'calcFunc-vsum vecs 0) ) (defun calcFunc-vprod (&rest vecs) (math-reduce-many-vecs 'calcFunc-mul 'calcFunc-vprod vecs 1) ) (defun calcFunc-vmax (&rest vecs) (if (eq (car-safe (car vecs)) 'sdev) '(var inf var-inf) (if (eq (car-safe (car vecs)) 'intv) (nth 3 (math-fix-int-intv (car vecs))) (math-reduce-many-vecs 'calcFunc-max 'calcFunc-vmax vecs '(neg (var inf var-inf))))) ) (defun calcFunc-vmin (&rest vecs) (if (eq (car-safe (car vecs)) 'sdev) '(neg (var inf var-inf)) (if (eq (car-safe (car vecs)) 'intv) (nth 2 (math-fix-int-intv (car vecs))) (math-reduce-many-vecs 'calcFunc-min 'calcFunc-vmin vecs '(var inf var-inf)))) ) (defun math-reduce-many-vecs (func whole-func vecs ident) (let ((const-part nil) (symb-part nil) val vec) (let ((calc-internal-prec (+ calc-internal-prec 2))) (while vecs (setq val (car vecs)) (and (eq (car-safe val) 'var) (eq (car-safe (calc-var-value (nth 2 val))) 'vec) (setq val (symbol-value (nth 2 val)))) (cond ((Math-vectorp val) (setq vec (append (and const-part (list const-part)) (math-flatten-vector val))) (setq const-part (if vec (calcFunc-reducer (math-calcFunc-to-var func) (cons 'vec vec)) ident))) ((or (Math-objectp val) (math-infinitep val)) (setq const-part (if const-part (funcall func const-part val) val))) (t (setq symb-part (nconc symb-part (list val))))) (setq vecs (cdr vecs)))) (if const-part (progn (setq const-part (math-normalize const-part)) (if symb-part (funcall func const-part (cons whole-func symb-part)) const-part)) (if symb-part (cons whole-func symb-part) ident))) ) ;;; Return the number of data elements among the arguments. (defun calcFunc-vcount (&rest vecs) (let ((count 0)) (while vecs (setq count (if (Math-vectorp (car vecs)) (+ count (math-count-elements (car vecs))) (if (Math-objectp (car vecs)) (1+ count) (if (and (eq (car-safe (car vecs)) 'var) (eq (car-safe (calc-var-value (nth 2 (car vecs)))) 'vec)) (+ count (math-count-elements (symbol-value (nth 2 (car vecs))))) (math-reject-arg (car vecs) 'numvecp)))) vecs (cdr vecs))) count) ) (defun math-count-elements (vec) (let ((count 0)) (while (setq vec (cdr vec)) (setq count (if (Math-vectorp (car vec)) (+ count (math-count-elements (car vec))) (1+ count)))) count) ) (defun math-flatten-many-vecs (vecs) (let ((p vecs) (vec (list 'vec))) (while p (setq vec (nconc vec (if (Math-vectorp (car p)) (math-flatten-vector (car p)) (if (Math-objectp (car p)) (list (car p)) (if (and (eq (car-safe (car p)) 'var) (eq (car-safe (calc-var-value (nth 2 (car p)))) 'vec)) (math-flatten-vector (symbol-value (nth 2 (car p)))) (math-reject-arg (car p) 'numvecp))))) p (cdr p))) vec) ) (defun calcFunc-vflat (&rest vecs) (math-flatten-many-vecs vecs) ) (defun math-split-sdev-vec (vec zero-ok) (let ((means (list 'vec)) (wts (list 'vec)) (exact nil) (p vec)) (while (and (setq p (cdr p)) (not (and (consp (car p)) (eq (car (car p)) 'sdev))))) (if (null p) (list vec nil) (while (setq vec (cdr vec)) (if (and (consp (setq p (car vec))) (eq (car p) 'sdev)) (or exact (setq means (cons (nth 1 p) means) wts (cons (nth 2 p) wts))) (if zero-ok (setq means (cons (nth 1 p) means) wts (cons 0 wts)) (or exact (setq means (list 'vec) wts nil exact t)) (setq means (cons p means))))) (list (nreverse means) (and wts (nreverse wts))))) ) ;;; Return the arithmetic mean of the argument numbers or vectors. ;;; (If numbers are error forms, computes the weighted mean.) (defun calcFunc-vmean (&rest vecs) (let* ((split (math-split-sdev-vec (math-flatten-many-vecs vecs) nil)) (means (car split)) (wts (nth 1 split)) (len (1- (length means)))) (if (= len 0) (math-reject-arg nil "*Must be at least 1 argument") (if (and (= len 1) (eq (car-safe (nth 1 means)) 'intv)) (let ((x (math-fix-int-intv (nth 1 means)))) (calcFunc-vmean (nth 2 x) (nth 3 x))) (math-with-extra-prec 2 (if (and wts (> len 1)) (let* ((sqrwts (calcFunc-map '(var mul var-mul) wts wts)) (suminvsqrwts (calcFunc-reduce '(var add var-add) (calcFunc-map '(var div var-div) 1 sqrwts)))) (math-div (calcFunc-reduce '(var add var-add) (calcFunc-map '(var div var-div) means sqrwts)) suminvsqrwts)) (math-div (calcFunc-reduce '(var add var-add) means) len)))))) ) (defun math-fix-int-intv (x) (if (math-floatp x) x (list 'intv 3 (if (memq (nth 1 x) '(2 3)) (nth 2 x) (math-add (nth 2 x) 1)) (if (memq (nth 1 x) '(1 3)) (nth 3 x) (math-sub (nth 3 x) 1)))) ) ;;; Compute the mean with an error estimate. (defun calcFunc-vmeane (&rest vecs) (let* ((split (math-split-sdev-vec (math-flatten-many-vecs vecs) nil)) (means (car split)) (wts (nth 1 split)) (len (1- (length means)))) (if (= len 0) (math-reject-arg nil "*Must be at least 1 argument") (math-with-extra-prec 2 (if wts (let* ((sqrwts (calcFunc-map '(var mul var-mul) wts wts)) (suminvsqrwts (calcFunc-reduce '(var add var-add) (calcFunc-map '(var div var-div) 1 sqrwts)))) (math-make-sdev (math-div (calcFunc-reduce '(var add var-add) (calcFunc-map '(var div var-div) means sqrwts)) suminvsqrwts) (list 'calcFunc-sqrt (math-div 1 suminvsqrwts)))) (let ((mean (math-div (calcFunc-reduce '(var add var-add) means) len))) (math-make-sdev mean (list 'calcFunc-sqrt (math-div (calcFunc-reducer '(var add var-add) (calcFunc-map '(var pow var-pow) (calcFunc-map '(var abs var-abs) (calcFunc-map '(var add var-add) means (math-neg mean))) 2)) (math-mul len (1- len)))))))))) ) ;;; Compute the median of a list of values. (defun calcFunc-vmedian (&rest vecs) (let* ((flat (copy-sequence (cdr (math-flatten-many-vecs vecs)))) (p flat) (len (length flat)) (hlen (/ len 2))) (if (= len 0) (math-reject-arg nil "*Must be at least 1 argument") (if (and (= len 1) (memq (car-safe (car flat)) '(sdev intv))) (calcFunc-vmean (car flat)) (while p (if (eq (car-safe (car p)) 'sdev) (setcar p (nth 1 (car p)))) (or (Math-anglep (car p)) (math-reject-arg (car p) 'anglep)) (setq p (cdr p))) (setq flat (sort flat 'math-lessp)) (if (= (% len 2) 0) (math-div (math-add (nth (1- hlen) flat) (nth hlen flat)) 2) (nth hlen flat))))) ) (defun calcFunc-vgmean (&rest vecs) (let* ((flat (math-flatten-many-vecs vecs)) (len (1- (length flat)))) (if (= len 0) (math-reject-arg nil "*Must be at least 1 argument") (math-with-extra-prec 2 (let ((x (calcFunc-reduce '(var mul math-mul) flat))) (if (= len 2) (math-sqrt x) (math-pow x (list 'frac 1 len))))))) ) (defun calcFunc-agmean (a b) (cond ((Math-equal a b) a) ((math-zerop a) a) ((math-zerop b) b) (calc-symbolic-mode (math-inexact-result)) ((not (Math-realp a)) (math-reject-arg a 'realp)) ((not (Math-realp b)) (math-reject-arg b 'realp)) (t (math-with-extra-prec 2 (setq a (math-float (math-abs a)) b (math-float (math-abs b))) (let (mean) (while (not (math-nearly-equal-float a b)) (setq mean (math-mul-float (math-add-float a b) '(float 5 -1)) b (math-sqrt-float (math-mul-float a b)) a mean)) a)))) ) (defun calcFunc-vhmean (&rest vecs) (let* ((flat (math-flatten-many-vecs vecs)) (len (1- (length flat)))) (if (= len 0) (math-reject-arg nil "*Must be at least 1 argument") (math-with-extra-prec 2 (math-div len (calcFunc-reduce '(var add math-add) (calcFunc-map '(var inv var-inv) flat)))))) ) ;;; Compute the sample variance or standard deviation of numbers or vectors. ;;; (If the numbers are error forms, only the mean part of them is used.) (defun calcFunc-vvar (&rest vecs) (if (and (= (length vecs) 1) (memq (car-safe (car vecs)) '(sdev intv))) (if (eq (car-safe (car vecs)) 'intv) (math-intv-variance (car vecs) nil) (math-sqr (nth 2 (car vecs)))) (math-covariance vecs nil nil 0)) ) (defun calcFunc-vsdev (&rest vecs) (if (and (= (length vecs) 1) (memq (car-safe (car vecs)) '(sdev intv))) (if (eq (car-safe (car vecs)) 'intv) (if (math-floatp (car vecs)) (math-div (math-sub (nth 3 (car vecs)) (nth 2 (car vecs))) (math-sqrt-12)) (math-sqrt (calcFunc-vvar (car vecs)))) (nth 2 (car vecs))) (math-sqrt (math-covariance vecs nil nil 0))) ) ;;; Compute the population variance or std deviation of numbers or vectors. (defun calcFunc-vpvar (&rest vecs) (if (and (= (length vecs) 1) (memq (car-safe (car vecs)) '(sdev intv))) (if (eq (car-safe (car vecs)) 'intv) (math-intv-variance (car vecs) t) (math-sqr (nth 2 (car vecs)))) (math-covariance vecs nil t 0)) ) (defun calcFunc-vpsdev (&rest vecs) (if (and (= (length vecs) 1) (memq (car-safe (car vecs)) '(sdev intv))) (if (eq (car-safe (car vecs)) 'intv) (if (math-floatp (car vecs)) (math-div (math-sub (nth 3 (car vecs)) (nth 2 (car vecs))) (math-sqrt-12)) (math-sqrt (calcFunc-vpvar (car vecs)))) (nth 2 (car vecs))) (math-sqrt (math-covariance vecs nil t 0))) ) (defun math-intv-variance (x pop) (or (math-constp x) (math-reject-arg x 'constp)) (if (math-floatp x) (math-div (math-sqr (math-sub (nth 3 x) (nth 2 x))) 12) (let* ((x (math-fix-int-intv x)) (len (math-sub (nth 3 x) (nth 2 x))) (hlen (math-quotient len 2))) (math-div (if (math-evenp len) (calcFunc-sum '(^ (var X var-X) 2) '(var X var-X) (math-neg hlen) hlen) (calcFunc-sum '(^ (- (var X var-X) (/ 1 2)) 2) '(var X var-X) (math-neg hlen) (math-add hlen 1))) (if pop (math-add len 1) len)))) ) ;;; Compute the covariance and linear correlation coefficient. (defun calcFunc-vcov (vec1 &optional vec2) (math-covariance (list vec1) (list vec2) nil 1) ) (defun calcFunc-vpcov (vec1 &optional vec2) (math-covariance (list vec1) (list vec2) t 1) ) (defun calcFunc-vcorr (vec1 &optional vec2) (math-covariance (list vec1) (list vec2) nil 2) ) (defun math-covariance (vec1 vec2 pop mode) (or (car vec2) (= mode 0) (progn (if (and (eq (car-safe (car vec1)) 'var) (eq (car-safe (calc-var-value (nth 2 (car vec1)))) 'vec)) (setq vec1 (symbol-value (nth 2 (car vec1)))) (setq vec1 (car vec1))) (or (math-matrixp vec1) (math-dimension-error)) (or (= (length (nth 1 vec1)) 3) (math-dimension-error)) (setq vec2 (list (math-mat-col vec1 2)) vec1 (list (math-mat-col vec1 1))))) (math-with-extra-prec 2 (let* ((split1 (math-split-sdev-vec (math-flatten-many-vecs vec1) nil)) (means1 (car split1)) (wts1 (nth 1 split1)) split2 means2 (wts2 nil) (sqrwts nil) suminvsqrwts (len (1- (length means1)))) (if (< len (if pop 1 2)) (math-reject-arg nil (if pop "*Must be at least 1 argument" "*Must be at least 2 arguments"))) (if (or wts1 wts2) (setq sqrwts (math-add (if wts1 (calcFunc-map '(var mul var-mul) wts1 wts1) 0) (if wts2 (calcFunc-map '(var mul var-mul) wts2 wts2) 0)) suminvsqrwts (calcFunc-reduce '(var add var-add) (calcFunc-map '(var div var-div) 1 sqrwts)))) (or (= mode 0) (progn (setq split2 (math-split-sdev-vec (math-flatten-many-vecs vec2) nil) means2 (car split2) wts2 (nth 2 split1)) (or (= len (1- (length means2))) (math-dimension-error)))) (let* ((diff1 (calcFunc-map '(var add var-add) means1 (if sqrwts (math-div (calcFunc-reduce '(var add var-add) (calcFunc-map '(var div var-div) means1 sqrwts)) (math-neg suminvsqrwts)) (math-div (calcFunc-reducer '(var add var-add) means1) (- len))))) (diff2 (if (= mode 0) diff1 (calcFunc-map '(var add var-add) means2 (if sqrwts (math-div (calcFunc-reduce '(var add var-add) (calcFunc-map '(var div var-div) means2 sqrwts)) (math-neg suminvsqrwts)) (math-div (calcFunc-reducer '(var add var-add) means2) (- len)))))) (covar (calcFunc-map '(var mul var-mul) diff1 diff2))) (if sqrwts (setq covar (calcFunc-map '(var div var-div) covar sqrwts))) (math-div (calcFunc-reducer '(var add var-add) covar) (if (= mode 2) (let ((var1 (calcFunc-map '(var mul var-mul) diff1 diff1)) (var2 (calcFunc-map '(var mul var-mul) diff2 diff2))) (if sqrwts (setq var1 (calcFunc-map '(var div var-div) var1 sqrwts) var2 (calcFunc-map '(var div var-div) var2 sqrwts))) (math-sqrt (math-mul (calcFunc-reducer '(var add var-add) var1) (calcFunc-reducer '(var add var-add) var2)))) (if sqrwts (if pop suminvsqrwts (math-div (math-mul suminvsqrwts (1- len)) len)) (if pop len (1- len)))))))) ) calc-2.02c/calc-poly.el100644 22403 13 105602 5402630712 13266 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-poly.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-poly () nil) (defun calcFunc-pcont (expr &optional var) (cond ((Math-primp expr) (cond ((Math-zerop expr) 1) ((Math-messy-integerp expr) (math-trunc expr)) ((Math-objectp expr) expr) ((or (equal expr var) (not var)) 1) (t expr))) ((eq (car expr) '*) (math-mul (calcFunc-pcont (nth 1 expr) var) (calcFunc-pcont (nth 2 expr) var))) ((eq (car expr) '/) (math-div (calcFunc-pcont (nth 1 expr) var) (calcFunc-pcont (nth 2 expr) var))) ((and (eq (car expr) '^) (Math-natnump (nth 2 expr))) (math-pow (calcFunc-pcont (nth 1 expr) var) (nth 2 expr))) ((memq (car expr) '(neg polar)) (calcFunc-pcont (nth 1 expr) var)) ((consp var) (let ((p (math-is-polynomial expr var))) (if p (let ((lead (nth (1- (length p)) p)) (cont (math-poly-gcd-list p))) (if (math-guess-if-neg lead) (math-neg cont) cont)) 1))) ((memq (car expr) '(+ - cplx sdev)) (let ((cont (calcFunc-pcont (nth 1 expr) var))) (if (eq cont 1) 1 (let ((c2 (calcFunc-pcont (nth 2 expr) var))) (if (and (math-negp cont) (if (eq (car expr) '-) (math-posp c2) (math-negp c2))) (math-neg (math-poly-gcd cont c2)) (math-poly-gcd cont c2)))))) (var expr) (t 1)) ) (defun calcFunc-pprim (expr &optional var) (let ((cont (calcFunc-pcont expr var))) (if (math-equal-int cont 1) expr (math-poly-div-exact expr cont var))) ) (defun math-div-poly-const (expr c) (cond ((memq (car-safe expr) '(+ -)) (list (car expr) (math-div-poly-const (nth 1 expr) c) (math-div-poly-const (nth 2 expr) c))) (t (math-div expr c))) ) (defun calcFunc-pdeg (expr &optional var) (if (Math-zerop expr) '(neg (var inf var-inf)) (if var (or (math-polynomial-p expr var) (math-reject-arg expr "Expected a polynomial")) (math-poly-degree expr))) ) (defun math-poly-degree (expr) (cond ((Math-primp expr) (if (eq (car-safe expr) 'var) 1 0)) ((eq (car expr) 'neg) (math-poly-degree (nth 1 expr))) ((eq (car expr) '*) (+ (math-poly-degree (nth 1 expr)) (math-poly-degree (nth 2 expr)))) ((eq (car expr) '/) (- (math-poly-degree (nth 1 expr)) (math-poly-degree (nth 2 expr)))) ((and (eq (car expr) '^) (natnump (nth 2 expr))) (* (math-poly-degree (nth 1 expr)) (nth 2 expr))) ((memq (car expr) '(+ -)) (max (math-poly-degree (nth 1 expr)) (math-poly-degree (nth 2 expr)))) (t 1)) ) (defun calcFunc-plead (expr var) (cond ((eq (car-safe expr) '*) (math-mul (calcFunc-plead (nth 1 expr) var) (calcFunc-plead (nth 2 expr) var))) ((eq (car-safe expr) '/) (math-div (calcFunc-plead (nth 1 expr) var) (calcFunc-plead (nth 2 expr) var))) ((and (eq (car-safe expr) '^) (math-natnump (nth 2 expr))) (math-pow (calcFunc-plead (nth 1 expr) var) (nth 2 expr))) ((Math-primp expr) (if (equal expr var) 1 expr)) (t (let ((p (math-is-polynomial expr var))) (if (cdr p) (nth (1- (length p)) p) 1)))) ) ;;; Polynomial quotient, remainder, and GCD. ;;; Originally by Ove Ewerlid (ewerlid@mizar.DoCS.UU.SE). ;;; Modifications and simplifications by daveg. (setq math-poly-modulus 1) ;;; Return gcd of two polynomials (defun calcFunc-pgcd (pn pd) (if (math-any-floats pn) (math-reject-arg pn "Coefficients must be rational")) (if (math-any-floats pd) (math-reject-arg pd "Coefficients must be rational")) (let ((calc-prefer-frac t) (math-poly-modulus (math-poly-modulus pn pd))) (math-poly-gcd pn pd)) ) ;;; Return only quotient to top of stack (nil if zero) (defun calcFunc-pdiv (pn pd &optional base) (let* ((calc-prefer-frac t) (math-poly-modulus (math-poly-modulus pn pd)) (res (math-poly-div pn pd base))) (setq calc-poly-div-remainder (cdr res)) (car res)) ) ;;; Return only remainder to top of stack (defun calcFunc-prem (pn pd &optional base) (let ((calc-prefer-frac t) (math-poly-modulus (math-poly-modulus pn pd))) (cdr (math-poly-div pn pd base))) ) (defun calcFunc-pdivrem (pn pd &optional base) (let* ((calc-prefer-frac t) (math-poly-modulus (math-poly-modulus pn pd)) (res (math-poly-div pn pd base))) (list 'vec (car res) (cdr res))) ) (defun calcFunc-pdivide (pn pd &optional base) (let* ((calc-prefer-frac t) (math-poly-modulus (math-poly-modulus pn pd)) (res (math-poly-div pn pd base))) (math-add (car res) (math-div (cdr res) pd))) ) ;;; Multiply two terms, expanding out products of sums. (defun math-mul-thru (lhs rhs) (if (memq (car-safe lhs) '(+ -)) (list (car lhs) (math-mul-thru (nth 1 lhs) rhs) (math-mul-thru (nth 2 lhs) rhs)) (if (memq (car-safe rhs) '(+ -)) (list (car rhs) (math-mul-thru lhs (nth 1 rhs)) (math-mul-thru lhs (nth 2 rhs))) (math-mul lhs rhs))) ) (defun math-div-thru (num den) (if (memq (car-safe num) '(+ -)) (list (car num) (math-div-thru (nth 1 num) den) (math-div-thru (nth 2 num) den)) (math-div num den)) ) ;;; Sort the terms of a sum into canonical order. (defun math-sort-terms (expr) (if (memq (car-safe expr) '(+ -)) (math-list-to-sum (sort (math-sum-to-list expr) (function (lambda (a b) (math-beforep (car a) (car b)))))) expr) ) (defun math-list-to-sum (lst) (if (cdr lst) (list (if (cdr (car lst)) '- '+) (math-list-to-sum (cdr lst)) (car (car lst))) (if (cdr (car lst)) (math-neg (car (car lst))) (car (car lst)))) ) (defun math-sum-to-list (tree &optional neg) (cond ((eq (car-safe tree) '+) (nconc (math-sum-to-list (nth 1 tree) neg) (math-sum-to-list (nth 2 tree) neg))) ((eq (car-safe tree) '-) (nconc (math-sum-to-list (nth 1 tree) neg) (math-sum-to-list (nth 2 tree) (not neg)))) (t (list (cons tree neg)))) ) ;;; Check if the polynomial coefficients are modulo forms. (defun math-poly-modulus (expr &optional expr2) (or (math-poly-modulus-rec expr) (and expr2 (math-poly-modulus-rec expr2)) 1) ) (defun math-poly-modulus-rec (expr) (if (and (eq (car-safe expr) 'mod) (Math-natnump (nth 2 expr))) (list 'mod 1 (nth 2 expr)) (and (memq (car-safe expr) '(+ - * /)) (or (math-poly-modulus-rec (nth 1 expr)) (math-poly-modulus-rec (nth 2 expr))))) ) ;;; Divide two polynomials. Return (quotient . remainder). (defun math-poly-div (u v &optional math-poly-div-base) (if math-poly-div-base (math-do-poly-div u v) (math-do-poly-div (calcFunc-expand u) (calcFunc-expand v))) ) (setq math-poly-div-base nil) (defun math-poly-div-exact (u v &optional base) (let ((res (math-poly-div u v base))) (if (eq (cdr res) 0) (car res) (math-reject-arg (list 'vec u v) "Argument is not a polynomial"))) ) (defun math-do-poly-div (u v) (cond ((math-constp u) (if (math-constp v) (cons (math-div u v) 0) (cons 0 u))) ((math-constp v) (cons (if (eq v 1) u (if (memq (car-safe u) '(+ -)) (math-add-or-sub (math-poly-div-exact (nth 1 u) v) (math-poly-div-exact (nth 2 u) v) nil (eq (car u) '-)) (math-div u v))) 0)) ((Math-equal u v) (cons math-poly-modulus 0)) ((and (math-atomic-factorp u) (math-atomic-factorp v)) (cons (math-simplify (math-div u v)) 0)) (t (let ((base (or math-poly-div-base (math-poly-div-base u v))) vp up res) (if (or (null base) (null (setq vp (math-is-polynomial v base nil 'gen)))) (cons 0 u) (setq up (math-is-polynomial u base nil 'gen) res (math-poly-div-coefs up vp)) (cons (math-build-polynomial-expr (car res) base) (math-build-polynomial-expr (cdr res) base)))))) ) (defun math-poly-div-rec (u v) (cond ((math-constp u) (math-div u v)) ((math-constp v) (if (eq v 1) u (if (memq (car-safe u) '(+ -)) (math-add-or-sub (math-poly-div-rec (nth 1 u) v) (math-poly-div-rec (nth 2 u) v) nil (eq (car u) '-)) (math-div u v)))) ((Math-equal u v) math-poly-modulus) ((and (math-atomic-factorp u) (math-atomic-factorp v)) (math-simplify (math-div u v))) (math-poly-div-base (math-div u v)) (t (let ((base (math-poly-div-base u v)) vp up res) (if (or (null base) (null (setq vp (math-is-polynomial v base nil 'gen)))) (math-div u v) (setq up (math-is-polynomial u base nil 'gen) res (math-poly-div-coefs up vp)) (math-add (math-build-polynomial-expr (car res) base) (math-div (math-build-polynomial-expr (cdr res) base) v)))))) ) ;;; Divide two polynomials in coefficient-list form. Return (quot . rem). (defun math-poly-div-coefs (u v) (cond ((null v) (math-reject-arg nil "Division by zero")) ((< (length u) (length v)) (cons nil u)) ((cdr u) (let ((q nil) (urev (reverse u)) (vrev (reverse v))) (while (let ((qk (math-poly-div-rec (math-simplify (car urev)) (car vrev))) (up urev) (vp vrev)) (if (or q (not (math-zerop qk))) (setq q (cons qk q))) (while (setq up (cdr up) vp (cdr vp)) (setcar up (math-sub (car up) (math-mul-thru qk (car vp))))) (setq urev (cdr urev)) up)) (while (and urev (Math-zerop (car urev))) (setq urev (cdr urev))) (cons q (nreverse (mapcar 'math-simplify urev))))) (t (cons (list (math-poly-div-rec (car u) (car v))) nil))) ) ;;; Perform a pseudo-division of polynomials. (See Knuth section 4.6.1.) ;;; This returns only the remainder from the pseudo-division. (defun math-poly-pseudo-div (u v) (cond ((null v) nil) ((< (length u) (length v)) u) ((or (cdr u) (cdr v)) (let ((urev (reverse u)) (vrev (reverse v)) up) (while (let ((vp vrev)) (setq up urev) (while (setq up (cdr up) vp (cdr vp)) (setcar up (math-sub (math-mul-thru (car vrev) (car up)) (math-mul-thru (car urev) (car vp))))) (setq urev (cdr urev)) up) (while up (setcar up (math-mul-thru (car vrev) (car up))) (setq up (cdr up)))) (while (and urev (Math-zerop (car urev))) (setq urev (cdr urev))) (nreverse (mapcar 'math-simplify urev)))) (t nil)) ) ;;; Compute the GCD of two multivariate polynomials. (defun math-poly-gcd (u v) (cond ((Math-equal u v) u) ((math-constp u) (if (Math-zerop u) v (calcFunc-gcd u (calcFunc-pcont v)))) ((math-constp v) (if (Math-zerop v) v (calcFunc-gcd v (calcFunc-pcont u)))) (t (let ((base (math-poly-gcd-base u v))) (if base (math-simplify (calcFunc-expand (math-build-polynomial-expr (math-poly-gcd-coefs (math-is-polynomial u base nil 'gen) (math-is-polynomial v base nil 'gen)) base))) (calcFunc-gcd (calcFunc-pcont u) (calcFunc-pcont u)))))) ) (defun math-poly-div-list (lst a) (if (eq a 1) lst (if (eq a -1) (math-mul-list lst a) (mapcar (function (lambda (x) (math-poly-div-exact x a))) lst))) ) (defun math-mul-list (lst a) (if (eq a 1) lst (if (eq a -1) (mapcar 'math-neg lst) (and (not (eq a 0)) (mapcar (function (lambda (x) (math-mul x a))) lst)))) ) ;;; Run GCD on all elements in a list. (defun math-poly-gcd-list (lst) (if (or (memq 1 lst) (memq -1 lst)) (math-poly-gcd-frac-list lst) (let ((gcd (car lst))) (while (and (setq lst (cdr lst)) (not (eq gcd 1))) (or (eq (car lst) 0) (setq gcd (math-poly-gcd gcd (car lst))))) (if lst (setq lst (math-poly-gcd-frac-list lst))) gcd)) ) (defun math-poly-gcd-frac-list (lst) (while (and lst (not (eq (car-safe (car lst)) 'frac))) (setq lst (cdr lst))) (if lst (let ((denom (nth 2 (car lst)))) (while (setq lst (cdr lst)) (if (eq (car-safe (car lst)) 'frac) (setq denom (calcFunc-lcm denom (nth 2 (car lst)))))) (list 'frac 1 denom)) 1) ) ;;; Compute the GCD of two monovariate polynomial lists. ;;; Knuth section 4.6.1, algorithm C. (defun math-poly-gcd-coefs (u v) (let ((d (math-poly-gcd (math-poly-gcd-list u) (math-poly-gcd-list v))) (g 1) (h 1) (z 0) hh r delta ghd) (while (and u v (Math-zerop (car u)) (Math-zerop (car v))) (setq u (cdr u) v (cdr v) z (1+ z))) (or (eq d 1) (setq u (math-poly-div-list u d) v (math-poly-div-list v d))) (while (progn (setq delta (- (length u) (length v))) (if (< delta 0) (setq r u u v v r delta (- delta))) (setq r (math-poly-pseudo-div u v)) (cdr r)) (setq u v v (math-poly-div-list r (math-mul g (math-pow h delta))) g (nth (1- (length u)) u) h (if (<= delta 1) (math-mul (math-pow g delta) (math-pow h (- 1 delta))) (math-poly-div-exact (math-pow g delta) (math-pow h (1- delta)))))) (setq v (if r (list d) (math-mul-list (math-poly-div-list v (math-poly-gcd-list v)) d))) (if (math-guess-if-neg (nth (1- (length v)) v)) (setq v (math-mul-list v -1))) (while (>= (setq z (1- z)) 0) (setq v (cons 0 v))) v) ) ;;; Return true if is a factor containing no sums or quotients. (defun math-atomic-factorp (expr) (cond ((eq (car-safe expr) '*) (and (math-atomic-factorp (nth 1 expr)) (math-atomic-factorp (nth 2 expr)))) ((memq (car-safe expr) '(+ - /)) nil) ((memq (car-safe expr) '(^ neg)) (math-atomic-factorp (nth 1 expr))) (t t)) ) ;;; Find a suitable base for dividing a by b. ;;; The base must exist in both expressions. ;;; The degree in the numerator must be higher or equal than the ;;; degree in the denominator. ;;; If the above conditions are not met the quotient is just a remainder. ;;; Return nil if this is the case. (defun math-poly-div-base (a b) (let (a-base b-base) (and (setq a-base (math-total-polynomial-base a)) (setq b-base (math-total-polynomial-base b)) (catch 'return (while a-base (let ((maybe (assoc (car (car a-base)) b-base))) (if maybe (if (>= (nth 1 (car a-base)) (nth 1 maybe)) (throw 'return (car (car a-base)))))) (setq a-base (cdr a-base)))))) ) ;;; Same as above but for gcd algorithm. ;;; Here there is no requirement that degree(a) > degree(b). ;;; Take the base that has the highest degree considering both a and b. ;;; ("a^20+b^21+x^3+a+b", "a+b^2+x^5+a^22+b^10") --> (a 22) (defun math-poly-gcd-base (a b) (let (a-base b-base) (and (setq a-base (math-total-polynomial-base a)) (setq b-base (math-total-polynomial-base b)) (catch 'return (while (and a-base b-base) (if (> (nth 1 (car a-base)) (nth 1 (car b-base))) (if (assoc (car (car a-base)) b-base) (throw 'return (car (car a-base))) (setq a-base (cdr a-base))) (if (assoc (car (car b-base)) a-base) (throw 'return (car (car b-base))) (setq b-base (cdr b-base)))))))) ) ;;; Sort a list of polynomial bases. (defun math-sort-poly-base-list (lst) (sort lst (function (lambda (a b) (or (> (nth 1 a) (nth 1 b)) (and (= (nth 1 a) (nth 1 b)) (math-beforep (car a) (car b))))))) ) ;;; Given an expression find all variables that are polynomial bases. ;;; Return list in the form '( (var1 degree1) (var2 degree2) ... ). ;;; Note dynamic scope of mpb-total-base. (defun math-total-polynomial-base (expr) (let ((mpb-total-base nil)) (math-polynomial-base expr 'math-polynomial-p1) (math-sort-poly-base-list mpb-total-base)) ) (defun math-polynomial-p1 (subexpr) (or (assoc subexpr mpb-total-base) (memq (car subexpr) '(+ - * / neg)) (and (eq (car subexpr) '^) (natnump (nth 2 subexpr))) (let* ((math-poly-base-variable subexpr) (exponent (math-polynomial-p mpb-top-expr subexpr))) (if exponent (setq mpb-total-base (cons (list subexpr exponent) mpb-total-base))))) nil ) (defun calcFunc-factors (expr &optional var) (let ((math-factored-vars (if var t nil)) (math-to-list t) (calc-prefer-frac t)) (or var (setq var (math-polynomial-base expr))) (let ((res (math-factor-finish (or (catch 'factor (math-factor-expr-try var)) expr)))) (math-simplify (if (math-vectorp res) res (list 'vec (list 'vec res 1)))))) ) (defun calcFunc-factor (expr &optional var) (let ((math-factored-vars nil) (math-to-list nil) (calc-prefer-frac t)) (math-simplify (math-factor-finish (if var (let ((math-factored-vars t)) (or (catch 'factor (math-factor-expr-try var)) expr)) (math-factor-expr expr))))) ) (defun math-factor-finish (x) (if (Math-primp x) x (if (eq (car x) 'calcFunc-Fac-Prot) (math-factor-finish (nth 1 x)) (cons (car x) (mapcar 'math-factor-finish (cdr x))))) ) (defun math-factor-protect (x) (if (memq (car-safe x) '(+ -)) (list 'calcFunc-Fac-Prot x) x) ) (defun math-factor-expr (expr) (cond ((eq math-factored-vars t) expr) ((or (memq (car-safe expr) '(* / ^ neg)) (assq (car-safe expr) calc-tweak-eqn-table)) (cons (car expr) (mapcar 'math-factor-expr (cdr expr)))) ((memq (car-safe expr) '(+ -)) (let* ((math-factored-vars math-factored-vars) (y (catch 'factor (math-factor-expr-part expr)))) (if y (math-factor-expr y) expr))) (t expr)) ) (defun math-factor-expr-part (x) ; uses "expr" (if (memq (car-safe x) '(+ - * / ^ neg)) (while (setq x (cdr x)) (math-factor-expr-part (car x))) (and (not (Math-objvecp x)) (not (assoc x math-factored-vars)) (> (math-factor-contains expr x) 1) (setq math-factored-vars (cons (list x) math-factored-vars)) (math-factor-expr-try x))) ) (defun math-factor-expr-try (x) (if (eq (car-safe expr) '*) (let ((res1 (catch 'factor (let ((expr (nth 1 expr))) (math-factor-expr-try x)))) (res2 (catch 'factor (let ((expr (nth 2 expr))) (math-factor-expr-try x))))) (and (or res1 res2) (throw 'factor (math-accum-factors (or res1 (nth 1 expr)) 1 (or res2 (nth 2 expr)))))) (let* ((p (math-is-polynomial expr x 30 'gen)) (math-poly-modulus (math-poly-modulus expr)) res) (and (cdr p) (setq res (math-factor-poly-coefs p)) (throw 'factor res)))) ) (defun math-accum-factors (fac pow facs) (if math-to-list (if (math-vectorp fac) (progn (while (setq fac (cdr fac)) (setq facs (math-accum-factors (nth 1 (car fac)) (* pow (nth 2 (car fac))) facs))) facs) (if (and (eq (car-safe fac) '^) (natnump (nth 2 fac))) (setq pow (* pow (nth 2 fac)) fac (nth 1 fac))) (if (eq fac 1) facs (or (math-vectorp facs) (setq facs (if (eq facs 1) '(vec) (list 'vec (list 'vec facs 1))))) (let ((found facs)) (while (and (setq found (cdr found)) (not (equal fac (nth 1 (car found)))))) (if found (progn (setcar (cdr (cdr (car found))) (+ pow (nth 2 (car found)))) facs) ;; Put constant term first. (if (and (cdr facs) (Math-ratp (nth 1 (nth 1 facs)))) (cons 'vec (cons (nth 1 facs) (cons (list 'vec fac pow) (cdr (cdr facs))))) (cons 'vec (cons (list 'vec fac pow) (cdr facs)))))))) (math-mul (math-pow fac pow) facs)) ) (defun math-factor-poly-coefs (p &optional square-free) ; uses "x" (let (t1 t2) (cond ((not (cdr p)) (or (car p) 0)) ;; Strip off multiples of x. ((Math-zerop (car p)) (let ((z 0)) (while (and p (Math-zerop (car p))) (setq z (1+ z) p (cdr p))) (if (cdr p) (setq p (math-factor-poly-coefs p square-free)) (setq p (math-sort-terms (math-factor-expr (car p))))) (math-accum-factors x z (math-factor-protect p)))) ;; Factor out content. ((and (not square-free) (not (eq 1 (setq t1 (math-mul (math-poly-gcd-list p) (if (math-guess-if-neg (nth (1- (length p)) p)) -1 1)))))) (math-accum-factors t1 1 (math-factor-poly-coefs (math-poly-div-list p t1) 'cont))) ;; Check if linear in x. ((not (cdr (cdr p))) (math-add (math-factor-protect (math-sort-terms (math-factor-expr (car p)))) (math-mul x (math-factor-protect (math-sort-terms (math-factor-expr (nth 1 p))))))) ;; If symbolic coefficients, use FactorRules. ((let ((pp p)) (while (and pp (or (Math-ratp (car pp)) (and (eq (car (car pp)) 'mod) (Math-integerp (nth 1 (car pp))) (Math-integerp (nth 2 (car pp)))))) (setq pp (cdr pp))) pp) (let ((res (math-rewrite (list 'calcFunc-thecoefs x (cons 'vec p)) '(var FactorRules var-FactorRules)))) (or (and (eq (car-safe res) 'calcFunc-thefactors) (= (length res) 3) (math-vectorp (nth 2 res)) (let ((facs 1) (vec (nth 2 res))) (while (setq vec (cdr vec)) (setq facs (math-accum-factors (car vec) 1 facs))) facs)) (math-build-polynomial-expr p x)))) ;; Check if rational coefficients (i.e., not modulo a prime). ((eq math-poly-modulus 1) ;; Check if there are any squared terms, or a content not = 1. (if (or (eq square-free t) (equal (setq t1 (math-poly-gcd-coefs p (setq t2 (math-poly-deriv-coefs p)))) '(1))) ;; We now have a square-free polynomial with integer coefs. ;; For now, we use a kludgey method that finds linear and ;; quadratic terms using floating-point root-finding. (if (setq t1 (let ((calc-symbolic-mode nil)) (math-poly-all-roots nil p t))) (let ((roots (car t1)) (csign (if (math-negp (nth (1- (length p)) p)) -1 1)) (expr 1) (unfac (nth 1 t1)) (scale (nth 2 t1))) (while roots (let ((coef0 (car (car roots))) (coef1 (cdr (car roots)))) (setq expr (math-accum-factors (if coef1 (let ((den (math-lcm-denoms coef0 coef1))) (setq scale (math-div scale den)) (math-add (math-add (math-mul den (math-pow x 2)) (math-mul (math-mul coef1 den) x)) (math-mul coef0 den))) (let ((den (math-lcm-denoms coef0))) (setq scale (math-div scale den)) (math-add (math-mul den x) (math-mul coef0 den)))) 1 expr) roots (cdr roots)))) (setq expr (math-accum-factors expr 1 (math-mul csign (math-build-polynomial-expr (math-mul-list (nth 1 t1) scale) x))))) (math-build-polynomial-expr p x)) ; can't factor it. ;; Separate out the squared terms (Knuth exercise 4.6.2-34). ;; This step also divides out the content of the polynomial. (let* ((cabs (math-poly-gcd-list p)) (csign (if (math-negp (nth (1- (length p)) p)) -1 1)) (t1s (math-mul-list t1 csign)) (uu nil) (v (car (math-poly-div-coefs p t1s))) (w (car (math-poly-div-coefs t2 t1s)))) (while (not (math-poly-zerop (setq t2 (math-poly-simplify (math-poly-mix w 1 (math-poly-deriv-coefs v) -1))))) (setq t1 (math-poly-gcd-coefs v t2) uu (cons t1 uu) v (car (math-poly-div-coefs v t1)) w (car (math-poly-div-coefs t2 t1)))) (setq t1 (length uu) t2 (math-accum-factors (math-factor-poly-coefs v t) (1+ t1) 1)) (while uu (setq t2 (math-accum-factors (math-factor-poly-coefs (car uu) t) t1 t2) t1 (1- t1) uu (cdr uu))) (math-accum-factors (math-mul cabs csign) 1 t2)))) ;; Factoring modulo a prime. ((and (= (length (setq temp (math-poly-gcd-coefs p (math-poly-deriv-coefs p)))) (length p))) (setq p (car temp)) (while (cdr temp) (setq temp (nthcdr (nth 2 math-poly-modulus) temp) p (cons (car temp) p))) (and (setq temp (math-factor-poly-coefs p)) (math-pow temp (nth 2 math-poly-modulus)))) (t (math-reject-arg nil "*Modulo factorization not yet implemented")))) ) (defun math-poly-deriv-coefs (p) (let ((n 1) (dp nil)) (while (setq p (cdr p)) (setq dp (cons (math-mul (car p) n) dp) n (1+ n))) (nreverse dp)) ) (defun math-factor-contains (x a) (if (equal x a) 1 (if (memq (car-safe x) '(+ - * / neg)) (let ((sum 0)) (while (setq x (cdr x)) (setq sum (+ sum (math-factor-contains (car x) a)))) sum) (if (and (eq (car-safe x) '^) (natnump (nth 2 x))) (* (math-factor-contains (nth 1 x) a) (nth 2 x)) 0))) ) ;;; Merge all quotients and expand/simplify the numerator (defun calcFunc-nrat (expr) (if (math-any-floats expr) (setq expr (calcFunc-pfrac expr))) (if (or (math-vectorp expr) (assq (car-safe expr) calc-tweak-eqn-table)) (cons (car expr) (mapcar 'calcFunc-nrat (cdr expr))) (let* ((calc-prefer-frac t) (res (math-to-ratpoly expr)) (num (math-simplify (math-sort-terms (calcFunc-expand (car res))))) (den (math-simplify (math-sort-terms (calcFunc-expand (cdr res))))) (g (math-poly-gcd num den))) (or (eq g 1) (let ((num2 (math-poly-div num g)) (den2 (math-poly-div den g))) (and (eq (cdr num2) 0) (eq (cdr den2) 0) (setq num (car num2) den (car den2))))) (math-simplify (math-div num den)))) ) ;;; Returns expressions (num . denom). (defun math-to-ratpoly (expr) (let ((res (math-to-ratpoly-rec expr))) (cons (math-simplify (car res)) (math-simplify (cdr res)))) ) (defun math-to-ratpoly-rec (expr) (cond ((Math-primp expr) (cons expr 1)) ((memq (car expr) '(+ -)) (let ((r1 (math-to-ratpoly-rec (nth 1 expr))) (r2 (math-to-ratpoly-rec (nth 2 expr)))) (if (equal (cdr r1) (cdr r2)) (cons (list (car expr) (car r1) (car r2)) (cdr r1)) (if (eq (cdr r1) 1) (cons (list (car expr) (math-mul (car r1) (cdr r2)) (car r2)) (cdr r2)) (if (eq (cdr r2) 1) (cons (list (car expr) (car r1) (math-mul (car r2) (cdr r1))) (cdr r1)) (let ((g (math-poly-gcd (cdr r1) (cdr r2)))) (let ((d1 (and (not (eq g 1)) (math-poly-div (cdr r1) g))) (d2 (and (not (eq g 1)) (math-poly-div (math-mul (car r1) (cdr r2)) g)))) (if (and (eq (cdr d1) 0) (eq (cdr d2) 0)) (cons (list (car expr) (car d2) (math-mul (car r2) (car d1))) (math-mul (car d1) (cdr r2))) (cons (list (car expr) (math-mul (car r1) (cdr r2)) (math-mul (car r2) (cdr r1))) (math-mul (cdr r1) (cdr r2))))))))))) ((eq (car expr) '*) (let* ((r1 (math-to-ratpoly-rec (nth 1 expr))) (r2 (math-to-ratpoly-rec (nth 2 expr))) (g (math-mul (math-poly-gcd (car r1) (cdr r2)) (math-poly-gcd (cdr r1) (car r2))))) (if (eq g 1) (cons (math-mul (car r1) (car r2)) (math-mul (cdr r1) (cdr r2))) (cons (math-poly-div-exact (math-mul (car r1) (car r2)) g) (math-poly-div-exact (math-mul (cdr r1) (cdr r2)) g))))) ((eq (car expr) '/) (let* ((r1 (math-to-ratpoly-rec (nth 1 expr))) (r2 (math-to-ratpoly-rec (nth 2 expr)))) (if (and (eq (cdr r1) 1) (eq (cdr r2) 1)) (cons (car r1) (car r2)) (let ((g (math-mul (math-poly-gcd (car r1) (car r2)) (math-poly-gcd (cdr r1) (cdr r2))))) (if (eq g 1) (cons (math-mul (car r1) (cdr r2)) (math-mul (cdr r1) (car r2))) (cons (math-poly-div-exact (math-mul (car r1) (cdr r2)) g) (math-poly-div-exact (math-mul (cdr r1) (car r2)) g))))))) ((and (eq (car expr) '^) (integerp (nth 2 expr))) (let ((r1 (math-to-ratpoly-rec (nth 1 expr)))) (if (> (nth 2 expr) 0) (cons (math-pow (car r1) (nth 2 expr)) (math-pow (cdr r1) (nth 2 expr))) (cons (math-pow (cdr r1) (- (nth 2 expr))) (math-pow (car r1) (- (nth 2 expr))))))) ((eq (car expr) 'neg) (let ((r1 (math-to-ratpoly-rec (nth 1 expr)))) (cons (math-neg (car r1)) (cdr r1)))) (t (cons expr 1))) ) (defun math-ratpoly-p (expr &optional var) (cond ((equal expr var) 1) ((Math-primp expr) 0) ((memq (car expr) '(+ -)) (let ((p1 (math-ratpoly-p (nth 1 expr) var)) p2) (and p1 (setq p2 (math-ratpoly-p (nth 2 expr) var)) (max p1 p2)))) ((eq (car expr) '*) (let ((p1 (math-ratpoly-p (nth 1 expr) var)) p2) (and p1 (setq p2 (math-ratpoly-p (nth 2 expr) var)) (+ p1 p2)))) ((eq (car expr) 'neg) (math-ratpoly-p (nth 1 expr) var)) ((eq (car expr) '/) (let ((p1 (math-ratpoly-p (nth 1 expr) var)) p2) (and p1 (setq p2 (math-ratpoly-p (nth 2 expr) var)) (- p1 p2)))) ((and (eq (car expr) '^) (integerp (nth 2 expr))) (let ((p1 (math-ratpoly-p (nth 1 expr) var))) (and p1 (* p1 (nth 2 expr))))) ((not var) 1) ((math-poly-depends expr var) nil) (t 0)) ) (defun calcFunc-apart (expr &optional var) (cond ((Math-primp expr) expr) ((eq (car expr) '+) (math-add (calcFunc-apart (nth 1 expr) var) (calcFunc-apart (nth 2 expr) var))) ((eq (car expr) '-) (math-sub (calcFunc-apart (nth 1 expr) var) (calcFunc-apart (nth 2 expr) var))) ((not (math-ratpoly-p expr var)) (math-reject-arg expr "Expected a rational function")) (t (let* ((calc-prefer-frac t) (rat (math-to-ratpoly expr)) (num (car rat)) (den (cdr rat)) (qr (math-poly-div num den)) (q (car qr)) (r (cdr qr))) (or var (setq var (math-polynomial-base den))) (math-add q (or (and var (math-expr-contains den var) (math-partial-fractions r den var)) (math-div r den)))))) ) (defun math-padded-polynomial (expr var deg) (let ((p (math-is-polynomial expr var deg))) (append p (make-list (- deg (length p)) 0))) ) (defun math-partial-fractions (r den var) (let* ((fden (calcFunc-factors den var)) (tdeg (math-polynomial-p den var)) (fp fden) (dlist nil) (eqns 0) (lz nil) (tz (make-list (1- tdeg) 0)) (calc-matrix-mode 'scalar)) (and (not (and (= (length fden) 2) (eq (nth 2 (nth 1 fden)) 1))) (progn (while (setq fp (cdr fp)) (let ((rpt (nth 2 (car fp))) (deg (math-polynomial-p (nth 1 (car fp)) var)) dnum dvar deg2) (while (> rpt 0) (setq deg2 deg dnum 0) (while (> deg2 0) (setq dvar (append '(vec) lz '(1) tz) lz (cons 0 lz) tz (cdr tz) deg2 (1- deg2) dnum (math-add dnum (math-mul dvar (math-pow var deg2))) dlist (cons (and (= deg2 (1- deg)) (math-pow (nth 1 (car fp)) rpt)) dlist))) (let ((fpp fden) (mult 1)) (while (setq fpp (cdr fpp)) (or (eq fpp fp) (setq mult (math-mul mult (math-pow (nth 1 (car fpp)) (nth 2 (car fpp))))))) (setq dnum (math-mul dnum mult))) (setq eqns (math-add eqns (math-mul dnum (math-pow (nth 1 (car fp)) (- (nth 2 (car fp)) rpt)))) rpt (1- rpt))))) (setq eqns (math-div (cons 'vec (math-padded-polynomial r var tdeg)) (math-transpose (cons 'vec (mapcar (function (lambda (x) (cons 'vec (math-padded-polynomial x var tdeg)))) (cdr eqns)))))) (and (math-vectorp eqns) (let ((res 0) (num nil)) (setq eqns (nreverse eqns)) (while eqns (setq num (cons (car eqns) num) eqns (cdr eqns)) (if (car dlist) (setq num (math-build-polynomial-expr (nreverse num) var) res (math-add res (math-div num (car dlist))) num nil)) (setq dlist (cdr dlist))) (math-normalize res)))))) ) (defun math-expand-term (expr) (cond ((and (eq (car-safe expr) '*) (memq (car-safe (nth 1 expr)) '(+ -))) (math-add-or-sub (list '* (nth 1 (nth 1 expr)) (nth 2 expr)) (list '* (nth 2 (nth 1 expr)) (nth 2 expr)) nil (eq (car (nth 1 expr)) '-))) ((and (eq (car-safe expr) '*) (memq (car-safe (nth 2 expr)) '(+ -))) (math-add-or-sub (list '* (nth 1 expr) (nth 1 (nth 2 expr))) (list '* (nth 1 expr) (nth 2 (nth 2 expr))) nil (eq (car (nth 2 expr)) '-))) ((and (eq (car-safe expr) '/) (memq (car-safe (nth 1 expr)) '(+ -))) (math-add-or-sub (list '/ (nth 1 (nth 1 expr)) (nth 2 expr)) (list '/ (nth 2 (nth 1 expr)) (nth 2 expr)) nil (eq (car (nth 1 expr)) '-))) ((and (eq (car-safe expr) '^) (memq (car-safe (nth 1 expr)) '(+ -)) (integerp (nth 2 expr)) (if (> (nth 2 expr) 0) (or (and (or (> mmt-many 500000) (< mmt-many -500000)) (math-expand-power (nth 1 expr) (nth 2 expr) nil t)) (list '* (nth 1 expr) (list '^ (nth 1 expr) (1- (nth 2 expr))))) (if (< (nth 2 expr) 0) (list '/ 1 (list '^ (nth 1 expr) (- (nth 2 expr)))))))) (t expr)) ) (defun calcFunc-expand (expr &optional many) (math-normalize (math-map-tree 'math-expand-term expr many)) ) (defun math-expand-power (x n &optional var else-nil) (or (and (natnump n) (memq (car-safe x) '(+ -)) (let ((terms nil) (cterms nil)) (while (memq (car-safe x) '(+ -)) (setq terms (cons (if (eq (car x) '-) (math-neg (nth 2 x)) (nth 2 x)) terms) x (nth 1 x))) (setq terms (cons x terms)) (if var (let ((p terms)) (while p (or (math-expr-contains (car p) var) (setq terms (delq (car p) terms) cterms (cons (car p) cterms))) (setq p (cdr p))) (if cterms (setq terms (cons (apply 'calcFunc-add cterms) terms))))) (if (= (length terms) 2) (let ((i 0) (accum 0)) (while (<= i n) (setq accum (list '+ accum (list '* (calcFunc-choose n i) (list '* (list '^ (nth 1 terms) i) (list '^ (car terms) (- n i))))) i (1+ i))) accum) (if (= n 2) (let ((accum 0) (p1 terms) p2) (while p1 (setq accum (list '+ accum (list '^ (car p1) 2)) p2 p1) (while (setq p2 (cdr p2)) (setq accum (list '+ accum (list '* 2 (list '* (car p1) (car p2)))))) (setq p1 (cdr p1))) accum) (if (= n 3) (let ((accum 0) (p1 terms) p2 p3) (while p1 (setq accum (list '+ accum (list '^ (car p1) 3)) p2 p1) (while (setq p2 (cdr p2)) (setq accum (list '+ (list '+ accum (list '* 3 (list '* (list '^ (car p1) 2) (car p2)))) (list '* 3 (list '* (car p1) (list '^ (car p2) 2)))) p3 p2) (while (setq p3 (cdr p3)) (setq accum (list '+ accum (list '* 6 (list '* (car p1) (list '* (car p2) (car p3)))))))) (setq p1 (cdr p1))) accum)))))) (and (not else-nil) (list '^ x n))) ) (defun calcFunc-expandpow (x n) (math-normalize (math-expand-power x n)) ) calc-2.02c/calc-comp.el100644 22403 13 154073 5402630542 13250 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-comp.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-comp () nil) ;;; A "composition" has one of the following forms: ;;; ;;; "string" A literal string ;;; ;;; (horiz C1 C2 ...) Horizontally abutted sub-compositions ;;; ;;; (set LEVEL OFF) Set left margin + offset for line-break level ;;; (break LEVEL) A potential line-break point ;;; ;;; (vleft N C1 C2 ...) Vertically stacked, left-justified sub-comps ;;; (vcent N C1 C2 ...) Vertically stacked, centered sub-comps ;;; (vright N C1 C2 ...) Vertically stacked, right-justified sub-comps ;;; N specifies baseline of the stack, 0=top line. ;;; ;;; (supscr C1 C2) Composition C1 with superscript C2 ;;; (subscr C1 C2) Composition C1 with subscript C2 ;;; (rule X) Horizontal line of X, full width of enclosing comp ;;; ;;; (tag X C) Composition C corresponds to sub-expression X (defun math-compose-expr (a prec) (let ((math-compose-level (1+ math-compose-level))) (cond ((or (and (eq a math-comp-selected) a) (and math-comp-tagged (not (eq math-comp-tagged a)))) (let ((math-comp-selected nil)) (and math-comp-tagged (setq math-comp-tagged a)) (list 'tag a (math-compose-expr a prec)))) ((and (not (consp a)) (not (integerp a))) (concat "'" (prin1-to-string a))) ((math-scalarp a) (if (or (eq (car-safe a) 'frac) (and (nth 1 calc-frac-format) (Math-integerp a))) (if (memq calc-language '(tex eqn math maple c fortran pascal)) (let ((aa (math-adjust-fraction a)) (calc-frac-format nil)) (math-compose-expr (list '/ (if (memq calc-language '(c fortran)) (math-float (nth 1 aa)) (nth 1 aa)) (nth 2 aa)) prec)) (if (and (eq calc-language 'big) (= (length (car calc-frac-format)) 1)) (let* ((aa (math-adjust-fraction a)) (calc-frac-format nil) (math-radix-explicit-format nil) (c (list 'horiz (if (math-negp (nth 1 aa)) "- " "") (list 'vcent 1 (math-format-number (math-abs (nth 1 aa))) '(rule ?-) (math-format-number (nth 2 aa)))))) (if (= calc-number-radix 10) c (list 'horiz "(" c (list 'subscr ")" (int-to-string calc-number-radix))))) (math-format-number a))) (if (not (eq calc-language 'big)) (math-format-number a prec) (if (memq (car-safe a) '(cplx polar)) (if (math-zerop (nth 2 a)) (math-compose-expr (nth 1 a) prec) (list 'horiz "(" (math-compose-expr (nth 1 a) 0) (if (eq (car a) 'cplx) ", " "; ") (math-compose-expr (nth 2 a) 0) ")")) (if (or (= calc-number-radix 10) (not (Math-realp a)) (and calc-group-digits (not (assoc calc-group-char '((",") (" ")))))) (math-format-number a prec) (let ((s (math-format-number a prec)) (c nil)) (while (string-match (if (> calc-number-radix 14) "\\([0-9]+\\)#\\([0-9a-zA-Z., ]+\\)" "\\([0-9]+\\)#\\([0-9a-dA-D., ]+\\)") s) (setq c (nconc c (list (substring s 0 (match-beginning 0)) (list 'subscr (math-match-substring s 2) (math-match-substring s 1)))) s (substring s (match-end 0)))) (if (string-match "\\*\\([0-9.]+\\)\\^\\(-?[0-9]+\\)\\()?\\)\\'" s) (setq s (list 'horiz (substring s 0 (match-beginning 0)) " " (list 'supscr (math-match-substring s 1) (math-match-substring s 2)) (math-match-substring s 3)))) (if c (cons 'horiz (nconc c (list s))) s))))))) ((and (get (car a) 'math-compose-forms) (not (eq calc-language 'unform)) (let ((comps (get (car a) 'math-compose-forms)) temp temp2) (or (and (setq temp (assq calc-language comps)) (or (and (setq temp2 (assq (1- (length a)) (cdr temp))) (setq temp (apply (cdr temp2) (cdr a))) (math-compose-expr temp prec)) (and (setq temp2 (assq nil (cdr temp))) (funcall (cdr temp2) a)))) (and (setq temp (assq nil comps)) (or (and (setq temp2 (assq (1- (length a)) (cdr temp))) (setq temp (apply (cdr temp2) (cdr a))) (math-compose-expr temp prec)) (and (setq temp2 (assq nil (cdr temp))) (funcall (cdr temp2) a)))))))) ((eq (car a) 'vec) (let* ((left-bracket (if calc-vector-brackets (substring calc-vector-brackets 0 1) "")) (right-bracket (if calc-vector-brackets (substring calc-vector-brackets 1 2) "")) (inner-brackets (memq 'R calc-matrix-brackets)) (outer-brackets (memq 'O calc-matrix-brackets)) (row-commas (memq 'C calc-matrix-brackets)) (comma-spc (or calc-vector-commas " ")) (comma (or calc-vector-commas "")) (vector-prec (if (or (and calc-vector-commas (math-vector-no-parens a)) (memq 'P calc-matrix-brackets)) 0 1000)) (just (cond ((eq calc-matrix-just 'right) 'vright) ((eq calc-matrix-just 'center) 'vcent) (t 'vleft))) (break calc-break-vectors)) (if (and (memq calc-language '(nil big)) (not calc-break-vectors) (math-matrixp a) (not (math-matrixp (nth 1 a))) (or calc-full-vectors (and (< (length a) 7) (< (length (nth 1 a)) 7)) (progn (setq break t) nil))) (if (progn (setq vector-prec (if (or (and calc-vector-commas (math-vector-no-parens (nth 1 a))) (memq 'P calc-matrix-brackets)) 0 1000)) (= (length a) 2)) (list 'horiz (concat left-bracket left-bracket " ") (math-compose-vector (cdr (nth 1 a)) (concat comma " ") vector-prec) (concat " " right-bracket right-bracket)) (let* ((rows (1- (length a))) (cols (1- (length (nth 1 a)))) (base (/ (1- rows) 2)) (calc-language 'flat)) (append '(horiz) (list (append '(vleft) (list base) (list (concat (and outer-brackets (concat left-bracket " ")) (and inner-brackets (concat left-bracket " ")))) (make-list (1- rows) (concat (and outer-brackets " ") (and inner-brackets (concat left-bracket " ")))))) (math-compose-matrix (cdr a) 1 cols base) (list (append '(vleft) (list base) (make-list (1- rows) (if inner-brackets (concat " " right-bracket (and row-commas comma)) (if (and outer-brackets row-commas) ";" ""))) (list (concat (and inner-brackets (concat " " right-bracket)) (and outer-brackets (concat " " right-bracket))))))))) (if (and calc-display-strings (cdr a) (math-vector-is-string a)) (math-vector-to-string a t) (if (and break (cdr a) (not (eq calc-language 'flat))) (let* ((full (or calc-full-vectors (< (length a) 7))) (rows (if full (1- (length a)) 5)) (base (/ (1- rows) 2)) (just 'vleft) (calc-break-vectors nil)) (list 'horiz (cons 'vleft (cons base (math-compose-rows (cdr a) (if full rows 3) t))))) (if (or calc-full-vectors (< (length a) 7)) (if (and (eq calc-language 'tex) (math-matrixp a)) (append '(horiz "\\matrix{ ") (math-compose-tex-matrix (cdr a)) '(" }")) (if (and (eq calc-language 'eqn) (math-matrixp a)) (append '(horiz "matrix { ") (math-compose-eqn-matrix (cdr (math-transpose a))) '("}")) (if (and (eq calc-language 'maple) (math-matrixp a)) (list 'horiz "matrix(" left-bracket (math-compose-vector (cdr a) (concat comma " ") vector-prec) right-bracket ")") (list 'horiz left-bracket (math-compose-vector (cdr a) (concat comma " ") vector-prec) right-bracket)))) (list 'horiz left-bracket (math-compose-vector (list (nth 1 a) (nth 2 a) (nth 3 a)) (concat comma " ") vector-prec) comma (if (eq calc-language 'tex) " \\ldots" " ...") comma " " (list 'break math-compose-level) (math-compose-expr (nth (1- (length a)) a) (if (equal comma "") 1000 0)) right-bracket))))))) ((eq (car a) 'incomplete) (if (cdr (cdr a)) (cond ((eq (nth 1 a) 'vec) (list 'horiz "[" (math-compose-vector (cdr (cdr a)) ", " 0) " ...")) ((eq (nth 1 a) 'cplx) (list 'horiz "(" (math-compose-vector (cdr (cdr a)) ", " 0) ", ...")) ((eq (nth 1 a) 'polar) (list 'horiz "(" (math-compose-vector (cdr (cdr a)) "; " 0) "; ...")) ((eq (nth 1 a) 'intv) (list 'horiz (if (memq (nth 2 a) '(0 1)) "(" "[") (math-compose-vector (cdr (cdr (cdr a))) " .. " 0) " .. ...")) (t (format "%s" a))) (cond ((eq (nth 1 a) 'vec) "[ ...") ((eq (nth 1 a) 'intv) (if (memq (nth 2 a) '(0 1)) "( ..." "[ ...")) (t "( ...")))) ((eq (car a) 'var) (let ((v (rassq (nth 2 a) math-expr-variable-mapping))) (if v (symbol-name (car v)) (if (and (eq calc-language 'tex) calc-language-option (not (= calc-language-option 0)) (string-match "\\`[a-zA-Z][a-zA-Z0-9]+\\'" (symbol-name (nth 1 a)))) (format "\\hbox{%s}" (symbol-name (nth 1 a))) (if (and math-compose-hash-args (let ((p calc-arg-values)) (setq v 1) (while (and p (not (equal (car p) a))) (setq p (and (eq math-compose-hash-args t) (cdr p)) v (1+ v))) p)) (if (eq math-compose-hash-args 1) "#" (format "#%d" v)) (if (memq calc-language '(c fortran pascal maple)) (math-to-underscores (symbol-name (nth 1 a))) (if (and (eq calc-language 'eqn) (string-match ".'\\'" (symbol-name (nth 2 a)))) (math-compose-expr (list 'calcFunc-Prime (list 'var (intern (substring (symbol-name (nth 1 a)) 0 -1)) (intern (substring (symbol-name (nth 2 a)) 0 -1)))) prec) (symbol-name (nth 1 a))))))))) ((eq (car a) 'intv) (list 'horiz (if (eq calc-language 'maple) "" (if (memq (nth 1 a) '(0 1)) "(" "[")) (math-compose-expr (nth 2 a) 0) (if (eq calc-language 'tex) " \\ldots " (if (eq calc-language 'eqn) " ... " " .. ")) (math-compose-expr (nth 3 a) 0) (if (eq calc-language 'maple) "" (if (memq (nth 1 a) '(0 2)) ")" "]")))) ((eq (car a) 'date) (if (eq (car calc-date-format) 'X) (math-format-date a) (concat "<" (math-format-date a) ">"))) ((and (eq (car a) 'calcFunc-subscr) (cdr (cdr a)) (memq calc-language '(c pascal fortran maple))) (let ((args (cdr (cdr a)))) (while (and (memq calc-language '(pascal fortran)) (eq (car-safe (nth 1 a)) 'calcFunc-subscr)) (setq args (append (cdr (cdr (nth 1 a))) args) a (nth 1 a))) (list 'horiz (math-compose-expr (nth 1 a) 1000) (if (eq calc-language 'fortran) "(" "[") (math-compose-vector args ", " 0) (if (eq calc-language 'fortran) ")" "]")))) ((and (eq (car a) 'calcFunc-subscr) (= (length a) 3) (eq calc-language 'big)) (let* ((a1 (math-compose-expr (nth 1 a) 1000)) (calc-language 'flat) (a2 (math-compose-expr (nth 2 a) 0))) (if (or (eq (car-safe a1) 'subscr) (and (eq (car-safe a1) 'tag) (eq (car-safe (nth 2 a1)) 'subscr) (setq a1 (nth 2 a1)))) (list 'subscr (nth 1 a1) (list 'horiz (nth 2 a1) ", " a2)) (list 'subscr a1 a2)))) ((and (eq (car a) 'calcFunc-subscr) (= (length a) 3) (eq calc-language 'math)) (list 'horiz (math-compose-expr (nth 1 a) 1000) "[[" (math-compose-expr (nth 2 a) 0) "]]")) ((and (eq (car a) 'calcFunc-sqrt) (eq calc-language 'tex)) (list 'horiz "\\sqrt{" (math-compose-expr (nth 1 a) 0) "}")) ((and nil (eq (car a) 'calcFunc-sqrt) (eq calc-language 'eqn)) (list 'horiz "sqrt {" (math-compose-expr (nth 1 a) -1) "}")) ((and (eq (car a) '^) (eq calc-language 'big)) (list 'supscr (if (or (math-looks-negp (nth 1 a)) (memq (car-safe (nth 1 a)) '(^ / frac calcFunc-sqrt)) (and (eq (car-safe (nth 1 a)) 'cplx) (math-negp (nth 1 (nth 1 a))) (eq (nth 2 (nth 1 a)) 0))) (list 'horiz "(" (math-compose-expr (nth 1 a) 0) ")") (math-compose-expr (nth 1 a) 201)) (let ((calc-language 'flat) (calc-number-radix 10)) (math-compose-expr (nth 2 a) 0)))) ((and (eq (car a) '/) (eq calc-language 'big)) (let ((a1 (let ((calc-language (if (memq (car-safe (nth 1 a)) '(/ frac)) 'flat 'big))) (math-compose-expr (nth 1 a) 0))) (a2 (let ((calc-language (if (memq (car-safe (nth 2 a)) '(/ frac)) 'flat 'big))) (math-compose-expr (nth 2 a) 0)))) (list 'vcent (math-comp-height a1) a1 '(rule ?-) a2))) ((and (memq (car a) '(calcFunc-sum calcFunc-prod)) (eq calc-language 'tex) (= (length a) 5)) (list 'horiz (if (eq (car a) 'calcFunc-sum) "\\sum" "\\prod") "_{" (math-compose-expr (nth 2 a) 0) "=" (math-compose-expr (nth 3 a) 0) "}^{" (math-compose-expr (nth 4 a) 0) "}{" (math-compose-expr (nth 1 a) 0) "}")) ((and (eq (car a) 'calcFunc-lambda) (> (length a) 2) (memq calc-language '(nil flat big))) (let ((p (cdr a)) (ap calc-arg-values) (math-compose-hash-args (if (= (length a) 3) 1 t))) (while (and (cdr p) (equal (car p) (car ap))) (setq p (cdr p) ap (cdr ap))) (append '(horiz "<") (if (cdr p) (list (math-compose-vector (nreverse (cdr (reverse (cdr a)))) ", " 0) " : ") nil) (list (math-compose-expr (nth (1- (length a)) a) 0) ">")))) ((and (eq (car a) 'calcFunc-string) (= (length a) 2) (math-vectorp (nth 1 a)) (math-vector-is-string (nth 1 a))) (if (eq calc-language 'unform) (concat "string(" (math-vector-to-string (nth 1 a) t) ")") (math-vector-to-string (nth 1 a) nil))) ((and (eq (car a) 'calcFunc-bstring) (= (length a) 2) (math-vectorp (nth 1 a)) (math-vector-is-string (nth 1 a))) (if (eq calc-language 'unform) (concat "bstring(" (math-vector-to-string (nth 1 a) t) ")") (let ((c nil) (s (math-vector-to-string (nth 1 a) nil)) p) (while (string-match "[^ ] +[^ ]" s) (setq p (1- (match-end 0)) c (cons (list 'break math-compose-level) (cons (substring s 0 p) c)) s (substring s p))) (setq c (nreverse (cons s c))) (or (= prec -123) (setq c (cons (list 'set math-compose-level 2) c))) (cons 'horiz c)))) ((and (eq (car a) 'calcFunc-cprec) (not (eq calc-language 'unform)) (= (length a) 3) (integerp (nth 2 a))) (let ((c (math-compose-expr (nth 1 a) -1))) (if (> prec (nth 2 a)) (if (eq calc-language 'tex) (list 'horiz "\\left( " c " \\right)") (if (eq calc-language 'eqn) (list 'horiz "{left ( " c " right )}") (list 'horiz "(" c ")"))) c))) ((and (eq (car a) 'calcFunc-choriz) (not (eq calc-language 'unform)) (memq (length a) '(2 3 4)) (math-vectorp (nth 1 a)) (if (integerp (nth 2 a)) (or (null (nth 3 a)) (and (math-vectorp (nth 3 a)) (math-vector-is-string (nth 3 a)))) (or (null (nth 2 a)) (and (math-vectorp (nth 2 a)) (math-vector-is-string (nth 2 a)))))) (let* ((cprec (and (integerp (nth 2 a)) (nth 2 a))) (sep (nth (if cprec 3 2) a)) (bprec nil)) (if sep (math-compose-vector (cdr (nth 1 a)) (math-vector-to-string sep nil) (or cprec prec)) (cons 'horiz (mapcar (function (lambda (x) (if (eq (car-safe x) 'calcFunc-bstring) (prog1 (math-compose-expr x (or bprec cprec prec)) (setq bprec -123)) (math-compose-expr x (or cprec prec))))) (cdr (nth 1 a))))))) ((and (memq (car a) '(calcFunc-cvert calcFunc-clvert calcFunc-crvert)) (not (eq calc-language 'unform)) (memq (length a) '(2 3)) (math-vectorp (nth 1 a)) (or (null (nth 2 a)) (integerp (nth 2 a)))) (let* ((base 0) (v 0) (prec (or (nth 2 a) prec)) (c (mapcar (function (lambda (x) (let ((b nil) (cc nil) a d) (if (and (memq (car-safe x) '(calcFunc-cbase calcFunc-ctbase calcFunc-cbbase)) (memq (length x) '(1 2))) (setq b (car x) x (nth 1 x))) (if (and (eq (car-safe x) 'calcFunc-crule) (memq (length x) '(1 2)) (or (null (nth 1 x)) (and (math-vectorp (nth 1 x)) (= (length (nth 1 x)) 2) (math-vector-is-string (nth 1 x))) (and (natnump (nth 1 x)) (<= (nth 1 x) 255)))) (setq cc (list 'rule (if (math-vectorp (nth 1 x)) (aref (math-vector-to-string (nth 1 x) nil) 0) (or (nth 1 x) ?-)))) (or (and (memq (car-safe x) '(calcFunc-cvspace calcFunc-ctspace calcFunc-cbspace)) (memq (length x) '(2 3)) (eq (nth 1 x) 0)) (null x) (setq cc (math-compose-expr x prec)))) (setq a (if cc (math-comp-ascent cc) 0) d (if cc (math-comp-descent cc) 0)) (if (eq b 'calcFunc-cbase) (setq base (+ v a -1)) (if (eq b 'calcFunc-ctbase) (setq base v) (if (eq b 'calcFunc-cbbase) (setq base (+ v a d -1))))) (setq v (+ v a d)) cc))) (cdr (nth 1 a))))) (setq c (delq nil c)) (if c (cons (if (eq (car a) 'calcFunc-cvert) 'vcent (if (eq (car a) 'calcFunc-clvert) 'vleft 'vright)) (cons base c)) " "))) ((and (memq (car a) '(calcFunc-csup calcFunc-csub)) (not (eq calc-language 'unform)) (memq (length a) '(3 4)) (or (null (nth 3 a)) (integerp (nth 3 a)))) (list (if (eq (car a) 'calcFunc-csup) 'supscr 'subscr) (math-compose-expr (nth 1 a) (or (nth 3 a) 0)) (math-compose-expr (nth 2 a) 0))) ((and (eq (car a) 'calcFunc-cflat) (not (eq calc-language 'unform)) (memq (length a) '(2 3)) (or (null (nth 2 a)) (integerp (nth 2 a)))) (let ((calc-language (if (memq calc-language '(nil big)) 'flat calc-language))) (math-compose-expr (nth 1 a) (or (nth 2 a) 0)))) ((and (eq (car a) 'calcFunc-cspace) (memq (length a) '(2 3)) (natnump (nth 1 a))) (if (nth 2 a) (cons 'horiz (make-list (nth 1 a) (if (and (math-vectorp (nth 2 a)) (math-vector-is-string (nth 2 a))) (math-vector-to-string (nth 2 a) nil) (math-compose-expr (nth 2 a) 0)))) (make-string (nth 1 a) ?\ ))) ((and (memq (car a) '(calcFunc-cvspace calcFunc-ctspace calcFunc-cbspace)) (memq (length a) '(2 3)) (natnump (nth 1 a))) (if (= (nth 1 a) 0) "" (let* ((c (if (nth 2 a) (if (and (math-vectorp (nth 2 a)) (math-vector-is-string (nth 2 a))) (math-vector-to-string (nth 2 a) nil) (math-compose-expr (nth 2 a) 0)) " ")) (ca (math-comp-ascent c)) (cd (math-comp-descent c))) (cons 'vleft (cons (if (eq (car a) 'calcFunc-ctspace) (1- ca) (if (eq (car a) 'calcFunc-cbspace) (+ (* (1- (nth 1 a)) (+ ca cd)) (1- ca)) (/ (1- (* (nth 1 a) (+ ca cd))) 2))) (make-list (nth 1 a) c)))))) ((and (eq (car a) 'calcFunc-evalto) (setq calc-any-evaltos t) (memq calc-language '(tex eqn)) (= math-compose-level (if math-comp-tagged 2 1)) (= (length a) 3)) (list 'horiz (if (eq calc-language 'tex) "\\evalto " "evalto ") (math-compose-expr (nth 1 a) 0) (if (eq calc-language 'tex) " \\to " " -> ") (math-compose-expr (nth 2 a) 0))) (t (let ((op (and (not (eq calc-language 'unform)) (if (and (eq (car a) 'calcFunc-if) (= (length a) 4)) (assoc "?" math-expr-opers) (math-assq2 (car a) math-expr-opers))))) (cond ((and op (or (= (length a) 3) (eq (car a) 'calcFunc-if)) (/= (nth 3 op) -1)) (cond ((> prec (or (nth 4 op) (min (nth 2 op) (nth 3 op)))) (if (and (eq calc-language 'tex) (not (math-tex-expr-is-flat a))) (if (eq (car-safe a) '/) (list 'horiz "{" (math-compose-expr a -1) "}") (list 'horiz "\\left( " (math-compose-expr a -1) " \\right)")) (if (eq calc-language 'eqn) (if (or (eq (car-safe a) '/) (= (/ prec 100) 9)) (list 'horiz "{" (math-compose-expr a -1) "}") (if (math-tex-expr-is-flat a) (list 'horiz "( " (math-compose-expr a -1) " )") (list 'horiz "{left ( " (math-compose-expr a -1) " right )}"))) (list 'horiz "(" (math-compose-expr a 0) ")")))) ((and (eq calc-language 'tex) (memq (car a) '(/ calcFunc-choose calcFunc-evalto)) (>= prec 0)) (list 'horiz "{" (math-compose-expr a -1) "}")) ((eq (car a) 'calcFunc-if) (list 'horiz (math-compose-expr (nth 1 a) (nth 2 op)) " ? " (math-compose-expr (nth 2 a) 0) " : " (math-compose-expr (nth 3 a) (nth 3 op)))) (t (let* ((math-comp-tagged (and math-comp-tagged (not (math-primp a)) math-comp-tagged)) (setlev (if (= prec (min (nth 2 op) (nth 3 op))) (progn (setq math-compose-level (1- math-compose-level)) nil) math-compose-level)) (lhs (math-compose-expr (nth 1 a) (nth 2 op))) (rhs (math-compose-expr (nth 2 a) (nth 3 op)))) (and (equal (car op) "^") (eq (math-comp-first-char lhs) ?-) (setq lhs (list 'horiz "(" lhs ")"))) (and (eq calc-language 'tex) (or (equal (car op) "^") (equal (car op) "_")) (not (and (stringp rhs) (= (length rhs) 1))) (setq rhs (list 'horiz "{" rhs "}"))) (or (and (eq (car a) '*) (or (null calc-language) (assoc "2x" math-expr-opers)) (let* ((prevt (math-prod-last-term (nth 1 a))) (nextt (math-prod-first-term (nth 2 a))) (prevc (or (math-comp-last-char lhs) (and (memq (car-safe prevt) '(^ calcFunc-subscr calcFunc-sqrt frac)) (eq calc-language 'big) ?0))) (nextc (or (math-comp-first-char rhs) (and (memq (car-safe nextt) '(calcFunc-sqrt calcFunc-sum calcFunc-prod calcFunc-integ)) (eq calc-language 'big) ?0)))) (and prevc nextc (or (and (>= nextc ?a) (<= nextc ?z)) (and (>= nextc ?A) (<= nextc ?Z)) (and (>= nextc ?0) (<= nextc ?9)) (memq nextc '(?. ?_ ?# ?\( ?\[ ?\{)) (and (eq nextc ?\\) (not (string-match "\\`\\\\left(" (math-comp-first-string rhs))))) (not (and (eq (car-safe prevt) 'var) (eq nextc ?\())) (list 'horiz (list 'set setlev 1) lhs (list 'break math-compose-level) " " rhs)))) (list 'horiz (list 'set setlev 1) lhs (list 'break math-compose-level) (if (or (equal (car op) "^") (equal (car op) "_") (equal (car op) "**") (and (equal (car op) "*") (math-comp-last-char lhs) (math-comp-first-char rhs)) (and (equal (car op) "/") (math-num-integerp (nth 1 a)) (math-integerp (nth 2 a)))) (car op) (if (and (eq calc-language 'big) (equal (car op) "=>")) " => " (concat " " (car op) " "))) rhs)))))) ((and op (= (length a) 2) (= (nth 3 op) -1)) (cond ((or (> prec (or (nth 4 op) (nth 2 op))) (and (not (eq (assoc (car op) math-expr-opers) op)) (> prec 0))) ; don't write x% + y (if (and (eq calc-language 'tex) (not (math-tex-expr-is-flat a))) (list 'horiz "\\left( " (math-compose-expr a -1) " \\right)") (if (eq calc-language 'eqn) (if (= (/ prec 100) 9) (list 'horiz "{" (math-compose-expr a -1) "}") (if (math-tex-expr-is-flat a) (list 'horiz "{( " (math-compose-expr a -1) " )}") (list 'horiz "{left ( " (math-compose-expr a -1) " right )}"))) (list 'horiz "(" (math-compose-expr a 0) ")")))) (t (let ((lhs (math-compose-expr (nth 1 a) (nth 2 op)))) (list 'horiz lhs (if (or (> (length (car op)) 1) (not (math-comp-is-flat lhs))) (concat " " (car op)) (car op))))))) ((and op (= (length a) 2) (= (nth 2 op) -1)) (cond ((eq (nth 3 op) 0) (let ((lr (and (eq calc-language 'tex) (not (math-tex-expr-is-flat (nth 1 a)))))) (list 'horiz (if lr "\\left" "") (if (string-match "\\`u\\([^a-zA-Z]\\)\\'" (car op)) (substring (car op) 1) (car op)) (if (or lr (> (length (car op)) 2)) " " "") (math-compose-expr (nth 1 a) -1) (if (or lr (> (length (car op)) 2)) " " "") (if lr "\\right" "") (car (nth 1 (memq op math-expr-opers)))))) ((> prec (or (nth 4 op) (nth 3 op))) (if (and (eq calc-language 'tex) (not (math-tex-expr-is-flat a))) (list 'horiz "\\left( " (math-compose-expr a -1) " \\right)") (if (eq calc-language 'eqn) (if (= (/ prec 100) 9) (list 'horiz "{" (math-compose-expr a -1) "}") (if (math-tex-expr-is-flat a) (list 'horiz "{( " (math-compose-expr a -1) " )}") (list 'horiz "{left ( " (math-compose-expr a -1) " right )}"))) (list 'horiz "(" (math-compose-expr a 0) ")")))) (t (let ((rhs (math-compose-expr (nth 1 a) (nth 3 op)))) (list 'horiz (let ((ops (if (string-match "\\`u\\([^a-zA-Z]\\)\\'" (car op)) (substring (car op) 1) (car op)))) (if (or (> (length ops) 1) (not (math-comp-is-flat rhs))) (concat ops " ") ops)) rhs))))) ((and (eq calc-language 'big) (setq op (get (car a) 'math-compose-big)) (funcall op a prec))) ((and (setq op (assq calc-language '( ( nil . math-compose-normal ) ( flat . math-compose-normal ) ( big . math-compose-normal ) ( c . math-compose-c ) ( pascal . math-compose-pascal ) ( fortran . math-compose-fortran ) ( tex . math-compose-tex ) ( eqn . math-compose-eqn ) ( math . math-compose-math ) ( maple . math-compose-maple )))) (setq op (get (car a) (cdr op))) (funcall op a prec))) (t (let* ((func (car a)) (func2 (assq func '(( mod . calcFunc-makemod ) ( sdev . calcFunc-sdev ) ( + . calcFunc-add ) ( - . calcFunc-sub ) ( * . calcFunc-mul ) ( / . calcFunc-div ) ( % . calcFunc-mod ) ( ^ . calcFunc-pow ) ( neg . calcFunc-neg ) ( | . calcFunc-vconcat )))) left right args) (if func2 (setq func (cdr func2))) (if (setq func2 (rassq func math-expr-function-mapping)) (setq func (car func2))) (setq func (math-remove-dashes (if (string-match "\\`calcFunc-\\([a-zA-Z0-9']+\\)\\'" (symbol-name func)) (math-match-substring (symbol-name func) 1) (symbol-name func)))) (if (memq calc-language '(c fortran pascal maple)) (setq func (math-to-underscores func))) (if (and (eq calc-language 'tex) calc-language-option (not (= calc-language-option 0)) (string-match "\\`[a-zA-Z][a-zA-Z0-9]+\\'" func)) (if (< (prefix-numeric-value calc-language-option) 0) (setq func (format "\\%s" func)) (setq func (format "\\hbox{%s}" func)))) (if (and (eq calc-language 'eqn) (string-match "[^']'+\\'" func)) (let ((n (- (length func) (match-beginning 0) 1))) (setq func (substring func 0 (- n))) (while (>= (setq n (1- n)) 0) (setq func (concat func " prime"))))) (cond ((and (eq calc-language 'tex) (or (> (length a) 2) (not (math-tex-expr-is-flat (nth 1 a))))) (setq left "\\left( " right " \\right)")) ((and (eq calc-language 'eqn) (or (> (length a) 2) (not (math-tex-expr-is-flat (nth 1 a))))) (setq left "{left ( " right " right )}")) ((and (or (and (eq calc-language 'tex) (eq (aref func 0) ?\\)) (and (eq calc-language 'eqn) (memq (car a) math-eqn-special-funcs))) (not (string-match "\\hbox{" func)) (= (length a) 2) (or (Math-realp (nth 1 a)) (memq (car (nth 1 a)) '(var *)))) (setq left (if (eq calc-language 'eqn) "~{" "{") right "}")) ((eq calc-language 'eqn) (setq left " ( " right " )")) (t (setq left calc-function-open right calc-function-close))) (list 'horiz func left (math-compose-vector (cdr a) (if (eq calc-language 'eqn) " , " ", ") 0) right)))))))) ) (defconst math-eqn-special-funcs '( calcFunc-log calcFunc-ln calcFunc-exp calcFunc-sin calcFunc-cos calcFunc-tan calcFunc-sinh calcFunc-cosh calcFunc-tanh calcFunc-arcsin calcFunc-arccos calcFunc-arctan calcFunc-arcsinh calcFunc-arccosh calcFunc-arctanh )) (defun math-prod-first-term (x) (while (eq (car-safe x) '*) (setq x (nth 1 x))) x ) (defun math-prod-last-term (x) (while (eq (car-safe x) '*) (setq x (nth 2 x))) x ) (defun math-compose-vector (a sep prec) (if a (cons 'horiz (cons (list 'set math-compose-level) (let ((c (list (math-compose-expr (car a) prec)))) (while (setq a (cdr a)) (setq c (cons (if (eq (car-safe (car a)) 'calcFunc-bstring) (let ((math-compose-level (1- math-compose-level))) (math-compose-expr (car a) -123)) (math-compose-expr (car a) prec)) (cons (list 'break math-compose-level) (cons sep c))))) (nreverse c)))) "") ) (defun math-vector-no-parens (a) (or (cdr (cdr a)) (not (eq (car-safe (nth 1 a)) '*))) ) (defun math-compose-matrix (a col cols base) (let ((col 0) (res nil)) (while (<= (setq col (1+ col)) cols) (setq res (cons (cons just (cons base (mapcar (function (lambda (r) (list 'horiz (math-compose-expr (nth col r) vector-prec) (if (= col cols) "" (concat comma-spc " "))))) a))) res))) (nreverse res)) ) (defun math-compose-rows (a count first) (if (cdr a) (if (<= count 0) (if (< count 0) (math-compose-rows (cdr a) -1 nil) (cons (concat (if (eq calc-language 'tex) " \\ldots" " ...") comma) (math-compose-rows (cdr a) -1 nil))) (cons (list 'horiz (if first (concat left-bracket " ") " ") (math-compose-expr (car a) vector-prec) comma) (math-compose-rows (cdr a) (1- count) nil))) (list (list 'horiz (if first (concat left-bracket " ") " ") (math-compose-expr (car a) vector-prec) (concat " " right-bracket)))) ) (defun math-compose-tex-matrix (a) (if (cdr a) (cons (math-compose-vector (cdr (car a)) " & " 0) (cons " \\\\ " (math-compose-tex-matrix (cdr a)))) (list (math-compose-vector (cdr (car a)) " & " 0))) ) (defun math-compose-eqn-matrix (a) (if a (cons (cond ((eq calc-matrix-just 'right) "rcol ") ((eq calc-matrix-just 'center) "ccol ") (t "lcol ")) (cons (list 'break math-compose-level) (cons "{ " (cons (let ((math-compose-level (1+ math-compose-level))) (math-compose-vector (cdr (car a)) " above " 1000)) (cons " } " (math-compose-eqn-matrix (cdr a))))))) nil) ) (defun math-vector-is-string (a) (while (and (setq a (cdr a)) (or (and (natnump (car a)) (<= (car a) 255)) (and (eq (car-safe (car a)) 'cplx) (natnump (nth 1 (car a))) (eq (nth 2 (car a)) 0) (<= (nth 1 (car a)) 255))))) (null a) ) (defun math-vector-to-string (a &optional quoted) (setq a (concat (mapcar (function (lambda (x) (if (consp x) (nth 1 x) x))) (cdr a)))) (if (string-match "[\000-\037\177\\\"]" a) (let ((p 0) (pat (if quoted "[\000-\037\177\\\"]" "[\000-\037\177]")) (codes (if quoted math-vector-to-string-chars '((?\^? . "^?")))) (fmt (if quoted "\\^%c" "^%c")) new) (while (setq p (string-match pat a p)) (if (setq new (assq (aref a p) codes)) (setq a (concat (substring a 0 p) (cdr new) (substring a (1+ p))) p (+ p (length (cdr new)))) (setq a (concat (substring a 0 p) (format fmt (+ (aref a p) 64)) (substring a (1+ p))) p (+ p 2)))))) (if quoted (concat "\"" a "\"") a) ) (defconst math-vector-to-string-chars '( ( ?\" . "\\\"" ) ( ?\\ . "\\\\" ) ( ?\a . "\\a" ) ( ?\b . "\\b" ) ( ?\e . "\\e" ) ( ?\f . "\\f" ) ( ?\n . "\\n" ) ( ?\r . "\\r" ) ( ?\t . "\\t" ) ( ?\^? . "\\^?" ) )) (defun math-to-underscores (x) (if (string-match "\\`\\(.*\\)#\\(.*\\)\\'" x) (math-to-underscores (concat (math-match-substring x 1) "_" (math-match-substring x 2))) x) ) (defun math-tex-expr-is-flat (a) (or (Math-integerp a) (memq (car a) '(float var)) (and (memq (car a) '(+ - * neg)) (progn (while (and (setq a (cdr a)) (math-tex-expr-is-flat (car a)))) (null a))) (and (memq (car a) '(^ calcFunc-subscr)) (math-tex-expr-is-flat (nth 1 a)))) ) (put 'calcFunc-log 'math-compose-big 'math-compose-log) (defun math-compose-log (a prec) (and (= (length a) 3) (list 'horiz (list 'subscr "log" (let ((calc-language 'flat)) (math-compose-expr (nth 2 a) 1000))) "(" (math-compose-expr (nth 1 a) 1000) ")")) ) (put 'calcFunc-log10 'math-compose-big 'math-compose-log10) (defun math-compose-log10 (a prec) (and (= (length a) 2) (list 'horiz (list 'subscr "log" "10") "(" (math-compose-expr (nth 1 a) 1000) ")")) ) (put 'calcFunc-deriv 'math-compose-big 'math-compose-deriv) (put 'calcFunc-tderiv 'math-compose-big 'math-compose-deriv) (defun math-compose-deriv (a prec) (and (= (length a) 3) (math-compose-expr (list '/ (list 'calcFunc-choriz (list 'vec '(calcFunc-string (vec ?d)) (nth 1 a))) (list 'calcFunc-choriz (list 'vec '(calcFunc-string (vec ?d)) (nth 2 a)))) prec)) ) (put 'calcFunc-sqrt 'math-compose-big 'math-compose-sqrt) (defun math-compose-sqrt (a prec) (and (= (length a) 2) (let* ((c (math-compose-expr (nth 1 a) 0)) (a (math-comp-ascent c)) (d (math-comp-descent c)) (h (+ a d)) (w (math-comp-width c))) (list 'vleft a (concat (if (= h 1) " " " ") (make-string (+ w 2) ?\_)) (list 'horiz (if (= h 1) "V" (append (list 'vleft (1- a)) (make-list (1- h) " |") '("\\|"))) " " c)))) ) (put 'calcFunc-choose 'math-compose-big 'math-compose-choose) (defun math-compose-choose (a prec) (let ((a1 (math-compose-expr (nth 1 a) 0)) (a2 (math-compose-expr (nth 2 a) 0))) (list 'horiz "(" (list 'vcent (math-comp-height a1) a1 " " a2) ")")) ) (put 'calcFunc-integ 'math-compose-big 'math-compose-integ) (defun math-compose-integ (a prec) (and (memq (length a) '(3 5)) (eq (car-safe (nth 2 a)) 'var) (let* ((parens (and (>= prec 196) (/= prec 1000))) (var (math-compose-expr (nth 2 a) 0)) (over (and (eq (car-safe (nth 2 a)) 'var) (or (and (eq (car-safe (nth 1 a)) '/) (math-numberp (nth 1 (nth 1 a)))) (and (eq (car-safe (nth 1 a)) '^) (math-looks-negp (nth 2 (nth 1 a))))))) (expr (math-compose-expr (if over (math-mul (nth 1 a) (math-build-var-name (format "d%s" (nth 1 (nth 2 a))))) (nth 1 a)) 185)) (calc-language 'flat) (low (and (nth 3 a) (math-compose-expr (nth 3 a) 0))) (high (and (nth 4 a) (math-compose-expr (nth 4 a) 0)))) (list 'horiz (if parens "(" "") (append (list 'vcent (if high 3 2)) (and high (list (list 'horiz " " high))) '(" /" " | " " | " " | " "/ ") (and low (list (list 'horiz low " ")))) expr (if over "" (list 'horiz " d" var)) (if parens ")" "")))) ) (put 'calcFunc-sum 'math-compose-big 'math-compose-sum) (defun math-compose-sum (a prec) (and (memq (length a) '(3 5 6)) (let* ((expr (math-compose-expr (nth 1 a) 185)) (calc-language 'flat) (var (math-compose-expr (nth 2 a) 0)) (low (and (nth 3 a) (math-compose-expr (nth 3 a) 0))) (high (and (nth 4 a) (math-compose-vector (nthcdr 4 a) ", " 0)))) (list 'horiz (if (memq prec '(180 201)) "(" "") (append (list 'vcent (if high 3 2)) (and high (list high)) '("---- " "\\ " " > " "/ " "---- ") (if low (list (list 'horiz var " = " low)) (list var))) (if (memq (car-safe (nth 1 a)) '(calcFunc-sum calcFunc-prod)) " " "") expr (if (memq prec '(180 201)) ")" "")))) ) (put 'calcFunc-prod 'math-compose-big 'math-compose-prod) (defun math-compose-prod (a prec) (and (memq (length a) '(3 5 6)) (let* ((expr (math-compose-expr (nth 1 a) 198)) (calc-language 'flat) (var (math-compose-expr (nth 2 a) 0)) (low (and (nth 3 a) (math-compose-expr (nth 3 a) 0))) (high (and (nth 4 a) (math-compose-vector (nthcdr 4 a) ", " 0)))) (list 'horiz (if (memq prec '(196 201)) "(" "") (append (list 'vcent (if high 3 2)) (and high (list high)) '("----- " " | | " " | | " " | | ") (if low (list (list 'horiz var " = " low)) (list var))) (if (memq (car-safe (nth 1 a)) '(calcFunc-sum calcFunc-prod)) " " "") expr (if (memq prec '(196 201)) ")" "")))) ) (defun math-stack-value-offset-fancy () (let ((cwid (+ (math-comp-width c)))) (cond ((eq calc-display-just 'right) (if calc-display-origin (setq wid (max calc-display-origin 5)) (if (integerp calc-line-breaking) (setq wid calc-line-breaking))) (setq off (- wid cwid (max (- (length calc-right-label) (if (and (integerp calc-line-breaking) calc-display-origin) (max (- calc-line-breaking calc-display-origin) 0) 0)) 0)))) (t (if calc-display-origin (progn (setq off (- calc-display-origin (/ cwid 2))) (if (integerp calc-line-breaking) (setq off (min off (- calc-line-breaking cwid (length calc-right-label))))) (if (>= off 0) (setq wid (max wid (+ off cwid))))) (if (integerp calc-line-breaking) (setq wid calc-line-breaking)) (setq off (/ (- wid cwid) 2))))) (and (integerp calc-line-breaking) (or (< off 0) (and calc-display-origin (> calc-line-breaking calc-display-origin))) (setq wid calc-line-breaking))) ) ;;; Convert a composition to string form, with embedded \n's if necessary. (defun math-composition-to-string (c &optional width) (or width (setq width (calc-window-width))) (if calc-display-raw (math-comp-to-string-raw c 0) (if (math-comp-is-flat c) (math-comp-to-string-flat c width) (math-vert-comp-to-string (math-comp-simplify c width)))) ) (defun math-comp-is-flat (c) ; check if c's height is 1. (cond ((not (consp c)) t) ((memq (car c) '(set break)) t) ((eq (car c) 'horiz) (while (and (setq c (cdr c)) (math-comp-is-flat (car c)))) (null c)) ((memq (car c) '(vleft vcent vright)) (and (= (length c) 3) (= (nth 1 c) 0) (math-comp-is-flat (nth 2 c)))) ((eq (car c) 'tag) (math-comp-is-flat (nth 2 c))) (t nil)) ) ;;; Convert a one-line composition to a string. Break into multiple ;;; lines if necessary, choosing break points according to the structure ;;; of the formula. (defun math-comp-to-string-flat (c full-width) (if math-comp-sel-hpos (let ((comp-pos 0)) (math-comp-sel-flat-term c)) (let ((comp-buf "") (comp-word "") (comp-pos 0) (comp-margin 0) (comp-highlight (and math-comp-selected calc-show-selections)) (comp-level -1)) (math-comp-to-string-flat-term '(set -1 0)) (math-comp-to-string-flat-term c) (math-comp-to-string-flat-term '(break -1)) (let ((str (aref math-comp-buf-string 0)) (prefix "")) (and (> (length str) 0) (= (aref str 0) ? ) (> (length comp-buf) 0) (let ((k (length comp-buf))) (while (not (= (aref comp-buf (setq k (1- k))) ?\n))) (aset comp-buf k ? ) (if (and (< (1+ k) (length comp-buf)) (= (aref comp-buf (1+ k)) ? )) (progn (aset comp-buf (1+ k) ?\n) (setq prefix " ")) (setq prefix "\n")))) (concat comp-buf prefix str)))) ) (setq math-comp-buf-string (make-vector 10 "")) (setq math-comp-buf-margin (make-vector 10 0)) (setq math-comp-buf-level (make-vector 10 0)) (defun math-comp-to-string-flat-term (c) (cond ((not (consp c)) (if comp-highlight (setq c (math-comp-highlight-string c))) (setq comp-word (if (= (length comp-word) 0) c (concat comp-word c)) comp-pos (+ comp-pos (length c)))) ((eq (car c) 'horiz) (while (setq c (cdr c)) (math-comp-to-string-flat-term (car c)))) ((eq (car c) 'set) (if (nth 1 c) (progn (setq comp-level (1+ comp-level)) (if (>= comp-level (length math-comp-buf-string)) (setq math-comp-buf-string (vconcat math-comp-buf-string math-comp-buf-string) math-comp-buf-margin (vconcat math-comp-buf-margin math-comp-buf-margin) math-comp-buf-level (vconcat math-comp-buf-level math-comp-buf-level))) (aset math-comp-buf-string comp-level "") (aset math-comp-buf-margin comp-level (+ comp-pos (or (nth 2 c) 0))) (aset math-comp-buf-level comp-level (nth 1 c))))) ((eq (car c) 'break) (if (not calc-line-breaking) (setq comp-buf (concat comp-buf comp-word) comp-word "") (let ((i 0) str) (if (and (> comp-pos full-width) (progn (while (progn (setq str (aref math-comp-buf-string i)) (and (= (length str) 0) (< i comp-level))) (setq i (1+ i))) (or (> (length str) 0) (> (length comp-buf) 0)))) (let ((prefix "") mrg wid) (setq mrg (aref math-comp-buf-margin i)) (if (> mrg 12) ; indenting too far, go back to far left (let ((j i) (new (if calc-line-numbering 5 1))) '(while (<= j comp-level) (aset math-comp-buf-margin j (+ (aref math-comp-buf-margin j) (- new mrg))) (setq j (1+ j))) (setq mrg new))) (setq wid (+ (length str) comp-margin)) (and (> (length str) 0) (= (aref str 0) ? ) (> (length comp-buf) 0) (let ((k (length comp-buf))) (while (not (= (aref comp-buf (setq k (1- k))) ?\n))) (aset comp-buf k ? ) (if (and (< (1+ k) (length comp-buf)) (= (aref comp-buf (1+ k)) ? )) (progn (aset comp-buf (1+ k) ?\n) (setq prefix " ")) (setq prefix "\n")))) (setq comp-buf (concat comp-buf prefix str "\n" (make-string mrg ? )) comp-pos (+ comp-pos (- mrg wid)) comp-margin mrg) (aset math-comp-buf-string i "") (while (<= (setq i (1+ i)) comp-level) (if (> (aref math-comp-buf-margin i) wid) (aset math-comp-buf-margin i (+ (aref math-comp-buf-margin i) (- mrg wid)))))))) (if (and (= (nth 1 c) (aref math-comp-buf-level comp-level)) (< comp-pos (+ (aref math-comp-buf-margin comp-level) 2))) () ; avoid stupid breaks, e.g., "1 +\n really_long_expr" (let ((str (aref math-comp-buf-string comp-level))) (setq str (if (= (length str) 0) comp-word (concat str comp-word)) comp-word "") (while (< (nth 1 c) (aref math-comp-buf-level comp-level)) (setq comp-level (1- comp-level)) (or (= (length (aref math-comp-buf-string comp-level)) 0) (setq str (concat (aref math-comp-buf-string comp-level) str)))) (aset math-comp-buf-string comp-level str))))) ((eq (car c) 'tag) (cond ((eq (nth 1 c) math-comp-selected) (let ((comp-highlight (not calc-show-selections))) (math-comp-to-string-flat-term (nth 2 c)))) ((eq (nth 1 c) t) (let ((comp-highlight nil)) (math-comp-to-string-flat-term (nth 2 c)))) (t (math-comp-to-string-flat-term (nth 2 c))))) (t (math-comp-to-string-flat-term (nth 2 c)))) ) (defun math-comp-highlight-string (s) (setq s (copy-sequence s)) (let ((i (length s))) (while (>= (setq i (1- i)) 0) (or (memq (aref s i) '(32 ?\n)) (aset s i (if calc-show-selections ?\. ?\#))))) s ) (defun math-comp-sel-flat-term (c) (cond ((not (consp c)) (setq comp-pos (+ comp-pos (length c)))) ((memq (car c) '(set break))) ((eq (car c) 'horiz) (while (and (setq c (cdr c)) (< math-comp-sel-cpos 1000000)) (math-comp-sel-flat-term (car c)))) ((eq (car c) 'tag) (if (<= comp-pos math-comp-sel-cpos) (progn (math-comp-sel-flat-term (nth 2 c)) (if (> comp-pos math-comp-sel-cpos) (setq math-comp-sel-tag c math-comp-sel-cpos 1000000))) (math-comp-sel-flat-term (nth 2 c)))) (t (math-comp-sel-flat-term (nth 2 c)))) ) ;;; Simplify a composition to a canonical form consisting of ;;; (vleft n "string" "string" "string" ...) ;;; where 0 <= n < number-of-strings. (defun math-comp-simplify (c full-width) (let ((comp-buf (list "")) (comp-base 0) (comp-height 1) (comp-hpos 0) (comp-vpos 0) (comp-highlight (and math-comp-selected calc-show-selections)) (comp-tag nil)) (math-comp-simplify-term c) (cons 'vleft (cons comp-base comp-buf))) ) (defun math-comp-add-string (s h v) (and (> (length s) 0) (let ((vv (+ v comp-base))) (if math-comp-sel-hpos (math-comp-add-string-sel h vv (length s) 1) (if (< vv 0) (setq comp-buf (nconc (make-list (- vv) "") comp-buf) comp-base (- v) comp-height (- comp-height vv) vv 0) (if (>= vv comp-height) (setq comp-buf (nconc comp-buf (make-list (1+ (- vv comp-height)) "")) comp-height (1+ vv)))) (let ((str (nthcdr vv comp-buf))) (setcar str (concat (car str) (make-string (- h (length (car str))) 32) (if comp-highlight (math-comp-highlight-string s) s))))))) ) (defun math-comp-add-string-sel (x y w h) (if (and (<= y math-comp-sel-vpos) (> (+ y h) math-comp-sel-vpos) (<= x math-comp-sel-hpos) (> (+ x w) math-comp-sel-hpos)) (setq math-comp-sel-tag comp-tag math-comp-sel-vpos 10000)) ) (defun math-comp-simplify-term (c) (cond ((stringp c) (math-comp-add-string c comp-hpos comp-vpos) (setq comp-hpos (+ comp-hpos (length c)))) ((memq (car c) '(set break)) nil) ((eq (car c) 'horiz) (while (setq c (cdr c)) (math-comp-simplify-term (car c)))) ((memq (car c) '(vleft vcent vright)) (let* ((comp-vpos (+ (- comp-vpos (nth 1 c)) (1- (math-comp-ascent (nth 2 c))))) (widths (mapcar 'math-comp-width (cdr (cdr c)))) (maxwid (apply 'max widths)) (bias (cond ((eq (car c) 'vleft) 0) ((eq (car c) 'vcent) 1) (t 2)))) (setq c (cdr c)) (while (setq c (cdr c)) (if (eq (car-safe (car c)) 'rule) (math-comp-add-string (make-string maxwid (nth 1 (car c))) comp-hpos comp-vpos) (let ((comp-hpos (+ comp-hpos (/ (* bias (- maxwid (car widths))) 2)))) (math-comp-simplify-term (car c)))) (and (cdr c) (setq comp-vpos (+ comp-vpos (+ (math-comp-descent (car c)) (math-comp-ascent (nth 1 c)))) widths (cdr widths)))) (setq comp-hpos (+ comp-hpos maxwid)))) ((eq (car c) 'supscr) (let* ((asc (or 1 (math-comp-ascent (nth 1 c)))) (desc (math-comp-descent (nth 2 c))) (oldh (prog1 comp-hpos (math-comp-simplify-term (nth 1 c)))) (comp-vpos (- comp-vpos (+ asc desc)))) (math-comp-simplify-term (nth 2 c)) (if math-comp-sel-hpos (math-comp-add-string-sel oldh (- comp-vpos -1 (math-comp-ascent (nth 2 c))) (- comp-hpos oldh) (math-comp-height c))))) ((eq (car c) 'subscr) (let* ((asc (math-comp-ascent (nth 2 c))) (desc (math-comp-descent (nth 1 c))) (oldv comp-vpos) (oldh (prog1 comp-hpos (math-comp-simplify-term (nth 1 c)))) (comp-vpos (+ comp-vpos (+ asc desc)))) (math-comp-simplify-term (nth 2 c)) (if math-comp-sel-hpos (math-comp-add-string-sel oldh oldv (- comp-hpos oldh) (math-comp-height c))))) ((eq (car c) 'tag) (cond ((eq (nth 1 c) math-comp-selected) (let ((comp-highlight (not calc-show-selections))) (math-comp-simplify-term (nth 2 c)))) ((eq (nth 1 c) t) (let ((comp-highlight nil)) (math-comp-simplify-term (nth 2 c)))) (t (let ((comp-tag c)) (math-comp-simplify-term (nth 2 c))))))) ) ;;; Measuring a composition. (defun math-comp-first-char (c) (cond ((stringp c) (and (> (length c) 0) (elt c 0))) ((memq (car c) '(horiz subscr supscr)) (while (and (setq c (cdr c)) (math-comp-is-null (car c)))) (and c (math-comp-first-char (car c)))) ((eq (car c) 'tag) (math-comp-first-char (nth 2 c)))) ) (defun math-comp-first-string (c) (cond ((stringp c) (and (> (length c) 0) c)) ((eq (car c) 'horiz) (while (and (setq c (cdr c)) (math-comp-is-null (car c)))) (and c (math-comp-first-string (car c)))) ((eq (car c) 'tag) (math-comp-first-string (nth 2 c)))) ) (defun math-comp-last-char (c) (cond ((stringp c) (and (> (length c) 0) (elt c (1- (length c))))) ((eq (car c) 'horiz) (let ((c (reverse (cdr c)))) (while (and c (math-comp-is-null (car c))) (setq c (cdr c))) (and c (math-comp-last-char (car c))))) ((eq (car c) 'tag) (math-comp-last-char (nth 2 c)))) ) (defun math-comp-is-null (c) (cond ((stringp c) (= (length c) 0)) ((memq (car c) '(horiz subscr supscr)) (while (and (setq c (cdr c)) (math-comp-is-null (car c)))) (null c)) ((eq (car c) 'tag) (math-comp-is-null (nth 2 c))) ((memq (car c) '(set break)) t)) ) (defun math-comp-width (c) (cond ((not (consp c)) (length c)) ((memq (car c) '(horiz subscr supscr)) (let ((accum 0)) (while (setq c (cdr c)) (setq accum (+ accum (math-comp-width (car c))))) accum)) ((memq (car c) '(vcent vleft vright)) (setq c (cdr c)) (let ((accum 0)) (while (setq c (cdr c)) (setq accum (max accum (math-comp-width (car c))))) accum)) ((eq (car c) 'tag) (math-comp-width (nth 2 c))) (t 0)) ) (defun math-comp-height (c) (if (stringp c) 1 (+ (math-comp-ascent c) (math-comp-descent c))) ) (defun math-comp-ascent (c) (cond ((not (consp c)) 1) ((eq (car c) 'horiz) (let ((accum 0)) (while (setq c (cdr c)) (setq accum (max accum (math-comp-ascent (car c))))) accum)) ((memq (car c) '(vcent vleft vright)) (if (> (nth 1 c) 0) (1+ (nth 1 c)) 1)) ((eq (car c) 'supscr) (max (math-comp-ascent (nth 1 c)) (1+ (math-comp-height (nth 2 c))))) ((eq (car c) 'subscr) (math-comp-ascent (nth 1 c))) ((eq (car c) 'tag) (math-comp-ascent (nth 2 c))) (t 1)) ) (defun math-comp-descent (c) (cond ((not (consp c)) 0) ((eq (car c) 'horiz) (let ((accum 0)) (while (setq c (cdr c)) (setq accum (max accum (math-comp-descent (car c))))) accum)) ((memq (car c) '(vcent vleft vright)) (let ((accum (- (nth 1 c)))) (setq c (cdr c)) (while (setq c (cdr c)) (setq accum (+ accum (math-comp-height (car c))))) (max (1- accum) 0))) ((eq (car c) 'supscr) (math-comp-descent (nth 1 c))) ((eq (car c) 'subscr) (+ (math-comp-descent (nth 1 c)) (math-comp-height (nth 2 c)))) ((eq (car c) 'tag) (math-comp-descent (nth 2 c))) (t 0)) ) (defun calcFunc-cwidth (a &optional prec) (if (and prec (not (integerp prec))) (math-reject-arg prec 'fixnump)) (math-comp-width (math-compose-expr a (or prec 0))) ) (defun calcFunc-cheight (a &optional prec) (if (and prec (not (integerp prec))) (math-reject-arg prec 'fixnump)) (if (and (memq (car a) '(calcFunc-cvspace calcFunc-ctspace calcFunc-cbspace)) (memq (length a) '(2 3)) (eq (nth 1 a) 0)) 0 (math-comp-height (math-compose-expr a (or prec 0)))) ) (defun calcFunc-cascent (a &optional prec) (if (and prec (not (integerp prec))) (math-reject-arg prec 'fixnump)) (if (and (memq (car a) '(calcFunc-cvspace calcFunc-ctspace calcFunc-cbspace)) (memq (length a) '(2 3)) (eq (nth 1 a) 0)) 0 (math-comp-ascent (math-compose-expr a (or prec 0)))) ) (defun calcFunc-cdescent (a &optional prec) (if (and prec (not (integerp prec))) (math-reject-arg prec 'fixnump)) (math-comp-descent (math-compose-expr a (or prec 0))) ) ;;; Convert a simplified composition into string form. (defun math-vert-comp-to-string (c) (if (stringp c) c (math-vert-comp-to-string-step (cdr (cdr c)))) ) (defun math-vert-comp-to-string-step (c) (if (cdr c) (concat (car c) "\n" (math-vert-comp-to-string-step (cdr c))) (car c)) ) ;;; Convert a composition to a string in "raw" form (for debugging). (defun math-comp-to-string-raw (c indent) (cond ((or (not (consp c)) (eq (car c) 'set)) (prin1-to-string c)) ((null (cdr c)) (concat "(" (symbol-name (car c)) ")")) (t (let ((next-indent (+ indent 2 (length (symbol-name (car c)))))) (concat "(" (symbol-name (car c)) " " (math-comp-to-string-raw (nth 1 c) next-indent) (math-comp-to-string-raw-step (cdr (cdr c)) next-indent) ")")))) ) (defun math-comp-to-string-raw-step (cl indent) (if cl (concat "\n" (make-string indent 32) (math-comp-to-string-raw (car cl) indent) (math-comp-to-string-raw-step (cdr cl) indent)) "") ) calc-2.02c/calc-keypd.el100644 22403 13 53633 5402630636 13412 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-keypd.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-keypd () nil) ;;; Pictorial interface to Calc using the X window system mouse. (defvar calc-keypad-buffer nil) (defvar calc-keypad-menu 0) (defvar calc-keypad-full-layout nil) (defvar calc-keypad-input nil) (defvar calc-keypad-prev-input nil) (defvar calc-keypad-prev-x-left-click nil) (defvar calc-keypad-prev-x-middle-click nil) (defvar calc-keypad-prev-x-right-click nil) (defvar calc-keypad-said-hello nil) (defvar calc-keypad-map nil) (if calc-keypad-map () (setq calc-keypad-map (make-sparse-keymap)) (define-key calc-keypad-map " " 'calc-keypad-press) (define-key calc-keypad-map "\r" 'calc-keypad-press) (define-key calc-keypad-map "\t" 'calc-keypad-menu) (define-key calc-keypad-map "q" 'calc-keypad-off)) (defun calc-do-keypad (&optional full-display interactive) (if (string-match "^19" emacs-version) (error "Sorry, calc-keypad not yet implemented for Emacs 19")) (calc-create-buffer) (let ((calcbuf (current-buffer))) (or (and calc-keypad-buffer (buffer-name calc-keypad-buffer)) (progn (setq calc-keypad-buffer (get-buffer-create "*Calc Keypad*")) (set-buffer calc-keypad-buffer) (use-local-map calc-keypad-map) (setq major-mode 'calc-keypad) (setq mode-name "Calculator") (put 'calc-keypad 'mode-class 'special) (make-local-variable 'calc-main-buffer) (setq calc-main-buffer calcbuf) (calc-keypad-redraw) (calc-trail-buffer))) (let ((width 29) (height 17) win old-win) (if (setq win (get-buffer-window "*Calculator*")) (delete-window win)) (if (setq win (get-buffer-window "*Calc Trail*")) (if (one-window-p) (switch-to-buffer (other-buffer)) (delete-window win))) (if (setq win (get-buffer-window calc-keypad-buffer)) (progn (bury-buffer "*Calculator*") (bury-buffer "*Calc Trail*") (bury-buffer calc-keypad-buffer) (if (one-window-p) (switch-to-buffer (other-buffer)) (delete-window win)) (if (and calc-keypad-prev-x-left-click (eq (aref mouse-map 0) 'calc-keypad-x-right-click) (eq (aref mouse-map 1) 'calc-keypad-x-middle-click) (eq (aref mouse-map 2) 'calc-keypad-x-left-click)) (progn (aset mouse-map 0 calc-keypad-prev-x-right-click) (aset mouse-map 1 calc-keypad-prev-x-middle-click) (aset mouse-map 2 calc-keypad-prev-x-left-click) (setq calc-keypad-prev-x-left-click nil)))) (setq calc-was-keypad-mode t old-win (get-largest-window)) (if (or (< (window-height old-win) (+ height 6)) (< (window-width old-win) (+ width 15)) full-display) (delete-other-windows old-win)) (if (< (window-height old-win) (+ height 4)) (error "Screen is not tall enough for this mode")) (if full-display (progn (setq win (split-window old-win (- (window-height old-win) height 1))) (set-window-buffer old-win (calc-trail-buffer)) (set-window-buffer win calc-keypad-buffer) (set-window-start win 1) (setq win (split-window win (+ width 3) t)) (set-window-buffer win calcbuf)) (if (or t ; left-side keypad not yet fully implemented (< (save-excursion (set-buffer (window-buffer old-win)) (current-column)) (/ (window-width) 2))) (setq win (split-window old-win (- (window-width old-win) width 2) t)) (setq old-win (split-window old-win (+ width 2) t))) (set-window-buffer win calc-keypad-buffer) (set-window-start win 1) (split-window win (- (window-height win) height 1)) (set-window-buffer win calcbuf)) (select-window old-win) (if (and (eq window-system 'x) (not calc-keypad-prev-x-left-click)) (progn (setq calc-keypad-prev-x-right-click (aref mouse-map 0) calc-keypad-prev-x-middle-click (aref mouse-map 1) calc-keypad-prev-x-left-click (aref mouse-map 2)) (aset mouse-map 0 'calc-keypad-x-right-click) (aset mouse-map 1 'calc-keypad-x-middle-click) (aset mouse-map 2 'calc-keypad-x-left-click))) (message "Welcome to GNU Emacs Calc! Use the left and right mouse buttons.") (run-hooks 'calc-keypad-start-hook) (and calc-keypad-said-hello interactive (progn (sit-for 2) (message ""))) (setq calc-keypad-said-hello t)))) (setq calc-keypad-input nil) ) (defun calc-keypad-off () (interactive) (if calc-standalone-flag (save-buffers-kill-emacs nil) (calc-keypad)) ) (defun calc-keypad-redraw () (set-buffer calc-keypad-buffer) (setq buffer-read-only t) (setq calc-keypad-full-layout (append (symbol-value (nth calc-keypad-menu calc-keypad-menus)) calc-keypad-layout)) (let ((buffer-read-only nil) (row calc-keypad-full-layout) (y 0)) (erase-buffer) (insert "\n") (while row (let ((col (car row))) (while col (let* ((key (car col)) (cwid (if (>= y 4) 5 (if (and (= y 3) (eq col (car row))) (progn (setq col (cdr col)) 9) 4))) (name (if (and calc-standalone-flag (eq (nth 1 key) 'calc-keypad-off)) "EXIT" (if (> (length (car key)) cwid) (substring (car key) 0 cwid) (car key)))) (wid (length name)) (pad (- cwid (/ wid 2)))) (insert (make-string (/ (- cwid wid) 2) 32) name (make-string (/ (- cwid wid -1) 2) 32) (if (equal name "MENU") (int-to-string (1+ calc-keypad-menu)) "|"))) (or (setq col (cdr col)) (insert "\n"))) (insert (if (>= y 4) "-----+-----+-----+-----+-----" (if (= y 3) "-----+---+-+--+--+-+---++----" "----+----+----+----+----+----")) (if (= y 7) "+\n" "|\n")) (setq y (1+ y) row (cdr row))))) (setq calc-keypad-prev-input t) (calc-keypad-show-input) (goto-char (point-min)) ) (defun calc-keypad-show-input () (or (equal calc-keypad-input calc-keypad-prev-input) (let ((buffer-read-only nil)) (save-excursion (goto-char (point-min)) (forward-line 1) (delete-region (point-min) (point)) (if calc-keypad-input (insert "Calc: " calc-keypad-input "\n") (insert "----+-----Calc " calc-version "-----+----" (int-to-string (1+ calc-keypad-menu)) "\n"))))) (setq calc-keypad-prev-input calc-keypad-input) ) (defun calc-keypad-press () (interactive) (or (eq major-mode 'calc-keypad) (error "Must be in *Calc Keypad* buffer for this command")) (let* ((row (save-excursion (beginning-of-line) (count-lines (point-min) (point)))) (y (/ row 2)) (x (/ (current-column) (if (>= y 4) 6 5))) radix frac inv (hyp (save-excursion (set-buffer calc-main-buffer) (setq radix calc-number-radix frac calc-prefer-frac inv calc-inverse-flag) calc-hyperbolic-flag)) (invhyp t) (menu (symbol-value (nth calc-keypad-menu calc-keypad-menus))) (input calc-keypad-input) (iexpon (and input (or (string-match "\\*[0-9]+\\.\\^" input) (and (<= radix 14) (string-match "e" input))) (match-end 0))) (key (nth x (nth y calc-keypad-full-layout))) (cmd (or (nth (if inv (if hyp 4 2) (if hyp 3 99)) key) (setq invhyp nil) (nth 1 key))) (isstring (and (consp cmd) (stringp (car cmd)))) (calc-is-keypad-press t)) (if invhyp (calc-wrapper)) ; clear Inv and Hyp flags (unwind-protect (cond ((or (null cmd) (= (% row 2) 0)) (beep)) ((and (> (minibuffer-depth) 0)) (cond (isstring (setq unread-command-char (aref (car cmd) 0))) ((eq cmd 'calc-pop) (setq unread-command-char ?\177)) ((eq cmd 'calc-enter) (setq unread-command-char 13)) ((eq cmd 'calc-undo) (setq unread-command-char 7)) (t (beep)))) ((and input (string-match "STO\\|RCL" input)) (cond ((and isstring (string-match "[0-9]" (car cmd))) (setq calc-keypad-input nil) (let ((var (intern (concat "var-q" (car cmd))))) (cond ((equal input "STO+") (calc-store-plus var)) ((equal input "STO-") (calc-store-minus var)) ((equal input "STO*") (calc-store-times var)) ((equal input "STO/") (calc-store-div var)) ((equal input "STO^") (calc-store-power var)) ((equal input "STOn") (calc-store-neg 1 var)) ((equal input "STO&") (calc-store-inv 1 var)) ((equal input "STO") (calc-store-into var)) (t (calc-recall var))))) ((memq cmd '(calc-pop calc-undo)) (setq calc-keypad-input nil)) ((and (equal input "STO") (setq frac (assq cmd '( ( calc-plus . "+" ) ( calc-minus . "-" ) ( calc-times . "*" ) ( calc-divide . "/" ) ( calc-power . "^") ( calc-change-sign . "n") ( calc-inv . "&") )))) (setq calc-keypad-input (concat input (cdr frac)))) (t (beep)))) (isstring (setq cmd (car cmd)) (if (or (and (equal cmd ".") input (string-match "[.:e^]" input)) (and (equal cmd "e") input (or (and (<= radix 14) (string-match "e" input)) (string-match "\\^\\|[-.:]\\'" input))) (and (not (equal cmd ".")) (let ((case-fold-search nil)) (string-match cmd "0123456789ABCDEF" (if (string-match "[e^]" (or input "")) 10 radix))))) (beep) (setq calc-keypad-input (concat (and (/= radix 10) (or (not input) (equal input "-")) (format "%d#" radix)) (and (or (not input) (equal input "-")) (or (and (equal cmd "e") "1") (and (equal cmd ".") (if frac "1" "0")))) input (if (and (equal cmd ".") frac) ":" (if (and (equal cmd "e") (or (not input) (string-match "#" input)) (> radix 14)) (format "*%d.^" radix) cmd)))))) ((and (eq cmd 'calc-change-sign) input) (let* ((epos (or iexpon 0)) (suffix (substring input epos))) (setq calc-keypad-input (concat (substring input 0 epos) (if (string-match "\\`-" suffix) (substring suffix 1) (concat "-" suffix)))))) ((and (eq cmd 'calc-pop) input) (if (equal input "") (beep) (setq calc-keypad-input (substring input 0 (or (string-match "\\*[0-9]+\\.\\^\\'" input) -1))))) ((and (eq cmd 'calc-undo) input) (setq calc-keypad-input nil)) (t (if input (let ((val (math-read-number input))) (setq calc-keypad-input nil) (if val (calc-wrapper (calc-push-list (list (calc-record (calc-normalize val))))) (or (equal input "") (beep)) (setq cmd nil)) (if (eq cmd 'calc-enter) (setq cmd nil)))) (setq prefix-arg current-prefix-arg) (if cmd (if (and (consp cmd) (eq (car cmd) 'progn)) (while (setq cmd (cdr cmd)) (if (integerp (car cmd)) (setq prefix-arg (car cmd)) (command-execute (car cmd)))) (command-execute cmd))))) (set-buffer calc-keypad-buffer) (calc-keypad-show-input))) ) (defun calc-keypad-x-left-click (arg) "Handle a left-button mouse click in Calc Keypad window." (let (coords) (if (and calc-keypad-buffer (buffer-name calc-keypad-buffer) (get-buffer-window calc-keypad-buffer) (setq coords (coordinates-in-window-p arg (get-buffer-window calc-keypad-buffer)))) (let ((win (selected-window))) (unwind-protect (progn (x-mouse-set-point arg) (calc-keypad-press)) (and (window-point win) (select-window win)))) (funcall calc-keypad-prev-x-left-click arg))) ) (defun calc-keypad-x-right-click (arg) "Handle a right-button mouse click in Calc Keypad window." (if (and calc-keypad-buffer (buffer-name calc-keypad-buffer) (get-buffer-window calc-keypad-buffer) (coordinates-in-window-p arg (get-buffer-window calc-keypad-buffer))) (save-excursion (set-buffer calc-keypad-buffer) (calc-keypad-menu)) (funcall calc-keypad-prev-x-right-click arg)) ) (defun calc-keypad-x-middle-click (arg) "Handle a middle-button mouse click in Calc Keypad window." (if (and calc-keypad-buffer (buffer-name calc-keypad-buffer) (get-buffer-window calc-keypad-buffer) (coordinates-in-window-p arg (get-buffer-window calc-keypad-buffer))) (save-excursion (set-buffer calc-keypad-buffer) (calc-keypad-menu-back)) (funcall calc-keypad-prev-x-middle-click arg)) ) (defun calc-keypad-menu () (interactive) (or (eq major-mode 'calc-keypad) (error "Must be in *Calc Keypad* buffer for this command")) (while (progn (setq calc-keypad-menu (% (1+ calc-keypad-menu) (length calc-keypad-menus))) (not (symbol-value (nth calc-keypad-menu calc-keypad-menus))))) (calc-keypad-redraw) ) (defun calc-keypad-menu-back () (interactive) (or (eq major-mode 'calc-keypad) (error "Must be in *Calc Keypad* buffer for this command")) (while (progn (setq calc-keypad-menu (% (1- (+ calc-keypad-menu (length calc-keypad-menus))) (length calc-keypad-menus))) (not (symbol-value (nth calc-keypad-menu calc-keypad-menus))))) (calc-keypad-redraw) ) (defun calc-keypad-store () (interactive) (setq calc-keypad-input "STO") ) (defun calc-keypad-recall () (interactive) (setq calc-keypad-input "RCL") ) (defun calc-pack-interval (mode) (interactive "p") (if (or (< mode 0) (> mode 3)) (error "Open/close code should be in the range from 0 to 3.")) (calc-pack (- -6 mode)) ) (defun calc-keypad-execute () (interactive) (let* ((prompt "Calc keystrokes: ") (flush 'x-flush-mouse-queue) (prefix nil) keys cmd) (save-excursion (calc-select-buffer) (while (progn (setq keys (read-key-sequence prompt)) (setq cmd (key-binding keys)) (if (or (memq cmd '(calc-inverse calc-hyperbolic universal-argument digit-argument negative-argument)) (and prefix (string-match "\\`\e?[-0-9]\\'" keys))) (progn (setq last-command-char (aref keys (1- (length keys)))) (command-execute cmd) (setq flush 'not-any-more prefix t prompt (concat prompt (key-description keys) " "))) (eq cmd flush))))) ; skip mouse-up event (message "") (if (commandp cmd) (command-execute cmd) (error "Not a Calc command: %s" (key-description keys)))) ) ;;; |----+----+----+----+----+----| ;;; | ENTER |+/- |EEX |UNDO| <- | ;;; |-----+---+-+--+--+-+---++----| ;;; | INV | 7 | 8 | 9 | / | ;;; |-----+-----+-----+-----+-----| ;;; | HYP | 4 | 5 | 6 | * | ;;; |-----+-----+-----+-----+-----| ;;; |EXEC | 1 | 2 | 3 | - | ;;; |-----+-----+-----+-----+-----| ;;; | OFF | 0 | . | PI | + | ;;; |-----+-----+-----+-----+-----| (defvar calc-keypad-layout '( ( ( "ENTER" calc-enter calc-roll-down calc-roll-up calc-over ) ( "ENTER" calc-enter calc-roll-down calc-roll-up calc-over ) ( "+/-" calc-change-sign calc-inv (progn -4 calc-pack) ) ( "EEX" ("e") (progn calc-num-prefix calc-pack-interval) (progn -5 calc-pack) ) ( "UNDO" calc-undo calc-redo calc-last-args ) ( "<-" calc-pop (progn 0 calc-pop) (progn calc-num-prefix calc-pop) ) ) ( ( "INV" calc-inverse ) ( "7" ("7") calc-round ) ( "8" ("8") (progn 2 calc-clean-num) ) ( "9" ("9") calc-float ) ( "/" calc-divide (progn calc-inverse calc-power) ) ) ( ( "HYP" calc-hyperbolic ) ( "4" ("4") calc-ln calc-log10 ) ( "5" ("5") calc-exp calc-exp10 ) ( "6" ("6") calc-abs ) ( "*" calc-times calc-power ) ) ( ( "EXEC" calc-keypad-execute ) ( "1" ("1") calc-arcsin calc-sin ) ( "2" ("2") calc-arccos calc-cos ) ( "3" ("3") calc-arctan calc-tan ) ( "-" calc-minus calc-conj ) ) ( ( "OFF" calc-keypad-off ) ( "0" ("0") calc-imaginary ) ( "." (".") calc-precision ) ( "PI" calc-pi ) ( "+" calc-plus calc-sqrt ) ) ) ) (defvar calc-keypad-menus '( calc-keypad-math-menu calc-keypad-funcs-menu calc-keypad-binary-menu calc-keypad-vector-menu calc-keypad-modes-menu calc-keypad-user-menu ) ) ;;; |----+----+----+----+----+----| ;;; |FLR |CEIL|RND |TRNC|CLN2|FLT | ;;; |----+----+----+----+----+----| ;;; | LN |EXP | |ABS |IDIV|MOD | ;;; |----+----+----+----+----+----| ;;; |SIN |COS |TAN |SQRT|y^x |1/x | (defvar calc-keypad-math-menu '( ( ( "FLR" calc-floor ) ( "CEIL" calc-ceiling ) ( "RND" calc-round ) ( "TRNC" calc-trunc ) ( "CLN2" (progn 2 calc-clean-num) ) ( "FLT" calc-float ) ) ( ( "LN" calc-ln ) ( "EXP" calc-exp ) ( "" nil ) ( "ABS" calc-abs ) ( "IDIV" calc-idiv ) ( "MOD" calc-mod ) ) ( ( "SIN" calc-sin ) ( "COS" calc-cos ) ( "TAN" calc-tan ) ( "SQRT" calc-sqrt ) ( "y^x" calc-power ) ( "1/x" calc-inv ) ) ) ) ;;; |----+----+----+----+----+----| ;;; |IGAM|BETA|IBET|ERF |BESJ|BESY| ;;; |----+----+----+----+----+----| ;;; |IMAG|CONJ| RE |ATN2|RAND|RAGN| ;;; |----+----+----+----+----+----| ;;; |GCD |FACT|DFCT|BNOM|PERM|NXTP| (defvar calc-keypad-funcs-menu '( ( ( "IGAM" calc-inc-gamma ) ( "BETA" calc-beta ) ( "IBET" calc-inc-beta ) ( "ERF" calc-erf ) ( "BESJ" calc-bessel-J ) ( "BESY" calc-bessel-Y ) ) ( ( "IMAG" calc-imaginary ) ( "CONJ" calc-conj ) ( "RE" calc-re calc-im ) ( "ATN2" calc-arctan2 ) ( "RAND" calc-random ) ( "RAGN" calc-random-again ) ) ( ( "GCD" calc-gcd calc-lcm ) ( "FACT" calc-factorial calc-gamma ) ( "DFCT" calc-double-factorial ) ( "BNOM" calc-choose ) ( "PERM" calc-perm ) ( "NXTP" calc-next-prime calc-prev-prime ) ) ) ) ;;; |----+----+----+----+----+----| ;;; |AND | OR |XOR |NOT |LSH |RSH | ;;; |----+----+----+----+----+----| ;;; |DEC |HEX |OCT |BIN |WSIZ|ARSH| ;;; |----+----+----+----+----+----| ;;; | A | B | C | D | E | F | (defvar calc-keypad-binary-menu '( ( ( "AND" calc-and calc-diff ) ( "OR" calc-or ) ( "XOR" calc-xor ) ( "NOT" calc-not calc-clip ) ( "LSH" calc-lshift-binary calc-rotate-binary ) ( "RSH" calc-rshift-binary ) ) ( ( "DEC" calc-decimal-radix ) ( "HEX" calc-hex-radix ) ( "OCT" calc-octal-radix ) ( "BIN" calc-binary-radix ) ( "WSIZ" calc-word-size ) ( "ARSH" calc-rshift-arith ) ) ( ( "A" ("A") ) ( "B" ("B") ) ( "C" ("C") ) ( "D" ("D") ) ( "E" ("E") ) ( "F" ("F") ) ) ) ) ;;; |----+----+----+----+----+----| ;;; |SUM |PROD|MAX |MAP*|MAP^|MAP$| ;;; |----+----+----+----+----+----| ;;; |INV |DET |TRN |IDNT|CRSS|"x" | ;;; |----+----+----+----+----+----| ;;; |PACK|UNPK|INDX|BLD |LEN |... | (defvar calc-keypad-vector-menu '( ( ( "SUM" calc-vector-sum calc-vector-alt-sum calc-vector-mean ) ( "PROD" calc-vector-product nil calc-vector-sdev ) ( "MAX" calc-vector-max calc-vector-min calc-vector-median ) ( "MAP*" (lambda () (interactive) (calc-map '(2 calcFunc-mul "*"))) ) ( "MAP^" (lambda () (interactive) (calc-map '(2 calcFunc-pow "^"))) ) ( "MAP$" calc-map-stack ) ) ( ( "MINV" calc-inv ) ( "MDET" calc-mdet ) ( "MTRN" calc-transpose calc-conj-transpose ) ( "IDNT" (progn calc-num-prefix calc-ident) ) ( "CRSS" calc-cross ) ( "\"x\"" "\excalc-algebraic-entry\rx\r" "\excalc-algebraic-entry\ry\r" "\excalc-algebraic-entry\rz\r" "\excalc-algebraic-entry\rt\r") ) ( ( "PACK" calc-pack ) ( "UNPK" calc-unpack ) ( "INDX" (progn calc-num-prefix calc-index) "\C-u\excalc-index\r" ) ( "BLD" (progn calc-num-prefix calc-build-vector) ) ( "LEN" calc-vlength ) ( "..." calc-full-vectors ) ) ) ) ;;; |----+----+----+----+----+----| ;;; |FLT |FIX |SCI |ENG |GRP | | ;;; |----+----+----+----+----+----| ;;; |RAD |DEG |FRAC|POLR|SYMB|PREC| ;;; |----+----+----+----+----+----| ;;; |SWAP|RLL3|RLL4|OVER|STO |RCL | (defvar calc-keypad-modes-menu '( ( ( "FLT" calc-normal-notation (progn calc-num-prefix calc-normal-notation) ) ( "FIX" (progn 2 calc-fix-notation) (progn calc-num-prefix calc-fix-notation) ) ( "SCI" calc-sci-notation (progn calc-num-prefix calc-sci-notation) ) ( "ENG" calc-eng-notation (progn calc-num-prefix calc-eng-notation) ) ( "GRP" calc-group-digits "\C-u-3\excalc-group-digits\r" ) ( "" nil ) ) ( ( "RAD" calc-radians-mode ) ( "DEG" calc-degrees-mode ) ( "FRAC" calc-frac-mode ) ( "POLR" calc-polar-mode ) ( "SYMB" calc-symbolic-mode ) ( "PREC" calc-precision ) ) ( ( "SWAP" calc-roll-down ) ( "RLL3" (progn 3 calc-roll-up) (progn 3 calc-roll-down) ) ( "RLL4" (progn 4 calc-roll-up) (progn 4 calc-roll-down) ) ( "OVER" calc-over ) ( "STO" calc-keypad-store ) ( "RCL" calc-keypad-recall ) ) ) ) calc-2.02c/README.prev100644 22403 13 74404 5144465773 12721 0ustar daveguser Summary of changes to "Calc" Preceding 2.00 ------- -- ------- -- ---- --------- ---- Version 2.00: * Changed to compile calc-macs/-maint, to allow "cp *.elc new-dir". * Improved calc-describe-bindings to avoid showing redundant ESC maps. Version 2.00 beta 3: * Removed version numbers from most .el files to reduce size of patches. * Added a "calc-version" command. * Changed `M-# ? ?' to allow for modified describe-function. * Changed date parser to accept "Sept" as an alternative for "Sep". * Inhibited answers to exercise from showing up in table of contents. * Changed Makefile to say "texindex calc.[cfkptv]?" to avoid "calc.el". * Fixed up the Makefile in various other ways. * Rearranged banner at top of `h h' command's output. * Changed "make summary" to print "Calc Summary" on the title page. * Added "IntegSimpRules". * Added `M-# :', `M-# _', and `M-# Z' options. * Changed `^' to evaluate "[-3..-1]^-2" properly. * Improved `f g' to give symbolic answers for, e.g., 101:2 and -3:2. * Fixed a bug where `h k RET' didn't find the right place on the page. * Fixed a bug that formatted "x*(y ? a : b)" as "x y ? a : b". * Fixed a bug where defmath translated (< x 0) as (math-posp x)! * Fixed a bug that prevented quick-calc from working sometimes. * Fixed the `z ?' bug again (maybe this time for good?). * Fixed a bug in which `V ^' (vint) was just plain wrong, wrong, wrong! * Scanned for and fixed remaining bugs relating to autoloading. Version 2.00 beta 2: * Changed "make info" to try "make texinfo" if "makeinfo" not found. * Changed to "New for Calc 2.00"; texinfo.tex chokes on apostrophes. * Added List Tutorial Exercise 14 (just in case there weren't enough!). * Added a discussion of the `Z F' command to the Programming Tutorial. * Improved `H a f' not to lose info if input is partially pre-factored. * Improved simplification of expressions like sqrt(3) + 3^3:2. * Changed Big mode to omit "*" in expressions like 2 sqrt(3) 5^3:4. * Replaced European date format D/M/Y with D.M.Y. * Changed `a N' and `a X' to consider the endpoints of the interval. * Fixed a bug where TeX mode made c*(1+a/b) look like a function call. * Fixed a bug formatting top-level evalto's while using selections. * Fixed a bug that caused `z ?' to crash. * Fixed a bug where `Z F' broke for argument names "t" and "nil". * Fixed several bugs relating to autoloading. Version 2.00 beta 1: * Added "What's new in Calc 2.00" to the manual (summary of info below). * Added support for many GNUPLOT 3.0 features. * Tweaked the Makefile and calc-compile a bit more. * Modified to work with Zawinski's/Furuseth's optimizing byte compiler. * Modified Calc to garbage-collect less often (raised gc-cons-threshold). * Changed quick-calc to avoid autoloading so many parts of Calc. * Changed Calc subfiles to work properly if not byte-compiled. * Renamed `M-# s' to `M-# j', made `M-# s' be equivalent to `h s'. * Changed calc-quit to avoid reapportioning space among other windows. * Added `M-DEL' (calc-pop-above) key, to DEL as LFD is to RET. * Added `{' and `}' to scroll vertically, analogous to `<' and `>'. * Added `m t' for "total" algebraic mode. * Added `d , \' option to group digits with "\,". * Improved support of "prime" accent in "eqn" language mode. * Changed macedit's read-kbd-macro to accept a string argument in Lisp. * Changed calc-check-defines to use a more concise run-hooks linkage. * Changed auto-why mode not to say [w=more] if next msg is not urgent. * Made `a d' able to differentiate "a?b:c" and "a_i" formulas. * Changed probability dist. functions to work with `a f' and `a d'. * Added special constants "phi" and "gamma". * Added "poly" function, simpler cousin of "gpoly". * Added "pdeg", "plead", "pcont", "pprim"; cleaned up "pdiv" and "pgcd". * Added `a p' command for polynomial interpolation. * Added `a I' command for numerical integration; made IntegLimit variable. * Added `a f' to factor polynomials; moved old `a f' to `a "'. * Added `a a' to do partial fraction decompositions. * Improved `a i' to integrate many more kinds of formulas. * Modified `a P' to find numerical roots of high-degree polynomials. * Modified `c 0' through `c 9' to convert int-valued floats to integers. * Made sinh, arctanh, etc., expandable into exps/logs by `a f'. * Added more algebraic simplifications having to do with logs and exps. * Changed `s s', `s t', `s x', `s l' to accept an equation at prompt. * Changed `s i' not to store Decls if its value is the default, []. * Changed `s i' to store in `d O' language mode if in Normal or Big mode. * Rearranged `V M'/`V R' matrix mapping modes. * Added <#1+#2> notation for lambda expressions. * Extended `b l' and other binary shifts to have a 2-argument version. * Changed `u c' and `u t' to give unitless result for unitless input. * Changed sqrt(1-cos(x)^2)-to-sin(x) to be an unsafe simplification. * Improved simplification of sqrts, e.g., sqrt(a^2 x + a^2 y). * Changed solver to treat (x-a)(x-b)(x-c) more intelligently. * Changed Pascal language mode to use "$FFFF" for hexadecimal numbers. * Added support for non-decimal display of floats. * Changed `p' to refresh stack display if current float format uses it. * Changed Big mode to use subscript notation for log10(x), log(x,b), r#nnn. * Changed Big mode to format deriv(u,x) and tderiv(u,x) as du/dx. * Changed Big mode to format integ(1/x,x) as "dx/x" instead of "1/x dx". * Added "tty" output type for graphics commands. * Documented Calc's random number generation algorithm in the manual. * Fixed a bug involving having "(setq calc-timing t)" in .emacs. * Fixed a bug that incorrectly parsed "|x| - 1" in TeX mode. * Fixed bugs and made improvements in `a R' when widening the guess. * Fixed a bug that where `a S' didn't solve (x - a)^2 = (x - b)^2. * Fixed a bug that sometimes crashed `a P' on systems of equations. * Fixed a bug that prevented `b p' (calc-pack-bits) from working. * Fixed some bugs in which certain functions didn't get autoloaded. * Fixed a bug in which the date <1/1/13> was incorrectly parsed. * Fixed a bug which prevented `j D' from expanding (a+b)/c. * Fixed a bug in solver: bad inverses for sinh and cosh. * Fixed a bug in math-possible-signs that failed for x*0. * Fixed a bug where sqrt(-a) was rewritten sqrt(a)*i even if a<0. * Fixed a bug in line breaker when first "word" of line was too long. * Worked around a makeinfo bug that handled @end group/@group badly. Version 2.00 alpha 3: * Changed logic for locating component .elc files to be even smarter. * Changed "make install" to "make compile"; added different "make install". * Improved "make compile" to check file dates and compile only when needed. * Made output of "make compile" in batch mode more compact and readable. * Replaced "Quick Overview" in manual with "Demonstration of Calc". * Changed to use keymaps for dispatching M-# and h prefix keys. * Added TAGS target to the Calc Makefile. * Removed most doc strings from functions; new help commands are better. * Got rid of some crufty "fset" calls that were cluttering the code. * Split calc-grab-region into two functions, calc-grab-region/-rectangle. * Swapped positions of stack and trail in full-calc-keypad display. * Improved line-breaking algorithm for displaying long formulas. * Improved display of control characters in vectors shown as strings. * Changed `d o' to allow fraction format to specify desired denominator. * Changed `M-# y' to respect overwrite mode in target buffer. * Added `H' prefix to display-mode commands to suppress stack refresh. * Changed "calc-why" mechanism to display urgent messages automatically. * Handled taking derivatives of symbolic integrals and vice-versa. * Handled integrating vectors of formulas. * Incorporated Ewerlid's polynomial division and GCD functions into Calc. * Improved algebraic operations on "mod" forms, esp. polynomials. * Added some more financial functions (sln, syd, ddb). * Added nest, anest, fixp, and afixp (`H V R' and `H V U') functions. * Added `a .' (calc-remove-equal) command to take apart equations. * Generalized dfact to work for negative odd integers; added !! syntax. * Changed `k f' to factor 1, 0, and negative integers. * Changed `u M', etc., to accept +/- and [ .. ] forms as distributions. * Changed `g q' to remove *Gnuplot Commands/Trail* window if present. * Added support for Francois Pinard's "dumb terminal" driver for GNUPLOT. * Added ":: remember" feature for rewrite rules. * Changed rewrites to let pattern "a*b" match "x/2" with a=x, b=1/2. * Added ability to put function names like "simplify" in rewrite schedule. * Added "Rewrites Tutorial" to the manual. * Changed ` to bind RET as newline instead of finish if editing a vector. * Added some new exercises to the List Tutorial. * Changed `Z F', `V M', etc. not to remove stored vars from def arg list. * Added parsing for /1, 2, 3/ notation for Fortran mode vectors. * Added a "%%" syntax for comments in formulas being read. * Fixed a bug in which failing `h k' removed an existing Info window. * Fixed a bug in `j /' operating on subformulas like "a + b". * Fixed a bug in which "inf = inf" undesirably evaluated to 1. * Fixed a bug that simplified "0 = 1 + a + 2" to "0 = a". * Fixed a bug that failed for rewrite patterns like "fib(1 ||| 2)". * Fixed a bug that arose because rewrite programs are non-reentrant. Version 2.00 alpha 2: * Changed LFD terminating algebraic entry to push in no-simplify mode. * Changed so that `K -' interprets `-' as calc-minus, not neg prefix arg. * Improved `h c' command to understand all Calc key sequences. * Fixed problems with DistribRules, NegateRules, and FitRules. * Fixed several bad node pointers in the manual. * Fixed a bug in `h C-w' when used with makeinfo-formatted manuals. * Fixed a bug in sqrt(-1) when Polar and HMS modes are enabled. * Fixed/improved dscalar and deven functions; added dodd. * Fixed a bug in polynomial handling that also affected sum(sin(k),k,1,n). * Fixed various other glitches in the manual. Version 2.00 alpha 1: * Calc's tar file now creates a calc-(version) directory to unpack into. * Calc now comes with a Makefile; install with "make install". * Calc now comes already split into many files; installation is much simpler. * Changed base file name of the manual from "calc-info" to "calc.info". * Key binding for `M-# w' was documented but not implemented. * Bound M-# ' to be synonymous with `M-# f' (used to be `M-# q'). * Changed M-# M-# to use last interface of C or K; E no longer counts. * Changed `i' (and `M-# i') not to return to Top node unnecessarily. * Changed `h' to be a prefix key with various help commands. * Changed `s' to be a prefix key with various store and recall commands. * Keys `i', `r', and `l' are obsolete (moved to `h' and `s' prefixes). * Rearranged `K', `X', and `M-RET' keys; `K' is now calc-keep-args. * Changed quick-calc to display input formula as well as output if room. * Changed quick-calc to interact with the editing buffer and kill ring. * Created pack, unpack, unpackt function equivalents of `v p', `v u'. * Changed to expand (a/b)^x to a^x/b^x only if b > 0 (not if a > 0). * Changed math-possible-signs to understand sqrt function. * Changed Z [, rewrites to consider any provably non-zero value as true. * Changed normal language modes to accept ** as a synonym for ^. * Added "maple" language mode. * Changed, e.g., Mathematica "(2 + 3 I)^(1.23*10^20)" to include parens. * Generalized math-compose-big properties for all language modes. * Introduced "string" and other function for composing expressions. * Changed many recursive vector routines to use loops instead. * Added evalv, evalvn function equivalents to `=', `N'. * Changed "expr =>" not to evaluate at all if in no-simplify mode. * Redesigned user interface of `a F' (calc-curve-fit) command. * Added "phase" feature to the rewrite rule system. * Added "&&&", "|||", "!!!" to the rewrite rule system. * Introduced a new notation for rewrites: LHS := RHS :: COND. * Changed `a r' (but not `j r') to repeat 100 times by default. * Integrated EvalRules more cleanly into the default simplifications. * Added `H v l' [mdims] to measure the dimensions of a matrix. * Changed `u c' to interpret "/units" as "1/units". * Added `u a' to adjust unit prefix letters automatically. * Changed `u s' to enable scalar mode while simplifying. * Changed `c f' [pfloat] not to float integer powers or subscripts. * Added a three-argument form for the "hms" function. * Changed, e.g., sin(90) degrees to produce 1 instead of 1.0. * Changed symbolic mode to prefer sqrt(int): abs([1 2 3]) => sqrt(14). * Enhanced solver to handle, e.g., x + 1/x = a; exp(x) + exp(-x) = a. * Enhanced simplifier to handle, e.g., exp(a+2) / e^a => e^2. * Enhanced `a s' to simplify sqrt(x) - x^1:2 and exp(x) - e^x to 0. * Added -(a + b) to -a - b as a default simplification. * Added rules for differentiating sum() and prod() functions. * Added a few more energy units (due to Przemek Klosowski). * Added overflow/underflow checking for all floating-point arithmetic. * Extended error forms to work with complex numbers. * Generalized GCD to handle fractional arguments. * Changed graphics routines to evaluate "x" values, e.g., [-pi .. pi]. * Added `g q', like `g K' but without viewing the Gnuplot Trail. * Changed `g p' and `V M' to display better "Working..." messages. * Modified `M-# g' to be more robust about grabbing formulas. * Added `Y' prefix key reserved for user-written extensions. * Added calc-load-hook and calc-ext-load-hook. * Prevented calc-install from leaving large ~ files behind. * Changed @bullet to @bullet{} in manual to conform to texinfo spec. * Rearranged some chapters in the manual to be a bit more logical. * Added calc-split-summary command. * Fixed several bugs in embedded mode. * Fixed a bug in calc-vector-covariance that required a prefix arg. * Fixed a bug that prevented parsing "a=>" with no right-hand side. * Fixed a bug which allowed incorrectly dividing a vector by a vector. * Fixed a bug formatting sum(...)^2 in Big mode. * Fixed a bug that prevented Calc from deleting old graphics temp files. * Fixed some typos calling calc-inverse-func instead of calc-invert-func. * Fixed bugs in the derivatives of conj, deg, and rad; added re, im. * Fixed a bug where (r;theta) parsed as r exp(theta i) even in Deg mode. * Fixed a bug which gave wrong answer for exp of a polar complex number. * Fixed a bug in `Z F' that failed if formula used non-arg variables. * Fixed a bad pointer to Info node "Assignments in Embedded Mode". * Fixed several errors in the Calc Summary. Version 1.08 beta 1: * Calc's copyright has been assigned to FSF, for inclusion in Emacs 19! * Changed M-# to be a two-key sequence; use M-# M-# to start Calc now. * Rewrote and expanded the introductory chapter of the manual. * Added a key and function summary to the manual. * Changed the manual to take better advantage of TeX's math formatting. * Changed manual to be printable in @smallbook format. * Added "calc-embedded" mode. * Added "=>" [evalto] operator. * Added facilities for date and date/time arithmetic. * Added a set of financial functions (pv, fv, etc.). * Added infinite quantities inf, uinf, and nan (plus infinite intervals). * Added "EvalRules", "SimpRules", and "ExtSimpRules" variables. * Added sum and product commands `a +', `a -', `a *', `a T'. * Enhanced `a S' and `a P' to solve systems of equations. * Enhanced solver to handle eqns like sin(x) = cos(2 x), sqrt(x) + x = 1. * Added `a M' (calc-map-equation) command. * Added new statistical functions: mean, standard deviation, etc. * Added line, polynomial, and curve fitting commands (`a L' and `a F'). * Added support for composite units, e.g., "mi+ft+in". * Enhanced "Big" mode to format square roots, choose, and powers better. * Enhanced "Big" mode to display fractions in large notation. * Added several alternate formats for matrix display. * Changed TeX mode to write "(1 + x^2)" instead of "\left(1 + x^2\right)". * Added support for relational operators in TeX and FORTRAN modes. * Added recognition of accents like \dot, \tilde, \underline in TeX mode. * Added "eqn" language mode. * Added extra control over display justification with `d <', `d =', `d >'. * Added calc-left-label and calc-right-label (`d {', `d }'). * Added "nn%" syntax for algebraic formulas; equivalent to "nn * .01". * Added input syntaxes like a = b = c, a != b != c, a <= b < c. * Changed "_" to mean subscripts; old use of "_" in vars is now "#". * Introduced "matrix mode" and "scalar mode" (`m v'). * Introduced generic identity matrices (idn(1)). * Added a method for declaring variables to be real, integer, > 0, etc. * Added `Z S' command for editing stored value of a variable. * Added "subst" algebraic function equivalent to the `a b' command. * Added `a f' command, changed deriv/integ/solve-for to use it. * Improved `a s' to simplify (x + y) (y + x) to (x + y)^2. * Improved `a s' to simplify i^2 to -1. * Improved `a s' to simplify, e.g., sin(pi/3) in Symbolic mode. * Improved `a s' to simplify sqrt(8) to 2 sqrt(2), 1/sqrt(2) to sqrt(2)/2. * Moved sin(arccos(x)) from `a e' to `a s'; not unsafe after all! * Changed (x y)^z => x^z y^z to be a usually-unsafe simplification. * Added thorough documentation of `a s' and `a e' to the manual. * Improved `a c' to collect "f(a)" even if "a" also appears elsewhere. * Introduced lin, linnt, islin, islinnt functions for linearity testing. * Improved `a x' to use binomial theorem to give simpler answers. * Improved `j D' to distribute powers of sums: (a + b)^n. * Improved `j M' to merge products of powers (may need no-simplify mode). * Changed to use defvar for DistribRules etc. so `Z V' works with them. * Improved `j *' and `j /' to work properly in a few more cases. * Improved `V R' to use identity value when reducing empty vectors. * Improved `v p' and `v u' to support more complex packing operations. * Disabled automatic simplification of sqrt(2)/2 to 1/sqrt(2). * Bound SPC and RET to press, TAB to next-menu in *Calc Keypad* buffer. * Added C-u ' to do algebraic entry with language mode forced to normal. * Added "$1", "$2", etc. input notation for algebraic entry. * Changed unary operators like `n', `&' to treat neg prefix args like RET. * Changed ` (calc-edit) to show full precision regardless of float format. * Enhanced quick-calc to display integers in several formats. * Documented `g H' (calc-graph-hide) command (had been left from manual). * Enhanced floor/ceil/trunc/round in several ways. * Added rounde and roundu functions. * Changed `c 1' through `c 9' to change small floats to 0.0; added `c 0'. * Enhanced set operations to work on sets of intervals. * Fixed erf(0), utpn(x,x,y), and arccosh(-1) to work properly. * Changed complex arctan and arctanh to follow Steele 2nd edition. * Expanded "Branch Cuts" section of the manual with some useful tables. * Rearranged order of words in mode line to be a bit more logical. * Changed `m N' (num-simplify) mode to evaluate constant vectors, too. * Changed `a r'/`j r' to prompt twice for separate LHS/RHS if necessary. * Enhanced `let(v,x)' in rewrites by allowing arbitrary patterns for v. * Changed cursor positioning in second prompt for `a b' (calc-substitute). * Changed `y' to omit line numbers more consistently. * Changed `o' (calc-realign) to reset horizontal scrolling to zero, also. * Added "pred" mode for calc-eval. * Added "calc-report-bug" as an alias for "report-calc-bug". * Added `Z T' and "calc-pass-errors" to aid debugging Calc-related code. * Added "calc-load-everything" (`m X' or `M-# L') command. * Enhanced calc-install to pre-build units table, CommuteRules, etc. * Changed Calc to interact more gracefully with load-path. * Changed Lisp Variable Index in manual to include user variables, too. * Fixed a bug that prevented calc-install from working under VMS. * Fixed a bug that sometimes crashed rewrites dealing with subtractions. * Fixed a bug that prevented `a S' from solving "3 - x = 1 + x"! * Fixed a bug in solver that crashed for certain cubics and quartics. * Fixed a bug in calc-simplify that crashed for equations and ineqs. * Fixed a bug which placed the "[" oddly in `d B' + `v /' mode. * Fixed a bug where finishing calc-edit improperly obeyed language mode. * Fixed a bug formatting (-1)^n in Big mode after selection commands. * Fixed a bug that got ">=" and "<=" backwards in rewrite conditions. * Fixed a bug that broke the `"x"' key in calc-keypad mode. * Fixed a bug in which `MAP$' in calc-keypad didn't display "Working...". * Fixed a bug where matrix division gave bad result for singular matrix. * Fixed a bug which closed Calc window if calc-grab-region got an error. * Fixed a bug where `a s' failed on formulas containing dimension errors. * Fixed a bug that caused `m F' to hang. * Fixed a bug in complex arithmetic that caused problems with solver. * Fixed a bug which raised intervals to interval powers incorrectly. * Fixed a bug in utpp/ltpp (order of arguments did not match the manual). * Fixed a bug in which `t y' rounded yanked data with old precision. * Fixed a bug in which "in(3, [3 .. 3))" returned true. * Fixed a bug which simplified abs(abs(x)) incorrectly. * Fixed a bug in which (a^2)^1:3 was unsafely simplified to a^2:3. * Fixed a bug in rewrite system which missed pattern "2 sin(x) cos(x)". * Fixed a bug in rewrite system which missed pattern "a - a cos(x)^2". * Fixed obsolete trail tags gsmp, gneg, ginv to jsmp, jneg, jinv. * Fixed some errors and made improvements in units table [Ulrich Mueller]. Version 1.07: * Added `m F' (calc-settings-file-name) command. * Added calc-autoload-directory variable. * Extended Z ` to accept a prefix argument. * Added keystrokes (v h, v k) for head, tail, cons. * Extended `v e' to accept a vector as the filler. * Changed `V M', `V R' to accept mapping-mode keys in uppercase, too. * Changed V M ' etc. to accept $, $$, ... as argument indicators. * Changed `t y' to accept a prefix argument. * Put in a cleaner and safer random number generator for `k r' et al. * Fixed a bug which completely broke `a r' command! * Fixed "0 * matrix" to generate a zero matrix instead of 0. * Fixed a bug in `a R' which sometimes caused it to crash. * Fixed a fatal typo in the TeX version of the manual. * Fixed a bug that prevented C-k, C-w, M-w from working in Trail buffer. * Fixed another bug in `Z P' command. * Fixed a bug in `u s' which incorrectly simplified subtractions. * Fixed an argument-name aliasing bug evaluating lambda( ) formulas. * Fixed overfull hboxes in the manual. * Fixed various other bugs in the manual. Version 1.06: * Added "calc-keypad" mode for X window system users (try it!). * Improved "calc-eval" for calling/operating Calc from user-written Lisp. * Moved vector accumulate command to `V U' (old `H V R' still supported). * Added right-to-left reductions: `I V R' and `I V U'. * Added set operations on vectors: intersect, union, diff, xor. * Added `I v s' to remove a subvector from a vector. * Introduced `H |' to append two vectors with no magical special cases. * Introduced rhead, rtail, and rcons for isolating last vector element. * Changed `g p' to keep temp files around until data actually change. * Improved `a S' to solve many higher-order polynomial equations. * Added `a P' to produce a vector of all solutions to an equation. * Enhanced `a v' and `j v' to allow top-level-only evaluation. * Changed `j DEL' to delete a side of an eqn or ineq, leaving other side. * Fixed binding for keys `j 1' through `j 9'. * Introduced "let" marker in rewrite rules. * Enhanced the "sign" function to provide a two-argument version. * Changed "max-specpdl-size exceeded" error message to be user-friendly. * Put "" in the trail in above case and when user presses C-g. * Changed TeX mode to generate \ldots instead of \dots, recognize both. * Changed "sin(0)" etc. (for integer 0) to generate "0" instead of "0.". * Enhanced Programming Tutorial exercise 2. * Fixed an error in the answer to Types Tutorial exercise 3. * Fixed several bugs relating to head, tail, and cons functions. * Fixed some other minor typos in the manual. * Fixed several bugs in `Z P' (calc-user-define-permanent). * Fixed several bugs that broke the `g P' command. Version 1.05: * Created a calc-install command to ease installation. * Added lots of exercises to the Tutorial section of the manual. * Added ability to select and operate on sub-formulas. * Substantially improved the algebraic rewrite-rule system. * Added a set of graphing commands that use GNUPLOT. * Added a command (`a R') for finding numerical roots to equations. * Added several new math functions, such as erf and Bessel functions. * Added key bindings for miscellaneous commands using the "f" prefix key. * Added lots of new vector operations, many of them in the spirit of APL. * Added more control over vector display, including an abbreviated mode. * Improved keyboard macro editing; added read-kbd-macro to macedit.el. * Introduced the `m S' (calc-shift-prefix) command. * Enhanced the calc-edit command in several ways. * Made it possible to hit ` (calc-edit) during numeric/algebraic entry. * Enhanced the calc-solve-for command to handle inequalities. * Enhanced calc-simplify to handle equations and inequalities. * Taught log10 and log to look for exact integer or rational results. * Added ability to take Nth roots directly. * Added "increment" and "decrement" commands for integers and floats. * Added "full-help" command, changed "h" key to invoke it. * Added special help for Inverse and Hyperbolic prefixes. * Added an optional prefix argument to `o' (calc-realign). * Changed `t s' and `t r' to use RET as the search exit key. * Made handling of operator keys for V M, V R, etc. more regular. * Improved TeX mode; added support for \matrix format. * Added a variant of `m a' mode that only affects ( and [ keys. * Fixed "Mismatch" message for algebraic entry of semi-open intervals. * Trimmed fat from calc.el to speed loading, moved more to calc-ext.el. * Fixed a bug in which minibuffer entry rounded to out-of-date precision. * Fixed a bug which crashed Calc 1.04 under Epoch. * Fixed a bug which messed up Calc Trail's mode line, among other things. * Fixed a bug which caused trail ">" to show only when in Trail buffer. * Fixed a bug in which "calc" called "calc-grab-region" with too few args. * Fixed bugs in both implementation and documentation of calc-perm. * Fixed a bug in which calc-simplify-extended always used radians. * Fixed a bug where calc-comma failed to override "polar" mode. * Fixed a bug doing mixed arithmetic on rectangular+polar complex numbers. * Fixed several bugs in transcendental functions with complex arguments. * Fixed a bug in which `a s' simplified "x / .5" to ".5 x". * Fixed numerous other bugs in various parts of Calc. * Completed the "Hooks" section of the "Internals" chapter of the manual. Version 1.04: * Included a copy of revision history (from README) in calc.el. * Added the "calc-split" feature to split calc-ext.el into smaller bits. * Changed calc-unpack to unpack floats and fractions, too. * Added "mant", "xpon", and "scf" functions for decomposing floats. * Fixed a bug in the "y" command with positive prefix arguments. * Rearranged binary shift/rotate command keys to be a bit more convenient. * Fixed a bug in which simplifying "(0/0) * 2" crashed with a Lisp error. * Made `H F' [ffloor] and friends faster for very large arguments. * Made calc-define-del more robust. * Handled pasting of data into the Calculator using the mouse under X. * Made overlay-arrow variables buffer-local to avoid interference. * Fixed a problem in which Calc Trail buffer got stuck after a C-x C-w. Version 1.03: * Changed math-choose to compute n-choose-m faster when m is large. * Fixed some problems with TeX mode. * Fixed a bug that prevented `b s' from working without a prefix argument. * Added "calc-eval" function. * Improved calc-grab-region. Version 1.02: * Fixed a bug in Tutorial: telephone pole height/distance were switched! * Fixed a few other things in the manual. * Added "full-calc" command. * Added "calc-insert-variables" (`Z I') command. * Quick Calc now works even if you are already in the minibuffer. * Fixed a bug in math-mul-bignum-digit which affected math-and, etc. * Definition of "Hectares" was wrong in units table. * Fixed a bug in calc-execute-kbd-macro concerning undo and refresh. * Bound "calc-undo" to `C-x u' as well as `C-_' and `U'. Version 1.01: * Added a tutorial section to the manual. * Next and Prev for node Strings in the manual were reversed; fixed. * Changed "'bignum" in calc-isqrt-bignum-iter to "'bigpos". * Fixed a bug that prevented "$" from working during algebraic entry. * Fixed a bug caused by an X (last-X) command following a K (macro) cmd. * Fixed a bug in which K command incorrectly formatted stack in Big mode. * Added space between unary operators and non-flat compositions. (Otherwise, "-(a/b)" in Big mode blended the minus sign into the rule!) * Fixed formatting of (-1)^n in Big mode. * Fixed some problems relating to "not" operator in Pascal language mode. * Fixed several bugs relating to V M ' and V M $ sequences. * Fixed matrix-vector multiplication to produce a vector. * Introduced Z ` ... Z ' commands; renamed old Z ' to Z #. * Fixed various other bugs. * Added calc-settings-file variable suggested by C. Witty. Version 1.00: * First official release of Calc. * If you used the Beta test version (0.01), you will find that this version of Calc is over 50% larger than the original release. General areas of improvement include much better algebra features; operations on units; language modes; simplification modes; interval arithmetic; vector mapping and reduction. Other new commands include calc-fraction and calc-grab-region. The program has been split into two parts for faster loading, and the manual is more complete. calc-2.02c/INSTALL100644 22403 13 44563 5144466243 12113 0ustar daveguser Installation ************ Calc 2.02 comes as a set of GNU Emacs Lisp files, with names like `calc.el' and `calc-ext.el', and also as a `calc.texinfo' file which can be used to generate both on-line and printed documentation. To install Calc, just follow these simple steps. If you want more information, each step is discussed at length in the sections below. 1. Change (`cd') to the Calc "home" directory. This directory was created when you unbundled the Calc `.tar' or `.shar' file. 2. Type `make' to install Calc privately for your own use, or type `make install' to install Calc system-wide. This will compile all the Calc component files, modify your `.emacs' or the system-wide `lisp/default' file to install Calc as appropriate, and format the on-line Calc manual. Both variants are shorthand for the following three steps: * `make compile' to run the byte-compiler. * `make private' or `make public', corresponding to `make' and `make install', respectively. (If `make public' fails because your system doesn't already have a `default' or `default.el' file, use Emacs or the Unix `touch' command to create a zero-sized one first.) * `make info' to format the on-line Calc manual. This first tries to use the `makeinfo' program; if that program is not present, it uses the Emacs `texinfo-format-buffer' command instead. The Unix `make' utility looks in the file `Makefile' in the current directory to see what Unix commands correspond to the various "targets" like `install' or `public'. If your system doesn't have `make', you will have to examine the `Makefile' and type in the corresponding commands by hand. 3. If you ever move Calc to a new home directory, just give the `make private' or `make public' command again in the new directory. 4. Test your installation as described at the end of these instructions. 5. (Optional.) To print a hardcopy of the Calc manual (over 500 pages) or just the Calc Summary (about 20 pages), follow the instructions under "Printed Documentation" below. Calc is now installed and ready to go! Upgrading from Calc 1.07 ========================= If you have Calc version 1.07 or earlier, you will find that Calc 2.00 is organized quite differently. For one, Calc 2.00 is now distributed already split into many parts; formerly this was done as part of the installation procedure. Also, some new functions must be autoloaded and the `M-#' key must be bound to `calc-dispatch' instead of to `calc'. The easiest way to upgrade is to delete your old Calc files and then install Calc 2.00 from scratch using the above instructions. You should then go into your `.emacs' or `default' file and remove the old `autoload' and `global-set-key' commands for Calc, since `make public'/`make private' has added new, better ones. See the `README' and `README.prev' files in the Calc distribution for more information about what has changed since version 1.07. (`README.prev' describes changes before 2.00, and is present only in the FTP and tape versions of the distribution.) The `make public' Command ========================== If you are not the regular Emacs administrator on your system, your account may not be allowed to execute the `make public' command, since the system-wide `default' file may be write-protected. If this is the case, you will have to ask your Emacs installer to execute this command. (Just `cd' to the Calc home directory and type `make public'.) The `make private' command adds exactly the same set of commands to your `.emacs' file as `make public' adds to `default'. If your Emacs installer is concerned about typing this command out of the blue, you can ask her/him instead to copy the necessary text from your `.emacs' file. (It will be marked by a comment that says "Commands added by `calc-private-autoloads' on (date and time).") Compilation ============ Calc is written in a way that maximizes performance when its code has been byte-compiled; a side effect is that performance is seriously degraded if it *isn't* compiled. Thus, it is essential to compile the Calculator before trying to use it. The function `calc-compile' in the file `calc-maint.el' runs the Emacs byte-compiler on all the Calc source files. (Specifically, it runs `M-x byte-compile-file' on all files in the current directory with names of the form `calc*.el', and also on the file `macedit.el'.) If `calc-compile' finds that certain files have already been compiled and have not been changed since, then it will not bother to recompile those files. The `calc-compile' command also pre-builds certain tables, such as the units table (see "The Units Table") and the built-in rewrite rules (see "Rearranging with Selections") which Calc would otherwise need to rebuild every time those features were used. The `make compile' shell command is simply a convenient way to start an Emacs and give it a `calc-compile' command. Auto-loading ============= To teach Emacs how to load in Calc when you type `M-#' for the first time, add these lines to your `.emacs' file (if you are installing Calc just for your own use), or the system's `lisp/default' file (if you are installing Calc publicly). The `make private' and `make public' commands, respectively, take care of this. (Note that `make' runs `make private', and `make install' runs `make public'.) (autoload 'calc-dispatch "calc" "Calculator Options" t) (autoload 'full-calc "calc" "Full-screen Calculator" t) (autoload 'full-calc-keypad "calc" "Full-screen X Calculator" t) (autoload 'calc-eval "calc" "Use Calculator from Lisp") (autoload 'defmath "calc" nil t t) (autoload 'calc "calc" "Calculator Mode" t) (autoload 'quick-calc "calc" "Quick Calculator" t) (autoload 'calc-keypad "calc" "X windows Calculator" t) (autoload 'calc-embedded "calc" "Use Calc from any buffer" t) (autoload 'calc-embedded-activate "calc" "Activate =>'s in buffer" t) (autoload 'calc-grab-region "calc" "Grab region of Calc data" t) (autoload 'calc-grab-rectangle "calc" "Grab rectangle of data" t) Unless you have installed the Calc files in Emacs' main `lisp/' directory, you will also have to add a command that looks like the following to tell Emacs where to find them. In this example, we have put the files in directory `/usr/gnu/src/calc-2.00'. (setq load-path (append load-path (list "/usr/gnu/src/calc-2.00"))) The `make public' and `make private' commands also do this (they use the then-current directory as the name to add to the path). If you move Calc to a new location, just repeat the `make public' or `make private' command to have this new location added to the `load-path'. The `autoload' command for `calc-dispatch' is what loads `calc.elc' when you type `M-#'. It is the only `autoload' that is absolutely necessary for Calc to work. The others are for commands and features that you may wish to use before typing `M-#' for the first time. In particular, `full-calc' and `full-calc-keypad' are autoloaded to support "standalone" operation (see "Standalone Operation"), `calc-eval' and `defmath' are autoloaded to allow other Emacs Lisp programs to use Calc facilities (see "Calling Calc from Your Programs"), and `calc-embedded-activate' is autoloaded because some Embedded Mode files may call it as soon as they are read into Emacs (see "Assignments in Embedded Mode"). Finding Component Files ======================== There is no need to write `autoload' commands that point to all the various Calc component files like `calc-misc.elc' and `calc-alg.elc'. The main file, `calc.elc', contains all the necessary `autoload' commands for these files. (Actually, to conserve space `calc.elc' only autoloads a few of the component files, plus `calc-ext.elc', which in turn autoloads the rest of the components. This allows Calc to load a little faster in the beginning, but the net effect is the same.) This autoloading mechanism assumes that all the component files can be found on the `load-path'. The `make public' and `make private' commands take care of this, but Calc has a few other strategies in case you have installed it in an unusual way. If, when Calc is loaded, it is unable to find its components on the `load-path' it is given, it checks the file name in the original `autoload' command for `calc-dispatch'. If that name included directory information, Calc adds that directory to the `load-path': (autoload 'calc-dispatch "calc-2.00/calc" "Calculator" t) Suppose the directory `/usr/gnu/src/emacs/lisp' is on the path, and the above `autoload' allows Emacs to find Calc under the name `/usr/gnu/src/emacs/lisp/calc-2.00/calc.elc'. Then when Calc starts up it will add `/usr/gnu/src/emacs/lisp/calc-2.00' to the path so that it will later be able to find its component files. If the above strategy does not locate the component files, Calc examines the variable `calc-autoload-directory'. This is initially `nil', but you can store the name of Calc's home directory in it as a sure-fire way of getting Calc to find its components. Merging Source Files ===================== If the `autoload' mechanism is not managing to load each part of Calc when it is needed, you can concatenate all the `.el' files into one big file. The order should be `calc.el', then `calc-ext.el', then all the other files in any order. Byte-compile the resulting big file. This merged Calculator ought to work just like Calc normally does, though it will be *substantially* slower to load. Key Bindings ============= Calc is normally bound to the `M-#' key. To set up this key binding, include the following command in your `.emacs' or `lisp/default' file. (This is done automatically by `make private' or `make public', respectively.) (global-set-key "\e#" 'calc-dispatch) Note that `calc-dispatch' actually works as a prefix for various two-key sequences. If you have a convenient unused function key on your keyboard, you may wish to bind `calc-dispatch' to that as well. You may even wish to bind other specific Calc functions like `calc' or `quick-calc' to other handy function keys. Even if you bind `calc-dispatch' to other keys, it is best to bind it to `M-#' as well if you possibly can: There are references to `M-#' all throughout the Calc manual which would confuse novice users if they didn't work as advertised. Another key binding issue is the DEL key. Some installations use a different key (such as backspace) for this purpose. Calc normally scans the entire keymap and maps all keys defined like DEL to the `calc-pop' command. However, this may be slow. You can set the variable `calc-scan-for-dels' to `nil' to cause only the actual DEL key to be mapped to `calc-pop'; this will speed loading of Calc. The `macedit' Package ====================== The file `macedit.el' contains another useful Emacs extension called `edit-kbd-macro'. It allows you to edit a keyboard macro in human-readable form. The `Z E' command in Calc knows how to use it to edit user commands that have been defined by keyboard macros. To autoload it, you will want to include the commands, (autoload 'edit-kbd-macro "macedit" "Edit Keyboard Macro" t) (autoload 'edit-last-kbd-macro "macedit" "Edit Keyboard Macro" t) (autoload 'read-kbd-macro "macedit" "Read Keyboard Macro" t) The `make public' and `make private' commands do this. The GNUPLOT Program ==================== Calc's graphing commands use the GNUPLOT program. If you have GNUPLOT but you must type some command other than `gnuplot' to get it, you should add a command to set the Lisp variable `calc-gnuplot-name' to the appropriate file name. You may also need to change the variables `calc-gnuplot-plot-command' and `calc-gnuplot-print-command' in order to get correct displays and hardcopies, respectively, of your plots. On-Line Documentation ====================== The documentation for Calc (this manual) comes in a file called `calc.texinfo'. To format this for use as an on-line manual, type `make info' (to use the `makeinfo' program), or `make texinfo' (to use the `texinfmt.el' program which runs inside of Emacs). The former command is recommended if it works on your system; it is faster and produces nicer-looking output. The `makeinfo' program will report inconsistencies involving the nodes "Copying" and "Interactive Tutorial"; these messages should be ignored. The result will be a collection of files whose names begin with `calc.info'. You may wish to add a reference to the first of these, `calc.info' itself, to your Info system's `dir' file. (This is optional since the `M-# i' command can access `calc.info' whether or not it appears in the `dir' file.) There is a Lisp variable called `calc-info-filename' which holds the name of the Info file containing Calc's on-line documentation. Its default value is `"calc.info"', which will work correctly if the Info files are stored in Emacs' main `info/' directory, or if they are in any of the directories listed in the `load-path'. If you keep them elsewhere, you will want to put a command of the form, (setq calc-info-filename ".../calc.info") in your `.emacs' or `lisp/default' file, where `...' represents the directory containing the Info files. This will not be necessary if you follow the normal installation procedures. The `make info' and `make texinfo' commands compare the dates on the files `calc.texinfo' and `calc.info', and run the appropriate program only if the latter file is older or does not exist. Printed Documentation ====================== Because the Calc manual is so large, you should only make a printed copy if you really need it. To print the manual, you will need the TeX typesetting program (this is a free program by Donald Knuth at Stanford University) as well as the `texindex' program and `texinfo.tex' file, both of which can be obtained from the FSF as part of the `texinfo2' package. To print the Calc manual in one huge 550 page tome, type `make tex'. This will take care of running the manual through TeX twice so that references to later parts of the manual will have correct page numbers. (Don't worry if you get some "overfull box" warnings.) The result will be a device-independent output file called `calc.dvi', which you must print in whatever way is right for your system. On many systems, the command is lpr -d calc.dvi Marginal notes for each function and key sequence normally alternate between the left and right sides of the page, which is correct if the manual is going to be bound as double-sided pages. Near the top of the file `calc.texinfo' you will find alternate definitions of the `\bumpoddpages' macro that put the marginal notes always on the same side, best if you plan to be binding single-sided pages. Some people find the Calc manual to be too large to handle easily. In fact, some versions of TeX have too little memory to print it. So Calc includes a `calc-split-manual' command that splits `calc.texinfo' into two volumes, the Calc Tutorial and the Calc Reference. The easiest way to use it is to type `make tex2' instead of `make tex'. The result will be two smaller files, `calctut.dvi' and `calcref.dvi'. The former contains the tutorial part of the manual; the latter contains the reference part. Both volumes include copies of the "Getting Started" chapter and licensing information. To save disk space, you may wish to delete `calctut.*' and `calcref.*' after you're done. Don't delete `calc.texinfo', because you will need it to install future patches to Calc. The `make tex2' command takes care of all of this for you. The `make textut' command formats only the Calc Tutorial volume, producing `calctut.dvi' but not `calcref.dvi'. Likewise, `make texref' formats only the Calc Reference volume. Finally, there is a `calc-split-summary' command that splits off just the Calc Summary appendix suitable for printing by itself. Type `make summary' instead of `make tex'. The resulting `calcsum.dvi' file will print in less than 20 pages. If the Key Index file `calc.ky' is present, left over from a previous `make tex' command, then `make summary' will insert a column of page numbers into the summary using that information. The `make isummary' command is like `make summary', but it prints a summary that is designed to be substituted into the regular manual. (The two summaries will be identical except for the additional column of page numbers.) To make a complete manual, run `make tex' and `make isummary', print the two resulting `.dvi' files, then discard the Summary pages that came from `calc.dvi' and insert the ones from `calcsum.dvi' in their place. Also, remember that the table of contents prints at the end of the manual but should generally be moved to the front (after the title and copyright pages). If you don't have TeX, you can print the summary as a plain text file by going to the "Summary" node in Calc's Info file, then typing `M-x print-buffer' (see "Summary"). Settings File ============== Another variable you might want to set is `calc-settings-file', which holds the file name in which commands like `m m' and `Z P' store "permanent" definitions. The default value for this variable is `"~/.emacs"'. If `calc-settings-file' does not contain `".emacs"' as a substring, and if the variable `calc-loaded-settings-file' is `nil', then Calc will automatically load your settings file (if it exists) the first time Calc is invoked. Testing the Installation ========================= To test your installation of Calc, start a new Emacs and type `M-# c' to make sure the autoloads and key bindings work. Type `M-# i' to make sure Calc can find its Info documentation. Press `q' to exit the Info system and `M-# c' to re-enter the Calculator. Type `20 S' to compute the sine of 20 degrees; this will test the autoloading of the extensions modules. The result should be 0.342020143326. Finally, press `M-# c' again to make sure the Calculator can exit. You may also wish to test the GNUPLOT interface; to plot a sine wave, type `' [0 .. 360], sin(x) RET g f'. Type `g q' when you are done viewing the plot. Calc is now ready to use. If you wish to go through the Calc Tutorial, press `M-# t' to begin. (The above text is included in both the Calc documentation and the file INSTALL in the Calc distribution directory.) calc-2.02c/Makefile100644 22403 13 11572 5402630405 12502 0ustar daveguser# Makefile for "Calc", the GNU Emacs Calculator. # Copyright (C) 1991, 1992, 1993 Free Software Foundation. # Author: Dave Gillespie. # Author's address: daveg@synaptics.com. # This program 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 (any version). # This program 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 this program; see the file COPYING. If not, write to # the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # To install Calc for private use, type `make'. # To install Calc for public use, type `make install'. # How to read a Makefile: # The command `make target' looks for `target:' in the Makefile. # First, any sub-targets after the `:' are made. # Then, the Unix commands on the following lines are executed. # `$(SYMBOL)' expands according to the `SYMBOL =' definition below. # Programs. EMACS = emacs TEX = tex TEXINDEX = texindex MAKEINFO = makeinfo MAKE = make ECHO = @echo REMOVE = -rm -f # (The leading `@' tells "make" not to echo the command itself during make; # The leading `-' tells "make" to keep going if the command fails.) # Other macros. EFLAGS = -batch MAINT = -l calc-maint.elc # Control whether intermediate files are kept. PURGE = -rm -f #PURGE = echo Not deleting: # Do full Calc installation. (Note that `make' == `make all'.) # These are written this way instead of `all: compile private info' # to make the steps more explicit while the `make' is in progress. all: $(MAKE) compile $(MAKE) private $(MAKE) info $(ECHO) "Calc is now installed." install: $(MAKE) compile $(MAKE) public $(MAKE) info $(ECHO) "Calc is now installed." # Compile Calc. compile: maint $(EMACS) $(EFLAGS) $(MAINT) -f calc-compile # Add autoload and set-global-key commands to system default file. public: maint $(EMACS) $(EFLAGS) $(MAINT) -f calc-public-autoloads # Add autoload and set-global-key commands to ~/.emacs file. private: maint $(EMACS) $(EFLAGS) $(MAINT) -f calc-private-autoloads # Format the Calc manual for the Info system using makeinfo. info: calc.info calc.info: calc.texinfo -$(MAKEINFO) calc.texinfo $(ECHO) "Please ignore warnings for Copying, Getting Started, and Interactive Tutorial." $(MAKE) texinfo # Format the Calc manual for the Info system using texinfo.el. # (Use this only if you do not have makeinfo.) texinfo: calc.info-2 calc.info-2: calc.texinfo $(EMACS) $(EFLAGS) calc.texinfo -f texinfo-format-buffer -f save-buffer # Format the Calc manual as one printable volume using TeX. tex: $(REMOVE) calc.aux $(TEX) calc.texinfo $(TEXINDEX) calc.[cfkptv]? $(TEX) calc.texinfo $(PURGE) calc.cp calc.fn calc.pg calc.tp calc.vr $(PURGE) calc.cps calc.fns calc.kys calc.pgs calc.tps calc.vrs $(PURGE) calc.toc # Note, calc.aux and calc.ky are left behind for the benefit of "make summary". # Format the Calc manual as two printable volumes (Tutorial and Reference). tex2: texsplit texvol1 texvol2 # Format the Calc Tutorial volume only. textut: texsplit1 texvol1 # Format the Calc Reference volume only. texref: texsplit2 texvol2 texsplit: maint $(EMACS) $(EFLAGS) $(MAINT) calc.texinfo -f calc-split-manual texsplit1: maint $(EMACS) $(EFLAGS) $(MAINT) calc.texinfo -f calc-split-tutorial texsplit2: maint $(EMACS) $(EFLAGS) $(MAINT) calc.texinfo -f calc-split-reference texvol1: $(TEX) calctut.tex $(TEXINDEX) calctut.?? $(TEX) calctut.tex $(PURGE) calctut.tex calctut.?? calctut.??s calctut.aux calctut.toc texvol2: $(TEX) calcref.tex $(TEXINDEX) calcref.?? $(TEX) calcref.tex $(PURGE) calcref.tex calcref.?? calcref.??s calcref.aux calcref.toc # Format the Calc summary separately using TeX. summary: texsum $(TEX) calcsum.tex $(PURGE) calcsum.?? calcsum.aux calcsum.toc texsum: maint $(EMACS) $(EFLAGS) $(MAINT) calc.texinfo -f calc-split-summary isummary: texisum $(TEX) calcsum.tex $(PURGE) calcsum.?? calcsum.aux calcsum.toc texisum: maint $(EMACS) $(EFLAGS) $(MAINT) calc.texinfo -f calc-inline-summary # All this because "-l calc-maint" doesn't work. maint: calc-maint.elc calc-maint.elc: calc-maint.el cp calc-maint.el calc-maint.elc # Create an Emacs TAGS file tags: TAGS TAGS: etags *.el # Delete .elc files and other reconstructible files. clean: clean.elc clean.info clean.tex clean.elc: $(REMOVE) calc-*.elc $(REMOVE) macedit.elc clean.info: $(REMOVE) calc.info* clean.tex: $(REMOVE) calc.cp calc.fn calc.ky calc.pg calc.tp calc.vr $(REMOVE) calc.cps calc.fns calc.kys calc.pgs calc.tps calc.vrs $(REMOVE) calc.aux calc.log calc.toc calc.dvi $(REMOVE) calcref.* $(REMOVE) calctut.* $(REMOVE) calcsum.* calc-2.02c/calc-ext.el100644 22403 13 353366 5547406472 13135 0ustar daveguser;; Calculator for GNU Emacs, part II ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. (provide 'calc-ext) (setq calc-extensions-loaded t) ;;; This function is the autoload "hook" to cause this file to be loaded. ;;;###autoload (defun calc-extensions () "This function is part of the autoload linkage for parts of Calc." t ) ;;; Auto-load calc.el part, in case this part was loaded first. (if (fboundp 'calc-dispatch) (and (eq (car-safe (symbol-function 'calc-dispatch)) 'autoload) (load (nth 1 (symbol-function 'calc-dispatch)))) (if (fboundp 'calc) (and (eq (car-safe (symbol-function 'calc)) 'autoload) (load (nth 1 (symbol-function 'calc)))) (error "Main part of Calc must be present in order to load this file."))) (require 'calc-macs) ;;; The following was made a function so that it could be byte-compiled. (defun calc-init-extensions () (setq gc-cons-threshold (max gc-cons-threshold 250000)) (define-key calc-mode-map ":" 'calc-fdiv) (define-key calc-mode-map "\\" 'calc-idiv) (define-key calc-mode-map "|" 'calc-concat) (define-key calc-mode-map "!" 'calc-factorial) (define-key calc-mode-map "C" 'calc-cos) (define-key calc-mode-map "E" 'calc-exp) (define-key calc-mode-map "H" 'calc-hyperbolic) (define-key calc-mode-map "I" 'calc-inverse) (define-key calc-mode-map "J" 'calc-conj) (define-key calc-mode-map "L" 'calc-ln) (define-key calc-mode-map "N" 'calc-eval-num) (define-key calc-mode-map "P" 'calc-pi) (define-key calc-mode-map "Q" 'calc-sqrt) (define-key calc-mode-map "R" 'calc-round) (define-key calc-mode-map "S" 'calc-sin) (define-key calc-mode-map "T" 'calc-tan) (define-key calc-mode-map "U" 'calc-undo) (define-key calc-mode-map "X" 'calc-call-last-kbd-macro) (define-key calc-mode-map "o" 'calc-realign) (define-key calc-mode-map "p" 'calc-precision) (define-key calc-mode-map "w" 'calc-why) (define-key calc-mode-map "x" 'calc-execute-extended-command) (define-key calc-mode-map "y" 'calc-copy-to-buffer) (define-key calc-mode-map "(" 'calc-begin-complex) (define-key calc-mode-map ")" 'calc-end-complex) (define-key calc-mode-map "[" 'calc-begin-vector) (define-key calc-mode-map "]" 'calc-end-vector) (define-key calc-mode-map "," 'calc-comma) (define-key calc-mode-map ";" 'calc-semi) (define-key calc-mode-map "`" 'calc-edit) (define-key calc-mode-map "=" 'calc-evaluate) (define-key calc-mode-map "~" 'calc-num-prefix) (define-key calc-mode-map "<" 'calc-scroll-left) (define-key calc-mode-map ">" 'calc-scroll-right) (define-key calc-mode-map "{" 'calc-scroll-down) (define-key calc-mode-map "}" 'calc-scroll-up) (define-key calc-mode-map "\C-k" 'calc-kill) (define-key calc-mode-map "\M-k" 'calc-copy-as-kill) (define-key calc-mode-map "\C-w" 'calc-kill-region) (define-key calc-mode-map "\M-w" 'calc-copy-region-as-kill) (define-key calc-mode-map "\C-y" 'calc-yank) (define-key calc-mode-map "\C-_" 'calc-undo) (define-key calc-mode-map "\C-xu" 'calc-undo) (define-key calc-mode-map "\M-\C-m" 'calc-last-args) (define-key calc-mode-map "a" nil) (define-key calc-mode-map "a?" 'calc-a-prefix-help) (define-key calc-mode-map "aa" 'calc-apart) (define-key calc-mode-map "ab" 'calc-substitute) (define-key calc-mode-map "ac" 'calc-collect) (define-key calc-mode-map "ad" 'calc-derivative) (define-key calc-mode-map "ae" 'calc-simplify-extended) (define-key calc-mode-map "af" 'calc-factor) (define-key calc-mode-map "ag" 'calc-poly-gcd) (define-key calc-mode-map "ai" 'calc-integral) (define-key calc-mode-map "am" 'calc-match) (define-key calc-mode-map "an" 'calc-normalize-rat) (define-key calc-mode-map "ap" 'calc-poly-interp) (define-key calc-mode-map "ar" 'calc-rewrite) (define-key calc-mode-map "as" 'calc-simplify) (define-key calc-mode-map "at" 'calc-taylor) (define-key calc-mode-map "av" 'calc-alg-evaluate) (define-key calc-mode-map "ax" 'calc-expand) (define-key calc-mode-map "aA" 'calc-abs) (define-key calc-mode-map "aF" 'calc-curve-fit) (define-key calc-mode-map "aI" 'calc-num-integral) (define-key calc-mode-map "aM" 'calc-map-equation) (define-key calc-mode-map "aN" 'calc-find-minimum) (define-key calc-mode-map "aP" 'calc-poly-roots) (define-key calc-mode-map "aS" 'calc-solve-for) (define-key calc-mode-map "aR" 'calc-find-root) (define-key calc-mode-map "aT" 'calc-tabulate) (define-key calc-mode-map "aX" 'calc-find-maximum) (define-key calc-mode-map "a+" 'calc-summation) (define-key calc-mode-map "a-" 'calc-alt-summation) (define-key calc-mode-map "a*" 'calc-product) (define-key calc-mode-map "a\\" 'calc-poly-div) (define-key calc-mode-map "a%" 'calc-poly-rem) (define-key calc-mode-map "a/" 'calc-poly-div-rem) (define-key calc-mode-map "a=" 'calc-equal-to) (define-key calc-mode-map "a#" 'calc-not-equal-to) (define-key calc-mode-map "a<" 'calc-less-than) (define-key calc-mode-map "a>" 'calc-greater-than) (define-key calc-mode-map "a[" 'calc-less-equal) (define-key calc-mode-map "a]" 'calc-greater-equal) (define-key calc-mode-map "a." 'calc-remove-equal) (define-key calc-mode-map "a{" 'calc-in-set) (define-key calc-mode-map "a&" 'calc-logical-and) (define-key calc-mode-map "a|" 'calc-logical-or) (define-key calc-mode-map "a!" 'calc-logical-not) (define-key calc-mode-map "a:" 'calc-logical-if) (define-key calc-mode-map "a_" 'calc-subscript) (define-key calc-mode-map "a\"" 'calc-expand-formula) (define-key calc-mode-map "b" nil) (define-key calc-mode-map "b?" 'calc-b-prefix-help) (define-key calc-mode-map "ba" 'calc-and) (define-key calc-mode-map "bc" 'calc-clip) (define-key calc-mode-map "bd" 'calc-diff) (define-key calc-mode-map "bl" 'calc-lshift-binary) (define-key calc-mode-map "bn" 'calc-not) (define-key calc-mode-map "bo" 'calc-or) (define-key calc-mode-map "bp" 'calc-pack-bits) (define-key calc-mode-map "br" 'calc-rshift-binary) (define-key calc-mode-map "bt" 'calc-rotate-binary) (define-key calc-mode-map "bu" 'calc-unpack-bits) (define-key calc-mode-map "bw" 'calc-word-size) (define-key calc-mode-map "bx" 'calc-xor) (define-key calc-mode-map "bB" 'calc-log) (define-key calc-mode-map "bD" 'calc-fin-ddb) (define-key calc-mode-map "bF" 'calc-fin-fv) (define-key calc-mode-map "bI" 'calc-fin-irr) (define-key calc-mode-map "bL" 'calc-lshift-arith) (define-key calc-mode-map "bM" 'calc-fin-pmt) (define-key calc-mode-map "bN" 'calc-fin-npv) (define-key calc-mode-map "bP" 'calc-fin-pv) (define-key calc-mode-map "bR" 'calc-rshift-arith) (define-key calc-mode-map "bS" 'calc-fin-sln) (define-key calc-mode-map "bT" 'calc-fin-rate) (define-key calc-mode-map "bY" 'calc-fin-syd) (define-key calc-mode-map "b#" 'calc-fin-nper) (define-key calc-mode-map "b%" 'calc-percent-change) (define-key calc-mode-map "c" nil) (define-key calc-mode-map "c?" 'calc-c-prefix-help) (define-key calc-mode-map "cc" 'calc-clean) (define-key calc-mode-map "cd" 'calc-to-degrees) (define-key calc-mode-map "cf" 'calc-float) (define-key calc-mode-map "ch" 'calc-to-hms) (define-key calc-mode-map "cp" 'calc-polar) (define-key calc-mode-map "cr" 'calc-to-radians) (define-key calc-mode-map "cC" 'calc-cos) (define-key calc-mode-map "cF" 'calc-fraction) (define-key calc-mode-map "c%" 'calc-convert-percent) (define-key calc-mode-map "d" nil) (define-key calc-mode-map "d?" 'calc-d-prefix-help) (define-key calc-mode-map "d0" 'calc-decimal-radix) (define-key calc-mode-map "d2" 'calc-binary-radix) (define-key calc-mode-map "d6" 'calc-hex-radix) (define-key calc-mode-map "d8" 'calc-octal-radix) (define-key calc-mode-map "db" 'calc-line-breaking) (define-key calc-mode-map "dc" 'calc-complex-notation) (define-key calc-mode-map "dd" 'calc-date-notation) (define-key calc-mode-map "de" 'calc-eng-notation) (define-key calc-mode-map "df" 'calc-fix-notation) (define-key calc-mode-map "dg" 'calc-group-digits) (define-key calc-mode-map "dh" 'calc-hms-notation) (define-key calc-mode-map "di" 'calc-i-notation) (define-key calc-mode-map "dj" 'calc-j-notation) (define-key calc-mode-map "dl" 'calc-line-numbering) (define-key calc-mode-map "dn" 'calc-normal-notation) (define-key calc-mode-map "do" 'calc-over-notation) (define-key calc-mode-map "dp" 'calc-show-plain) (define-key calc-mode-map "dr" 'calc-radix) (define-key calc-mode-map "ds" 'calc-sci-notation) (define-key calc-mode-map "dt" 'calc-truncate-stack) (define-key calc-mode-map "dw" 'calc-auto-why) (define-key calc-mode-map "dz" 'calc-leading-zeros) (define-key calc-mode-map "dB" 'calc-big-language) (define-key calc-mode-map "dD" 'calc-redo) (define-key calc-mode-map "dC" 'calc-c-language) (define-key calc-mode-map "dE" 'calc-eqn-language) (define-key calc-mode-map "dF" 'calc-fortran-language) (define-key calc-mode-map "dM" 'calc-mathematica-language) (define-key calc-mode-map "dN" 'calc-normal-language) (define-key calc-mode-map "dO" 'calc-flat-language) (define-key calc-mode-map "dP" 'calc-pascal-language) (define-key calc-mode-map "dT" 'calc-tex-language) (define-key calc-mode-map "dU" 'calc-unformatted-language) (define-key calc-mode-map "dW" 'calc-maple-language) (define-key calc-mode-map "d[" 'calc-truncate-up) (define-key calc-mode-map "d]" 'calc-truncate-down) (define-key calc-mode-map "d." 'calc-point-char) (define-key calc-mode-map "d," 'calc-group-char) (define-key calc-mode-map "d\"" 'calc-display-strings) (define-key calc-mode-map "d<" 'calc-left-justify) (define-key calc-mode-map "d=" 'calc-center-justify) (define-key calc-mode-map "d>" 'calc-right-justify) (define-key calc-mode-map "d{" 'calc-left-label) (define-key calc-mode-map "d}" 'calc-right-label) (define-key calc-mode-map "d'" 'calc-display-raw) (define-key calc-mode-map "d " 'calc-refresh) (define-key calc-mode-map "d\r" 'calc-refresh-top) (define-key calc-mode-map "f" nil) (define-key calc-mode-map "f?" 'calc-f-prefix-help) (define-key calc-mode-map "fb" 'calc-beta) (define-key calc-mode-map "fe" 'calc-erf) (define-key calc-mode-map "fg" 'calc-gamma) (define-key calc-mode-map "fh" 'calc-hypot) (define-key calc-mode-map "fi" 'calc-im) (define-key calc-mode-map "fj" 'calc-bessel-J) (define-key calc-mode-map "fn" 'calc-min) (define-key calc-mode-map "fr" 'calc-re) (define-key calc-mode-map "fs" 'calc-sign) (define-key calc-mode-map "fx" 'calc-max) (define-key calc-mode-map "fy" 'calc-bessel-Y) (define-key calc-mode-map "fA" 'calc-abssqr) (define-key calc-mode-map "fB" 'calc-inc-beta) (define-key calc-mode-map "fE" 'calc-expm1) (define-key calc-mode-map "fF" 'calc-floor) (define-key calc-mode-map "fG" 'calc-inc-gamma) (define-key calc-mode-map "fI" 'calc-ilog) (define-key calc-mode-map "fL" 'calc-lnp1) (define-key calc-mode-map "fM" 'calc-mant-part) (define-key calc-mode-map "fQ" 'calc-isqrt) (define-key calc-mode-map "fS" 'calc-scale-float) (define-key calc-mode-map "fT" 'calc-arctan2) (define-key calc-mode-map "fX" 'calc-xpon-part) (define-key calc-mode-map "f[" 'calc-decrement) (define-key calc-mode-map "f]" 'calc-increment) (define-key calc-mode-map "g" nil) (define-key calc-mode-map "g?" 'calc-g-prefix-help) (define-key calc-mode-map "ga" 'calc-graph-add) (define-key calc-mode-map "gb" 'calc-graph-border) (define-key calc-mode-map "gc" 'calc-graph-clear) (define-key calc-mode-map "gd" 'calc-graph-delete) (define-key calc-mode-map "gf" 'calc-graph-fast) (define-key calc-mode-map "gg" 'calc-graph-grid) (define-key calc-mode-map "gh" 'calc-graph-header) (define-key calc-mode-map "gk" 'calc-graph-key) (define-key calc-mode-map "gj" 'calc-graph-juggle) (define-key calc-mode-map "gl" 'calc-graph-log-x) (define-key calc-mode-map "gn" 'calc-graph-name) (define-key calc-mode-map "gp" 'calc-graph-plot) (define-key calc-mode-map "gq" 'calc-graph-quit) (define-key calc-mode-map "gr" 'calc-graph-range-x) (define-key calc-mode-map "gs" 'calc-graph-line-style) (define-key calc-mode-map "gt" 'calc-graph-title-x) (define-key calc-mode-map "gv" 'calc-graph-view-commands) (define-key calc-mode-map "gx" 'calc-graph-display) (define-key calc-mode-map "gz" 'calc-graph-zero-x) (define-key calc-mode-map "gA" 'calc-graph-add-3d) (define-key calc-mode-map "gC" 'calc-graph-command) (define-key calc-mode-map "gD" 'calc-graph-device) (define-key calc-mode-map "gF" 'calc-graph-fast-3d) (define-key calc-mode-map "gG" 'calc-argument) (define-key calc-mode-map "gH" 'calc-graph-hide) (define-key calc-mode-map "gK" 'calc-graph-kill) (define-key calc-mode-map "gL" 'calc-graph-log-y) (define-key calc-mode-map "gN" 'calc-graph-num-points) (define-key calc-mode-map "gO" 'calc-graph-output) (define-key calc-mode-map "gP" 'calc-graph-print) (define-key calc-mode-map "gR" 'calc-graph-range-y) (define-key calc-mode-map "gS" 'calc-graph-point-style) (define-key calc-mode-map "gT" 'calc-graph-title-y) (define-key calc-mode-map "gV" 'calc-graph-view-trail) (define-key calc-mode-map "gX" 'calc-graph-geometry) (define-key calc-mode-map "gZ" 'calc-graph-zero-y) (define-key calc-mode-map "g\C-l" 'calc-graph-log-z) (define-key calc-mode-map "g\C-r" 'calc-graph-range-z) (define-key calc-mode-map "g\C-t" 'calc-graph-title-z) (define-key calc-mode-map "h" 'calc-help-prefix) (define-key calc-mode-map "j" nil) (define-key calc-mode-map "j?" 'calc-j-prefix-help) (define-key calc-mode-map "ja" 'calc-select-additional) (define-key calc-mode-map "jb" 'calc-break-selections) (define-key calc-mode-map "jc" 'calc-clear-selections) (define-key calc-mode-map "jd" 'calc-show-selections) (define-key calc-mode-map "je" 'calc-enable-selections) (define-key calc-mode-map "jl" 'calc-select-less) (define-key calc-mode-map "jm" 'calc-select-more) (define-key calc-mode-map "jn" 'calc-select-next) (define-key calc-mode-map "jo" 'calc-select-once) (define-key calc-mode-map "jp" 'calc-select-previous) (define-key calc-mode-map "jr" 'calc-rewrite-selection) (define-key calc-mode-map "js" 'calc-select-here) (define-key calc-mode-map "jv" 'calc-sel-evaluate) (define-key calc-mode-map "ju" 'calc-unselect) (define-key calc-mode-map "jC" 'calc-sel-commute) (define-key calc-mode-map "jD" 'calc-sel-distribute) (define-key calc-mode-map "jE" 'calc-sel-jump-equals) (define-key calc-mode-map "jI" 'calc-sel-isolate) (define-key calc-mode-map "jJ" 'calc-conj) (define-key calc-mode-map "jL" 'calc-commute-left) (define-key calc-mode-map "jM" 'calc-sel-merge) (define-key calc-mode-map "jN" 'calc-sel-negate) (define-key calc-mode-map "jO" 'calc-select-once-maybe) (define-key calc-mode-map "jR" 'calc-commute-right) (define-key calc-mode-map "jS" 'calc-select-here-maybe) (define-key calc-mode-map "jU" 'calc-sel-unpack) (define-key calc-mode-map "j&" 'calc-sel-invert) (define-key calc-mode-map "j\r" 'calc-copy-selection) (define-key calc-mode-map "j\n" 'calc-copy-selection) (define-key calc-mode-map "j\010" 'calc-del-selection) (define-key calc-mode-map "j\177" 'calc-del-selection) (define-key calc-mode-map "j'" 'calc-enter-selection) (define-key calc-mode-map "j`" 'calc-edit-selection) (define-key calc-mode-map "j+" 'calc-sel-add-both-sides) (define-key calc-mode-map "j-" 'calc-sel-sub-both-sides) (define-key calc-mode-map "j*" 'calc-sel-mult-both-sides) (define-key calc-mode-map "j/" 'calc-sel-div-both-sides) (define-key calc-mode-map "j\"" 'calc-sel-expand-formula) (define-key calc-mode-map "k" nil) (define-key calc-mode-map "k?" 'calc-k-prefix-help) (define-key calc-mode-map "ka" 'calc-random-again) (define-key calc-mode-map "kb" 'calc-bernoulli-number) (define-key calc-mode-map "kc" 'calc-choose) (define-key calc-mode-map "kd" 'calc-double-factorial) (define-key calc-mode-map "ke" 'calc-euler-number) (define-key calc-mode-map "kf" 'calc-prime-factors) (define-key calc-mode-map "kg" 'calc-gcd) (define-key calc-mode-map "kh" 'calc-shuffle) (define-key calc-mode-map "kl" 'calc-lcm) (define-key calc-mode-map "km" 'calc-moebius) (define-key calc-mode-map "kn" 'calc-next-prime) (define-key calc-mode-map "kp" 'calc-prime-test) (define-key calc-mode-map "kr" 'calc-random) (define-key calc-mode-map "ks" 'calc-stirling-number) (define-key calc-mode-map "kt" 'calc-totient) (define-key calc-mode-map "kB" 'calc-utpb) (define-key calc-mode-map "kC" 'calc-utpc) (define-key calc-mode-map "kE" 'calc-extended-gcd) (define-key calc-mode-map "kF" 'calc-utpf) (define-key calc-mode-map "kK" 'calc-keep-args) (define-key calc-mode-map "kN" 'calc-utpn) (define-key calc-mode-map "kP" 'calc-utpp) (define-key calc-mode-map "kT" 'calc-utpt) (define-key calc-mode-map "m" nil) (define-key calc-mode-map "m?" 'calc-m-prefix-help) (define-key calc-mode-map "ma" 'calc-algebraic-mode) (define-key calc-mode-map "md" 'calc-degrees-mode) (define-key calc-mode-map "mf" 'calc-frac-mode) (define-key calc-mode-map "mg" 'calc-get-modes) (define-key calc-mode-map "mh" 'calc-hms-mode) (define-key calc-mode-map "mi" 'calc-infinite-mode) (define-key calc-mode-map "mm" 'calc-save-modes) (define-key calc-mode-map "mp" 'calc-polar-mode) (define-key calc-mode-map "mr" 'calc-radians-mode) (define-key calc-mode-map "ms" 'calc-symbolic-mode) (define-key calc-mode-map "mt" 'calc-total-algebraic-mode) (define-key calc-mode-map "\emt" 'calc-total-algebraic-mode) (define-key calc-mode-map "\em\et" 'calc-total-algebraic-mode) (define-key calc-mode-map "mv" 'calc-matrix-mode) (define-key calc-mode-map "mw" 'calc-working) (define-key calc-mode-map "mx" 'calc-always-load-extensions) (define-key calc-mode-map "mA" 'calc-alg-simplify-mode) (define-key calc-mode-map "mB" 'calc-bin-simplify-mode) (define-key calc-mode-map "mC" 'calc-auto-recompute) (define-key calc-mode-map "mD" 'calc-default-simplify-mode) (define-key calc-mode-map "mE" 'calc-ext-simplify-mode) (define-key calc-mode-map "mF" 'calc-settings-file-name) (define-key calc-mode-map "mM" 'calc-more-recursion-depth) (define-key calc-mode-map "mN" 'calc-num-simplify-mode) (define-key calc-mode-map "mO" 'calc-no-simplify-mode) (define-key calc-mode-map "mR" 'calc-mode-record-mode) (define-key calc-mode-map "mS" 'calc-shift-prefix) (define-key calc-mode-map "mU" 'calc-units-simplify-mode) (define-key calc-mode-map "mX" 'calc-load-everything) (define-key calc-mode-map "r" nil) (define-key calc-mode-map "r?" 'calc-r-prefix-help) (define-key calc-mode-map "s" nil) (define-key calc-mode-map "s?" 'calc-s-prefix-help) (define-key calc-mode-map "sc" 'calc-copy-variable) (define-key calc-mode-map "sd" 'calc-declare-variable) (define-key calc-mode-map "se" 'calc-edit-variable) (define-key calc-mode-map "si" 'calc-insert-variables) (define-key calc-mode-map "sl" 'calc-let) (define-key calc-mode-map "sm" 'calc-store-map) (define-key calc-mode-map "sn" 'calc-store-neg) (define-key calc-mode-map "sp" 'calc-permanent-variable) (define-key calc-mode-map "sr" 'calc-recall) (define-key calc-mode-map "ss" 'calc-store) (define-key calc-mode-map "st" 'calc-store-into) (define-key calc-mode-map "su" 'calc-unstore) (define-key calc-mode-map "sx" 'calc-store-exchange) (define-key calc-mode-map "sA" 'calc-edit-AlgSimpRules) (define-key calc-mode-map "sD" 'calc-edit-Decls) (define-key calc-mode-map "sE" 'calc-edit-EvalRules) (define-key calc-mode-map "sF" 'calc-edit-FitRules) (define-key calc-mode-map "sG" 'calc-edit-GenCount) (define-key calc-mode-map "sH" 'calc-edit-Holidays) (define-key calc-mode-map "sI" 'calc-edit-IntegLimit) (define-key calc-mode-map "sL" 'calc-edit-LineStyles) (define-key calc-mode-map "sP" 'calc-edit-PointStyles) (define-key calc-mode-map "sR" 'calc-edit-PlotRejects) (define-key calc-mode-map "sS" 'calc-sin) (define-key calc-mode-map "sT" 'calc-edit-TimeZone) (define-key calc-mode-map "sU" 'calc-edit-Units) (define-key calc-mode-map "sX" 'calc-edit-ExtSimpRules) (define-key calc-mode-map "s+" 'calc-store-plus) (define-key calc-mode-map "s-" 'calc-store-minus) (define-key calc-mode-map "s*" 'calc-store-times) (define-key calc-mode-map "s/" 'calc-store-div) (define-key calc-mode-map "s^" 'calc-store-power) (define-key calc-mode-map "s|" 'calc-store-concat) (define-key calc-mode-map "s&" 'calc-store-inv) (define-key calc-mode-map "s[" 'calc-store-decr) (define-key calc-mode-map "s]" 'calc-store-incr) (define-key calc-mode-map "s:" 'calc-assign) (define-key calc-mode-map "s=" 'calc-evalto) (define-key calc-mode-map "t" nil) (define-key calc-mode-map "t?" 'calc-t-prefix-help) (define-key calc-mode-map "tb" 'calc-trail-backward) (define-key calc-mode-map "td" 'calc-trail-display) (define-key calc-mode-map "tf" 'calc-trail-forward) (define-key calc-mode-map "th" 'calc-trail-here) (define-key calc-mode-map "ti" 'calc-trail-in) (define-key calc-mode-map "tk" 'calc-trail-kill) (define-key calc-mode-map "tm" 'calc-trail-marker) (define-key calc-mode-map "tn" 'calc-trail-next) (define-key calc-mode-map "to" 'calc-trail-out) (define-key calc-mode-map "tp" 'calc-trail-previous) (define-key calc-mode-map "tr" 'calc-trail-isearch-backward) (define-key calc-mode-map "ts" 'calc-trail-isearch-forward) (define-key calc-mode-map "ty" 'calc-trail-yank) (define-key calc-mode-map "t[" 'calc-trail-first) (define-key calc-mode-map "t]" 'calc-trail-last) (define-key calc-mode-map "t<" 'calc-trail-scroll-left) (define-key calc-mode-map "t>" 'calc-trail-scroll-right) (define-key calc-mode-map "t{" 'calc-trail-backward) (define-key calc-mode-map "t}" 'calc-trail-forward) (define-key calc-mode-map "t." 'calc-full-trail-vectors) (define-key calc-mode-map "tC" 'calc-convert-time-zones) (define-key calc-mode-map "tD" 'calc-date) (define-key calc-mode-map "tI" 'calc-inc-month) (define-key calc-mode-map "tJ" 'calc-julian) (define-key calc-mode-map "tM" 'calc-new-month) (define-key calc-mode-map "tN" 'calc-now) (define-key calc-mode-map "tP" 'calc-date-part) (define-key calc-mode-map "tT" 'calc-tan) (define-key calc-mode-map "tU" 'calc-unix-time) (define-key calc-mode-map "tW" 'calc-new-week) (define-key calc-mode-map "tY" 'calc-new-year) (define-key calc-mode-map "tZ" 'calc-time-zone) (define-key calc-mode-map "t+" 'calc-business-days-plus) (define-key calc-mode-map "t-" 'calc-business-days-minus) (define-key calc-mode-map "u" 'nil) (define-key calc-mode-map "u?" 'calc-u-prefix-help) (define-key calc-mode-map "ua" 'calc-autorange-units) (define-key calc-mode-map "ub" 'calc-base-units) (define-key calc-mode-map "uc" 'calc-convert-units) (define-key calc-mode-map "ud" 'calc-define-unit) (define-key calc-mode-map "ue" 'calc-explain-units) (define-key calc-mode-map "ug" 'calc-get-unit-definition) (define-key calc-mode-map "up" 'calc-permanent-units) (define-key calc-mode-map "ur" 'calc-remove-units) (define-key calc-mode-map "us" 'calc-simplify-units) (define-key calc-mode-map "ut" 'calc-convert-temperature) (define-key calc-mode-map "uu" 'calc-undefine-unit) (define-key calc-mode-map "uv" 'calc-enter-units-table) (define-key calc-mode-map "ux" 'calc-extract-units) (define-key calc-mode-map "uV" 'calc-view-units-table) (define-key calc-mode-map "uC" 'calc-vector-covariance) (define-key calc-mode-map "uG" 'calc-vector-geometric-mean) (define-key calc-mode-map "uM" 'calc-vector-mean) (define-key calc-mode-map "uN" 'calc-vector-min) (define-key calc-mode-map "uS" 'calc-vector-sdev) (define-key calc-mode-map "uU" 'calc-undo) (define-key calc-mode-map "uX" 'calc-vector-max) (define-key calc-mode-map "u#" 'calc-vector-count) (define-key calc-mode-map "u+" 'calc-vector-sum) (define-key calc-mode-map "u*" 'calc-vector-product) (define-key calc-mode-map "v" 'nil) (define-key calc-mode-map "v?" 'calc-v-prefix-help) (define-key calc-mode-map "va" 'calc-arrange-vector) (define-key calc-mode-map "vb" 'calc-build-vector) (define-key calc-mode-map "vc" 'calc-mcol) (define-key calc-mode-map "vd" 'calc-diag) (define-key calc-mode-map "ve" 'calc-expand-vector) (define-key calc-mode-map "vf" 'calc-vector-find) (define-key calc-mode-map "vh" 'calc-head) (define-key calc-mode-map "vi" 'calc-ident) (define-key calc-mode-map "vk" 'calc-cons) (define-key calc-mode-map "vl" 'calc-vlength) (define-key calc-mode-map "vm" 'calc-mask-vector) (define-key calc-mode-map "vn" 'calc-rnorm) (define-key calc-mode-map "vp" 'calc-pack) (define-key calc-mode-map "vr" 'calc-mrow) (define-key calc-mode-map "vs" 'calc-subvector) (define-key calc-mode-map "vt" 'calc-transpose) (define-key calc-mode-map "vu" 'calc-unpack) (define-key calc-mode-map "vv" 'calc-reverse-vector) (define-key calc-mode-map "vx" 'calc-index) (define-key calc-mode-map "vA" 'calc-apply) (define-key calc-mode-map "vC" 'calc-cross) (define-key calc-mode-map "vD" 'calc-mdet) (define-key calc-mode-map "vE" 'calc-set-enumerate) (define-key calc-mode-map "vF" 'calc-set-floor) (define-key calc-mode-map "vG" 'calc-grade) (define-key calc-mode-map "vH" 'calc-histogram) (define-key calc-mode-map "vI" 'calc-inner-product) (define-key calc-mode-map "vJ" 'calc-conj-transpose) (define-key calc-mode-map "vL" 'calc-mlud) (define-key calc-mode-map "vM" 'calc-map) (define-key calc-mode-map "vN" 'calc-cnorm) (define-key calc-mode-map "vO" 'calc-outer-product) (define-key calc-mode-map "vR" 'calc-reduce) (define-key calc-mode-map "vS" 'calc-sort) (define-key calc-mode-map "vT" 'calc-mtrace) (define-key calc-mode-map "vU" 'calc-accumulate) (define-key calc-mode-map "vV" 'calc-set-union) (define-key calc-mode-map "vX" 'calc-set-xor) (define-key calc-mode-map "v^" 'calc-set-intersect) (define-key calc-mode-map "v-" 'calc-set-difference) (define-key calc-mode-map "v~" 'calc-set-complement) (define-key calc-mode-map "v:" 'calc-set-span) (define-key calc-mode-map "v#" 'calc-set-cardinality) (define-key calc-mode-map "v+" 'calc-remove-duplicates) (define-key calc-mode-map "v&" 'calc-inv) (define-key calc-mode-map "v<" 'calc-matrix-left-justify) (define-key calc-mode-map "v=" 'calc-matrix-center-justify) (define-key calc-mode-map "v>" 'calc-matrix-right-justify) (define-key calc-mode-map "v." 'calc-full-vectors) (define-key calc-mode-map "v/" 'calc-break-vectors) (define-key calc-mode-map "v," 'calc-vector-commas) (define-key calc-mode-map "v[" 'calc-vector-brackets) (define-key calc-mode-map "v]" 'calc-matrix-brackets) (define-key calc-mode-map "v{" 'calc-vector-braces) (define-key calc-mode-map "v}" 'calc-matrix-brackets) (define-key calc-mode-map "v(" 'calc-vector-parens) (define-key calc-mode-map "v)" 'calc-matrix-brackets) (define-key calc-mode-map "V" (lookup-key calc-mode-map "v")) (define-key calc-mode-map "z" 'nil) (define-key calc-mode-map "z?" 'calc-z-prefix-help) (define-key calc-mode-map "Z" 'nil) (define-key calc-mode-map "Z?" 'calc-shift-Z-prefix-help) (define-key calc-mode-map "ZC" 'calc-user-define-composition) (define-key calc-mode-map "ZD" 'calc-user-define) (define-key calc-mode-map "ZE" 'calc-user-define-edit) (define-key calc-mode-map "ZF" 'calc-user-define-formula) (define-key calc-mode-map "ZG" 'calc-get-user-defn) (define-key calc-mode-map "ZI" 'calc-user-define-invocation) (define-key calc-mode-map "ZK" 'calc-user-define-kbd-macro) (define-key calc-mode-map "ZP" 'calc-user-define-permanent) (define-key calc-mode-map "ZS" 'calc-edit-user-syntax) (define-key calc-mode-map "ZT" 'calc-timing) (define-key calc-mode-map "ZU" 'calc-user-undefine) (define-key calc-mode-map "Z[" 'calc-kbd-if) (define-key calc-mode-map "Z:" 'calc-kbd-else) (define-key calc-mode-map "Z|" 'calc-kbd-else-if) (define-key calc-mode-map "Z]" 'calc-kbd-end-if) (define-key calc-mode-map "Z<" 'calc-kbd-repeat) (define-key calc-mode-map "Z>" 'calc-kbd-end-repeat) (define-key calc-mode-map "Z(" 'calc-kbd-for) (define-key calc-mode-map "Z)" 'calc-kbd-end-for) (define-key calc-mode-map "Z{" 'calc-kbd-loop) (define-key calc-mode-map "Z}" 'calc-kbd-end-loop) (define-key calc-mode-map "Z/" 'calc-kbd-break) (define-key calc-mode-map "Z`" 'calc-kbd-push) (define-key calc-mode-map "Z'" 'calc-kbd-pop) (define-key calc-mode-map "Z=" 'calc-kbd-report) (define-key calc-mode-map "Z#" 'calc-kbd-query) (calc-init-prefixes) (mapcar (function (lambda (x) (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 "r%c" x) 'calc-recall-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 "u%c" x) 'calc-quick-units))) "0123456789") (or calc-emacs-type-19 (progn (let ((i ?A)) (while (and (<= i ?z) (vectorp calc-mode-map)) (if (eq (car-safe (aref calc-mode-map i)) 'keymap) (aset calc-mode-map i (cons 'keymap (cons (cons ?\e (aref calc-mode-map i)) (cdr (aref calc-mode-map i)))))) (setq i (1+ i)))) (setq calc-alg-map (copy-sequence calc-mode-map) calc-alg-esc-map (copy-sequence esc-map)) (let ((i 32)) (while (< i 127) (or (memq i '(?' ?` ?= ??)) (aset calc-alg-map i 'calc-auto-algebraic-entry)) (or (memq i '(?# ?x ?0 ?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9)) (aset calc-alg-esc-map i (aref calc-mode-map i))) (setq i (1+ i)))) (define-key calc-alg-map "\e" calc-alg-esc-map) (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) )) ;; The following is a relic for backward compatability only. ;; The calc-define property list is now the recommended method. (if (and (boundp 'calc-ext-defs) calc-ext-defs) (progn (calc-need-macros) (message "Evaluating calc-ext-defs...") (eval (cons 'progn calc-ext-defs)) (setq calc-ext-defs nil))) ;;;; (Autoloads here) (mapcar (function (lambda (x) (mapcar (function (lambda (func) (autoload func (car x)))) (cdr x)))) '( ("calc-alg" calc-Need-calc-alg calc-has-rules calc-modify-simplify-mode calcFunc-collect calcFunc-esimplify calcFunc-islin calcFunc-islinnt calcFunc-lin calcFunc-linnt calcFunc-simplify calcFunc-subst math-beforep math-build-polynomial-expr math-expand-formula math-expr-contains math-expr-contains-count math-expr-depends math-expr-height math-expr-subst math-expr-weight math-integer-plus math-is-linear math-is-multiple math-is-polynomial math-linear-in math-multiple-of math-need-std-simps math-poly-depends math-poly-mix math-poly-mul math-poly-simplify math-poly-zerop math-polynomial-base math-polynomial-p math-recompile-eval-rules math-simplify math-simplify-exp math-simplify-extended math-simplify-sqrt math-to-simple-fraction) ("calc-alg-2" calc-Need-calc-alg-2 calcFunc-asum calcFunc-deriv calcFunc-ffinv calcFunc-finv calcFunc-fsolve calcFunc-gpoly calcFunc-integ calcFunc-poly calcFunc-prod calcFunc-roots calcFunc-solve calcFunc-sum calcFunc-table calcFunc-taylor calcFunc-tderiv math-expr-calls math-integral-q02 math-integral-q12 math-integral-rational-funcs math-lcm-denoms math-looks-evenp math-poly-all-roots math-prod-rec math-reject-solution math-solve-eqn math-solve-for math-sum-rec math-try-integral) ("calc-alg-3" calc-Need-calc-alg-3 calcFunc-efit calcFunc-fit calcFunc-fitdummy calcFunc-fitparam calcFunc-fitvar calcFunc-hasfitparams calcFunc-hasfitvars calcFunc-maximize calcFunc-minimize calcFunc-ninteg calcFunc-polint calcFunc-ratint calcFunc-root calcFunc-wmaximize calcFunc-wminimize calcFunc-wroot calcFunc-xfit math-find-minimum math-find-root math-ninteg-evaluate math-ninteg-midpoint math-ninteg-romberg math-poly-interp) ("calc-arith" calc-Need-calc-arith calcFunc-abs calcFunc-abssqr calcFunc-add calcFunc-ceil calcFunc-decr calcFunc-deven calcFunc-dimag calcFunc-dint calcFunc-div calcFunc-dnatnum calcFunc-dneg calcFunc-dnonneg calcFunc-dnonzero calcFunc-dnumint calcFunc-dodd calcFunc-dpos calcFunc-drange calcFunc-drat calcFunc-dreal calcFunc-dscalar calcFunc-fceil calcFunc-ffloor calcFunc-float calcFunc-fround calcFunc-frounde calcFunc-froundu calcFunc-ftrunc calcFunc-idiv calcFunc-incr calcFunc-mant calcFunc-max calcFunc-min calcFunc-mod calcFunc-mul calcFunc-neg calcFunc-percent calcFunc-pow calcFunc-relch calcFunc-round calcFunc-rounde calcFunc-roundu calcFunc-scf calcFunc-sub calcFunc-xpon math-abs math-abs-approx math-add-objects-fancy math-add-or-sub math-add-symb-fancy math-ceiling math-combine-prod math-combine-sum math-div-by-zero math-div-objects-fancy math-div-symb-fancy math-div-zero math-float-fancy math-floor-fancy math-floor-special math-guess-if-neg math-intv-constp math-known-evenp math-known-imagp math-known-integerp math-known-matrixp math-known-negp math-known-nonnegp math-known-nonposp math-known-nonzerop math-known-num-integerp math-known-oddp math-known-posp math-known-realp math-known-scalarp math-max math-min math-mod-fancy math-mul-float math-mul-objects-fancy math-mul-or-div math-mul-symb-fancy math-mul-zero math-neg-fancy math-neg-float math-okay-neg math-possible-signs math-possible-types math-pow-fancy math-pow-mod math-pow-of-zero math-pow-zero math-quarter-integer math-round math-setup-declarations math-sqr math-sqr-float math-trunc-fancy math-trunc-special) ("calc-bin" calc-Need-calc-bin calcFunc-and calcFunc-ash calcFunc-clip calcFunc-diff calcFunc-lsh calcFunc-not calcFunc-or calcFunc-rash calcFunc-rot calcFunc-rsh calcFunc-xor math-clip math-compute-max-digits math-convert-radix-digits math-float-parts math-format-bignum-binary math-format-bignum-hex math-format-bignum-octal math-format-bignum-radix math-format-binary math-format-radix math-format-radix-float math-integer-log2 math-power-of-2 math-radix-float-power) ("calc-comb" calc-Need-calc-comb calc-report-prime-test calcFunc-choose calcFunc-dfact calcFunc-egcd calcFunc-fact calcFunc-gcd calcFunc-lcm calcFunc-moebius calcFunc-nextprime calcFunc-perm calcFunc-prevprime calcFunc-prfac calcFunc-prime calcFunc-random calcFunc-shuffle calcFunc-stir1 calcFunc-stir2 calcFunc-totient math-init-random-base math-member math-prime-test math-random-base) ("calc-comp" calc-Need-calc-comp calcFunc-cascent calcFunc-cdescent calcFunc-cheight calcFunc-cwidth math-comp-ascent math-comp-descent math-comp-height math-comp-width math-compose-expr math-composition-to-string math-stack-value-offset-fancy math-vector-is-string math-vector-to-string) ("calc-cplx" calc-Need-calc-cplx calcFunc-arg calcFunc-conj calcFunc-im calcFunc-polar calcFunc-re calcFunc-rect math-complex math-fix-circular math-imaginary math-imaginary-i math-normalize-polar math-polar math-want-polar) ("calc-embed" calc-Need-calc-embed calc-do-embedded calc-do-embedded-activate calc-embedded-evaluate-expr calc-embedded-modes-change calc-embedded-var-change) ("calc-fin" calc-Need-calc-fin calc-to-percentage calcFunc-ddb calcFunc-fv calcFunc-fvb calcFunc-fvl calcFunc-irr calcFunc-irrb calcFunc-nper calcFunc-nperb calcFunc-nperl calcFunc-npv calcFunc-npvb calcFunc-pmt calcFunc-pmtb calcFunc-pv calcFunc-pvb calcFunc-pvl calcFunc-rate calcFunc-rateb calcFunc-ratel calcFunc-sln calcFunc-syd) ("calc-forms" calc-Need-calc-forms calcFunc-badd calcFunc-bsub calcFunc-date calcFunc-day calcFunc-dsadj calcFunc-hms calcFunc-holiday calcFunc-hour calcFunc-incmonth calcFunc-incyear calcFunc-intv calcFunc-julian calcFunc-makemod calcFunc-minute calcFunc-month calcFunc-newmonth calcFunc-newweek calcFunc-newyear calcFunc-now calcFunc-pwday calcFunc-sdev calcFunc-second calcFunc-time calcFunc-tzconv calcFunc-tzone calcFunc-unixtime calcFunc-weekday calcFunc-year calcFunc-yearday math-combine-intervals math-date-parts math-date-to-dt math-div-mod math-dt-to-date math-format-date math-from-business-day math-from-hms math-make-intv math-make-mod math-make-sdev math-mod-intv math-normalize-hms math-normalize-mod math-parse-date math-read-angle-brackets math-setup-add-holidays math-setup-holidays math-setup-year-holidays math-sort-intv math-to-business-day math-to-hms) ("calc-frac" calc-Need-calc-frac calc-add-fractions calc-div-fractions calc-mul-fractions calcFunc-fdiv calcFunc-frac math-make-frac) ("calc-funcs" calc-Need-calc-funcs calc-prob-dist calcFunc-bern calcFunc-besJ calcFunc-besY calcFunc-beta calcFunc-betaB calcFunc-betaI calcFunc-erf calcFunc-erfc calcFunc-euler calcFunc-gamma calcFunc-gammaG calcFunc-gammaP calcFunc-gammaQ calcFunc-gammag calcFunc-ltpb calcFunc-ltpc calcFunc-ltpf calcFunc-ltpn calcFunc-ltpp calcFunc-ltpt calcFunc-utpb calcFunc-utpc calcFunc-utpf calcFunc-utpn calcFunc-utpp calcFunc-utpt math-bernoulli-number math-gammap1-raw) ("calc-graph" calc-Need-calc-graph calc-graph-show-tty) ("calc-help" calc-Need-calc-help) ("calc-incom" calc-Need-calc-incom calc-digit-dots) ("calc-keypd" calc-Need-calc-keypd calc-do-keypad calc-keypad-x-left-click calc-keypad-x-middle-click calc-keypad-x-right-click) ("calc-lang" calc-Need-calc-lang calc-set-language math-read-big-balance math-read-big-rec) ("calc-map" calc-Need-calc-map calc-get-operator calcFunc-accum calcFunc-afixp calcFunc-anest calcFunc-apply calcFunc-call calcFunc-fixp calcFunc-inner calcFunc-map calcFunc-mapa calcFunc-mapc calcFunc-mapd calcFunc-mapeq calcFunc-mapeqp calcFunc-mapeqr calcFunc-mapr calcFunc-nest calcFunc-outer calcFunc-raccum calcFunc-reduce calcFunc-reducea calcFunc-reducec calcFunc-reduced calcFunc-reducer calcFunc-rreduce calcFunc-rreducea calcFunc-rreducec calcFunc-rreduced calcFunc-rreducer math-build-call math-calcFunc-to-var math-multi-subst math-multi-subst-rec math-var-to-calcFunc) ("calc-mat" calc-Need-calc-mat calcFunc-det calcFunc-lud calcFunc-tr math-col-matrix math-lud-solve math-matrix-inv-raw math-matrix-lud math-mul-mat-vec math-mul-mats math-row-matrix) ("calc-math" calc-Need-calc-math calcFunc-alog calcFunc-arccos calcFunc-arccosh calcFunc-arcsin calcFunc-arcsincos calcFunc-arcsinh calcFunc-arctan calcFunc-arctan2 calcFunc-arctanh calcFunc-cos calcFunc-cosh calcFunc-deg calcFunc-exp calcFunc-exp10 calcFunc-expm1 calcFunc-hypot calcFunc-ilog calcFunc-isqrt calcFunc-ln calcFunc-lnp1 calcFunc-log calcFunc-log10 calcFunc-nroot calcFunc-rad calcFunc-sin calcFunc-sincos calcFunc-sinh calcFunc-sqr calcFunc-sqrt calcFunc-tan calcFunc-tanh math-arccos-raw math-arcsin-raw math-arctan-raw math-arctan2-raw math-cos-raw math-exp-minus-1-raw math-exp-raw math-from-radians math-from-radians-2 math-hypot math-infinite-dir math-isqrt-small math-ln-raw math-nearly-equal math-nearly-equal-float math-nearly-zerop math-nearly-zerop-float math-nth-root math-sin-cos-raw math-sin-raw math-sqrt math-sqrt-float math-sqrt-raw math-tan-raw math-to-radians math-to-radians-2) ("calc-mode" calc-Need-calc-mode math-get-modes-vec) ("calc-poly" calc-Need-calc-poly calcFunc-apart calcFunc-expand calcFunc-expandpow calcFunc-factor calcFunc-factors calcFunc-nrat calcFunc-pcont calcFunc-pdeg calcFunc-pdiv calcFunc-pdivide calcFunc-pdivrem calcFunc-pgcd calcFunc-plead calcFunc-pprim calcFunc-prem math-accum-factors math-atomic-factorp math-div-poly-const math-div-thru math-expand-power math-expand-term math-factor-contains math-factor-expr math-factor-expr-part math-factor-expr-try math-factor-finish math-factor-poly-coefs math-factor-protect math-mul-thru math-padded-polynomial math-partial-fractions math-poly-degree math-poly-deriv-coefs math-poly-gcd-frac-list math-poly-modulus-rec math-ratpoly-p math-to-ratpoly math-to-ratpoly-rec) ("calc-prog" calc-Need-calc-prog calc-default-formula-arglist calc-execute-kbd-macro calc-finish-user-syntax-edit calc-fix-token-name calc-fix-user-formula calc-read-parse-table calc-read-parse-table-part calc-subsetp calc-write-parse-table calc-write-parse-table-part calcFunc-constant calcFunc-eq calcFunc-geq calcFunc-gt calcFunc-if calcFunc-in calcFunc-integer calcFunc-istrue calcFunc-land calcFunc-leq calcFunc-lnot calcFunc-lor calcFunc-lt calcFunc-negative calcFunc-neq calcFunc-nonvar calcFunc-real calcFunc-refers calcFunc-rmeq calcFunc-typeof calcFunc-variable math-body-refers-to math-break math-composite-inequalities math-do-defmath math-handle-for math-handle-foreach math-normalize-logical-op math-return) ("calc-rewr" calc-Need-calc-rewr calcFunc-match calcFunc-matches calcFunc-matchnot calcFunc-rewrite calcFunc-vmatches math-apply-rewrites math-compile-patterns math-compile-rewrites math-flatten-lands math-match-patterns math-rewrite math-rewrite-heads) ("calc-rules" calc-CommuteRules calc-DistribRules calc-FactorRules calc-FitRules calc-IntegAfterRules calc-InvertRules calc-JumpRules calc-MergeRules calc-Need-calc-rules calc-NegateRules calc-compile-rule-set) ("calc-sel" calc-Need-calc-sel calc-auto-selection calc-delete-selection calc-encase-atoms calc-find-assoc-parent-formula calc-find-parent-formula calc-find-sub-formula calc-prepare-selection calc-preserve-point calc-replace-selections calc-replace-sub-formula calc-roll-down-with-selections calc-roll-up-with-selections calc-sel-error) ("calc-sel-2" calc-Need-calc-sel-2) ("calc-stat" calc-Need-calc-stat calc-vector-op calcFunc-agmean calcFunc-vcorr calcFunc-vcount calcFunc-vcov calcFunc-vflat calcFunc-vgmean calcFunc-vhmean calcFunc-vmax calcFunc-vmean calcFunc-vmeane calcFunc-vmedian calcFunc-vmin calcFunc-vpcov calcFunc-vprod calcFunc-vpsdev calcFunc-vpvar calcFunc-vsdev calcFunc-vsum calcFunc-vvar math-flatten-many-vecs) ("calc-store" calc-Need-calc-store calc-read-var-name calc-store-value calc-var-name) ("calc-stuff" calc-Need-calc-stuff calc-explain-why calcFunc-clean calcFunc-pclean calcFunc-pfloat calcFunc-pfrac) ("calc-trail" calc-Need-calc-trail) ("calc-undo" calc-Need-calc-undo) ("calc-units" calc-Need-calc-units calcFunc-usimplify math-build-units-table math-build-units-table-buffer math-check-unit-name math-convert-temperature math-convert-units math-extract-units math-remove-units math-simplify-units math-single-units-in-expr-p math-to-standard-units math-units-in-expr-p) ("calc-vec" calc-Need-calc-vec calcFunc-append calcFunc-appendrev calcFunc-arrange calcFunc-cnorm calcFunc-cons calcFunc-cross calcFunc-ctrn calcFunc-cvec calcFunc-diag calcFunc-find calcFunc-getdiag calcFunc-grade calcFunc-head calcFunc-histogram calcFunc-idn calcFunc-index calcFunc-mcol calcFunc-mdims calcFunc-mrcol calcFunc-mrow calcFunc-mrrow calcFunc-pack calcFunc-rcons calcFunc-rdup calcFunc-rev calcFunc-rgrade calcFunc-rhead calcFunc-rnorm calcFunc-rsort calcFunc-rsubvec calcFunc-rtail calcFunc-sort calcFunc-subscr calcFunc-subvec calcFunc-tail calcFunc-trn calcFunc-unpack calcFunc-unpackt calcFunc-vcard calcFunc-vcompl calcFunc-vconcat calcFunc-vconcatrev calcFunc-vdiff calcFunc-vec calcFunc-venum calcFunc-vexp calcFunc-vfloor calcFunc-vint calcFunc-vlen calcFunc-vmask calcFunc-vpack calcFunc-vspan calcFunc-vunion calcFunc-vunpack calcFunc-vxor math-check-for-commas math-clean-set math-copy-matrix math-dimension-error math-dot-product math-flatten-vector math-map-vec math-map-vec-2 math-mat-col math-mimic-ident math-prepare-set math-read-brackets math-reduce-cols math-reduce-vec math-transpose) ("calc-yank" calc-Need-calc-yank calc-alg-edit calc-clean-newlines calc-do-grab-rectangle calc-do-grab-region calc-finish-stack-edit calc-force-refresh calc-locate-cursor-element calc-show-edit-buffer) )) (mapcar (function (lambda (x) (mapcar (function (lambda (cmd) (autoload cmd (car x) nil t))) (cdr x)))) '( ("calc-alg" calc-alg-evaluate calc-apart calc-collect calc-expand calc-expand-formula calc-factor calc-normalize-rat calc-poly-div calc-poly-div-rem calc-poly-gcd calc-poly-rem calc-simplify calc-simplify-extended calc-substitute) ("calc-alg-2" calc-alt-summation calc-derivative calc-dump-integral-cache calc-integral calc-num-integral calc-poly-roots calc-product calc-solve-for calc-summation calc-tabulate calc-taylor) ("calc-alg-3" calc-curve-fit calc-find-maximum calc-find-minimum calc-find-root calc-poly-interp) ("calc-arith" calc-abs calc-abssqr calc-ceiling calc-decrement calc-floor calc-idiv calc-increment calc-mant-part calc-max calc-min calc-round calc-scale-float calc-sign calc-trunc calc-xpon-part) ("calc-bin" calc-and calc-binary-radix calc-clip calc-decimal-radix calc-diff calc-hex-radix calc-leading-zeros calc-lshift-arith calc-lshift-binary calc-not calc-octal-radix calc-or calc-radix calc-rotate-binary calc-rshift-arith calc-rshift-binary calc-word-size calc-xor) ("calc-comb" calc-choose calc-double-factorial calc-extended-gcd calc-factorial calc-gamma calc-gcd calc-lcm calc-moebius calc-next-prime calc-perm calc-prev-prime calc-prime-factors calc-prime-test calc-random calc-random-again calc-rrandom calc-shuffle calc-totient) ("calc-cplx" calc-argument calc-complex-notation calc-i-notation calc-im calc-j-notation calc-polar calc-polar-mode calc-re) ("calc-embed" calc-embedded-copy-formula-as-kill calc-embedded-duplicate calc-embedded-edit calc-embedded-forget calc-embedded-kill-formula calc-embedded-mark-formula calc-embedded-new-formula calc-embedded-next calc-embedded-previous calc-embedded-select calc-embedded-update-formula calc-embedded-word calc-find-globals calc-show-plain) ("calc-fin" calc-convert-percent calc-fin-ddb calc-fin-fv calc-fin-irr calc-fin-nper calc-fin-npv calc-fin-pmt calc-fin-pv calc-fin-rate calc-fin-sln calc-fin-syd calc-percent-change) ("calc-forms" calc-business-days-minus calc-business-days-plus calc-convert-time-zones calc-date calc-date-notation calc-date-part calc-from-hms calc-hms-mode calc-hms-notation calc-inc-month calc-julian calc-new-month calc-new-week calc-new-year calc-now calc-time calc-time-zone calc-to-hms calc-unix-time) ("calc-frac" calc-fdiv calc-frac-mode calc-fraction calc-over-notation calc-slash-notation) ("calc-funcs" calc-bernoulli-number calc-bessel-J calc-bessel-Y calc-beta calc-erf calc-erfc calc-euler-number calc-inc-beta calc-inc-gamma calc-stirling-number calc-utpb calc-utpc calc-utpf calc-utpn calc-utpp calc-utpt) ("calc-graph" calc-graph-add calc-graph-add-3d calc-graph-border calc-graph-clear calc-graph-command calc-graph-delete calc-graph-device calc-graph-display calc-graph-fast calc-graph-fast-3d calc-graph-geometry calc-graph-grid calc-graph-header calc-graph-hide calc-graph-juggle calc-graph-key calc-graph-kill calc-graph-line-style calc-graph-log-x calc-graph-log-y calc-graph-log-z calc-graph-name calc-graph-num-points calc-graph-output calc-graph-plot calc-graph-point-style calc-graph-print calc-graph-quit calc-graph-range-x calc-graph-range-y calc-graph-range-z calc-graph-show-dumb calc-graph-title-x calc-graph-title-y calc-graph-title-z calc-graph-view-commands calc-graph-view-trail calc-graph-zero-x calc-graph-zero-y) ("calc-help" calc-a-prefix-help calc-b-prefix-help calc-c-prefix-help calc-d-prefix-help calc-describe-function calc-describe-key calc-describe-key-briefly calc-describe-variable calc-f-prefix-help calc-full-help calc-g-prefix-help calc-help-prefix calc-hyperbolic-prefix-help calc-inv-hyp-prefix-help calc-inverse-prefix-help calc-j-prefix-help calc-k-prefix-help calc-m-prefix-help calc-r-prefix-help calc-s-prefix-help calc-t-prefix-help calc-u-prefix-help calc-v-prefix-help) ("calc-incom" calc-begin-complex calc-begin-vector calc-comma calc-dots calc-end-complex calc-end-vector calc-semi) ("calc-keypd" calc-keypad-menu calc-keypad-menu-back calc-keypad-press) ("calc-lang" calc-big-language calc-c-language calc-eqn-language calc-flat-language calc-fortran-language calc-maple-language calc-mathematica-language calc-normal-language calc-pascal-language calc-tex-language calc-unformatted-language) ("calc-map" calc-accumulate calc-apply calc-inner-product calc-map calc-map-equation calc-map-stack calc-outer-product calc-reduce) ("calc-mat" calc-mdet calc-mlud calc-mtrace) ("calc-math" calc-arccos calc-arccosh calc-arcsin calc-arcsinh calc-arctan calc-arctan2 calc-arctanh calc-conj calc-cos calc-cosh 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-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 calc-bin-simplify-mode calc-break-vectors calc-center-justify calc-default-simplify-mode calc-display-raw calc-eng-notation calc-ext-simplify-mode calc-fix-notation calc-full-trail-vectors calc-full-vectors calc-get-modes calc-group-char calc-group-digits calc-infinite-mode calc-left-justify calc-left-label calc-line-breaking calc-line-numbering calc-matrix-brackets calc-matrix-center-justify calc-matrix-left-justify calc-matrix-mode calc-matrix-right-justify calc-mode-record-mode calc-no-simplify-mode calc-normal-notation calc-num-simplify-mode calc-point-char calc-right-justify calc-right-label calc-save-modes calc-sci-notation calc-settings-file-name calc-shift-prefix calc-symbolic-mode calc-total-algebraic-mode calc-truncate-down calc-truncate-stack calc-truncate-up calc-units-simplify-mode calc-vector-braces calc-vector-brackets calc-vector-commas calc-vector-parens calc-working) ("calc-prog" calc-call-last-kbd-macro calc-edit-user-syntax calc-equal-to calc-get-user-defn calc-greater-equal calc-greater-than calc-in-set calc-kbd-break calc-kbd-else calc-kbd-else-if calc-kbd-end-for calc-kbd-end-if calc-kbd-end-loop calc-kbd-end-repeat calc-kbd-for calc-kbd-if calc-kbd-loop calc-kbd-pop calc-kbd-push calc-kbd-query calc-kbd-repeat calc-kbd-report calc-less-equal calc-less-than calc-logical-and calc-logical-if calc-logical-not calc-logical-or calc-not-equal-to calc-pass-errors calc-remove-equal calc-timing calc-user-define calc-user-define-composition calc-user-define-edit calc-user-define-formula calc-user-define-invocation calc-user-define-kbd-macro calc-user-define-permanent calc-user-undefine) ("calc-rewr" calc-match calc-rewrite calc-rewrite-selection) ("calc-sel" calc-break-selections calc-clear-selections calc-copy-selection calc-del-selection calc-edit-selection calc-enable-selections calc-enter-selection calc-sel-add-both-sides calc-sel-div-both-sides calc-sel-evaluate calc-sel-expand-formula calc-sel-mult-both-sides calc-sel-sub-both-sides calc-select-additional calc-select-here calc-select-here-maybe calc-select-less calc-select-more calc-select-next calc-select-once calc-select-once-maybe calc-select-part calc-select-previous calc-show-selections calc-unselect) ("calc-sel-2" calc-commute-left calc-commute-right calc-sel-commute calc-sel-distribute calc-sel-invert calc-sel-isolate calc-sel-jump-equals calc-sel-merge calc-sel-negate calc-sel-unpack) ("calc-stat" calc-vector-correlation calc-vector-count calc-vector-covariance calc-vector-geometric-mean calc-vector-harmonic-mean calc-vector-max calc-vector-mean calc-vector-mean-error calc-vector-median calc-vector-min calc-vector-pop-covariance calc-vector-pop-sdev calc-vector-pop-variance calc-vector-product calc-vector-sdev calc-vector-sum calc-vector-variance) ("calc-store" calc-assign calc-copy-variable calc-declare-variable calc-edit-AlgSimpRules calc-edit-Decls calc-edit-EvalRules calc-edit-ExtSimpRules calc-edit-FitRules calc-edit-GenCount calc-edit-Holidays calc-edit-IntegLimit calc-edit-LineStyles calc-edit-PlotRejects calc-edit-PointStyles calc-edit-TimeZone calc-edit-Units calc-edit-variable calc-evalto calc-insert-variables calc-let calc-permanent-variable calc-recall calc-recall-quick calc-store calc-store-concat calc-store-decr calc-store-div calc-store-exchange calc-store-incr calc-store-into calc-store-into-quick calc-store-inv calc-store-map calc-store-minus calc-store-neg calc-store-plus calc-store-power calc-store-quick calc-store-times calc-subscript calc-unstore) ("calc-stuff" calc-clean calc-clean-num calc-flush-caches calc-less-recursion-depth calc-more-recursion-depth calc-num-prefix calc-version calc-why) ("calc-trail" calc-trail-backward calc-trail-first calc-trail-forward calc-trail-in calc-trail-isearch-backward calc-trail-isearch-forward calc-trail-kill calc-trail-last calc-trail-marker calc-trail-next calc-trail-out calc-trail-previous calc-trail-scroll-left calc-trail-scroll-right calc-trail-yank) ("calc-undo" calc-last-args calc-redo calc-undo) ("calc-units" calc-autorange-units calc-base-units calc-convert-temperature calc-convert-units calc-define-unit calc-enter-units-table calc-explain-units calc-extract-units calc-get-unit-definition calc-permanent-units calc-quick-units calc-remove-units calc-simplify-units calc-undefine-unit calc-view-units-table) ("calc-vec" calc-arrange-vector calc-build-vector calc-cnorm calc-conj-transpose calc-cons calc-cross calc-diag calc-display-strings calc-expand-vector calc-grade calc-head calc-histogram calc-ident calc-index calc-mask-vector calc-mcol calc-mrow calc-pack calc-pack-bits calc-remove-duplicates calc-reverse-vector calc-rnorm calc-set-cardinality calc-set-complement calc-set-difference calc-set-enumerate calc-set-floor calc-set-intersect calc-set-span calc-set-union calc-set-xor calc-sort calc-subvector calc-tail calc-transpose calc-unpack calc-unpack-bits calc-vector-find calc-vlength) ("calc-yank" calc-copy-as-kill calc-copy-region-as-kill calc-copy-to-buffer calc-edit calc-edit-cancel calc-edit-mode calc-kill calc-kill-region calc-yank) )) ) (defun calc-init-prefixes () (if calc-shift-prefix (progn (define-key calc-mode-map "A" (lookup-key calc-mode-map "a")) (define-key calc-mode-map "B" (lookup-key calc-mode-map "b")) (define-key calc-mode-map "C" (lookup-key calc-mode-map "c")) (define-key calc-mode-map "D" (lookup-key calc-mode-map "d")) (define-key calc-mode-map "F" (lookup-key calc-mode-map "f")) (define-key calc-mode-map "G" (lookup-key calc-mode-map "g")) (define-key calc-mode-map "J" (lookup-key calc-mode-map "j")) (define-key calc-mode-map "K" (lookup-key calc-mode-map "k")) (define-key calc-mode-map "M" (lookup-key calc-mode-map "m")) (define-key calc-mode-map "S" (lookup-key calc-mode-map "s")) (define-key calc-mode-map "T" (lookup-key calc-mode-map "t")) (define-key calc-mode-map "U" (lookup-key calc-mode-map "u"))) (define-key calc-mode-map "A" 'calc-abs) (define-key calc-mode-map "B" 'calc-log) (define-key calc-mode-map "C" 'calc-cos) (define-key calc-mode-map "D" 'calc-redo) (define-key calc-mode-map "F" 'calc-floor) (define-key calc-mode-map "G" 'calc-argument) (define-key calc-mode-map "J" 'calc-conj) (define-key calc-mode-map "K" 'calc-keep-args) (define-key calc-mode-map "M" 'calc-more-recursion-depth) (define-key calc-mode-map "S" 'calc-sin) (define-key calc-mode-map "T" 'calc-tan) (define-key calc-mode-map "U" 'calc-undo)) ) (calc-init-extensions) ;;;; Miscellaneous. (defun calc-clear-command-flag (f) (setq calc-command-flags (delq f calc-command-flags)) ) (defun calc-record-message (tag &rest args) (let ((msg (apply 'format args))) (message "%s" msg) (calc-record msg tag)) (calc-clear-command-flag 'clear-message) ) (defun calc-normalize-fancy (val) (let ((simp (if (consp calc-simplify-mode) (car calc-simplify-mode) calc-simplify-mode))) (cond ((eq simp 'binary) (let ((s (math-normalize val))) (if (math-realp s) (math-clip (math-round s)) s))) ((eq simp 'alg) (math-simplify val)) ((eq simp 'ext) (math-simplify-extended val)) ((eq simp 'units) (math-simplify-units val)) (t ; nil, none, num (math-normalize val)))) ) (if (boundp 'calc-help-map) nil (setq calc-help-map (make-keymap)) (define-key calc-help-map "b" 'calc-describe-bindings) (define-key calc-help-map "c" 'calc-describe-key-briefly) (define-key calc-help-map "f" 'calc-describe-function) (define-key calc-help-map "h" 'calc-full-help) (define-key calc-help-map "i" 'calc-info) (define-key calc-help-map "k" 'calc-describe-key) (define-key calc-help-map "n" 'calc-view-news) (define-key calc-help-map "s" 'calc-info-summary) (define-key calc-help-map "t" 'calc-tutorial) (define-key calc-help-map "v" 'calc-describe-variable) (define-key calc-help-map "\C-c" 'calc-describe-copying) (define-key calc-help-map "\C-d" 'calc-describe-distribution) (define-key calc-help-map "\C-n" 'calc-view-news) (define-key calc-help-map "\C-w" 'calc-describe-no-warranty) (define-key calc-help-map "?" 'calc-help-for-help) (define-key calc-help-map "\C-h" 'calc-help-for-help) ) (defun calc-do-prefix-help (msgs group key) (if calc-full-help-flag (list msgs group key) (if (cdr msgs) (progn (setq calc-prefix-help-phase (if (eq this-command last-command) (% (1+ calc-prefix-help-phase) (1+ (length msgs))) 0)) (let ((msg (nth calc-prefix-help-phase msgs))) (message "%s" (if msg (concat group ": " msg ":" (make-string (- (apply 'max (mapcar 'length msgs)) (length msg)) 32) " [MORE]" (if key (concat " " (char-to-string key) "-") "")) (if key (format "%c-" key) ""))))) (setq calc-prefix-help-phase 0) (if key (if msgs (message "%s: %s: %c-" group (car msgs) key) (message "%s: (none) %c-" group (car msgs) key)) (message "%s: %s" group (car msgs)))) (and key (calc-unread-command key))) ) (defvar calc-prefix-help-phase 0) ;;;; Commands. ;;; General. (defun calc-reset (arg) (interactive "P") (save-excursion (or (eq major-mode 'calc-mode) (calc-create-buffer)) (if calc-embedded-info (calc-embedded nil)) (or arg (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) (mapcar (function (lambda (v) (set (car v) (nth 1 v)))) calc-mode-var-list)) (calc-set-language nil nil t) (calc-mode) (let ((executing-kbd-macro "")) ; inhibit message (calc-flush-caches)) (run-hooks 'calc-reset-hook)) (calc-wrapper (let ((win (get-buffer-window (current-buffer)))) (calc-realign 0) (if win (let ((height (- (window-height win) 2))) (set-window-point win (point)) (or (= height calc-window-height) (let ((swin (selected-window))) (select-window win) (enlarge-window (- calc-window-height height)) (select-window swin))))))) (message "(Calculator reset)") ) (defun calc-scroll-left (n) (interactive "P") (scroll-left (or n (/ (window-width) 2))) ) (defun calc-scroll-right (n) (interactive "P") (scroll-right (or n (/ (window-width) 2))) ) (defun calc-scroll-up (n) (interactive "P") (condition-case err (scroll-up (or n (/ (window-height) 2))) (error nil)) (if (pos-visible-in-window-p (max 1 (- (point-max) 2))) (if (eq major-mode 'calc-mode) (calc-realign) (goto-char (point-max)) (set-window-start (selected-window) (save-excursion (forward-line (- (1- (window-height)))) (point))) (forward-line -1))) ) (defun calc-scroll-down (n) (interactive "P") (or (pos-visible-in-window-p 1) (scroll-down (or n (/ (window-height) 2)))) ) (defun calc-precision (n) (interactive "NPrecision: ") (calc-wrapper (if (< (prefix-numeric-value n) 3) (error "Precision must be at least 3 digits.") (calc-change-mode 'calc-internal-prec (prefix-numeric-value n) (and (memq (car calc-float-format) '(float sci eng)) (< (nth 1 calc-float-format) (if (= calc-number-radix 10) 0 1)))) (calc-record calc-internal-prec "prec")) (message "Floating-point precision is %d digits." calc-internal-prec)) ) (defun calc-inverse (&optional n) (interactive "P") (calc-fancy-prefix 'calc-inverse-flag "Inverse..." n) ) (defun calc-fancy-prefix (flag msg n) (let (prefix) (calc-wrapper (calc-set-command-flag 'keep-flags) (calc-set-command-flag 'no-align) (setq prefix (set flag (not (symbol-value flag))) prefix-arg n) (message (if prefix msg ""))) (and prefix (not calc-is-keypad-press) (let ((event (calc-read-key t))) (if (eq (setq last-command-char (car event)) ?\C-u) (universal-argument) (if (or (not (integerp last-command-char)) (and (>= last-command-char 0) (< last-command-char ? ) (not (memq last-command-char '(?\e))))) (calc-wrapper)) ; clear flags if not a Calc command. (if calc-emacs-type-19 (setq last-command-event (cdr event))) (if (or (not (integerp last-command-char)) (eq last-command-char ?-)) (calc-unread-command) (digit-argument n)))))) ) (setq calc-is-keypad-press nil) (defun calc-invert-func () (save-excursion (calc-select-buffer) (setq calc-inverse-flag (not (calc-is-inverse)) calc-hyperbolic-flag (calc-is-hyperbolic) current-prefix-arg nil)) ) (defun calc-is-inverse () calc-inverse-flag ) (defun calc-hyperbolic (&optional n) (interactive "P") (calc-fancy-prefix 'calc-hyperbolic-flag "Hyperbolic..." n) ) (defun calc-hyperbolic-func () (save-excursion (calc-select-buffer) (setq calc-inverse-flag (calc-is-inverse) calc-hyperbolic-flag (not (calc-is-hyperbolic)) current-prefix-arg nil)) ) (defun calc-is-hyperbolic () calc-hyperbolic-flag ) (defun calc-keep-args (&optional n) (interactive "P") (calc-fancy-prefix 'calc-keep-args-flag "Keep args..." n) ) (defun calc-change-mode (var value &optional refresh option) (if option (setq value (if value (> (prefix-numeric-value value) 0) (not (symbol-value var))))) (or (consp var) (setq var (list var) value (list value))) (if calc-inverse-flag (let ((old nil)) (or refresh (error "Not a display-mode command")) (calc-check-stack 1) (unwind-protect (let ((v var)) (while v (setq old (cons (symbol-value (car v)) old)) (set (car v) (car value)) (setq v (cdr v) value (cdr value))) (calc-refresh-top 1) (calc-refresh-evaltos) (symbol-value (car var))) (let ((v var)) (setq old (nreverse old)) (while v (set (car v) (car old)) (setq v (cdr v) old (cdr old))) (if (eq (car var) 'calc-language) (calc-set-language calc-language calc-language-option t))))) (let ((chg nil) (v var)) (while v (or (equal (symbol-value (car v)) (car value)) (progn (set (car v) (car value)) (if (eq (car v) 'calc-float-format) (setq calc-full-float-format (list (if (eq (car (car value)) 'fix) 'float (car (car value))) 0))) (setq chg t))) (setq v (cdr v) value (cdr value))) (if chg (progn (or (and refresh (calc-do-refresh)) (calc-refresh-evaltos)) (and (eq calc-mode-save-mode 'save) (not (equal var '(calc-mode-save-mode))) (calc-save-modes t)))) (if calc-embedded-info (calc-embedded-modes-change var)) (symbol-value (car var)))) ) (defun calc-refresh-top (n) (interactive "p") (calc-wrapper (cond ((< n 0) (setq n (- n)) (let ((entry (calc-top n 'entry)) (calc-undo-list nil) (calc-redo-list nil)) (calc-pop-stack 1 n t) (calc-push-list (list (car entry)) n (list (nth 2 entry))))) ((= n 0) (calc-refresh)) (t (let ((entries (calc-top-list n 1 'entry)) (calc-undo-list nil) (calc-redo-list nil)) (calc-pop-stack n 1 t) (calc-push-list (mapcar 'car entries) 1 (mapcar (function (lambda (x) (nth 2 x))) entries)))))) ) (defun calc-refresh-evaltos (&optional which-var) (and calc-any-evaltos calc-auto-recompute (not calc-no-refresh-evaltos) (let ((calc-refreshing-evaltos t) (num (calc-stack-size)) (calc-undo-list nil) (calc-redo-list nil) value new-val) (while (> num 0) (setq value (calc-top num 'entry)) (if (and (not (nth 2 value)) (setq value (car value)) (or (eq (car-safe value) 'calcFunc-evalto) (and (eq (car-safe value) 'vec) (eq (car-safe (nth 1 value)) 'calcFunc-evalto)))) (progn (setq new-val (math-normalize value)) (or (equal new-val value) (progn (calc-push-list (list new-val) num) (calc-pop-stack 1 (1+ num) t))))) (setq num (1- num))))) (and calc-embedded-active which-var (calc-embedded-var-change which-var)) ) (setq calc-refreshing-evaltos nil) (setq calc-no-refresh-evaltos nil) (defun calc-push (&rest vals) (calc-push-list vals) ) (defun calc-pop-push (n &rest vals) (calc-pop-push-list n vals) ) (defun calc-pop-push-record (n prefix &rest vals) (calc-pop-push-record-list n prefix vals) ) (defun calc-evaluate (n) (interactive "p") (calc-slow-wrapper (if (= n 0) (setq n (calc-stack-size))) (calc-with-default-simplification (if (< n 0) (calc-pop-push-record-list 1 "eval" (math-evaluate-expr (calc-top (- n))) (- n)) (calc-pop-push-record-list n "eval" (mapcar 'math-evaluate-expr (calc-top-list n))))) (calc-handle-whys)) ) (defun calc-eval-num (n) (interactive "P") (calc-slow-wrapper (let* ((nn (prefix-numeric-value n)) (calc-internal-prec (cond ((>= nn 3) nn) ((< nn 0) (max (+ calc-internal-prec nn) 3)) (t calc-internal-prec))) (calc-symbolic-mode nil)) (calc-with-default-simplification (calc-pop-push-record 1 "num" (math-evaluate-expr (calc-top 1))))) (calc-handle-whys)) ) (defun calc-execute-extended-command (n) (interactive "P") (let* ((prompt (concat (calc-num-prefix-name n) "M-x ")) (cmd (intern (completing-read prompt obarray 'commandp t "calc-")))) (setq prefix-arg n) (command-execute cmd)) ) (defun calc-realign (&optional num) (interactive "P") (if (and num (eq major-mode 'calc-mode)) (progn (calc-check-stack num) (calc-cursor-stack-index num) (and calc-line-numbering (forward-char 4))) (if (and calc-embedded-info (eq (current-buffer) (aref calc-embedded-info 0))) (progn (goto-char (aref calc-embedded-info 2)) (if (save-excursion (set-buffer (aref calc-embedded-info 1)) calc-show-plain) (forward-line 1))) (calc-wrapper (if (get-buffer-window (current-buffer)) (set-window-hscroll (get-buffer-window (current-buffer)) 0))))) ) (setq math-cache-list nil) (defun calc-var-value (v) (and (symbolp v) (boundp v) (symbol-value v) (if (symbolp (symbol-value v)) (set v (funcall (symbol-value v))) (if (stringp (symbol-value v)) (let ((val (math-read-expr (symbol-value v)))) (if (eq (car-safe val) 'error) (error "Bad format in variable contents: %s" (nth 2 val)) (set v val))) (symbol-value v)))) ) ;;; In the following table, ( OP LOPS ROPS ) means that if an OP ;;; term appears as the first argument to any LOPS term, or as the ;;; second argument to any ROPS term, then they should be treated ;;; as one large term for purposes of associative selection. (defconst calc-assoc-ops '( ( + ( + - ) ( + ) ) ( - ( + - ) ( + ) ) ( * ( * ) ( * ) ) ( / ( / ) ( ) ) ( | ( | ) ( | ) ) ( calcFunc-land ( calcFunc-land ) ( calcFunc-land ) ) ( calcFunc-lor ( calcFunc-lor ) ( calcFunc-lor ) ) )) (defvar var-CommuteRules 'calc-CommuteRules) (defvar var-JumpRules 'calc-JumpRules) (defvar var-DistribRules 'calc-DistribRules) (defvar var-MergeRules 'calc-MergeRules) (defvar var-NegateRules 'calc-NegateRules) (defvar var-InvertRules 'calc-InvertRules) (defconst calc-tweak-eqn-table '( ( calcFunc-eq calcFunc-eq calcFunc-neq ) ( calcFunc-neq calcFunc-neq calcFunc-eq ) ( calcFunc-lt calcFunc-gt calcFunc-geq ) ( calcFunc-gt calcFunc-lt calcFunc-leq ) ( calcFunc-leq calcFunc-geq calcFunc-gt ) ( calcFunc-geq calcFunc-leq calcFunc-lt ) )) (defun calc-float (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "flt" (if (calc-is-hyperbolic) 'calcFunc-float 'calcFunc-pfloat) arg)) ) (defvar calc-gnuplot-process nil) (defun calc-gnuplot-alive () (and calc-gnuplot-process calc-gnuplot-buffer (buffer-name calc-gnuplot-buffer) calc-gnuplot-input (buffer-name calc-gnuplot-input) (memq (process-status calc-gnuplot-process) '(run stop))) ) (defun calc-load-everything () (interactive) (calc-need-macros) ; calc-macs.el (calc-record-list nil) ; calc-misc.el (math-read-exprs "0") ; calc-aent.el ;;;; (Loads here) (calc-Need-calc-alg-2) (calc-Need-calc-alg-3) (calc-Need-calc-alg) (calc-Need-calc-arith) (calc-Need-calc-bin) (calc-Need-calc-comb) (calc-Need-calc-comp) (calc-Need-calc-cplx) (calc-Need-calc-embed) (calc-Need-calc-fin) (calc-Need-calc-forms) (calc-Need-calc-frac) (calc-Need-calc-funcs) (calc-Need-calc-graph) (calc-Need-calc-help) (calc-Need-calc-incom) (calc-Need-calc-keypd) (calc-Need-calc-lang) (calc-Need-calc-map) (calc-Need-calc-mat) (calc-Need-calc-math) (calc-Need-calc-mode) (calc-Need-calc-poly) (calc-Need-calc-prog) (calc-Need-calc-rewr) (calc-Need-calc-rules) (calc-Need-calc-sel-2) (calc-Need-calc-sel) (calc-Need-calc-stat) (calc-Need-calc-store) (calc-Need-calc-stuff) (calc-Need-calc-trail) (calc-Need-calc-undo) (calc-Need-calc-units) (calc-Need-calc-vec) (calc-Need-calc-yank) (message "All parts of Calc are now loaded.") ) ;;; Vector commands. (defun calc-concat (arg) (interactive "P") (calc-wrapper (if (calc-is-inverse) (if (calc-is-hyperbolic) (calc-enter-result 2 "apnd" (list 'calcFunc-append (calc-top 1) (calc-top 2))) (calc-enter-result 2 "|" (list 'calcFunc-vconcat (calc-top 1) (calc-top 2)))) (if (calc-is-hyperbolic) (calc-binary-op "apnd" 'calcFunc-append arg '(vec)) (calc-binary-op "|" 'calcFunc-vconcat arg '(vec) nil '|)))) ) (defun calc-append (arg) (interactive "P") (calc-hyperbolic-func) (calc-concat arg) ) (defconst calc-arg-values '( ( var ArgA var-ArgA ) ( var ArgB var-ArgB ) ( var ArgC var-ArgC ) ( var ArgD var-ArgD ) ( var ArgE var-ArgE ) ( var ArgF var-ArgF ) ( var ArgG var-ArgG ) ( var ArgH var-ArgH ) ( var ArgI var-ArgI ) ( var ArgJ var-ArgJ ) )) (defun calc-invent-args (n) (nreverse (nthcdr (- (length calc-arg-values) n) (reverse calc-arg-values))) ) ;;; User menu. (defun calc-user-key-map () (if calc-emacs-type-lucid (error "User-defined keys are not supported in Lucid Emacs")) (let ((res (cdr (lookup-key calc-mode-map "z")))) (if (eq (car (car res)) 27) (cdr res) res)) ) (defun calc-z-prefix-help () (interactive) (let* ((msgs nil) (buf "") (kmap (sort (copy-sequence (calc-user-key-map)) (function (lambda (x y) (< (car x) (car y)))))) (flags (apply 'logior (mapcar (function (lambda (k) (calc-user-function-classify (car k)))) kmap)))) (if (= (logand flags 8) 0) (calc-user-function-list kmap 7) (calc-user-function-list kmap 1) (setq msgs (cons buf msgs) buf "") (calc-user-function-list kmap 6)) (if (/= flags 0) (setq msgs (cons buf msgs))) (calc-do-prefix-help (nreverse msgs) "user" ?z)) ) (defun calc-user-function-classify (key) (cond ((/= key (downcase key)) ; upper-case (if (assq (downcase key) (calc-user-key-map)) 9 1)) ((/= key (upcase key)) 2) ; lower-case ((= key ??) 0) (t 4)) ; other ) (defun calc-user-function-list (map flags) (and map (let* ((key (car (car map))) (kind (calc-user-function-classify key)) (func (cdr (car map)))) (if (or (= (logand kind flags) 0) (not (symbolp func))) () (let* ((name (symbol-name func)) (name (if (string-match "\\`calc-" name) (substring name 5) name)) (pos (string-match (char-to-string key) name)) (desc (if (symbolp func) (if (= (logand kind 3) 0) (format "`%c' = %s" key name) (if pos (format "%s%c%s" (downcase (substring name 0 pos)) (upcase key) (downcase (substring name (1+ pos)))) (format "%c = %s" (upcase key) (downcase name)))) (char-to-string (upcase key))))) (if (= (length buf) 0) (setq buf (concat (if (= flags 1) "SHIFT + " "") desc)) (if (> (+ (length buf) (length desc)) 58) (setq msgs (cons buf msgs) buf (concat (if (= flags 1) "SHIFT + " "") desc)) (setq buf (concat buf ", " desc)))))) (calc-user-function-list (cdr map) flags))) ) (defun calc-shift-Z-prefix-help () (interactive) (calc-do-prefix-help '("Define, Undefine, Formula, Kbd-macro, Edit, Get-defn" "Composition, Syntax; Invocation; Permanent; Timing" "kbd-macros: [ (if), : (else), | (else-if), ] (end-if)" "kbd-macros: < > (repeat), ( ) (for), { } (loop)" "kbd-macros: / (break)" "kbd-macros: ` (save), ' (restore)") "user" ?Z) ) ;;;; Caches. (defmacro math-defcache (name init form) (let ((cache-prec (intern (concat (symbol-name name) "-cache-prec"))) (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 'setq cache-prec (if init (math-numdigs (nth 1 init)) -100)) (list 'setq cache-val (list 'quote init)) (list 'setq last-prec -100) (list 'setq last-val nil) (list 'setq 'math-cache-list (list 'cons (list 'quote cache-prec) (list 'cons (list 'quote last-prec) 'math-cache-list))) (list 'defun name () (list 'or (list '= last-prec 'calc-internal-prec) (list 'setq last-val (list 'math-normalize (list 'progn (list 'or (list '>= cache-prec 'calc-internal-prec) (list 'setq cache-val (list 'let '((calc-internal-prec (+ calc-internal-prec 4))) form) cache-prec '(+ calc-internal-prec 2))) cache-val)) last-prec 'calc-internal-prec)) last-val))) ) (put 'math-defcache 'lisp-indent-hook 2) ;;; Betcha didn't know that pi = 16 atan(1/5) - 4 atan(1/239). [F] [Public] (math-defcache math-pi (float (bigpos 463 238 793 589 653 592 141 3) -21) (math-add-float (math-mul-float '(float 16 0) (math-arctan-raw '(float 2 -1))) (math-mul-float '(float -4 0) (math-arctan-raw (math-float '(frac 1 239)))))) (math-defcache math-two-pi nil (math-mul-float (math-pi) '(float 2 0))) (math-defcache math-pi-over-2 nil (math-mul-float (math-pi) '(float 5 -1))) (math-defcache math-pi-over-4 nil (math-mul-float (math-pi) '(float 25 -2))) (math-defcache math-pi-over-180 nil (math-div-float (math-pi) '(float 18 1))) (math-defcache math-sqrt-pi nil (math-sqrt-float (math-pi))) (math-defcache math-sqrt-2 nil (math-sqrt-float '(float 2 0))) (math-defcache math-sqrt-12 nil (math-sqrt-float '(float 12 0))) (math-defcache math-sqrt-two-pi nil (math-sqrt-float (math-two-pi))) (math-defcache math-sqrt-e (float (bigpos 849 146 128 700 270 721 648 1) -21) (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))) (math-defcache math-gamma-const nil '(float (bigpos 495 467 917 632 470 369 709 646 776 267 677 848 348 672 057 988 235 399 359 593 421 310 024 824 900 120 065 606 328 015 649 156 772 5) -100)) (defun math-half-circle (symb) (if (eq calc-angle-mode 'rad) (if symb '(var pi var-pi) (math-pi)) 180) ) (defun math-full-circle (symb) (math-mul 2 (math-half-circle symb)) ) (defun math-quarter-circle (symb) (math-div (math-half-circle symb) 2) ) ;;;; Miscellaneous math routines. ;;; True if A is an odd integer. [P R R] [Public] (defun math-oddp (a) (if (consp a) (and (memq (car a) '(bigpos bigneg)) (= (% (nth 1 a) 2) 1)) (/= (% a 2) 0)) ) ;;; True if A is a small or big integer. [P x] [Public] (defun math-integerp (a) (or (integerp a) (memq (car-safe a) '(bigpos bigneg))) ) ;;; True if A is (numerically) a non-negative integer. [P N] [Public] (defun math-natnump (a) (or (natnump a) (eq (car-safe a) 'bigpos)) ) ;;; True if A is a rational (or integer). [P x] [Public] (defun math-ratp (a) (or (integerp a) (memq (car-safe a) '(bigpos bigneg frac))) ) ;;; True if A is a real (or rational). [P x] [Public] (defun math-realp (a) (or (integerp a) (memq (car-safe a) '(bigpos bigneg frac float))) ) ;;; True if A is a real or HMS form. [P x] [Public] (defun math-anglep (a) (or (integerp a) (memq (car-safe a) '(bigpos bigneg frac float hms))) ) ;;; True if A is a number of any kind. [P x] [Public] (defun math-numberp (a) (or (integerp a) (memq (car-safe a) '(bigpos bigneg frac float cplx polar))) ) ;;; True if A is a complex number or angle. [P x] [Public] (defun math-scalarp (a) (or (integerp a) (memq (car-safe a) '(bigpos bigneg frac float cplx polar hms))) ) ;;; True if A is a vector. [P x] [Public] (defun math-vectorp (a) (eq (car-safe a) 'vec) ) ;;; True if A is any vector or scalar data object. [P x] (defun math-objvecp (a) ; [Public] (or (integerp a) (memq (car-safe a) '(bigpos bigneg frac float cplx polar hms date sdev intv mod vec incomplete))) ) ;;; True if A is an object not composed of sub-formulas . [P x] [Public] (defun math-primp (a) (or (integerp a) (memq (car-safe a) '(bigpos bigneg frac float cplx polar hms date mod var))) ) ;;; True if A is numerically (but not literally) an integer. [P x] [Public] (defun math-messy-integerp (a) (cond ((eq (car-safe a) 'float) (>= (nth 2 a) 0)) ((eq (car-safe a) 'frac) (Math-integerp (math-normalize a)))) ) ;;; True if A is numerically an integer. [P x] [Public] (defun math-num-integerp (a) (or (Math-integerp a) (Math-messy-integerp a)) ) ;;; True if A is (numerically) a non-negative integer. [P N] [Public] (defun math-num-natnump (a) (or (natnump a) (eq (car-safe a) 'bigpos) (and (eq (car-safe a) 'float) (Math-natnump (nth 1 a)) (>= (nth 2 a) 0))) ) ;;; True if A is an integer or will evaluate to an integer. [P x] [Public] (defun math-provably-integerp (a) (or (Math-integerp a) (and (memq (car-safe a) '(calcFunc-trunc calcFunc-round calcFunc-rounde calcFunc-roundu calcFunc-floor calcFunc-ceil)) (= (length a) 2))) ) ;;; True if A is a real or will evaluate to a real. [P x] [Public] (defun math-provably-realp (a) (or (Math-realp a) (math-provably-integer a) (memq (car-safe a) '(abs arg))) ) ;;; True if A is a non-real, complex number. [P x] [Public] (defun math-complexp (a) (memq (car-safe a) '(cplx polar)) ) ;;; True if A is a non-real, rectangular complex number. [P x] [Public] (defun math-rect-complexp (a) (eq (car-safe a) 'cplx) ) ;;; True if A is a non-real, polar complex number. [P x] [Public] (defun math-polar-complexp (a) (eq (car-safe a) 'polar) ) ;;; True if A is a matrix. [P x] [Public] (defun math-matrixp (a) (and (Math-vectorp a) (Math-vectorp (nth 1 a)) (cdr (nth 1 a)) (let ((len (length (nth 1 a)))) (setq a (cdr a)) (while (and (setq a (cdr a)) (Math-vectorp (car a)) (= (length (car a)) len))) (null a))) ) (defun math-matrixp-step (a len) ; [P L] (or (null a) (and (Math-vectorp (car a)) (= (length (car a)) len) (math-matrixp-step (cdr a) len))) ) ;;; True if A is a square matrix. [P V] [Public] (defun math-square-matrixp (a) (let ((dims (math-mat-dimens a))) (and (cdr dims) (= (car dims) (nth 1 dims)))) ) ;;; True if A is any scalar data object. [P x] (defun math-objectp (a) ; [Public] (or (integerp a) (memq (car-safe a) '(bigpos bigneg frac float cplx polar hms date sdev intv mod))) ) ;;; Verify that A is an integer and return A in integer form. [I N; - x] (defun math-check-integer (a) ; [Public] (cond ((integerp a) a) ; for speed ((math-integerp a) a) ((math-messy-integerp a) (math-trunc a)) (t (math-reject-arg a 'integerp))) ) ;;; Verify that A is a small integer and return A in integer form. [S N; - x] (defun math-check-fixnum (a &optional allow-inf) ; [Public] (cond ((integerp a) a) ; for speed ((Math-num-integerp a) (let ((a (math-trunc a))) (if (integerp a) a (if (or (Math-lessp (lsh -1 -1) a) (Math-lessp a (- (lsh -1 -1)))) (math-reject-arg a 'fixnump) (math-fixnum a))))) ((and allow-inf (equal a '(var inf var-inf))) (lsh -1 -1)) ((and allow-inf (equal a '(neg (var inf var-inf)))) (- (lsh -1 -1))) (t (math-reject-arg a 'fixnump))) ) ;;; Verify that A is an integer >= 0 and return A in integer form. [I N; - x] (defun math-check-natnum (a) ; [Public] (cond ((natnump a) a) ((and (not (math-negp a)) (Math-num-integerp a)) (math-trunc a)) (t (math-reject-arg a 'natnump))) ) ;;; Verify that A is in floating-point form, or force it to be a float. [F N] (defun math-check-float (a) ; [Public] (cond ((eq (car-safe a) 'float) a) ((Math-vectorp a) (math-map-vec 'math-check-float a)) ((Math-objectp a) (math-float a)) (t a)) ) ;;; Verify that A is a constant. (defun math-check-const (a &optional exp-ok) (if (or (math-constp a) (and exp-ok math-expand-formulas)) a (math-reject-arg a 'constp)) ) ;;; Coerce integer A to be a small integer. [S I] (defun math-fixnum (a) (if (consp a) (if (cdr a) (if (eq (car a) 'bigneg) (- (math-fixnum-big (cdr a))) (math-fixnum-big (cdr a))) 0) a) ) (defun math-fixnum-big (a) (if (cdr a) (+ (car a) (* (math-fixnum-big (cdr a)) 1000)) (car a)) ) (defun math-normalize-fancy (a) (cond ((eq (car a) 'frac) (math-make-frac (math-normalize (nth 1 a)) (math-normalize (nth 2 a)))) ((eq (car a) 'cplx) (let ((real (math-normalize (nth 1 a))) (imag (math-normalize (nth 2 a)))) (if (and (math-zerop imag) (not math-simplify-only)) ; oh, what a kludge! real (list 'cplx real imag)))) ((eq (car a) 'polar) (math-normalize-polar a)) ((eq (car a) 'hms) (math-normalize-hms a)) ((eq (car a) 'date) (list 'date (math-normalize (nth 1 a)))) ((eq (car a) 'mod) (math-normalize-mod a)) ((eq (car a) 'sdev) (let ((x (math-normalize (nth 1 a))) (s (math-normalize (nth 2 a)))) (if (or (and (Math-objectp x) (not (Math-scalarp x))) (and (Math-objectp s) (not (Math-scalarp s)))) (list 'calcFunc-sdev x s) (math-make-sdev x s)))) ((eq (car a) 'intv) (let ((mask (math-normalize (nth 1 a))) (lo (math-normalize (nth 2 a))) (hi (math-normalize (nth 3 a)))) (if (if (eq (car-safe lo) 'date) (not (eq (car-safe hi) 'date)) (or (and (Math-objectp lo) (not (Math-anglep lo))) (and (Math-objectp hi) (not (Math-anglep hi))))) (list 'calcFunc-intv mask lo hi) (math-make-intv mask lo hi)))) ((eq (car a) 'vec) (cons 'vec (mapcar 'math-normalize (cdr a)))) ((eq (car a) 'quote) (math-normalize (nth 1 a))) ((eq (car a) 'special-const) (calc-with-default-simplification (math-normalize (nth 1 a)))) ((eq (car a) 'var) (cons 'var (cdr a))) ; need to re-cons for selection routines ((eq (car a) 'calcFunc-if) (math-normalize-logical-op a)) ((memq (car a) '(calcFunc-lambda calcFunc-quote calcFunc-condition)) (let ((calc-simplify-mode 'none)) (cons (car a) (mapcar 'math-normalize (cdr a))))) ((eq (car a) 'calcFunc-evalto) (setq a (or (nth 1 a) 0)) (or calc-refreshing-evaltos (setq a (let ((calc-simplify-mode 'none)) (math-normalize a)))) (let ((b (if (and (eq (car-safe a) 'calcFunc-assign) (= (length a) 3)) (nth 2 a) a))) (list 'calcFunc-evalto a (if (eq calc-simplify-mode 'none) (math-normalize b) (calc-with-default-simplification (math-evaluate-expr b)))))) ((or (integerp (car a)) (consp (car a))) (if (null (cdr a)) (math-normalize (car a)) (error "Can't use multi-valued function in an expression")))) ) (defun math-normalize-nonstandard () ; uses "a" (if (consp calc-simplify-mode) (progn (setq calc-simplify-mode 'none math-simplify-only (car-safe (cdr-safe a))) nil) (and (symbolp (car a)) (or (eq calc-simplify-mode 'none) (and (eq calc-simplify-mode 'num) (let ((aptr (setq a (cons (car a) (mapcar 'math-normalize (cdr a)))))) (while (and aptr (math-constp (car aptr))) (setq aptr (cdr aptr))) aptr))) (cons (car a) (mapcar 'math-normalize (cdr a))))) ) (setq math-expand-formulas nil) ;;; Normalize a bignum digit list by trimming high-end zeros. [L l] (defun math-norm-bignum (a) (let ((digs a) (last nil)) (while digs (or (eq (car digs) 0) (setq last digs)) (setq digs (cdr digs))) (and last (progn (setcdr last nil) a))) ) (defun math-bignum-test (a) ; [B N; B s; b b] (if (consp a) a (math-bignum a)) ) ;;; Return 0 for zero, -1 for negative, 1 for positive. [S n] [Public] (defun calcFunc-sign (a &optional x) (let ((signs (math-possible-signs a))) (cond ((eq signs 4) (or x 1)) ((eq signs 2) 0) ((eq signs 1) (if x (math-neg x) -1)) ((math-looks-negp a) (math-neg (calcFunc-sign (math-neg a)))) (t (calc-record-why 'realp a) (if x (list 'calcFunc-sign a x) (list 'calcFunc-sign a))))) ) ;;; Return 0 if A is numerically equal to B, <0 if less, >0 if more. ;;; Arguments must be normalized! [S N N] (defun math-compare (a b) (cond ((equal a b) (if (and (consp a) (memq (car a) '(var neg * /)) (math-infinitep a)) 2 0)) ((and (integerp a) (Math-integerp b)) (if (consp b) (if (eq (car b) 'bigpos) -1 1) (if (< a b) -1 1))) ((and (eq (car-safe a) 'bigpos) (Math-integerp b)) (if (eq (car-safe b) 'bigpos) (math-compare-bignum (cdr a) (cdr b)) 1)) ((and (eq (car-safe a) 'bigneg) (Math-integerp b)) (if (eq (car-safe b) 'bigneg) (math-compare-bignum (cdr b) (cdr a)) -1)) ((eq (car-safe a) 'frac) (if (eq (car-safe b) 'frac) (math-compare (math-mul (nth 1 a) (nth 2 b)) (math-mul (nth 1 b) (nth 2 a))) (math-compare (nth 1 a) (math-mul b (nth 2 a))))) ((eq (car-safe b) 'frac) (math-compare (math-mul a (nth 2 b)) (nth 1 b))) ((and (eq (car-safe a) 'float) (eq (car-safe b) 'float)) (if (math-lessp-float a b) -1 1)) ((and (eq (car-safe a) 'date) (eq (car-safe b) 'date)) (math-compare (nth 1 a) (nth 1 b))) ((and (or (Math-anglep a) (and (eq (car a) 'cplx) (eq (nth 2 a) 0))) (or (Math-anglep b) (and (eq (car b) 'cplx) (eq (nth 2 b) 0)))) (calcFunc-sign (math-add a (math-neg b)))) ((and (eq (car-safe a) 'intv) (or (Math-anglep b) (eq (car-safe b) 'date))) (let ((res (math-compare (nth 2 a) b))) (cond ((eq res 1) 1) ((and (eq res 0) (memq (nth 1 a) '(0 1))) 1) ((eq (setq res (math-compare (nth 3 a) b)) -1) -1) ((and (eq res 0) (memq (nth 1 a) '(0 2))) -1) (t 2)))) ((and (eq (car-safe b) 'intv) (or (Math-anglep a) (eq (car-safe a) 'date))) (let ((res (math-compare a (nth 2 b)))) (cond ((eq res -1) -1) ((and (eq res 0) (memq (nth 1 b) '(0 1))) -1) ((eq (setq res (math-compare a (nth 3 b))) 1) 1) ((and (eq res 0) (memq (nth 1 b) '(0 2))) 1) (t 2)))) ((and (eq (car-safe a) 'intv) (eq (car-safe b) 'intv)) (let ((res (math-compare (nth 3 a) (nth 2 b)))) (cond ((eq res -1) -1) ((and (eq res 0) (or (memq (nth 1 a) '(0 2)) (memq (nth 1 b) '(0 1)))) -1) ((eq (setq res (math-compare (nth 2 a) (nth 3 b))) 1) 1) ((and (eq res 0) (or (memq (nth 1 a) '(0 1)) (memq (nth 1 b) '(0 2)))) 1) (t 2)))) ((math-infinitep a) (if (or (equal a '(var uinf var-uinf)) (equal a '(var nan var-nan))) 2 (let ((dira (math-infinite-dir a))) (if (math-infinitep b) (if (or (equal b '(var uinf var-uinf)) (equal b '(var nan var-nan))) 2 (let ((dirb (math-infinite-dir b))) (cond ((and (eq dira 1) (eq dirb -1)) 1) ((and (eq dira -1) (eq dirb 1)) -1) (t 2)))) (cond ((eq dira 1) 1) ((eq dira -1) -1) (t 2)))))) ((math-infinitep b) (if (or (equal b '(var uinf var-uinf)) (equal b '(var nan var-nan))) 2 (let ((dirb (math-infinite-dir b))) (cond ((eq dirb 1) -1) ((eq dirb -1) 1) (t 2))))) ((and (eq (car-safe a) 'calcFunc-exp) (eq (car-safe b) '^) (equal (nth 1 b) '(var e var-e))) (math-compare (nth 1 a) (nth 2 b))) ((and (eq (car-safe b) 'calcFunc-exp) (eq (car-safe a) '^) (equal (nth 1 a) '(var e var-e))) (math-compare (nth 2 a) (nth 1 b))) ((or (and (eq (car-safe a) 'calcFunc-sqrt) (eq (car-safe b) '^) (or (equal (nth 2 b) '(frac 1 2)) (equal (nth 2 b) '(float 5 -1)))) (and (eq (car-safe b) 'calcFunc-sqrt) (eq (car-safe a) '^) (or (equal (nth 2 a) '(frac 1 2)) (equal (nth 2 a) '(float 5 -1))))) (math-compare (nth 1 a) (nth 1 b))) ((eq (car-safe a) 'var) 2) (t (if (and (consp a) (consp b) (eq (car a) (car b)) (math-compare-lists (cdr a) (cdr b))) 0 2))) ) ;;; Compare two bignum digit lists, return -1 for AB. (defun math-compare-bignum (a b) ; [S l l] (let ((res 0)) (while (and a b) (if (< (car a) (car b)) (setq res -1) (if (> (car a) (car b)) (setq res 1))) (setq a (cdr a) b (cdr b))) (if a (progn (while (eq (car a) 0) (setq a (cdr a))) (if a 1 res)) (while (eq (car b) 0) (setq b (cdr b))) (if b -1 res))) ) (defun math-compare-lists (a b) (cond ((null a) (null b)) ((null b) nil) (t (and (Math-equal (car a) (car b)) (math-compare-lists (cdr a) (cdr b))))) ) (defun math-lessp-float (a b) ; [P F F] (let ((ediff (- (nth 2 a) (nth 2 b)))) (if (>= ediff 0) (if (>= ediff (+ calc-internal-prec calc-internal-prec)) (if (eq (nth 1 a) 0) (Math-integer-posp (nth 1 b)) (Math-integer-negp (nth 1 a))) (Math-lessp (math-scale-int (nth 1 a) ediff) (nth 1 b))) (if (>= (setq ediff (- ediff)) (+ calc-internal-prec calc-internal-prec)) (if (eq (nth 1 b) 0) (Math-integer-negp (nth 1 a)) (Math-integer-posp (nth 1 b))) (Math-lessp (nth 1 a) (math-scale-int (nth 1 b) ediff))))) ) ;;; True if A is numerically equal to B. [P N N] [Public] (defun math-equal (a b) (= (math-compare a b) 0) ) ;;; True if A is numerically less than B. [P R R] [Public] (defun math-lessp (a b) (= (math-compare a b) -1) ) ;;; True if A is numerically equal to the integer B. [P N S] [Public] ;;; B must not be a multiple of 10. (defun math-equal-int (a b) (or (eq a b) (and (eq (car-safe a) 'float) (eq (nth 1 a) b) (= (nth 2 a) 0))) ) ;;; Return the dimensions of a matrix as a list. [l x] [Public] (defun math-mat-dimens (m) (if (math-vectorp m) (if (math-matrixp m) (cons (1- (length m)) (math-mat-dimens (nth 1 m))) (list (1- (length m)))) nil) ) (defun calc-binary-op-fancy (name func arg ident unary) (let ((n (prefix-numeric-value arg))) (cond ((> n 1) (calc-enter-result n name (list 'calcFunc-reduce (math-calcFunc-to-var func) (cons 'vec (calc-top-list-n n))))) ((= n 1) (if unary (calc-enter-result 1 name (list unary (calc-top-n 1))))) ((= n 0) (if ident (calc-enter-result 0 name ident) (error "Argument must be nonzero"))) (t (let ((rhs (calc-top-n 1))) (calc-enter-result (- 1 n) name (mapcar (function (lambda (x) (list func x rhs))) (calc-top-list-n (- n) 2))))))) ) (defun calc-unary-op-fancy (name func arg) (let ((n (prefix-numeric-value arg))) (if (= n 0) (setq n (calc-stack-size))) (cond ((> n 0) (calc-enter-result n name (mapcar (function (lambda (x) (list func x))) (calc-top-list-n n)))) ((< n 0) (calc-enter-result 1 name (list func (calc-top-n (- n))) (- n))))) ) (defvar var-Holidays '(vec (var sat var-sat) (var sun var-sun))) (defvar var-Decls (list 'vec)) (setq math-simplify-only nil) (defun math-inexact-result () (and calc-symbolic-mode (signal 'inexact-result nil)) ) (defun math-overflow (&optional exp) (if (and exp (math-negp exp)) (math-underflow) (signal 'math-overflow nil)) ) (defun math-underflow () (signal 'math-underflow nil) ) ;;; Compute the greatest common divisor of A and B. [I I I] [Public] (defun math-gcd (a b) (cond ((not (or (consp a) (consp b))) (if (< a 0) (setq a (- a))) (if (< b 0) (setq b (- b))) (let (c) (if (< a b) (setq c b b a a c)) (while (> b 0) (setq c b b (% a b) a c)) a)) ((eq a 0) b) ((eq b 0) a) (t (if (Math-integer-negp a) (setq a (math-neg a))) (if (Math-integer-negp b) (setq b (math-neg b))) (let (c) (if (Math-natnum-lessp a b) (setq c b b a a c)) (while (and (consp a) (not (eq b 0))) (setq c b b (math-imod a b) a c)) (while (> b 0) (setq c b b (% a b) a c)) a))) ) ;;;; Algebra. ;;; Evaluate variables in an expression. (defun math-evaluate-expr (x) ; [Public] (if calc-embedded-info (calc-embedded-evaluate-expr x) (calc-normalize (math-evaluate-expr-rec x))) ) (fset 'calcFunc-evalv (symbol-function 'math-evaluate-expr)) (defun calcFunc-evalvn (x &optional prec) (if prec (progn (or (math-num-integerp prec) (if (and (math-vectorp prec) (= (length prec) 2) (math-num-integerp (nth 1 prec))) (setq prec (math-add (nth 1 prec) calc-internal-prec)) (math-reject-arg prec 'integerp))) (setq prec (math-trunc prec)) (if (< prec 3) (setq prec 3)) (if (> prec calc-internal-prec) (math-normalize (let ((calc-internal-prec prec)) (calcFunc-evalvn x))) (let ((calc-internal-prec prec)) (calcFunc-evalvn x)))) (let ((calc-symbolic-mode nil)) (math-evaluate-expr x))) ) (defun math-evaluate-expr-rec (x) (if (consp x) (if (memq (car x) '(calcFunc-quote calcFunc-condition calcFunc-evalto calcFunc-assign)) (if (and (eq (car x) 'calcFunc-assign) (= (length x) 3)) (list (car x) (nth 1 x) (math-evaluate-expr-rec (nth 2 x))) x) (if (eq (car x) 'var) (if (and (calc-var-value (nth 2 x)) (not (eq (car-safe (symbol-value (nth 2 x))) 'incomplete))) (let ((val (symbol-value (nth 2 x)))) (if (eq (car-safe val) 'special-const) (if calc-symbolic-mode x val) val)) x) (if (Math-primp x) x (cons (car x) (mapcar 'math-evaluate-expr-rec (cdr x)))))) x) ) (setq math-simplifying nil) (setq math-living-dangerously nil) ; true if unsafe simplifications are okay. (setq math-integrating nil) (defmacro math-defsimplify (funcs &rest code) (append '(progn (math-need-std-simps)) (mapcar (function (lambda (func) (list 'put (list 'quote func) ''math-simplify (list 'nconc (list 'get (list 'quote func) ''math-simplify) (list 'list (list 'function (append '(lambda (expr)) code))))))) (if (symbolp funcs) (list funcs) funcs))) ) (put 'math-defsimplify 'lisp-indent-hook 1) (defun math-any-floats (expr) (if (Math-primp expr) (math-floatp expr) (while (and (setq expr (cdr expr)) (not (math-any-floats (car expr))))) expr) ) (defvar var-FactorRules 'calc-FactorRules) (defun math-map-tree (mmt-func mmt-expr &optional mmt-many) (or mmt-many (setq mmt-many 1000000)) (math-map-tree-rec mmt-expr) ) (defun math-map-tree-rec (mmt-expr) (or (= mmt-many 0) (let ((mmt-done nil) mmt-nextval) (while (not mmt-done) (while (and (/= mmt-many 0) (setq mmt-nextval (funcall mmt-func mmt-expr)) (not (equal mmt-expr mmt-nextval))) (setq mmt-expr mmt-nextval mmt-many (if (> mmt-many 0) (1- mmt-many) (1+ mmt-many)))) (if (or (Math-primp mmt-expr) (<= mmt-many 0)) (setq mmt-done t) (setq mmt-nextval (cons (car mmt-expr) (mapcar 'math-map-tree-rec (cdr mmt-expr)))) (if (equal mmt-nextval mmt-expr) (setq mmt-done t) (setq mmt-expr mmt-nextval)))))) mmt-expr ) (setq math-rewrite-selections nil) (defun math-is-true (expr) (if (Math-numberp expr) (not (Math-zerop expr)) (math-known-nonzerop expr)) ) (defun math-const-var (expr) (and (consp expr) (eq (car expr) 'var) (or (and (symbolp (nth 2 expr)) (boundp (nth 2 expr)) (eq (car-safe (symbol-value (nth 2 expr))) 'special-const)) (memq (nth 2 expr) '(var-inf var-uinf var-nan)))) ) (defmacro math-defintegral (funcs &rest code) (setq math-integral-cache nil) (append '(progn) (mapcar (function (lambda (func) (list 'put (list 'quote func) ''math-integral (list 'nconc (list 'get (list 'quote func) ''math-integral) (list 'list (list 'function (append '(lambda (u)) code))))))) (if (symbolp funcs) (list funcs) funcs))) ) (put 'math-defintegral 'lisp-indent-hook 1) (defmacro math-defintegral-2 (funcs &rest code) (setq math-integral-cache nil) (append '(progn) (mapcar (function (lambda (func) (list 'put (list 'quote func) ''math-integral-2 (list 'nconc (list 'get (list 'quote func) ''math-integral-2) (list 'list (list 'function (append '(lambda (u v)) code))))))) (if (symbolp funcs) (list funcs) funcs))) ) (put 'math-defintegral-2 'lisp-indent-hook 1) (defvar var-IntegAfterRules 'calc-IntegAfterRules) (defvar var-FitRules 'calc-FitRules) (setq math-poly-base-variable nil) (setq math-poly-neg-powers nil) (setq math-poly-mult-powers 1) (setq math-poly-frac-powers nil) (setq math-poly-exp-base nil) (defun math-build-var-name (name) (if (stringp name) (setq name (intern name))) (if (string-match "\\`var-." (symbol-name name)) (list 'var (intern (substring (symbol-name name) 4)) name) (list 'var name (intern (concat "var-" (symbol-name name))))) ) (setq math-simplifying-units nil) (setq math-combining-units t) (put 'math-while 'lisp-indent-hook 1) (put 'math-for 'lisp-indent-hook 1) (put 'math-foreach 'lisp-indent-hook 1) ;;; Nontrivial number parsing. (defun math-read-number-fancy (s) (cond ;; Integer+fractions ((string-match "^\\([0-9]*\\)[:/]\\([0-9]*\\)[:/]\\([0-9]*\\)$" s) (let ((int (math-match-substring s 1)) (num (math-match-substring s 2)) (den (math-match-substring s 3))) (let ((int (if (> (length int) 0) (math-read-number int) 0)) (num (if (> (length num) 0) (math-read-number num) 1)) (den (if (> (length num) 0) (math-read-number den) 1))) (and int num den (math-integerp int) (math-integerp num) (math-integerp den) (not (math-zerop den)) (list 'frac (math-add num (math-mul int den)) den))))) ;; Fractions ((string-match "^\\([0-9]*\\)[:/]\\([0-9]*\\)$" s) (let ((num (math-match-substring s 1)) (den (math-match-substring s 2))) (let ((num (if (> (length num) 0) (math-read-number num) 1)) (den (if (> (length num) 0) (math-read-number den) 1))) (and num den (math-integerp num) (math-integerp den) (not (math-zerop den)) (list 'frac num den))))) ;; Modulo forms ((string-match "^\\(.*\\) *mod *\\(.*\\)$" s) (let* ((n (math-match-substring s 1)) (m (math-match-substring s 2)) (n (math-read-number n)) (m (math-read-number m))) (and n m (math-anglep n) (math-anglep m) (list 'mod n m)))) ;; Error forms ((string-match "^\\(.*\\) *\\+/- *\\(.*\\)$" s) (let* ((x (math-match-substring s 1)) (sigma (math-match-substring s 2)) (x (math-read-number x)) (sigma (math-read-number sigma))) (and x sigma (math-scalarp x) (math-anglep sigma) (list 'sdev x sigma)))) ;; Hours (or degrees) ((or (string-match "^\\([^#^]+\\)[@oOhH]\\(.*\\)$" s) (string-match "^\\([^#^]+\\)[dD][eE]?[gG]?\\(.*\\)$" s)) (let* ((hours (math-match-substring s 1)) (minsec (math-match-substring s 2)) (hours (math-read-number hours)) (minsec (if (> (length minsec) 0) (math-read-number minsec) 0))) (and hours minsec (math-num-integerp hours) (not (math-negp hours)) (not (math-negp minsec)) (cond ((math-num-integerp minsec) (and (Math-lessp minsec 60) (list 'hms hours minsec 0))) ((and (eq (car-safe minsec) 'hms) (math-zerop (nth 1 minsec))) (math-add (list 'hms hours 0 0) minsec)) (t nil))))) ;; Minutes ((string-match "^\\([^'#^]+\\)[mM']\\(.*\\)$" s) (let* ((minutes (math-match-substring s 1)) (seconds (math-match-substring s 2)) (minutes (math-read-number minutes)) (seconds (if (> (length seconds) 0) (math-read-number seconds) 0))) (and minutes seconds (math-num-integerp minutes) (not (math-negp minutes)) (not (math-negp seconds)) (cond ((math-realp seconds) (and (Math-lessp minutes 60) (list 'hms 0 minutes seconds))) ((and (eq (car-safe seconds) 'hms) (math-zerop (nth 1 seconds)) (math-zerop (nth 2 seconds))) (math-add (list 'hms 0 minutes 0) seconds)) (t nil))))) ;; Seconds ((string-match "^\\([^\"#^]+\\)[sS\"]$" s) (let ((seconds (math-read-number (math-match-substring s 1)))) (and seconds (math-realp seconds) (not (math-negp seconds)) (Math-lessp seconds 60) (list 'hms 0 0 seconds)))) ;; Integer+fraction with explicit radix ((string-match "^\\([0-9]+\\)\\(#\\|\\^\\^\\)\\([0-9a-zA-Z]*\\)[:/]\\([0-9a-zA-Z]*\\)[:/]\\([0-9a-zA-Z]\\)$" s) (let ((radix (string-to-int (math-match-substring s 1))) (int (math-match-substring s 3)) (num (math-match-substring s 4)) (den (math-match-substring s 5))) (let ((int (if (> (length int) 0) (math-read-radix int radix) 0)) (num (if (> (length num) 0) (math-read-radix num radix) 1)) (den (if (> (length den) 0) (math-read-radix den radix) 1))) (and int num den (not (math-zerop den)) (list 'frac (math-add num (math-mul int den)) den))))) ;; Fraction with explicit radix ((string-match "^\\([0-9]+\\)\\(#\\|\\^\\^\\)\\([0-9a-zA-Z]*\\)[:/]\\([0-9a-zA-Z]*\\)$" s) (let ((radix (string-to-int (math-match-substring s 1))) (num (math-match-substring s 3)) (den (math-match-substring s 4))) (let ((num (if (> (length num) 0) (math-read-radix num radix) 1)) (den (if (> (length den) 0) (math-read-radix den radix) 1))) (and num den (not (math-zerop den)) (list 'frac num den))))) ;; Float with explicit radix and exponent ((or (string-match "^0*\\(\\([2-9]\\|1[0-4]\\)\\(#\\|\\^\\^\\)[0-9a-dA-D.]+\\)[eE]\\([-+]?[0-9]+\\)$" s) (string-match "^\\(\\([0-9]+\\)\\(#\\|\\^\\^\\)[0-9a-zA-Z.]+\\) *\\* *\\2\\.? *\\^ *\\([-+]?[0-9]+\\)$" s)) (let ((radix (string-to-int (math-match-substring s 2))) (mant (math-match-substring s 1)) (exp (math-match-substring s 4))) (let ((mant (math-read-number mant)) (exp (math-read-number exp))) (and mant exp (math-mul mant (math-pow (math-float radix) exp)))))) ;; Float with explicit radix, no exponent ((string-match "^\\([0-9]+\\)\\(#\\|\\^\\^\\)\\([0-9a-zA-Z]*\\)\\.\\([0-9a-zA-Z]*\\)$" s) (let ((radix (string-to-int (math-match-substring s 1))) (int (math-match-substring s 3)) (fracs (math-match-substring s 4))) (let ((int (if (> (length int) 0) (math-read-radix int radix) 0)) (frac (if (> (length fracs) 0) (math-read-radix fracs radix) 0)) (calc-prefer-frac nil)) (and int frac (math-add int (math-div frac (math-pow radix (length fracs)))))))) ;; Integer with explicit radix ((string-match "^\\([0-9]+\\)\\(#\\|\\^\\^\\)\\([0-9a-zA-Z]+\\)$" s) (math-read-radix (math-match-substring s 3) (string-to-int (math-match-substring s 1)))) ;; C language hexadecimal notation ((and (eq calc-language 'c) (string-match "^0[xX]\\([0-9a-fA-F]+\\)$" s)) (let ((digs (math-match-substring s 1))) (math-read-radix digs 16))) ;; Pascal language hexadecimal notation ((and (eq calc-language 'pascal) (string-match "^\\$\\([0-9a-fA-F]+\\)$" s)) (let ((digs (math-match-substring s 1))) (math-read-radix digs 16))) ;; Fraction using "/" instead of ":" ((string-match "^\\([0-9]+\\)/\\([0-9/]+\\)$" s) (math-read-number (concat (math-match-substring s 1) ":" (math-match-substring s 2)))) ;; Syntax error! (t nil)) ) (defun math-read-radix (s r) ; [I X D] (setq s (upcase s)) (let ((i 0) (res 0) dig) (while (and (< i (length s)) (setq dig (math-read-radix-digit (elt s i))) (< dig r)) (setq res (math-add (math-mul res r) dig) i (1+ i))) (and (= i (length s)) res)) ) ;;; Expression parsing. (defun math-read-expr (exp-str) (let ((exp-pos 0) (exp-old-pos 0) (exp-keep-spaces nil) exp-token exp-data) (while (setq exp-token (string-match "\\.\\.\\([^.]\\|.[^.]\\)" exp-str)) (setq exp-str (concat (substring exp-str 0 exp-token) "\\dots" (substring exp-str (+ exp-token 2))))) (math-build-parse-table) (math-read-token) (let ((val (catch 'syntax (math-read-expr-level 0)))) (if (stringp val) (list 'error exp-old-pos val) (if (equal exp-token 'end) val (list 'error exp-old-pos "Syntax error"))))) ) (defun math-read-plain-expr (exp-str &optional error-check) (let* ((calc-language nil) (math-expr-opers math-standard-opers) (val (math-read-expr exp-str))) (and error-check (eq (car-safe val) 'error) (error "%s: %s" (nth 2 val) exp-str)) val) ) (defun math-read-string () (let ((str (read-from-string (concat exp-data "\"")))) (or (and (= (cdr str) (1+ (length exp-data))) (stringp (car str))) (throw 'syntax "Error in string constant")) (math-read-token) (append '(vec) (car str) nil)) ) ;;; They said it couldn't be done... (defun math-read-big-expr (str) (and (> (length calc-left-label) 0) (string-match (concat "^" (regexp-quote calc-left-label)) str) (setq str (concat (substring str 0 (match-beginning 0)) (substring str (match-end 0))))) (and (> (length calc-right-label) 0) (string-match (concat (regexp-quote calc-right-label) " *$") str) (setq str (concat (substring str 0 (match-beginning 0)) (substring str (match-end 0))))) (if (string-match "\\\\[^ \n|]" str) (if (eq calc-language 'tex) (math-read-expr str) (let ((calc-language 'tex) (calc-language-option nil) (math-expr-opers (get 'tex 'math-oper-table)) (math-expr-function-mapping (get 'tex 'math-function-table)) (math-expr-variable-mapping (get 'tex 'math-variable-table))) (math-read-expr str))) (let ((lines nil) (pos 0) (width 0) (err-msg nil) the-baseline the-h2 new-pos p) (while (setq new-pos (string-match "\n" str pos)) (setq lines (cons (substring str pos new-pos) lines) pos (1+ new-pos))) (setq lines (nreverse (cons (substring str pos) lines)) p lines) (while p (setq width (max width (length (car p))) p (cdr p))) (if (math-read-big-bigp lines) (or (catch 'syntax (math-read-big-rec 0 0 width (length lines))) err-msg '(error 0 "Syntax error")) (math-read-expr str)))) ) (defun math-read-big-bigp (lines) (and (cdr lines) (let ((matrix nil) (v 0) (height (if (> (length (car lines)) 0) 1 0))) (while (and (cdr lines) (let* ((i 0) j (l1 (car lines)) (l2 (nth 1 lines)) (len (min (length l1) (length l2)))) (if (> (length l2) 0) (setq height (1+ height))) (while (and (< i len) (or (memq (aref l1 i) '(?\ ?\- ?\_)) (memq (aref l2 i) '(?\ ?\-)) (and (memq (aref l1 i) '(?\| ?\,)) (= (aref l2 i) (aref l1 i))) (and (eq (aref l1 i) ?\[) (eq (aref l2 i) ?\[) (let ((h2 (length l1))) (setq j (math-read-big-balance (1+ i) v "["))) (setq i (1- j))))) (setq i (1+ i))) (or (= i len) (and (eq (aref l1 i) ?\[) (eq (aref l2 i) ?\[) (setq matrix t) nil)))) (setq lines (cdr lines) v (1+ v))) (or (and (> height 1) (not (cdr lines))) matrix))) ) ;;; Nontrivial "flat" formatting. (defun math-format-flat-expr-fancy (a prec) (cond ((eq (car a) 'incomplete) (format "" (nth 1 a))) ((eq (car a) 'vec) (if (or calc-full-trail-vectors (not calc-can-abbrev-vectors) (< (length a) 7)) (concat "[" (math-format-flat-vector (cdr a) ", " (if (cdr (cdr a)) 0 1000)) "]") (concat "[" (math-format-flat-expr (nth 1 a) 0) ", " (math-format-flat-expr (nth 2 a) 0) ", " (math-format-flat-expr (nth 3 a) 0) ", ..., " (math-format-flat-expr (nth (1- (length a)) a) 0) "]"))) ((eq (car a) 'intv) (concat (if (memq (nth 1 a) '(0 1)) "(" "[") (math-format-flat-expr (nth 2 a) 1000) " .. " (math-format-flat-expr (nth 3 a) 1000) (if (memq (nth 1 a) '(0 2)) ")" "]"))) ((eq (car a) 'date) (concat "<" (math-format-date a) ">")) ((and (eq (car a) 'calcFunc-lambda) (> (length a) 2)) (let ((p (cdr a)) (ap calc-arg-values) (math-format-hash-args (if (= (length a) 3) 1 t))) (while (and (cdr p) (equal (car p) (car ap))) (setq p (cdr p) ap (cdr ap))) (concat "<" (if (cdr p) (concat (math-format-flat-vector (nreverse (cdr (reverse (cdr a)))) ", " 0) " : ") "") (math-format-flat-expr (nth (1- (length a)) a) 0) ">"))) ((eq (car a) 'var) (or (and math-format-hash-args (let ((p calc-arg-values) (v 1)) (while (and p (not (equal (car p) a))) (setq p (and (eq math-format-hash-args t) (cdr p)) v (1+ v))) (and p (if (eq math-format-hash-args 1) "#" (format "#%d" v))))) (symbol-name (nth 1 a)))) ((and (memq (car a) '(calcFunc-string calcFunc-bstring)) (= (length a) 2) (math-vectorp (nth 1 a)) (math-vector-is-string (nth 1 a))) (concat (substring (symbol-name (car a)) 9) "(" (math-vector-to-string (nth 1 a) t) ")")) (t (let ((op (math-assq2 (car a) math-standard-opers))) (cond ((and op (= (length a) 3)) (if (> prec (min (nth 2 op) (nth 3 op))) (concat "(" (math-format-flat-expr a 0) ")") (let ((lhs (math-format-flat-expr (nth 1 a) (nth 2 op))) (rhs (math-format-flat-expr (nth 2 a) (nth 3 op)))) (setq op (car op)) (if (or (equal op "^") (equal op "_")) (if (= (aref lhs 0) ?-) (setq lhs (concat "(" lhs ")"))) (setq op (concat " " op " "))) (concat lhs op rhs)))) ((eq (car a) 'neg) (concat "-" (math-format-flat-expr (nth 1 a) 1000))) (t (concat (math-remove-dashes (if (string-match "\\`calcFunc-\\([a-zA-Z0-9']+\\)\\'" (symbol-name (car a))) (math-match-substring (symbol-name (car a)) 1) (symbol-name (car a)))) "(" (math-format-flat-vector (cdr a) ", " 0) ")")))))) ) (setq math-format-hash-args nil) (defun math-format-flat-vector (vec sep prec) (if vec (let ((buf (math-format-flat-expr (car vec) prec))) (while (setq vec (cdr vec)) (setq buf (concat buf sep (math-format-flat-expr (car vec) prec)))) buf) "") ) (setq calc-can-abbrev-vectors nil) (defun math-format-nice-expr (x w) (cond ((and (eq (car-safe x) 'vec) (cdr (cdr x)) (let ((ops '(vec calcFunc-assign calcFunc-condition calcFunc-schedule calcFunc-iterations calcFunc-phase))) (or (memq (car-safe (nth 1 x)) ops) (memq (car-safe (nth 2 x)) ops) (memq (car-safe (nth 3 x)) ops) calc-break-vectors))) (concat "[ " (math-format-flat-vector (cdr x) ",\n " 0) " ]")) (t (let ((str (math-format-flat-expr x 0)) (pos 0) p) (or (string-match "\"" str) (while (<= (setq p (+ pos w)) (length str)) (while (and (> (setq p (1- p)) pos) (not (= (aref str p) ? )))) (if (> p (+ pos 5)) (setq str (concat (substring str 0 p) "\n " (substring str p)) pos (1+ p)) (setq pos (+ pos w))))) str))) ) (defun math-assq2 (v a) (while (and a (not (eq v (nth 1 (car a))))) (setq a (cdr a))) (car a) ) (defun math-format-number-fancy (a prec) (cond ((eq (car a) 'float) ; non-decimal radix (if (Math-integer-negp (nth 1 a)) (concat "-" (math-format-number (math-neg a))) (let ((str (if (and calc-radix-formatter (not (memq calc-language '(c pascal)))) (funcall calc-radix-formatter calc-number-radix (math-format-radix-float a prec)) (format "%d#%s" calc-number-radix (math-format-radix-float a prec))))) (if (and prec (> prec 191) (string-match "\\*" str)) (concat "(" str ")") str)))) ((eq (car a) 'frac) (setq a (math-adjust-fraction a)) (if (> (length (car calc-frac-format)) 1) (if (Math-integer-negp (nth 1 a)) (concat "-" (math-format-number (math-neg a))) (let ((q (math-idivmod (nth 1 a) (nth 2 a)))) (concat (let ((calc-frac-format nil)) (math-format-number (car q))) (substring (car calc-frac-format) 0 1) (let ((math-radix-explicit-format nil) (calc-frac-format nil)) (math-format-number (cdr q))) (substring (car calc-frac-format) 1 2) (let ((math-radix-explicit-format nil) (calc-frac-format nil)) (math-format-number (nth 2 a)))))) (concat (let ((calc-frac-format nil)) (math-format-number (nth 1 a))) (car calc-frac-format) (let ((math-radix-explicit-format nil) (calc-frac-format nil)) (math-format-number (nth 2 a)))))) ((eq (car a) 'cplx) (if (math-zerop (nth 2 a)) (math-format-number (nth 1 a)) (if (null calc-complex-format) (concat "(" (math-format-number (nth 1 a)) ", " (math-format-number (nth 2 a)) ")") (if (math-zerop (nth 1 a)) (if (math-equal-int (nth 2 a) 1) (symbol-name calc-complex-format) (if (math-equal-int (nth 2 a) -1) (concat "-" (symbol-name calc-complex-format)) (if prec (math-compose-expr (list '* (nth 2 a) '(cplx 0 1)) prec) (concat (math-format-number (nth 2 a)) " " (symbol-name calc-complex-format))))) (if prec (math-compose-expr (list (if (math-negp (nth 2 a)) '- '+) (nth 1 a) (list 'cplx 0 (math-abs (nth 2 a)))) prec) (concat (math-format-number (nth 1 a)) (if (math-negp (nth 2 a)) " - " " + ") (math-format-number (list 'cplx 0 (math-abs (nth 2 a)))))))))) ((eq (car a) 'polar) (concat "(" (math-format-number (nth 1 a)) "; " (math-format-number (nth 2 a)) ")")) ((eq (car a) 'hms) (if (math-negp a) (concat "-" (math-format-number (math-neg a))) (let ((calc-number-radix 10) (calc-leading-zeros nil) (calc-group-digits nil)) (format calc-hms-format (let ((calc-frac-format '(":" nil))) (math-format-number (nth 1 a))) (let ((calc-frac-format '(":" nil))) (math-format-number (nth 2 a))) (math-format-number (nth 3 a)))))) ((eq (car a) 'intv) (concat (if (memq (nth 1 a) '(0 1)) "(" "[") (math-format-number (nth 2 a)) " .. " (math-format-number (nth 3 a)) (if (memq (nth 1 a) '(0 2)) ")" "]"))) ((eq (car a) 'sdev) (concat (math-format-number (nth 1 a)) " +/- " (math-format-number (nth 2 a)))) ((eq (car a) 'vec) (math-format-flat-expr a 0)) (t (format "%s" a))) ) (defun math-adjust-fraction (a) (if (nth 1 calc-frac-format) (progn (if (Math-integerp a) (setq a (list 'frac a 1))) (let ((g (math-quotient (nth 1 calc-frac-format) (math-gcd (nth 2 a) (nth 1 calc-frac-format))))) (list 'frac (math-mul (nth 1 a) g) (math-mul (nth 2 a) g)))) a) ) (defun math-format-bignum-fancy (a) ; [X L] (let ((str (cond ((= calc-number-radix 10) (math-format-bignum-decimal a)) ((= calc-number-radix 2) (math-format-bignum-binary a)) ((= calc-number-radix 8) (math-format-bignum-octal a)) ((= calc-number-radix 16) (math-format-bignum-hex a)) (t (math-format-bignum-radix a))))) (if calc-leading-zeros (let* ((calc-internal-prec 6) (digs (math-compute-max-digits (math-abs calc-word-size) calc-number-radix)) (len (length str))) (if (< len digs) (setq str (concat (make-string (- digs len) ?0) str))))) (if calc-group-digits (let ((i (length str)) (g (if (integerp calc-group-digits) (math-abs calc-group-digits) (if (memq calc-number-radix '(2 16)) 4 3)))) (while (> i g) (setq i (- i g) str (concat (substring str 0 i) calc-group-char (substring str i)))) str)) (if (and (/= calc-number-radix 10) math-radix-explicit-format) (if calc-radix-formatter (funcall calc-radix-formatter calc-number-radix str) (format "%d#%s" calc-number-radix str)) str)) ) (defun math-group-float (str) ; [X X] (let* ((pt (or (string-match "[^0-9a-zA-Z]" str) (length str))) (g (if (integerp calc-group-digits) (math-abs calc-group-digits) 3)) (i pt)) (if (and (integerp calc-group-digits) (< calc-group-digits 0)) (while (< (setq i (+ (1+ i) g)) (length str)) (setq str (concat (substring str 0 i) calc-group-char (substring str i)) i (+ i (1- (length calc-group-char)))))) (setq i pt) (while (> i g) (setq i (- i g) str (concat (substring str 0 i) calc-group-char (substring str i)))) str) ) (setq math-compose-level 0) (setq math-comp-selected nil) (setq math-comp-tagged nil) (setq math-comp-sel-hpos nil) (setq math-comp-sel-vpos nil) (setq math-comp-sel-cpos nil) (setq math-compose-hash-args nil) ;;; Users can redefine this in their .emacs files. (defvar calc-keypad-user-menu nil "If not NIL, this describes an additional menu for calc-keypad. It should contain a list of three rows. Each row should be a list of six keys. Each key should be a list of a label string, plus a Calc command name spec. A command spec is a command name symbol, a keyboard macro string, a list containing a numeric entry string, or nil. A key may contain additional specs for Inverse, Hyperbolic, and Inv+Hyp.") (run-hooks 'calc-ext-load-hook) calc-2.02c/calc-help.el100644 22403 13 54050 5547406500 13221 0ustar daveguser;; Calculator for GNU Emacs, part II [calc-help.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc-ext.el. (require 'calc-ext) (require 'calc-macs) (defun calc-Need-calc-help () nil) (defun calc-help-prefix (arg) "This key is the prefix for Calc help functions. See calc-help-for-help." (interactive "P") (or calc-dispatch-help (sit-for echo-keystrokes)) (let ((key (calc-read-key-sequence (if calc-dispatch-help "Calc Help options: Help, Info, Tutorial, Summary; Key, Function; ?=more" (format "%s (Type ? for a list of Calc Help options)" (key-description (this-command-keys)))) calc-help-map))) (setq key (lookup-key calc-help-map key)) (message "") (if key (call-interactively key) (beep))) ) (defun calc-help-for-help (arg) "You have typed `h', the Calc help character. Type a Help option: B calc-describe-bindings. Display a table of all key bindings. H calc-full-help. Display all `?' key messages at once. I calc-info. Read the Calc manual using the Info system. T calc-tutorial. Read the Calc tutorial using the Info system. S calc-info-summary. Read the Calc summary using the Info system. C calc-describe-key-briefly. Look up the command name for a given key. K calc-describe-key. Look up a key's documentation in the manual. F calc-describe-function. Look up a function's documentation in the manual. V calc-describe-variable. Look up a variable's documentation in the manual. N calc-view-news. Display Calc history of changes. C-c Describe conditions for copying Calc. C-d Describe how you can get a new copy of Calc or report a bug. C-w Describe how there is no warranty for Calc." (interactive "P") (if calc-dispatch-help (let (key) (save-window-excursion (describe-function 'calc-help-for-help) (select-window (get-buffer-window "*Help*")) (while (progn (message "Calc Help options: Help, Info, ... press SPC, DEL to scroll, C-g to cancel") (memq (car (setq key (calc-read-key t))) '(? ?\C-h ?\C-? ?\C-v ?\M-v))) (condition-case err (if (memq (car key) '(? ?\C-v)) (scroll-up) (scroll-down)) (error (beep))))) (calc-unread-command (cdr key)) (calc-help-prefix nil)) (let ((calc-dispatch-help t)) (calc-help-prefix arg))) ) (defun calc-describe-copying () (interactive) (calc-info) (Info-goto-node "Copying") ) (defun calc-describe-distribution () (interactive) (calc-info) (Info-goto-node "Reporting Bugs") ) (defun calc-describe-no-warranty () (interactive) (calc-info) (Info-goto-node "Copying") (let ((case-fold-search nil)) (search-forward " NO WARRANTY")) (beginning-of-line) (recenter 0) ) (defun calc-describe-bindings () (interactive) (describe-bindings) (save-excursion (set-buffer "*Help*") (goto-char (point-min)) (if (search-forward "Global bindings:" nil t) (delete-region (match-beginning 0) (point-max))) (goto-char (point-min)) (while (re-search-forward "\n[a-z] ESC" nil t) (end-of-line) (delete-region (match-beginning 0) (point))) (goto-char (point-min)) (while (re-search-forward "\nESC m" nil t) (end-of-line) (delete-region (match-beginning 0) (point))) (goto-char (point-min)) (while (search-forward "\n\n\n" nil t) (backward-delete-char 1) (backward-char 2)) (goto-char (point-min)) (while (re-search-forward "\n[a-z] [0-9]\\(\t\t.*\n\\)\\([a-z] [0-9]\\1\\)*[a-z] \\([0-9]\\)\\1" nil t) (let ((dig1 (char-after (1- (match-beginning 1)))) (dig2 (char-after (match-beginning 3)))) (delete-region (match-end 1) (match-end 0)) (goto-char (match-beginning 1)) (delete-backward-char 1) (delete-char 1) (insert (format "%c .. %c" (min dig1 dig2) (max dig1 dig2))))) (goto-char (point-min))) ) (defun calc-describe-key-briefly (key) (interactive "kDescribe key briefly: ") (calc-describe-key key t) ) (defun calc-describe-key (key &optional briefly) (interactive "kDescribe key: ") (let ((defn (if (eq (key-binding key) 'calc-dispatch) (let ((key2 (calc-read-key-sequence (format "Describe key briefly: %s-" (key-description key)) calc-dispatch-map))) (setq key (concat key key2)) (lookup-key calc-dispatch-map key2)) (if (eq (key-binding key) 'calc-help-prefix) (let ((key2 (calc-read-key-sequence (format "Describe key briefly: %s-" (key-description key)) calc-help-map))) (setq key (concat key key2)) (lookup-key calc-help-map key2)) (key-binding key)))) (inv nil) (hyp nil)) (while (or (equal key "I") (equal key "H")) (if (equal key "I") (setq inv (not inv)) (setq hyp (not hyp))) (setq key (read-key-sequence (format "Describe key%s:%s%s " (if briefly " briefly" "") (if inv " I" "") (if hyp " H" ""))) defn (key-binding key))) (let ((desc (key-description key)) target) (if (string-match "^ESC " desc) (setq desc (concat "M-" (substring desc 4)))) (while (string-match "^M-# \\(ESC \\|C-\\)" desc) (setq desc (concat "M-# " (substring desc (match-end 0))))) (if briefly (let ((msg (save-excursion (set-buffer (get-buffer-create "*Calc Summary*")) (if (= (buffer-size) 0) (progn (message "Reading Calc summary from manual...") (save-window-excursion (save-excursion (calc-info) (Info-goto-node "Summary") (goto-char (point-min)) (forward-line 1) (copy-to-buffer "*Calc Summary*" (point) (point-max)) (Info-last))) (setq case-fold-search nil) (re-search-forward "^\\(.*\\)\\[\\.\\. a b") (setq calc-summary-indentation (- (match-end 1) (match-beginning 1))))) (goto-char (point-min)) (setq target (if (and (string-match "[0-9]\\'" desc) (not (string-match "[d#]" desc))) (concat (substring desc 0 -1) "0-9") desc)) (if (re-search-forward (format "\n%s%s%s%s[ a-zA-Z]" (make-string (+ calc-summary-indentation 9) ?\.) (if (string-match "M-#" desc) " " (if inv (if hyp "I H " " I ") (if hyp " H " " "))) (regexp-quote target) (make-string (max (- 6 (length target)) 0) ?\ )) nil t) (let (pt) (beginning-of-line) (forward-char calc-summary-indentation) (setq pt (point)) (end-of-line) (buffer-substring pt (point))))))) (if msg (let ((args (substring msg 0 9)) (keys (substring msg 9 19)) (prompts (substring msg 19 38)) (notes "") (cmd (substring msg 40)) msg) (if (string-match "\\` +" args) (setq args (substring args (match-end 0)))) (if (string-match " +\\'" args) (setq args (substring args 0 (match-beginning 0)))) (if (string-match "\\` +" keys) (setq keys (substring keys (match-end 0)))) (if (string-match " +\\'" keys) (setq keys (substring keys 0 (match-beginning 0)))) (if (string-match " [0-9,]+\\'" prompts) (setq notes (substring prompts (1+ (match-beginning 0))) prompts (substring prompts 0 (match-beginning 0)))) (if (string-match " +\\'" prompts) (setq prompts (substring prompts 0 (match-beginning 0)))) (if (string-match "\\` +" prompts) (setq prompts (substring prompts (match-end 0)))) (setq msg (format "%s: %s%s`%s'%s%s %s%s" (if (string-match "\\`\\(calc-[-a-zA-Z0-9]+\\) *\\(.*\\)\\'" cmd) (prog1 (math-match-substring cmd 1) (setq cmd (math-match-substring cmd 2))) defn) args (if (equal args "") "" " ") keys (if (equal prompts "") "" " ") prompts (if (equal cmd "") "" " => ") cmd)) (message "%s%s%s runs %s%s" (if inv "I " "") (if hyp "H " "") desc msg (if (equal notes "") "" (format " (?=notes %s)" notes))) (let ((key (calc-read-key t))) (if (eq (car key) ??) (if (equal notes "") (message "No notes for this command") (while (string-match "," notes) (aset notes (match-beginning 0) ? )) (setq notes (sort (car (read-from-string (format "(%s)" notes))) '<)) (with-output-to-temp-buffer "*Help*" (princ (format "%s\n\n" msg)) (set-buffer "*Calc Summary*") (re-search-forward "^ *NOTES") (while notes (re-search-forward (format "^ *%d\\. " (car notes))) (beginning-of-line) (let ((pt (point))) (forward-line 1) (or (re-search-forward "^ ? ?[0-9]+\\. " nil t) (goto-char (point-max))) (beginning-of-line) (princ (buffer-substring pt (point)))) (setq notes (cdr notes))) (print-help-return-message))) (calc-unread-command (cdr key))))) (if (or (null defn) (integerp defn)) (message "%s is undefined" desc) (message "%s runs the command %s" desc (if (symbolp defn) defn (prin1-to-string defn)))))) (if inv (setq desc (concat "I " desc))) (if hyp (setq desc (concat "H " desc))) (calc-describe-thing desc "Key Index" nil (string-match "[A-Z][A-Z][A-Z]" desc))))) ) (defun calc-describe-function (&optional func) (interactive) (or func (setq func (intern (completing-read "Describe function: " obarray nil t "calcFunc-")))) (setq func (symbol-name func)) (if (string-match "\\`calc-." func) (calc-describe-thing func "Command Index") (calc-describe-thing (if (string-match "\\`calcFunc-." func) (substring func 9) func) "Function Index")) ) (defun calc-describe-variable (&optional var) (interactive) (or var (setq var (intern (completing-read "Describe variable: " obarray nil t "var-")))) (setq var (symbol-name var)) (calc-describe-thing var "Variable Index" (if (string-match "\\`var-." var) (substring var 4) var)) ) (defun calc-describe-thing (thing where &optional target not-quoted) (message "Looking for `%s' in %s..." thing where) (let ((savewin (current-window-configuration))) (calc-info) (Info-goto-node where) (or (let ((case-fold-search nil)) (re-search-forward (format "\n\\* +%s: \\(.*\\)\\." (regexp-quote thing)) nil t)) (and (string-match "\\`\\([a-z ]*\\)[0-9]\\'" thing) (re-search-forward (format "\n\\* +%s[01]-9: \\(.*\\)\\." (substring thing 0 -1)) nil t) (setq thing (format "%s9" (substring thing 0 -1)))) (progn (Info-last) (set-window-configuration savewin) (error "Can't find `%s' in %s" thing where))) (let (Info-history) (Info-goto-node (buffer-substring (match-beginning 1) (match-end 1)))) (or (let ((case-fold-search nil)) (or (search-forward (format "\\[`%s'\\]\\|(`%s')\\|\\)" "Let; Copy; Declare; Insert, Perm; Edit" "Negate, +, -, *, /, ^, &, |, [, ]; Map" "SHIFT + Decls, GenCount, TimeZone, Holidays; IntegLimit" "SHIFT + LineStyles, PointStyles, plotRejects; Units" "SHIFT + Eval-, AlgSimp-, ExtSimp-, FitRules") "store" ?s) ) (defun calc-r-prefix-help () (interactive) (calc-do-prefix-help '("digits 0-9: recall, same as `s r 0-9'") "recall" ?r) ) (defun calc-j-prefix-help () (interactive) (calc-do-prefix-help '("Select, Additional, Once; eVal, Formula; Rewrite" "More, Less, 1-9, Next, Previous" "Unselect, Clear; Display; Enable; Breakable" "' (replace), ` (edit), +, -, *, /, RET (grab), DEL" "SHIFT + swap: Left, Right; maybe: Select, Once" "SHIFT + Commute, Merge, Distrib, jump-Eqn, Isolate" "SHIFT + Negate, & (invert); Unpack") "select" ?j) ) (defun calc-a-prefix-help () (interactive) (calc-do-prefix-help '("Simplify, Extended-simplify, eVal; \" (exp-formula)" "eXpand, Collect, Factor, Apart, Norm-rat" "GCD, /, \\, % (polys); Polint" "Derivative, Integral, Taylor; _ (subscr)" "suBstitute; Rewrite, Match" "SHIFT + Solve; Root, miN, maX; Poly-roots; Fit" "SHIFT + Map; Tabulate, + (sum), * (prod); num-Integ" "relations: =, # (not =), <, >, [ (< or =), ] (> or =)" "logical: & (and), | (or), ! (not); : (if)" "misc: { (in-set); . (rmeq)") "algebra" ?a) ) (defun calc-b-prefix-help () (interactive) (calc-do-prefix-help '("And, Or, Xor, Diff, Not; Wordsize, Clip" "Lshift, Rshift, roTate; SHIFT + signed Lshift, Rshift" "SHIFT + business: Pv, Npv, Fv, pMt, #pmts, raTe, Irr" "SHIFT + business: Sln, sYd, Ddb; %ch") "binary/bus" ?b) ) (defun calc-c-prefix-help () (interactive) (calc-do-prefix-help '("Deg, Rad, HMS; Float; Polar/rect; Clean, 0-9; %" "SHIFT + Fraction") "convert" ?c) ) (defun calc-d-prefix-help () (interactive) (calc-do-prefix-help '("Group, \",\"; Normal, Fix, Sci, Eng, \".\"; Over" "Radix, Zeros, 2, 8, 0, 6; Hms; Date; Complex, I, J" "Why; Line-nums, line-Breaks; <, =, > (justify); Plain" "\" (strings); Truncate, [, ]; SPC (refresh), RET" "SHIFT + language: Normal, One-line, Big, Unformatted" "SHIFT + language: C, Pascal, Fortran; TeX, Eqn" "SHIFT + language: Mathematica, W=Maple") "display" ?d) ) (defun calc-g-prefix-help () (interactive) (calc-do-prefix-help '("Fast; Add, Delete, Juggle; Plot, Clear; Quit" "Header, Name, Grid, Border, Key; View-commands, X-display" "x-axis: Range, Title, Log, Zero; lineStyle" "SHIFT + y-axis: Range, Title, Log, Zero; pointStyle" "SHIFT + Print; Device, Output-file; X-geometry" "SHIFT + Num-pts; Command, Kill, View-trail" "SHIFT + 3d: Fast, Add; CTRL + z-axis: Range, Title, Log") "graph" ?g) ) (defun calc-k-prefix-help () (interactive) (calc-do-prefix-help '("GCD, LCM; Choose (binomial), Double-factorial" "Random, random-Again, sHuffle" "Factors, Prime-test, Next-prime, Totient, Moebius" "Bernoulli, Euler, Stirling" "SHIFT + Extended-gcd" "SHIFT + dists: Binomial, Chi-square, F, Normal" "SHIFT + dists: Poisson, student's-T") "combinatorics" ?k) ) (defun calc-m-prefix-help () (interactive) (calc-do-prefix-help '("Deg, Rad, HMS; Frac; Polar; Inf; Alg, Total; Symb; Vec/mat" "Working; Xtensions; Mode-save" "SHIFT + Shifted-prefixes, mode-Filename; Record; reCompute" "SHIFT + simplify: Off, Num, Default, Bin, Alg, Ext, Units") "mode" ?m) ) (defun calc-t-prefix-help () (interactive) (calc-do-prefix-help '("Display; Fwd, Back; Next, Prev, Here, [, ]; Yank" "Search, Rev; In, Out; <, >; Kill; Marker; . (abbrev)" "SHIFT + time: Now; Part; Date, Julian, Unix, Czone" "SHIFT + time: newWeek, newMonth, newYear; Incmonth" "SHIFT + time: +, - (business days)" "digits 0-9: store-to, same as `s t 0-9'") "trail/time" ?t) ) (defun calc-u-prefix-help () (interactive) (calc-do-prefix-help '("Simplify, Convert, Temperature-convert, Base-units" "Autorange; Remove, eXtract; Explain; View-table; 0-9" "Define, Undefine, Get-defn, Permanent" "SHIFT + View-table-other-window" "SHIFT + stat: Mean, G-mean, Std-dev, Covar, maX, miN" "SHIFT + stat: + (sum), - (asum), * (prod), # (count)") "units/stat" ?u) ) (defun calc-v-prefix-help () (interactive) (calc-do-prefix-help '("Pack, Unpack, Identity, Diagonal, indeX, Build" "Row, Column, Subvector; Length; Find; Mask, Expand" "Tranpose, Arrange, reVerse; Head, Kons; rNorm" "SHIFT + Det, & (inverse), LUD, Trace, conJtrn, Cross" "SHIFT + Sort, Grade, Histogram; cNorm" "SHIFT + Apply, Map, Reduce, accUm, Inner-, Outer-prod" "SHIFT + sets: V (union), ^ (intersection), - (diff)" "SHIFT + sets: Xor, ~ (complement), Floor, Enum" "SHIFT + sets: : (span), # (card), + (rdup)" "<, =, > (justification); , (commas); [, {, ( (brackets)" "} (matrix brackets); . (abbreviate); / (multi-lines)") "vec/mat" ?v) ) calc-2.02c/calc-macs.el100644 22403 13 14053 5402630650 13206 0ustar daveguser;; Calculator for GNU Emacs, part I [calc-macs.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. (provide 'calc-macs) (defun calc-need-macros () nil) (defmacro calc-record-compilation-date-macro () (` (setq calc-installed-date (, (concat (current-time-string) " by " (user-full-name))))) ) (defmacro calc-wrapper (&rest body) (list 'calc-do (list 'function (append (list 'lambda ()) body))) ) ;; We use "point" here to generate slightly smaller byte-code than "t". (defmacro calc-slow-wrapper (&rest body) (list 'calc-do (list 'function (append (list 'lambda ()) body)) (point)) ) (defmacro math-showing-full-precision (body) (list 'let '((calc-float-format calc-full-float-format)) body) ) (defmacro math-with-extra-prec (delta &rest body) (` (math-normalize (let ((calc-internal-prec (+ calc-internal-prec (, delta)))) (,@ body)))) ) ;;; Faster in-line version zerop, normalized values only. (defmacro Math-zerop (a) ; [P N] (` (if (consp (, a)) (and (not (memq (car (, a)) '(bigpos bigneg))) (if (eq (car (, a)) 'float) (eq (nth 1 (, a)) 0) (math-zerop (, a)))) (eq (, a) 0))) ) (defmacro Math-integer-negp (a) (` (if (consp (, a)) (eq (car (, a)) 'bigneg) (< (, a) 0))) ) (defmacro Math-integer-posp (a) (` (if (consp (, a)) (eq (car (, a)) 'bigpos) (> (, a) 0))) ) (defmacro Math-negp (a) (` (if (consp (, a)) (or (eq (car (, a)) 'bigneg) (and (not (eq (car (, a)) 'bigpos)) (if (memq (car (, a)) '(frac float)) (Math-integer-negp (nth 1 (, a))) (math-negp (, a))))) (< (, a) 0))) ) (defmacro Math-looks-negp (a) ; [P x] [Public] (` (or (Math-negp (, a)) (and (consp (, a)) (or (eq (car (, a)) 'neg) (and (memq (car (, a)) '(* /)) (or (math-looks-negp (nth 1 (, a))) (math-looks-negp (nth 2 (, a))))))))) ) (defmacro Math-posp (a) (` (if (consp (, a)) (or (eq (car (, a)) 'bigpos) (and (not (eq (car (, a)) 'bigneg)) (if (memq (car (, a)) '(frac float)) (Math-integer-posp (nth 1 (, a))) (math-posp (, a))))) (> (, a) 0))) ) (defmacro Math-integerp (a) (` (or (not (consp (, a))) (memq (car (, a)) '(bigpos bigneg)))) ) (defmacro Math-natnump (a) (` (if (consp (, a)) (eq (car (, a)) 'bigpos) (>= (, a) 0))) ) (defmacro Math-ratp (a) (` (or (not (consp (, a))) (memq (car (, a)) '(bigpos bigneg frac)))) ) (defmacro Math-realp (a) (` (or (not (consp (, a))) (memq (car (, a)) '(bigpos bigneg frac float)))) ) (defmacro Math-anglep (a) (` (or (not (consp (, a))) (memq (car (, a)) '(bigpos bigneg frac float hms)))) ) (defmacro Math-numberp (a) (` (or (not (consp (, a))) (memq (car (, a)) '(bigpos bigneg frac float cplx polar)))) ) (defmacro Math-scalarp (a) (` (or (not (consp (, a))) (memq (car (, a)) '(bigpos bigneg frac float cplx polar hms)))) ) (defmacro Math-vectorp (a) (` (and (consp (, a)) (eq (car (, a)) 'vec))) ) (defmacro Math-messy-integerp (a) (` (and (consp (, a)) (eq (car (, a)) 'float) (>= (nth 2 (, a)) 0))) ) (defmacro Math-objectp (a) ; [Public] (` (or (not (consp (, a))) (memq (car (, a)) '(bigpos bigneg frac float cplx polar hms date sdev intv mod)))) ) (defmacro Math-objvecp (a) ; [Public] (` (or (not (consp (, a))) (memq (car (, a)) '(bigpos bigneg frac float cplx polar hms date sdev intv mod vec)))) ) ;;; Compute the negative of A. [O O; o o] [Public] (defmacro Math-integer-neg (a) (` (if (consp (, a)) (if (eq (car (, a)) 'bigpos) (cons 'bigneg (cdr (, a))) (cons 'bigpos (cdr (, a)))) (- (, a)))) ) (defmacro Math-equal (a b) (` (= (math-compare (, a) (, b)) 0)) ) (defmacro Math-lessp (a b) (` (= (math-compare (, a) (, b)) -1)) ) (defmacro math-working (msg arg) ; [Public] (` (if (eq calc-display-working-message 'lots) (math-do-working (, msg) (, arg)))) ) (defmacro calc-with-default-simplification (body) (list 'let '((calc-simplify-mode (and (not (memq calc-simplify-mode '(none num))) calc-simplify-mode))) body) ) (defmacro Math-primp (a) (` (or (not (consp (, a))) (memq (car (, a)) '(bigpos bigneg frac float cplx polar hms date mod var)))) ) (defmacro calc-with-trail-buffer (&rest body) (` (let ((save-buf (current-buffer)) (calc-command-flags nil)) (unwind-protect (, (append '(progn (set-buffer (calc-trail-display t)) (goto-char calc-trail-pointer)) body)) (set-buffer save-buf)))) ) (defmacro Math-num-integerp (a) (` (or (not (consp (, a))) (memq (car (, a)) '(bigpos bigneg)) (and (eq (car (, a)) 'float) (>= (nth 2 (, a)) 0)))) ) (defmacro Math-bignum-test (a) ; [B N; B s; b b] (` (if (consp (, a)) (, a) (math-bignum (, a)))) ) (defmacro Math-equal-int (a b) (` (or (eq (, a) (, b)) (and (consp (, a)) (eq (car (, a)) 'float) (eq (nth 1 (, a)) (, b)) (= (nth 2 (, a)) 0)))) ) (defmacro Math-natnum-lessp (a b) (` (if (consp (, a)) (and (consp (, b)) (= (math-compare-bignum (cdr (, a)) (cdr (, b))) -1)) (or (consp (, b)) (< (, a) (, b))))) ) (defmacro math-format-radix-digit (a) ; [X D] (` (aref math-radix-digits (, a))) ) calc-2.02c/calc-maint.el100644 22403 13 37011 5547406502 13401 0ustar daveguser;; Calculator for GNU Emacs, maintenance routines ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. (defun calc-compile () "Compile all parts of Calc. Unix usage: emacs -batch -l calc-maint -f calc-compile" (interactive) (if (equal (user-full-name) "David Gillespie") (load "~/lisp/newbytecomp")) (setq byte-compile-verbose t) (if noninteractive (let ((old-message (symbol-function 'message)) (old-write-region (symbol-function 'write-region)) (comp-was-func nil) (comp-len 0)) (unwind-protect (progn (fset 'message (symbol-function 'calc-compile-message)) (fset 'write-region (symbol-function 'calc-compile-write-region)) (calc-do-compile)) (fset 'message old-message) (fset 'write-region old-write-region))) (calc-do-compile)) ) (defun calc-do-compile () (let ((make-backup-files nil) (changed-rules nil) (changed-units nil) (message-bug (string-match "^18.\\([0-4][0-9]\\|5[0-6]\\)" emacs-version))) (setq max-lisp-eval-depth (max 400 max-lisp-eval-depth)) (setq byte-compile-warnings nil) ;; Make sure we're in the right directory. (find-file "calc.el") (if (= (buffer-size) 0) (error "This command must be used in the Calc source directory.")) ;; Make sure current directory is in load-path. (setq load-path (cons default-directory load-path)) (load "calc-macs.el" nil t t) (provide 'calc) (provide 'calc-ext) ;; Compile all the source files. (let ((files (append '("calc.el" "calc-ext.el") (sort (directory-files default-directory nil "\\`\\(calc-.[^x].*\\|macedit\\)\\.el\\'") 'string<)))) (while files (if (file-newer-than-file-p (car files) (concat (car files) "c")) (progn (if (string-match "calc-rules" (car files)) (setq changed-rules t)) (if (string-match "calc-units" (car files)) (setq changed-units t)) (or message-bug (message "")) (byte-compile-file (car files))) (message "File %s is up to date." (car files))) (if (string-match "calc\\(-ext\\)?.el" (car files)) (load (concat (car files) "c") nil t t)) (setq files (cdr files)))) (if (or changed-units changed-rules) (condition-case err (progn ;; Pre-build the units table. (if (and changed-units (not (string-match "Lucid" emacs-version))) (progn (or message-bug (message "")) (save-excursion (calc-create-buffer) (math-build-units-table)) (find-file "calc-units.elc") (goto-char (point-max)) (insert "\n(setq math-units-table '" (prin1-to-string math-units-table) ")\n") (save-buffer))) ;; Pre-build rewrite rules for j D, j M, etc. (if (and changed-rules (not (string-match "^19" emacs-version))) (let ((rules nil)) (or message-bug (message "")) (find-file "calc-rules.elc") (goto-char (point-min)) (while (re-search-forward "defun calc-\\([A-Za-z]*Rules\\)" nil t) (setq rules (cons (buffer-substring (match-beginning 1) (match-end 1)) rules))) (goto-char (point-min)) (re-search-forward "\n(defun calc-[A-Za-z]*Rules") (beginning-of-line) (delete-region (point) (point-max)) (mapcar (function (lambda (v) (let* ((vv (intern (concat "var-" v))) (val (save-excursion (calc-create-buffer) (calc-var-value vv)))) (insert "\n(defun calc-" v " () '" (prin1-to-string val) ")\n")))) (sort rules 'string<)) (save-buffer)))) (error (message "Unable to pre-build tables %s" err)))) (message "Done. Don't forget to install with \"make public\" or \"make private\".")) ) (defun calc-compile-message (fmt &rest args) (cond ((and (= (length args) 2) (stringp (car args)) (string-match ".elc?\\'" (car args)) (symbolp (nth 1 args))) (let ((name (symbol-name (nth 1 args)))) (princ (if comp-was-func ", " " ")) (if (and comp-was-func (eq (string-match comp-was-func name) 0)) (setq name (substring name (1- (length comp-was-func)))) (setq comp-was-func (if (string-match "\\`[a-zA-Z]+-" name) (substring name 0 (match-end 0)) " "))) (if (> (+ comp-len (length name)) 75) (progn (princ "\n ") (setq comp-len 0))) (princ name) (send-string-to-terminal "") ; cause an fflush(stdout) (setq comp-len (+ comp-len 2 (length name))))) ((and (setq comp-was-func nil comp-len 0) (= (length args) 1) (stringp (car args)) (string-match ".elc?\\'" (car args))) (or (string-match "Saving file %s..." fmt) (funcall old-message fmt (file-name-nondirectory (car args))))) ((string-match "\\(Preparing\\|Building\\).*\\.\\.\\.$" fmt) (send-string-to-terminal (apply 'format fmt args))) ((string-match "\\(Preparing\\|Building\\).*\\.\\.\\. *done$" fmt) (send-string-to-terminal "done\n")) (t (apply old-message fmt args))) ) (defun calc-compile-write-region (start end filename &optional append visit) (if (eq visit t) (set-buffer-auto-saved)) (if (and (string-match "\\.elc" filename) (= start (point-min)) (= end (point-max))) (save-excursion (goto-char (point-min)) (if (search-forward "\n(require (quote calc-macs))\n" nil t) (replace-match "")) (setq end (point-max)))) (funcall old-write-region start end filename append 'quietly) (message "Wrote %s" filename) nil ) (defun calc-split-tutorial (&optional force) (interactive "P") (calc-split-manual force 1)) (defun calc-split-reference (&optional force) (interactive "P") (calc-split-manual force 2)) (defun calc-split-manual (&optional force part) "Split the Calc manual into separate Tutorial and Reference manuals. Use this if your TeX installation is too small-minded to handle calc.texinfo all at once. Usage: C-x C-f calc.texinfo RET M-x calc-split-manual RET" (interactive "P") (or (let ((case-fold-search t)) (string-match "calc\\.texinfo" (buffer-name))) force (error "This command should be used in the calc.texinfo buffer.")) (let ((srcbuf (current-buffer)) tutpos refpos endpos (maxpos (point-max))) (goto-char 1) (search-forward "@c [tutorial]") (beginning-of-line) (setq tutpos (point)) (search-forward "@c [reference]") (beginning-of-line) (setq refpos (point)) (search-forward "@c [end]") (beginning-of-line) (setq endpos (point)) (or (eq part 2) (progn (find-file "calctut.tex") (erase-buffer) (insert-buffer-substring srcbuf 1 refpos) (insert-buffer-substring srcbuf endpos maxpos) (calc-split-volume "I" "ref" "Tutorial" "Reference") (save-buffer))) (or (eq part 1) (progn (find-file "calcref.tex") (erase-buffer) (insert-buffer-substring srcbuf 1 tutpos) (insert "\n@tex\n\\global\\advance\\chapno by 1\n@end tex\n") (insert-buffer-substring srcbuf refpos maxpos) (calc-split-volume "II" "tut" "Reference" "Tutorial") (save-buffer))) (switch-to-buffer srcbuf) (goto-char 1)) (message (cond ((eq part 1) "Wrote file calctut.tex") ((eq part 2) "Wrote file calcref.tex") (t "Wrote files calctut.tex and calcref.tex"))) ) (defun calc-split-volume (number fix name other-name) (goto-char 1) (search-forward "@c [title]\n") (search-forward "Manual") (delete-backward-char 6) (insert name) (search-forward "@c [volume]\n") (insert "@sp 1\n@center Volume " number ": " name "\n") (let ((pat (format "@c \\[fix-%s \\(.*\\)\\]\n" fix))) (while (re-search-forward pat nil t) (let ((topic (buffer-substring (match-beginning 1) (match-end 1)))) (re-search-forward "@\\(p?xref\\){[^}]*}") (let ((cmd (buffer-substring (match-beginning 1) (match-end 1)))) (delete-region (match-beginning 0) (match-end 0)) (insert (if (equal cmd "pxref") "see" "See") " ``" topic "'' in @emph{the Calc " other-name "}"))))) (goto-char 1) (while (search-forward "@c [when-split]\n" nil t) (while (looking-at "@c ") (delete-char 3) (forward-line 1))) (goto-char 1) (while (search-forward "@c [not-split]\n" nil t) (while (not (looking-at "@c")) (insert "@c ") (forward-line 1))) ) (defun calc-inline-summary () "Make a special \"calcsum.tex\" file to be used with main manual." (calc-split-summary nil t) ) (defun calc-split-summary (&optional force in-line) "Make a special \"calcsum.tex\" file with just the Calc summary." (interactive "P") (or (let ((case-fold-search t)) (string-match "calc\\.texinfo" (buffer-name))) force (error "This command should be used in the calc.texinfo buffer.")) (let ((srcbuf (current-buffer)) begpos sumpos endpos midpos) (goto-char 1) (search-forward "{Calc Manual}") (backward-char 1) (delete-backward-char 6) (insert "Summary") (search-forward "@c [begin]") (beginning-of-line) (setq begpos (point)) (search-forward "@c [summary]") (beginning-of-line) (setq sumpos (point)) (search-forward "@c [end-summary]") (beginning-of-line) (setq endpos (point)) (find-file "calcsum.tex") (erase-buffer) (insert-buffer-substring srcbuf 1 begpos) (insert "@tex\n" "\\global\\advance\\appendixno2\n" "\\gdef\\xref#1.{See ``#1.''}\n") (setq midpos (point)) (insert "@end tex\n") (insert-buffer-substring srcbuf sumpos endpos) (insert "@bye\n") (goto-char 1) (if (search-forward "{. a b c" nil t) (replace-match "{... a b c")) (goto-char 1) (if in-line (let ((buf (current-buffer)) (page nil)) (find-file "calc.aux") (if (> (buffer-size) 0) (progn (goto-char 1) (re-search-forward "{Summary-pg}{\\([0-9]+\\)}") (setq page (string-to-int (buffer-substring (match-beginning 1) (match-end 1)))))) (switch-to-buffer buf) (if page (progn (message "Adjusting starting page number to %d" page) (goto-char midpos) (insert (format "\\global\\pageno=%d\n" page))) (message "Unable to find page number from calc.aux"))) (if (search-forward "@c smallbook" nil t) (progn ; activate "smallbook" format for compactness (beginning-of-line) (forward-char 1) (delete-char 2)))) (let ((buf (current-buffer))) (find-file "calc.ky") (if (> (buffer-size) 0) (let ((ibuf (current-buffer))) (message "Mixing in page numbers from Key Index (calc.ky)") (switch-to-buffer buf) (goto-char 1) (search-forward "notes at the end") (insert "; the number in italics is\n" "the page number where the command is described") (while (re-search-forward "@r{.*@: *\\([^ ]\\(.*[^ ]\\)?\\) *@:.*@:.*@:\\(.*\\)@:.*}" nil t) (let ((key (buffer-substring (match-beginning 1) (match-end 1))) (pos (match-beginning 3)) num) (set-buffer ibuf) (goto-char 1) (let ((p '( ( "I H " . "H I " ) ; oops! ( "@@ ' \"" . "@@" ) ( "h m s" . "@@" ) ( "\\\\" . "{\\tt\\indexbackslash }" ) ( "_" . "{\\_}" ) ( "\\^" . "{\\tt\\hat}" ) ( "<" . "{\\tt\\less}" ) ( ">" . "{\\tt\\gtr}" ) ( "\"" ) ( "@{" ) ( "@}" ) ( "~" ) ( "|" ) ( "@@" ) ( "\\+" . "{\\tt\\char43}" ) ( "# l" . "# L" ) ( "I f I" . "f I" ) ( "I f Q" . "f Q" ) ( "V &" . "&" ) ( "C-u " . "" ) )) (case-fold-search nil)) (while p (if (string-match (car (car p)) key) (setq key (concat (substring key 0 (match-beginning 0)) (or (cdr (car p)) (format "{\\tt\\char'%03o}" (aref key (1- (match-end 0))))) (substring key (match-end 0))))) (setq p (cdr p))) (setq num (and (search-forward (format "\\entry {%s}{" key) nil t) (looking-at "[0-9]+") (buffer-substring (point) (match-end 0))))) (set-buffer buf) (goto-char pos) (insert "@pgref{" (or num "") "}"))) (goto-char midpos) (insert "\\gdef\\pgref#1{\\hbox to 2em{\\indsl\\hss#1}\\ \\ }\n")) (message "Unable to find Key Index (calc.ky); no page numbers inserted")) (switch-to-buffer buf)) (save-buffer)) (message "Wrote file calcsum.tex") ) (defun calc-public-autoloads () "Modify the public \"default\" file to contain the necessary autoload and global-set-key commands for Calc." (interactive) (let ((home default-directory) (p load-path) instbuf name) (while (and p (not (file-exists-p (setq name (expand-file-name "default" (car p))))) (not (file-exists-p (setq name (expand-file-name "default.el" (car p)))))) (setq p (cdr p))) (or p (error "Unable to find \"default\" file. Create one and try again.")) (find-file name) (if buffer-read-only (error "No write permission for \"%s\"" buffer-file-name)) (goto-char (point-max)) (calc-add-autoloads home "calc-public-autoloads")) ) (defun calc-private-autoloads () "Modify the user's \".emacs\" file to contain the necessary autoload and global-set-key commands for Calc." (interactive) (let ((home default-directory)) (find-file "~/.emacs") (goto-char (point-max)) (calc-add-autoloads home "calc-private-autoloads")) ) (defun calc-add-autoloads (home cmd) (barf-if-buffer-read-only) (let (top) (if (and (re-search-backward ";;; Commands added by calc-.*-autoloads" nil t) (setq top (point)) (search-forward ";;; End of Calc autoloads" nil t)) (progn (forward-line 1) (message "(Removing previous autoloads)") (delete-region top (point))) (insert "\n\n") (backward-char 1))) (insert ";;; Commands added by " cmd " on " (current-time-string) ". \(autoload 'calc-dispatch \"calc\" \"Calculator Options\" t) \(autoload 'full-calc \"calc\" \"Full-screen Calculator\" t) \(autoload 'full-calc-keypad \"calc\" \"Full-screen X Calculator\" t) \(autoload 'calc-eval \"calc\" \"Use Calculator from Lisp\") \(autoload 'defmath \"calc\" nil t t) \(autoload 'calc \"calc\" \"Calculator Mode\" t) \(autoload 'quick-calc \"calc\" \"Quick Calculator\" t) \(autoload 'calc-keypad \"calc\" \"X windows Calculator\" t) \(autoload 'calc-embedded \"calc\" \"Use Calc inside any buffer\" t) \(autoload 'calc-embedded-activate \"calc\" \"Activate =>'s in buffer\" t) \(autoload 'calc-grab-region \"calc\" \"Grab region of Calc data\" t) \(autoload 'calc-grab-rectangle \"calc\" \"Grab rectangle of data\" t) \(autoload 'edit-kbd-macro \"macedit\" \"Edit Keyboard Macro\" t) \(autoload 'edit-last-kbd-macro \"macedit\" \"Edit Keyboard Macro\" t) \(autoload 'read-kbd-macro \"macedit\" \"Read Keyboard Macro\" t) \(setq load-path (append load-path (list \"" (directory-file-name home) "\"))) \(global-set-key \"\\e#\" 'calc-dispatch) ;;; End of Calc autoloads.\n") (let ((trim-versions-without-asking t)) (save-buffer)) ) ;;; End. calc-2.02c/calc-misc.el100644 22403 13 60541 5547406507 13235 0ustar daveguser;; Calculator for GNU Emacs, part I [calc-misc.el] ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;; This file is autoloaded from calc.el. (require 'calc) (require 'calc-macs) (defun calc-Need-calc-misc () nil) (defun calc-dispatch-help (arg) "M-# is a prefix key; follow it with one of these letters: For turning Calc on and off: C calc. Start the Calculator in a window at the bottom of the screen. O calc-other-window. Start the Calculator but don't select its window. B calc-big-or-small. Control whether to use the full Emacs screen for Calc. Q quick-calc. Use the Calculator in the minibuffer. K calc-keypad. Start the Calculator in keypad mode (X window system only). E calc-embedded. Use the Calculator on a formula in this editing buffer. J calc-embedded-select. Like E, but select appropriate half of => or :=. W calc-embedded-word. Like E, but activate a single word, i.e., a number. Z calc-user-invocation. Invoke Calc in the way you defined with `Z I' cmd. X calc-quit. Turn Calc off. For moving data into and out of Calc: G calc-grab-region. Grab the region defined by mark and point into Calc. R calc-grab-rectangle. Grab the rectangle defined by mark, point into Calc. : calc-grab-sum-down. Grab a rectangle and sum the columns. _ calc-grab-sum-across. Grab a rectangle and sum the rows. Y calc-copy-to-buffer. Copy a value from the stack into the editing buffer. For use with Embedded mode: A calc-embedded-activate. Find and activate all :='s and =>'s in buffer. D calc-embedded-duplicate. Make a copy of this formula and select it. F calc-embedded-new-formula. Insert a new formula at current point. N calc-embedded-next. Advance cursor to next known formula in buffer. P calc-embedded-previous. Advance cursor to previous known formula. U calc-embedded-update-formula. Re-evaluate formula at point. ` calc-embedded-edit. Use calc-edit to edit formula at point. Documentation: I calc-info. Read the Calculator manual in the Emacs Info system. T calc-tutorial. Run the Calculator Tutorial using the Emacs Info system. S calc-summary. Read the Summary from the Calculator manual in Info. Miscellaneous: L calc-load-everything. Load all parts of the Calculator into memory. M read-kbd-macro. Read a region of keystroke names as a keyboard macro. 0 (zero) calc-reset. Reset Calc stack and modes to default state. Press twice (`M-# M-#' or `M-# #') to turn Calc on or off using the same Calc user interface as before (either M-# C or M-# K; initially M-# C)." (interactive "P") (calc-check-defines) (if calc-dispatch-help (progn (save-window-excursion (describe-function 'calc-dispatch-help) (let ((win (get-buffer-window "*Help*"))) (if win (let (key) (select-window win) (while (progn (message "Calc options: Calc, Keypad, ... %s" "press SPC, DEL to scroll, C-g to cancel") (memq (car (setq key (calc-read-key t))) '(? ?\C-h ?\C-? ?\C-v ?\M-v))) (condition-case err (if (memq (car key) '(? ?\C-v)) (scroll-up) (scroll-down)) (error (beep)))) (calc-unread-command (cdr key)))))) (calc-do-dispatch nil)) (let ((calc-dispatch-help t)) (calc-do-dispatch arg))) ) (defun calc-big-or-small (arg) "Toggle Calc between full-screen and regular mode." (interactive "P") (let ((cwin (get-buffer-window "*Calculator*")) (twin (get-buffer-window "*Calc Trail*")) (kwin (get-buffer-window "*Calc Keypad*"))) (if cwin (setq calc-full-mode (if kwin (and twin (eq (window-width twin) (screen-width))) (eq (window-height cwin) (1- (screen-height)))))) (setq calc-full-mode (if arg (> (prefix-numeric-value arg) 0) (not calc-full-mode))) (if kwin (progn (calc-quit) (calc-do-keypad calc-full-mode nil)) (if cwin (progn (calc-quit) (calc nil calc-full-mode nil)))) (message (if calc-full-mode "Now using full screen for Calc." "Now using partial screen for Calc."))) ) (defun calc-other-window () "Invoke the Calculator in another window." (interactive) (if (memq major-mode '(calc-mode calc-trail-mode)) (progn (other-window 1) (if (memq major-mode '(calc-mode calc-trail-mode)) (other-window 1))) (if (get-buffer-window "*Calculator*") (calc-quit) (let ((win (selected-window))) (calc nil win (interactive-p))))) ) (defun another-calc () "Create another, independent Calculator buffer." (interactive) (if (eq major-mode 'calc-mode) (mapcar (function (lambda (v) (set-default v (symbol-value v)))) calc-local-var-list)) (set-buffer (generate-new-buffer "*Calculator*")) (pop-to-buffer (current-buffer)) (calc-mode) ) ;;; Make an attempt to preserve the window configuration, while deleting ;;; windows on "bufs". Emacs 19's delete-window function will probably ;;; make this kludgery unnecessary, but Emacs 18's tendency to grow all ;;; windows on the screen to take up the slack from the deleted windows ;;; can be annoying when Calc was called during another multi-window ;;; application, such as GNUS. (defun calc-delete-windows-keep (&rest bufs) (if (one-window-p) (mapcar 'delete-windows-on bufs) (let* ((w (car calc-was-split)) (e (window-edges w)) (wins nil) w2 e2) (while (progn (setq w2 (previous-window w) e2 (window-edges w2)) (and (= (car e2) (car e)) (= (nth 2 e2) (nth 2 e)) (< (nth 1 e2) (nth 1 e)))) (setq w w2 e e2)) (setq w2 w e2 e) (while (progn (setq wins (cons (list w (nth 1 e) (window-buffer w) (window-point w) (window-start w)) wins) w (next-window w) e (window-edges w)) (and (not (eq w w2)) (= (car e2) (car e)) (= (nth 2 e2) (nth 2 e))))) (setq wins (nreverse wins)) (mapcar 'delete-windows-on bufs) (or (one-window-p) (let ((w wins) (main nil) (mainpos 0) (sel (if (window-point (nth 2 calc-was-split)) (nth 2 calc-was-split) (selected-window)))) (while w (if (window-point (car (car w))) (if main (delete-window (car (car w))) (setq main (car (car w)) mainpos (nth 1 (car w)) wins (cdr wins))) (setq wins (delq (car w) wins))) (setq w (cdr w))) (while wins (setq w (split-window main (if (eq main (car calc-was-split)) (nth 1 calc-was-split) (- (nth 1 (car wins)) mainpos)))) (set-window-buffer w (nth 2 (car wins))) (set-window-point w (nth 3 (car wins))) (set-window-start w (nth 4 (car wins))) (if (eq sel (car (car wins))) (select-window w)) (setq main w mainpos (nth 1 (car wins)) wins (cdr wins))) (if (window-point sel) (select-window sel)))))) ) (defun calc-info () "Run the Emacs Info system on the Calculator documentation." (interactive) (require 'info) (select-window (get-largest-window)) (or (file-name-absolute-p calc-info-filename) (let ((p load-path) name) (if (boundp 'Info-directory) (setq p (cons Info-directory p))) (while (and p (not (file-exists-p (setq name (expand-file-name calc-info-filename (car p)))))) (setq p (cdr p))) (if p (setq calc-info-filename name)))) (condition-case err (info) (error nil)) (or (and (boundp 'Info-current-file) (stringp Info-current-file) (string-match "calc" Info-current-file)) (Info-find-node calc-info-filename "Top")) ) (defun calc-tutorial () "Run the Emacs Info system on the Calculator Tutorial." (interactive) (if (get-buffer-window "*Calculator*") (calc-quit)) (calc-info) (Info-goto-node "Interactive Tutorial") (calc-other-window) (message "Welcome to the Calc Tutorial!") ) (defun calc-info-summary () "Run the Emacs Info system on the Calculator Summary." (interactive) (calc-info) (Info-goto-node "Summary") ) (defun calc-help () (interactive) (let ((msgs (append '("Press `h' for complete help; press `?' repeatedly for a summary" "Letter keys: Negate; Precision; Yank; Why; Xtended cmd; Quit" "Letter keys: SHIFT + Undo, reDo; Keep-args; Inverse, Hyperbolic" "Letter keys: SHIFT + sQrt; Sin, Cos, Tan; Exp, Ln, logB" "Letter keys: SHIFT + Floor, Round; Abs, conJ, arG; Pi" "Letter keys: SHIFT + Num-eval; More-recn; eXec-kbd-macro" "Other keys: +, -, *, /, ^, \\ (int div), : (frac div)" "Other keys: & (1/x), | (concat), % (modulo), ! (factorial)" "Other keys: ' (alg-entry), = (eval), ` (edit); M-RET (last-args)" "Other keys: SPC/RET (enter/dup), LFD (over); < > (scroll horiz)" "Other keys: DEL (drop), M-DEL (drop-above); { } (scroll vert)" "Other keys: TAB (swap/roll-dn), M-TAB (roll-up)" "Other keys: [ , ; ] (vector), ( , ) (complex), ( ; ) (polar)" "Prefix keys: Algebra, Binary/business, Convert, Display" "Prefix keys: Functions, Graphics, Help, J (select)" "Prefix keys: Kombinatorics/statistics, Modes, Store/recall" "Prefix keys: Trail/time, Units/statistics, Vector/matrix" "Prefix keys: Z (user), SHIFT + Z (define)" "Prefix keys: prefix + ? gives further help for that prefix") (list (format " Calc %s by Dave Gillespie, daveg@synaptics.com" calc-version))))) (if calc-full-help-flag msgs (if (or calc-inverse-flag calc-hyperbolic-flag) (if calc-inverse-flag (if calc-hyperbolic-flag (calc-inv-hyp-prefix-help) (calc-inverse-prefix-help)) (calc-hyperbolic-prefix-help)) (setq calc-help-phase (if (eq this-command last-command) (% (1+ calc-help-phase) (1+ (length msgs))) 0)) (let ((msg (nth calc-help-phase msgs))) (message "%s" (if msg (concat msg ":" (make-string (- (apply 'max (mapcar 'length msgs)) (length msg)) 32) " [?=MORE]") "")))))) ) ;;;; Stack and buffer management. (defun calc-do-handle-whys () (setq calc-why (sort calc-next-why (function (lambda (x y) (and (eq (car x) '*) (not (eq (car y) '*)))))) calc-next-why nil) (if (and calc-why (or (eq calc-auto-why t) (and (eq (car (car calc-why)) '*) calc-auto-why))) (progn (calc-extensions) (calc-explain-why (car calc-why) (if (eq calc-auto-why t) (cdr calc-why) (if calc-auto-why (eq (car (nth 1 calc-why)) '*)))) (setq calc-last-why-command this-command) (calc-clear-command-flag 'clear-message))) ) (defun calc-record-why (&rest stuff) (if (eq (car stuff) 'quiet) (setq stuff (cdr stuff)) (if (and (symbolp (car stuff)) (cdr stuff) (or (Math-objectp (nth 1 stuff)) (and (Math-vectorp (nth 1 stuff)) (math-constp (nth 1 stuff))) (math-infinitep (nth 1 stuff)))) (setq stuff (cons '* stuff)) (if (and (stringp (car stuff)) (string-match "\\`\\*" (car stuff))) (setq stuff (cons '* (cons (substring (car stuff) 1) (cdr stuff))))))) (setq calc-next-why (cons stuff calc-next-why)) nil ) ;;; True if A is a constant or vector of constants. [P x] [Public] (defun math-constp (a) (or (Math-scalarp a) (and (memq (car a) '(sdev intv mod vec)) (progn (while (and (setq a (cdr a)) (or (Math-scalarp (car a)) ; optimization (math-constp (car a))))) (null a)))) ) (defun calc-roll-down-stack (n &optional m) (if (< n 0) (calc-roll-up-stack (- n) m) (if (or (= n 0) (> n (calc-stack-size))) (setq n (calc-stack-size))) (or m (setq m 1)) (and (> n 1) (< m n) (if (and calc-any-selections (not calc-use-selections)) (calc-roll-down-with-selections n m) (calc-pop-push-list n (append (calc-top-list m 1) (calc-top-list (- n m) (1+ m))))))) ) (defun calc-roll-up-stack (n &optional m) (if (< n 0) (calc-roll-down-stack (- n) m) (if (or (= n 0) (> n (calc-stack-size))) (setq n (calc-stack-size))) (or m (setq m 1)) (and (> n 1) (< m n) (if (and calc-any-selections (not calc-use-selections)) (calc-roll-up-with-selections n m) (calc-pop-push-list n (append (calc-top-list (- n m) 1) (calc-top-list m (- n m -1))))))) ) (defun calc-do-refresh () (if calc-hyperbolic-flag (progn (setq calc-display-dirty t) nil) (calc-refresh) t) ) (defun calc-record-list (vals &optional prefix) (while vals (or (eq (car vals) 'top-of-stack) (progn (calc-record (car vals) prefix) (setq prefix "..."))) (setq vals (cdr vals))) ) (defun calc-last-args-stub (arg) (interactive "p") (calc-extensions) (calc-last-args arg) ) (defun calc-power (arg) (interactive "P") (calc-slow-wrapper (if (and calc-extensions-loaded (calc-is-inverse)) (calc-binary-op "root" 'calcFunc-nroot arg nil nil) (calc-binary-op "^" 'calcFunc-pow arg nil nil '^))) ) (defun calc-mod (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "%" 'calcFunc-mod arg nil nil '%)) ) (defun calc-inv (arg) (interactive "P") (calc-slow-wrapper (calc-unary-op "inv" 'calcFunc-inv arg)) ) (defun calc-percent () (interactive) (calc-slow-wrapper (calc-pop-push-record-list 1 "%" (list (list 'calcFunc-percent (calc-top-n 1))))) ) (defun calc-over (n) (interactive "P") (if n (calc-enter (- (prefix-numeric-value n))) (calc-enter -2)) ) (defun calc-pop-above (n) (interactive "P") (if n (calc-pop (- (prefix-numeric-value n))) (calc-pop -2)) ) (defun calc-roll-down (n) (interactive "P") (calc-wrapper (let ((nn (prefix-numeric-value n))) (cond ((null n) (calc-roll-down-stack 2)) ((> nn 0) (calc-roll-down-stack nn)) ((= nn 0) (calc-pop-push-list (calc-stack-size) (reverse (calc-top-list (calc-stack-size))))) (t (calc-roll-down-stack (calc-stack-size) (- nn)))))) ) (defun calc-roll-up (n) (interactive "P") (calc-wrapper (let ((nn (prefix-numeric-value n))) (cond ((null n) (calc-roll-up-stack 3)) ((> nn 0) (calc-roll-up-stack nn)) ((= nn 0) (calc-pop-push-list (calc-stack-size) (reverse (calc-top-list (calc-stack-size))))) (t (calc-roll-up-stack (calc-stack-size) (- nn)))))) ) ;;; Other commands. (defun calc-num-prefix-name (n) (cond ((eq n '-) "- ") ((equal n '(4)) "C-u ") ((consp n) (format "%d " (car n))) ((integerp n) (format "%d " n)) (t "")) ) (defun calc-missing-key (n) "This is a placeholder for a command which needs to be loaded from calc-ext. When this key is used, calc-ext (the Calculator extensions module) will be loaded and the keystroke automatically re-typed." (interactive "P") (calc-extensions) (if (keymapp (key-binding (char-to-string last-command-char))) (message "%s%c-" (calc-num-prefix-name n) last-command-char)) (calc-unread-command) (setq prefix-arg n) ) (defun calc-shift-Y-prefix-help () (interactive) (calc-extensions) (calc-do-prefix-help calc-Y-help-msgs "other" ?Y) ) (defun calcDigit-letter () (interactive) (if (calc-minibuffer-contains "[-+]?\\(1[1-9]\\|[2-9][0-9]\\)#.*") (progn (setq last-command-char (upcase last-command-char)) (calcDigit-key)) (calcDigit-nondigit)) ) ;; A Lisp version of temp_minibuffer_message from minibuf.c. (defun calc-temp-minibuffer-message (m) (let ((savemax (point-max))) (save-excursion (goto-char (point-max)) (insert m)) (let ((okay nil)) (unwind-protect (progn (sit-for 2) (identity 1) ; this forces a call to QUIT; in bytecode.c. (setq okay t)) (progn (delete-region savemax (point-max)) (or okay (abort-recursive-edit)))))) ) (put 'math-with-extra-prec 'lisp-indent-hook 1) ;;; Concatenate two vectors, or a vector and an object. [V O O] [Public] (defun math-concat (v1 v2) (if (stringp v1) (concat v1 v2) (calc-extensions) (if (and (or (math-objvecp v1) (math-known-scalarp v1)) (or (math-objvecp v2) (math-known-scalarp v2))) (append (if (and (math-vectorp v1) (or (math-matrixp v1) (not (math-matrixp v2)))) v1 (list 'vec v1)) (if (and (math-vectorp v2) (or (math-matrixp v2) (not (math-matrixp v1)))) (cdr v2) (list v2))) (list '| v1 v2))) ) ;;; True if A is zero. Works for un-normalized values. [P n] [Public] (defun math-zerop (a) (if (consp a) (cond ((memq (car a) '(bigpos bigneg)) (while (eq (car (setq a (cdr a))) 0)) (null a)) ((memq (car a) '(frac float polar mod)) (math-zerop (nth 1 a))) ((eq (car a) 'cplx) (and (math-zerop (nth 1 a)) (math-zerop (nth 2 a)))) ((eq (car a) 'hms) (and (math-zerop (nth 1 a)) (math-zerop (nth 2 a)) (math-zerop (nth 3 a))))) (eq a 0)) ) ;;; True if A is real and negative. [P n] [Public] (defun math-negp (a) (if (consp a) (cond ((eq (car a) 'bigpos) nil) ((eq (car a) 'bigneg) (cdr a)) ((memq (car a) '(float frac)) (Math-integer-negp (nth 1 a))) ((eq (car a) 'hms) (if (math-zerop (nth 1 a)) (if (math-zerop (nth 2 a)) (math-negp (nth 3 a)) (math-negp (nth 2 a))) (math-negp (nth 1 a)))) ((eq (car a) 'date) (math-negp (nth 1 a))) ((eq (car a) 'intv) (or (math-negp (nth 3 a)) (and (math-zerop (nth 3 a)) (memq (nth 1 a) '(0 2))))) ((equal a '(neg (var inf var-inf))) t)) (< a 0)) ) ;;; True if A is a negative number or an expression the starts with '-'. (defun math-looks-negp (a) ; [P x] [Public] (or (Math-negp a) (eq (car-safe a) 'neg) (and (memq (car-safe a) '(* /)) (or (math-looks-negp (nth 1 a)) (math-looks-negp (nth 2 a)))) (and (eq (car-safe a) '-) (math-looks-negp (nth 1 a)))) ) ;;; True if A is real and positive. [P n] [Public] (defun math-posp (a) (if (consp a) (cond ((eq (car a) 'bigpos) (cdr a)) ((eq (car a) 'bigneg) nil) ((memq (car a) '(float frac)) (Math-integer-posp (nth 1 a))) ((eq (car a) 'hms) (if (math-zerop (nth 1 a)) (if (math-zerop (nth 2 a)) (math-posp (nth 3 a)) (math-posp (nth 2 a))) (math-posp (nth 1 a)))) ((eq (car a) 'date) (math-posp (nth 1 a))) ((eq (car a) 'mod) (not (math-zerop (nth 1 a)))) ((eq (car a) 'intv) (or (math-posp (nth 2 a)) (and (math-zerop (nth 2 a)) (memq (nth 1 a) '(0 1))))) ((equal a '(var inf var-inf)) t)) (> a 0)) ) (fset 'math-fixnump (symbol-function 'integerp)) (fset 'math-fixnatnump (symbol-function 'natnump)) ;;; True if A is an even integer. [P R R] [Public] (defun math-evenp (a) (if (consp a) (and (memq (car a) '(bigpos bigneg)) (= (% (nth 1 a) 2) 0)) (= (% a 2) 0)) ) ;;; Compute A / 2, for small or big integer A. [I i] ;;; If A is negative, type of truncation is undefined. (defun math-div2 (a) (if (consp a) (if (cdr a) (math-normalize (cons (car a) (math-div2-bignum (cdr a)))) 0) (/ a 2)) ) (defun math-div2-bignum (a) ; [l l] (if (cdr a) (cons (+ (/ (car a) 2) (* (% (nth 1 a) 2) 500)) (math-div2-bignum (cdr a))) (list (/ (car a) 2))) ) ;;; Reject an argument to a calculator function. [Public] (defun math-reject-arg (&optional a p option) (if option (calc-record-why option p a) (if p (calc-record-why p a))) (signal 'wrong-type-argument (and a (if p (list p a) (list a)))) ) ;;; Coerce A to be an integer (by truncation toward zero). [I N] [Public] (defun math-trunc (a &optional prec) (cond (prec (calc-extensions) (math-trunc-special a prec)) ((Math-integerp a) a) ((Math-looks-negp a) (math-neg (math-trunc (math-neg a)))) ((eq (car a) 'float) (math-scale-int (nth 1 a) (nth 2 a))) (t (calc-extensions) (math-trunc-fancy a))) ) (fset 'calcFunc-trunc (symbol-function 'math-trunc)) ;;; Coerce A to be an integer (by truncation toward minus infinity). [I N] (defun math-floor (a &optional prec) ; [Public] (cond (prec (calc-extensions) (math-floor-special a prec)) ((Math-integerp a) a) ((Math-messy-integerp a) (math-trunc a)) ((Math-realp a) (if (Math-negp a) (math-add (math-trunc a) -1) (math-trunc a))) (t (calc-extensions) (math-floor-fancy a))) ) (fset 'calcFunc-floor (symbol-function 'math-floor)) (defun math-imod (a b) ; [I I I] [Public] (if (and (not (consp a)) (not (consp b))) (if (= b 0) (math-reject-arg a "*Division by zero") (% a b)) (cdr (math-idivmod a b))) ) (defun calcFunc-inv (m) (if (Math-vectorp m) (progn (calc-extensions) (if (math-square-matrixp m) (or (math-with-extra-prec 2 (math-matrix-inv-raw m)) (math-reject-arg m "*Singular matrix")) (math-reject-arg m 'square-matrixp))) (math-div 1 m)) ) (defun math-do-working (msg arg) (or executing-macro (progn (calc-set-command-flag 'clear-message) (if math-working-step (if math-working-step-2 (setq msg (format "[%d/%d] %s" math-working-step math-working-step-2 msg)) (setq msg (format "[%d] %s" math-working-step msg)))) (message "Working... %s = %s" msg (math-showing-full-precision (math-format-number arg))))) ) ;;; Compute A modulo B, defined in terms of truncation toward minus infinity. (defun math-mod (a b) ; [R R R] [Public] (cond ((and (Math-zerop a) (not (eq (car-safe a) 'mod))) a) ((Math-zerop b) (math-reject-arg a "*Division by zero")) ((and (Math-natnump a) (Math-natnump b)) (math-imod a b)) ((and (Math-anglep a) (Math-anglep b)) (math-sub a (math-mul (math-floor (math-div a b)) b))) (t (calc-extensions) (math-mod-fancy a b))) ) ;;; General exponentiation. (defun math-pow (a b) ; [O O N] [Public] (cond ((equal b '(var nan var-nan)) b) ((Math-zerop a) (if (and (Math-scalarp b) (Math-posp b)) (if (math-floatp b) (math-float a) a) (calc-extensions) (math-pow-of-zero a b))) ((or (eq a 1) (eq b 1)) a) ((or (equal a '(float 1 0)) (equal b '(float 1 0))) a) ((Math-zerop b) (if (Math-scalarp a) (if (or (math-floatp a) (math-floatp b)) '(float 1 0) 1) (calc-extensions) (math-pow-zero a b))) ((and (Math-integerp b) (or (Math-numberp a) (Math-vectorp a))) (if (and (equal a '(float 1 1)) (integerp b)) (math-make-float 1 b) (math-with-extra-prec 2 (math-ipow a b)))) (t (calc-extensions) (math-pow-fancy a b))) ) (defun math-ipow (a n) ; [O O I] [Public] (cond ((Math-integer-negp n) (math-ipow (math-div 1 a) (Math-integer-neg n))) ((not (consp n)) (if (and (Math-ratp a) (> n 20)) (math-iipow-show a n) (math-iipow a n))) ((math-evenp n) (math-ipow (math-mul a a) (math-div2 n))) (t (math-mul a (math-ipow (math-mul a a) (math-div2 (math-add n -1)))))) ) (defun math-iipow (a n) ; [O O S] (cond ((= n 0) 1) ((= n 1) a) ((= (% n 2) 0) (math-iipow (math-mul a a) (/ n 2))) (t (math-mul a (math-iipow (math-mul a a) (/ n 2))))) ) (defun math-iipow-show (a n) ; [O O S] (math-working "pow" a) (let ((val (cond ((= n 0) 1) ((= n 1) a) ((= (% n 2) 0) (math-iipow-show (math-mul a a) (/ n 2))) (t (math-mul a (math-iipow-show (math-mul a a) (/ n 2))))))) (math-working "pow" val) val) ) (defun math-read-radix-digit (dig) ; [D S; Z S] (if (> dig ?9) (if (< dig ?A) nil (- dig 55)) (if (>= dig ?0) (- dig ?0) nil)) ) ;;; Bug reporting (defun report-calc-bug (topic) "Report a bug in Calc, the GNU Emacs calculator. Prompts for bug subject. Leaves you in a mail buffer." (interactive "sBug Subject: ") (mail nil calc-bug-address topic) (goto-char (point-max)) (insert "\nIn Calc " calc-version ", Emacs " (emacs-version) "\n\n") (message (substitute-command-keys "Type \\[mail-send] to send bug report.")) ) (fset 'calc-report-bug (symbol-function 'report-calc-bug)) calc-2.02c/calc.el100644 22403 13 340243 5547406525 12324 0ustar daveguser;; Calculator for GNU Emacs, part I ;; Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. ;; Written by Dave Gillespie, daveg@synaptics.com. ;; 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. ;;; Calc is split into many files. This file is the main entry point. ;;; This file includes autoload commands for various other basic Calc ;;; facilities. The more advanced features are based in calc-ext, which ;;; in turn contains autoloads for the rest of the Calc files. This ;;; odd set of interactions is designed to make Calc's loading time ;;; be as short as possible when only simple calculations are needed. ;;; Suggested usage: ;;; ;;; (autoload 'calc-dispatch "calc" "Emacs Calculator" t nil) ;;; (global-set-key "\e#" 'calc-dispatch) ;;; Type `M-# M-#' to start. ;;; ;;; The Calc home directory must be added to the Emacs load-path: ;;; ;;; (setq load-path (cons "/x/y/z/calc" load-path)) ;;; ;;; where "/x/y/z/calc" represents the full name of the Calc home directory. ;;; ;;; See the file INSTALL for a complete list of recommeded autoload ;;; commands (though only calc-dispatch is absolutely necessary). ;;; Author's address: ;;; Dave Gillespie, daveg@synaptics.com, uunet!synaptx!daveg. ;;; Synaptics, Inc., 2698 Orchard Parkway, San Jose, CA 95134. ;;; ;;; The old address daveg@csvax.cs.caltech.edu will continue to ;;; work for the foreseeable future. ;;; ;;; The latest version of Calc is always available from anonymous FTP ;;; on csvax.cs.caltech.edu [131.215.131.131]; look in ~ftp/pub/calc*. ;;; It should also be available on prep.ai.mit.edu. ;;; ;;; Bug reports and suggestions are always welcome! ;;; All functions, macros, and Lisp variables defined here begin with one ;;; of the prefixes "math", "Math", or "calc", with the exceptions of ;;; "full-calc", "full-calc-keypad", "another-calc", "quick-calc", ;;; "report-calc-bug", and "defmath". User-accessible variables begin ;;; with "var-". (provide 'calc) (defun calc-record-compilation-date () (calc-record-compilation-date-macro) ) (calc-record-compilation-date) ;;; The "###autoload" comment will be used by Emacs version 19 for ;;; maintaining the loaddefs.el file automatically. ;;;###autoload (defvar calc-info-filename "calc.info" "*File name in which to look for the Calculator's Info documentation.") ;;;###autoload (defvar calc-settings-file "~/.emacs" "*File in which to record permanent settings; default is \"~/.emacs\".") ;;;###autoload (defvar calc-autoload-directory nil "Name of directory from which additional \".elc\" files for Calc should be loaded. Should include a trailing \"/\". If nil, use original installation directory. This can safely be nil as long as the Calc files are on the load-path.") ;;;###autoload (defvar calc-gnuplot-name "gnuplot" "*Name of GNUPLOT program, for calc-graph features.") ;;;###autoload (defvar calc-gnuplot-plot-command nil "*Name of command for displaying GNUPLOT output; %s = file name to print.") ;;;###autoload (defvar calc-gnuplot-print-command "lp %s" "*Name of command for printing GNUPLOT output; %s = file name to print.") ;; Address of the author of Calc, for use by report-calc-bug. (defvar calc-bug-address "daveg@synaptics.com") ;; If T, scan keymaps to find all DEL-like keys. ;; If NIL, only DEL itself is mapped to calc-pop. (defvar calc-scan-for-dels t) (defvar calc-extensions-loaded nil) ;;; IDEAS: ;;; ;;; Fix rewrite mechanism to do less gratuitous rearrangement of terms. ;;; Implement a pattern-based "refers" predicate. ;;; ;;; Make it possible to Undo a selection command. ;;; Figure out how to allow selecting rows of matrices. ;;; If cursor was in selection before, move it after j n, j p, j L, etc. ;;; Consider reimplementing calc-delete-selection using rewrites. ;;; ;;; Implement line-breaking in non-flat compositions (is this desirable?). ;;; Implement matrix formatting with multi-line components. ;;; ;;; Have "Z R" define a user command based on a set of rewrite rules. ;;; Support "incf" and "decf" in defmath definitions. ;;; Have defmath generate calls to calc-binary-op or calc-unary-op. ;;; Make some way to define algebraic functions using keyboard macros. ;;; ;;; Allow calc-word-size=0 => Common Lisp-style signed bitwise arithmetic. ;;; Consider digamma function (and thus arb. prec. Euler's gamma constant). ;;; May as well make continued-fractions stuff available to the user. ;;; ;;; How about matrix eigenvalues, SVD, pseudo-inverse, etc.? ;;; Should cache matrix inverses as well as decompositions. ;;; If dividing by a non-square matrix, use least-squares automatically. ;;; Consider supporting matrix exponentials. ;;; ;;; Have ninteg detect and work around singularities at the endpoints. ;;; Use an adaptive subdivision algorithm for ninteg. ;;; Provide nsum and nprod to go along with ninteg. ;;; ;;; Handle TeX-mode parsing of \matrix{ ... } where ... contains braces. ;;; Support AmS-TeX's \{d,t,}frac, \{d,t,}binom notations. ;;; Format and parse sums and products in Eqn and Math modes. ;;; ;;; Get math-read-big-expr to read sums, products, etc. ;;; Change calc-grab-region to use math-read-big-expr. ;;; Have a way to define functions using := in Embedded Mode. ;;; ;;; Support polar plotting with GNUPLOT. ;;; Make a calc-graph-histogram function. ;;; ;;; Replace hokey formulas for complex functions with formulas designed ;;; to minimize roundoff while maintaining the proper branch cuts. ;;; Test accuracy of advanced math functions over whole complex plane. ;;; Extend Bessel functions to provide arbitrary precision. ;;; Extend advanced math functions to handle error forms and intervals. ;;; Provide a better implementation for math-sin-cos-raw. ;;; Provide a better implementation for math-hypot. ;;; Provide a better implementation for math-make-frac. ;;; Provide a better implementation for calcFunc-prfac. ;;; Provide a better implementation for calcFunc-factor. ;;; ;;; Provide more examples in the tutorial section of the manual. ;;; Cover in the tutorial: simplification modes, declarations, ;;; bitwise stuff, selections, matrix mapping, financial functions. ;;; Provide more Lisp programming examples in the manual. ;;; Finish the Internals section of the manual (and bring it up to date). ;;; ;;; Tim suggests adding spreadsheet-like features. ;;; Implement language modes for Gnuplot, Lisp, Ada, APL, ...? ;;; ;;; For atan series, if x > tan(pi/12) (about 0.268) reduce using the identity ;;; atan(x) = atan((x * sqrt(3) - 1) / (sqrt(3) + x)) + pi/6. ;;; A better integration algorithm: ;;; Use breadth-first instead of depth-first search, as follows: ;;; The integral cache allows unfinished integrals in symbolic notation ;;; on the righthand side. An entry with no unfinished integrals on the ;;; RHS is "complete"; references to it elsewhere are replaced by the ;;; integrated value. More than one cache entry for the same integral ;;; may exist, though if one becomes complete, the others may be deleted. ;;; The integrator works by using every applicable rule (such as ;;; substitution, parts, linearity, etc.) to generate possible righthand ;;; sides, all of which are entered into the cache. Now, as long as the ;;; target integral is not complete (and the time limit has not run out) ;;; choose an incomplete integral from the cache and, for every integral ;;; appearing in its RHS's, add those integrals to the cache using the ;;; same substitition, parts, etc. rules. The cache should be organized ;;; as a priority queue, choosing the "simplest" incomplete integral at ;;; each step, or choosing randomly among equally simple integrals. ;;; Simplicity equals small size, and few steps removed from the original ;;; target integral. Note that when the integrator finishes, incomplete ;;; integrals can be left in the cache, so the algorithm can start where ;;; it left off if another similar integral is later requested. ;;; Breadth-first search would avoid the nagging problem of, e.g., whether ;;; to use parts or substitution first, and which decomposition is best. ;;; All are tried, and any path that diverges will quickly be put on the ;;; back burner by the priority queue. ;;; Note: Probably a good idea to call math-simplify-extended before ;;; measuring a formula's simplicity. ;; Calculator stack. ;; Entries are 3-lists: Formula, Height (in lines), Selection (or nil). (defvar calc-stack '((top-of-stack 1 nil))) ;; Index into calc-stack of "top" of stack. ;; This is 1 unless calc-truncate-stack has been used. ;;(defvar calc-stack-top 1) ;; If non-NIL, load the calc-ext module automatically when calc is loaded. ;;(defvar calc-always-load-extensions nil) ;; If non-NIL, display line numbers in Calculator stack. ;;(defvar calc-line-numbering t) ;; If non-NIL, break long values across multiple lines in Calculator stack. ;;(defvar calc-line-breaking t) ;; If NIL, stack display is left-justified. ;; If 'right, stack display is right-justified. ;; If 'center, stack display is centered." ;;(defvar calc-display-just nil) ;; Horizontal origin of displayed stack entries. ;; In left-justified mode, this is effectively indentation. (Default 0). ;; In right-justified mode, this is effectively window width. ;; In centered mode, center of stack entry is placed here. ;;(defvar calc-display-origin nil) ;; Radix for entry and display of numbers in calc-mode, 2-36. ;;(defvar calc-number-radix 10) ;; If non-NIL, leading zeros are provided to pad integers to calc-word-size. ;;(defvar calc-leading-zeros nil) ;; If non-NIL, group digits in large displayed integers by inserting spaces. ;; If an integer, group that many digits at a time. ;; If 't', use 4 for binary and hex, 3 otherwise. ;;(defvar calc-group-digits nil) ;; The character (in the form of a string) to be used for grouping digits. ;; This is used only when calc-group-digits mode is on. ;;(defvar calc-group-char ",") ;; The character (in the form of a string) to be used as a decimal point. ;;(defvar calc-point-char ".") ;; Format of displayed fractions; a string of one or two of ":" or "/". ;;(defvar calc-frac-format '(":" nil)) ;; If non-NIL, prefer fractional over floating-point results. ;;(defvar calc-prefer-frac nil) ;; Format of displayed hours-minutes-seconds angles, a format string. ;; String must contain three %s marks for hours, minutes, seconds respectively. ;;(defvar calc-hms-format "%s@ %s' %s\"") ;; Format of displayed date forms. ;;(defvar calc-date-format '((H ":" mm ":" SS pp " ") Www " " Mmm " " D ", " YYYY)) ;; Format to use for display of floating-point numbers in calc-mode. ;; Must be a list of one of the following forms: ;; (float 0) Floating point format, display full precision. ;; (float N) N > 0: Floating point format, at most N significant figures. ;; (float -N) -N < 0: Floating point format, calc-internal-prec - N figs. ;; (fix N) N >= 0: Fixed point format, N places after decimal point. ;; (sci 0) Scientific notation, full precision. ;; (sci N) N > 0: Scientific notation, N significant figures. ;; (sci -N) -N < 0: Scientific notation, calc-internal-prec - N figs. ;; (eng 0) Engineering notation, full precision. ;; (eng N) N > 0: Engineering notation, N significant figures. ;; (eng -N) -N < 0: Engineering notation, calc-internal-prec - N figs. ;;(defvar calc-float-format '(float 0)) ;; Format to use when full precision must be displayed. ;;(defvar calc-full-float-format '(float 0)) ;; Format to use for display of complex numbers in calc-mode. Must be one of: ;; nil Use (x, y) form. ;; i Use x + yi form. ;; j Use x + yj form. ;;(defvar calc-complex-format nil) ;; Preferred form, either 'cplx or 'polar, for complex numbers. ;;(defvar calc-complex-mode 'cplx) ;; If NIL, 1 / 0 is left unsimplified. ;; If 0, 1 / 0 is changed to inf (zeros are considered positive). ;; Otherwise, 1 / 0 is changed to uinf (undirected infinity). ;;(defvar calc-infinite-mode nil) ;; If non-NIL, display vectors of byte-sized integers as strings. ;;(defvar calc-display-strings nil) ;; If NIL, vector elements are left-justified. ;; If 'right, vector elements are right-justified. ;; If 'center, vector elements are centered." ;;(defvar calc-matrix-just 'center) ;; If non-NIL, display vectors one element per line. ;;(defvar calc-break-vectors nil) ;; If non-NIL, display long vectors in full. If NIL, use abbreviated form. ;;(defvar calc-full-vectors t) ;; If non-NIL, display long vectors in full in the trail. ;;(defvar calc-full-trail-vectors t) ;; If non-NIL, separate elements of displayed vectors with this string. ;;(defvar calc-vector-commas ",") ;; If non-NIL, surround displayed vectors with these characters. ;;(defvar calc-vector-brackets "[]") ;; A list of code-letter symbols that control "big" matrix display. ;; If 'R is present, display inner brackets for matrices. ;; If 'O is present, display outer brackets for matrices (above/below). ;; If 'C is present, display outer brackets for matrices (centered). ;;(defvar calc-matrix-brackets '(R O)) ;; Language or format for entry and display of stack values. Must be one of: ;; nil Use standard Calc notation. ;; flat Use standard Calc notation, one-line format. ;; big Display formulas in 2-d notation (enter w/std notation). ;; unform Use unformatted display: add(a, mul(b,c)). ;; c Use C language notation. ;; pascal Use Pascal language notation. ;; fortran Use Fortran language notation. ;; tex Use TeX notation. ;; eqn Use eqn notation. ;; math Use Mathematica(tm) notation. ;; maple Use Maple notation. ;;(defvar calc-language nil) ;; Numeric prefix argument for the command that set calc-language. ;;(defvar calc-language-option nil) ;; Open-parenthesis string for function call notation. ;;(defvar calc-function-open "(") ;; Close-parenthesis string for function call notation. ;;(defvar calc-function-close ")") ;; Function through which to pass strings after formatting. ;;(defvar calc-language-output-filter nil) ;; Function through which to pass strings before parsing. ;;(defvar calc-language-input-filter nil) ;; Formatting function used for non-decimal numbers. ;;(defvar calc-radix-formatter nil) ;; Label to display at left of formula. ;;(defvar calc-left-label "") ;; Label to display at right of formula. ;;(defvar calc-right-label "") ;; Minimum number of bits per word, if any, for binary operations in calc-mode. ;;(defvar calc-word-size 32) ;; Most recently used value of M in a modulo form. ;;(defvar calc-previous-modulo nil) ;; Type of simplification applied to results. ;; If 'none, results are not simplified when pushed on the stack. ;; If 'num, functions are simplified only when args are constant. ;; If NIL, only fast simplifications are applied. ;; If 'binary, math-clip is applied if appropriate. ;; If 'alg, math-simplify is applied. ;; If 'ext, math-simplify-extended is applied. ;; If 'units, math-simplify-units is applied. ;;(defvar calc-simplify-mode nil) ;; If non-NIL, recompute evalto's automatically when necessary. ;;(defvar calc-auto-recompute t) ;; If non-NIL, display shows unformatted Lisp exprs. (For debugging) ;;(defvar calc-display-raw nil) ;; Number of digits of internal precision for calc-mode calculations. ;;(defvar calc-internal-prec 12) ;; If non-NIL, next operation is Inverse. ;;(defvar calc-inverse-flag nil) ;; If non-NIL, next operation is Hyperbolic. ;;(defvar calc-hyperbolic-flag nil) ;; If non-NIL, next operation should not remove its arguments from stack. ;;(defvar calc-keep-args-flag nil) ;; If deg, angles are in degrees; if rad, angles are in radians. ;; If hms, angles are in degrees-minutes-seconds. ;;(defvar calc-angle-mode 'deg) ;; If non-NIL, numeric entry accepts whole algebraic expressions. ;; If NIL, algebraic expressions must be preceded by "'". ;;(defvar calc-algebraic-mode nil) ;; Like calc-algebraic-mode except only affects ( and [ keys. ;;(defvar calc-incomplete-algebraic-mode nil) ;; If non-NIL, inexact numeric computations like sqrt(2) are postponed. ;; If NIL, computations on numbers always yield numbers where possible. ;;(defvar calc-symbolic-mode nil) ;; If 'matrix, variables are assumed to be matrix-valued. ;; If a number, variables are assumed to be NxN matrices. ;; If 'scalar, variables are assumed to be scalar-valued. ;; If NIL, symbolic math routines make no assumptions about variables. ;;(defvar calc-matrix-mode nil) ;; If non-NIL, shifted letter keys are prefix keys rather than normal meanings. ;;(defvar calc-shift-prefix nil) ;; Initial height of Calculator window. ;;(defvar calc-window-height 7) ;; If non-NIL, M-x calc creates a window to display Calculator trail. ;;(defvar calc-display-trail t) ;; If non-NIL, selected sub-formulas are shown by obscuring rest of formula. ;; If NIL, selected sub-formulas are highlighted by obscuring the sub-formulas. ;;(defvar calc-show-selections t) ;; If non-NIL, commands operate only on selected portions of formulas. ;; If NIL, selections displayed but ignored. ;;(defvar calc-use-selections t) ;; If non-NIL, selection hides deep structure of associative formulas. ;;(defvar calc-assoc-selections t) ;; If non-NIL, display "Working..." for potentially slow Calculator commands. ;;(defvar calc-display-working-message 'lots) ;; If non-NIL, automatically execute a "why" command to explain odd results. ;;(defvar calc-auto-why nil) ;; If non-NIL, display timing information on each slow command. ;;(defvar calc-timing nil) ;; Floating-point numbers with this positive exponent or higher above the ;; current precision are displayed in scientific notation in calc-mode. (defvar calc-display-sci-high 0) ;; Floating-point numbers with this negative exponent or lower are displayed ;; scientific notation in calc-mode. (defvar calc-display-sci-low -3) ;; List of used-defined strings to append to Calculator mode line. (defvar calc-other-modes nil) ;; List of strings for Y prefix help. (defvar calc-Y-help-msgs nil) ;; T if calc-settings-file has been loaded yet. (defvar calc-loaded-settings-file nil) (defconst calc-mode-var-list '((calc-always-load-extensions nil) (calc-mode-save-mode local) (calc-line-numbering t) (calc-line-breaking t) (calc-display-just nil) (calc-display-origin nil) (calc-left-label "") (calc-right-label "") (calc-number-radix 10) (calc-leading-zeros nil) (calc-group-digits nil) (calc-group-char ",") (calc-point-char ".") (calc-frac-format (":" nil)) (calc-prefer-frac nil) (calc-hms-format "%s@ %s' %s\"") (calc-date-format ((H ":" mm C SS pp " ") Www " " Mmm " " D ", " YYYY)) (calc-standard-date-formats ("N" "Www Mmm D, YYYY" "D Mmm YYYY<, h:mm:SS>" "Www Mmm BD< hh:mm:ss> YYYY" "M/D/Y< H:mm:SSpp>" "D.M.Y< h:mm:SS>" "M-D-Y< H:mm:SSpp>" "D-M-Y< h:mm:SS>" "j<, h:mm:SS>" "YYddd< hh:mm:ss>")) (calc-float-format (float 0)) (calc-full-float-format (float 0)) (calc-complex-format nil) (calc-matrix-just center) (calc-full-vectors t) (calc-full-trail-vectors t) (calc-break-vectors nil) (calc-vector-commas ",") (calc-vector-brackets "[]") (calc-matrix-brackets (R O)) (calc-complex-mode cplx) (calc-infinite-mode nil) (calc-display-strings nil) (calc-simplify-mode nil) (calc-auto-recompute t) (calc-word-size 32) (calc-previous-modulo nil) (calc-display-raw nil) (calc-internal-prec 12) (calc-angle-mode deg) (calc-algebraic-mode nil) (calc-incomplete-algebraic-mode nil) (calc-symbolic-mode nil) (calc-matrix-mode nil) (calc-autorange-units nil) (calc-shift-prefix nil) (calc-window-height 7) (calc-was-keypad-mode nil) (calc-full-mode nil) (calc-language nil) (calc-language-option nil) (calc-user-parse-tables nil) (calc-show-selections t) (calc-use-selections t) (calc-assoc-selections t) (calc-display-trail t) (calc-display-working-message lots) (calc-auto-why 'maybe) (calc-timing nil) (calc-gnuplot-default-device "default") (calc-gnuplot-default-output "STDOUT") (calc-gnuplot-print-device "postscript") (calc-gnuplot-print-output "auto") (calc-gnuplot-geometry nil) (calc-graph-default-resolution 15) (calc-graph-default-resolution-3d 5) (calc-invocation-macro nil))) (defconst calc-local-var-list '(calc-stack calc-stack-top calc-undo-list calc-redo-list calc-always-load-extensions calc-mode-save-mode calc-display-raw calc-line-numbering calc-line-breaking calc-display-just calc-display-origin calc-left-label calc-right-label calc-auto-why calc-algebraic-mode calc-incomplete-algebraic-mode calc-symbolic-mode calc-matrix-mode calc-inverse-flag calc-hyperbolic-flag calc-keep-args-flag calc-angle-mode calc-number-radix calc-leading-zeros calc-group-digits calc-group-char calc-point-char calc-frac-format calc-prefer-frac calc-hms-format calc-date-format calc-standard-date-formats calc-float-format calc-full-float-format calc-complex-format calc-matrix-just calc-full-vectors calc-full-trail-vectors calc-break-vectors calc-vector-commas calc-vector-brackets calc-matrix-brackets calc-complex-mode calc-infinite-mode calc-display-strings calc-simplify-mode calc-auto-recompute calc-autorange-units calc-show-plain calc-show-selections calc-use-selections calc-assoc-selections calc-word-size calc-internal-prec)) (defun calc-init-base () ;; Verify that Calc is running on the right kind of system. (setq calc-emacs-type-epoch (and (fboundp 'epoch::version) epoch::version) calc-emacs-type-19 (not (or calc-emacs-type-epoch (string-lessp emacs-version "19"))) calc-emacs-type-lucid (not (not (string-match "Lucid" emacs-version))) calc-emacs-type-gnu19 (and calc-emacs-type-19 (not calc-emacs-type-lucid))) ;; Set up the standard keystroke (M-#) to run the Calculator, if that key ;; has not yet been bound to anything. For best results, the user should ;; do this before Calc is even loaded, so that M-# can auto-load Calc. (or (global-key-binding "\e#") (global-set-key "\e#" 'calc-dispatch)) ;; Set up the autoloading linkage. (let ((name (and (fboundp 'calc-dispatch) (eq (car-safe (symbol-function 'calc-dispatch)) 'autoload) (nth 1 (symbol-function 'calc-dispatch)))) (p load-path)) ;; If Calc files exist on the load-path, we're all set. (while (and p (not (file-exists-p (expand-file-name "calc-misc.elc" (car p))))) (setq p (cdr p))) (or p ;; If Calc is autoloaded using a path name, look there for Calc files. ;; This works for both relative ("calc/calc.elc") and absolute paths. (and name (file-name-directory name) (let ((p2 load-path) (name2 (concat (file-name-directory name) "calc-misc.elc"))) (while (and p2 (not (file-exists-p (expand-file-name name2 (car p2))))) (setq p2 (cdr p2))) (if p2 (setq load-path (nconc load-path (list (directory-file-name (file-name-directory (expand-file-name name (car p2)))))))))) ;; If calc-autoload-directory is given, use that (and hope it works!). (and calc-autoload-directory (not (equal calc-autoload-directory "")) (setq load-path (nconc load-path (list (directory-file-name calc-autoload-directory))))))) ;; The following modes use specially-formatted data. (put 'calc-mode 'mode-class 'special) (put 'calc-trail-mode 'mode-class 'special) ;; Define "inexact-result" as an e-lisp error symbol. (put 'inexact-result 'error-conditions '(error inexact-result calc-error)) (put 'inexact-result 'error-message "Calc internal error (inexact-result)") ;; Define "math-overflow" and "math-underflow" as e-lisp error symbols. (put 'math-overflow 'error-conditions '(error math-overflow calc-error)) (put 'math-overflow 'error-message "Floating-point overflow occurred") (put 'math-underflow 'error-conditions '(error math-underflow calc-error)) (put 'math-underflow 'error-message "Floating-point underflow occurred") (setq calc-version "2.02c" calc-version-date "Tue Mar 22 1994" calc-trail-pointer nil ; "Current" entry in trail buffer. calc-trail-overlay nil ; Value of overlay-arrow-string. calc-was-split nil ; Had multiple windows before Calc. calc-undo-list nil ; List of previous operations for undo. calc-redo-list nil ; List of recent undo operations. calc-main-buffer nil ; Pointer to Calculator buffer. calc-trail-buffer nil ; Pointer to Calc Trail buffer. calc-why nil ; Explanations of most recent errors. calc-next-why nil calc-inverse-flag nil calc-hyperbolic-flag nil calc-keep-args-flag nil calc-function-open "(" calc-function-close ")" calc-language-output-filter nil calc-language-input-filter nil calc-radix-formatter nil calc-last-kill nil ; Last number killed in calc-mode. calc-previous-alg-entry nil ; Previous algebraic entry. calc-dollar-values nil ; Values to be used for '$'. calc-dollar-used nil ; Highest order of '$' that occurred. calc-hashes-used nil ; Highest order of '#' that occurred. calc-quick-prev-results nil ; Previous results from Quick Calc. calc-said-hello nil ; Has welcome message been said yet? calc-executing-macro nil ; Kbd macro executing from "K" key. calc-any-selections nil ; Nil means no selections present. calc-help-phase 0 ; Count of consecutive "?" keystrokes. calc-full-help-flag nil ; Executing calc-full-help? calc-refresh-count 0 ; Count of calc-refresh calls. calc-display-dirty nil calc-prepared-composition nil calc-selection-cache-default-entry nil calc-embedded-info nil calc-embedded-active nil calc-standalone-flag nil var-EvalRules nil math-eval-rules-cache-tag t math-radix-explicit-format t math-expr-function-mapping nil math-expr-variable-mapping nil math-read-expr-quotes nil math-working-step nil math-working-step-2 nil var-i '(special-const (math-imaginary 1)) var-pi '(special-const (math-pi)) var-e '(special-const (math-e)) var-phi '(special-const (math-phi)) var-gamma '(special-const (math-gamma-const)) var-Modes '(special-const (math-get-modes-vec))) (mapcar (function (lambda (v) (or (boundp (car v)) (set (car v) (nth 1 v))))) calc-mode-var-list) (mapcar (function (lambda (v) (or (boundp v) (set v nil)))) calc-local-var-list) (if (boundp 'calc-mode-map) nil (setq calc-mode-map (make-keymap)) (suppress-keymap calc-mode-map t) (define-key calc-mode-map "+" 'calc-plus) (define-key calc-mode-map "-" 'calc-minus) (define-key calc-mode-map "*" 'calc-times) (define-key calc-mode-map "/" 'calc-divide) (define-key calc-mode-map "%" 'calc-mod) (define-key calc-mode-map "&" 'calc-inv) (define-key calc-mode-map "^" 'calc-power) (define-key calc-mode-map "\M-%" 'calc-percent) (define-key calc-mode-map "e" 'calcDigit-start) (define-key calc-mode-map "i" 'calc-info) (define-key calc-mode-map "n" 'calc-change-sign) (define-key calc-mode-map "q" 'calc-quit) (define-key calc-mode-map "Y" 'nil) (define-key calc-mode-map "Y?" 'calc-shift-Y-prefix-help) (define-key calc-mode-map "?" 'calc-help) (define-key calc-mode-map " " 'calc-enter) (define-key calc-mode-map "'" 'calc-algebraic-entry) (define-key calc-mode-map "$" 'calc-auto-algebraic-entry) (define-key calc-mode-map "\"" 'calc-auto-algebraic-entry) (define-key calc-mode-map "\t" 'calc-roll-down) (define-key calc-mode-map "\M-\t" 'calc-roll-up) (define-key calc-mode-map "\C-m" 'calc-enter) (define-key calc-mode-map "\M-\C-m" 'calc-last-args-stub) (define-key calc-mode-map "\C-j" 'calc-over) (mapcar (function (lambda (x) (define-key calc-mode-map (char-to-string x) 'undefined))) "lOW") (mapcar (function (lambda (x) (define-key calc-mode-map (char-to-string x) 'calc-missing-key))) (concat "ABCDEFGHIJKLMNPQRSTUVXZabcdfghjkmoprstuvwxyz" ":\\|!()[]<>{},;=~`\C-k\M-k\C-w\M-w\C-y\C-_")) (mapcar (function (lambda (x) (define-key calc-mode-map (char-to-string x) 'calcDigit-start))) "_0123456789.#@") (setq calc-digit-map (make-keymap)) (if calc-emacs-type-lucid (map-keymap (function (lambda (keys bind) (define-key calc-digit-map keys (if (eq bind 'undefined) 'undefined 'calcDigit-nondigit)))) calc-mode-map) (let ((cmap (if calc-emacs-type-19 (nth 1 calc-mode-map) calc-mode-map)) (dmap (if calc-emacs-type-19 (nth 1 calc-digit-map) calc-digit-map)) (i 0)) (while (< i 128) (aset dmap i (if (eq (aref cmap i) 'undefined) 'undefined 'calcDigit-nondigit)) (setq i (1+ i))))) (mapcar (function (lambda (x) (define-key calc-digit-map (char-to-string x) 'calcDigit-key))) "_0123456789.e+-:n#@oh'\"mspM") (mapcar (function (lambda (x) (define-key calc-digit-map (char-to-string x) 'calcDigit-letter))) "abcdfgijklqrtuvwxyzABCDEFGHIJKLNOPQRSTUVWXYZ") (define-key calc-digit-map "'" 'calcDigit-algebraic) (define-key calc-digit-map "`" 'calcDigit-edit) (define-key calc-digit-map "\C-g" 'abort-recursive-edit) (mapcar (function (lambda (x) (condition-case err (progn (define-key calc-digit-map x 'calcDigit-backspace) (define-key calc-mode-map x 'calc-pop) (define-key calc-mode-map (if (vectorp x) (if calc-emacs-type-lucid (if (= (length x) 1) (vector (if (consp (aref x 0)) (cons 'meta (aref x 0)) (list 'meta (aref x 0)))) "\e\C-d") (vconcat "\e" x)) (concat "\e" x)) 'calc-pop-above)) (error nil)))) (if calc-scan-for-dels (append (where-is-internal 'delete-backward-char global-map) (where-is-internal 'backward-delete-char global-map) '("\C-d")) '("\177" "\C-d"))) (setq calc-dispatch-map (make-keymap)) (mapcar (function (lambda (x) (define-key calc-dispatch-map (char-to-string (car x)) (cdr x)) (if (string-match "abcdefhijklnopqrstuwxyz" (char-to-string (car x))) (define-key calc-dispatch-map (char-to-string (- (car x) ?a -1)) (cdr x))) (define-key calc-dispatch-map (format "\e%c" (car x)) (cdr x)))) '( ( ?a . calc-embedded-activate ) ( ?b . calc-big-or-small ) ( ?c . calc ) ( ?d . calc-embedded-duplicate ) ( ?e . calc-embedded ) ( ?f . calc-embedded-new-formula ) ( ?g . calc-grab-region ) ( ?h . calc-dispatch-help ) ( ?i . calc-info ) ( ?j . calc-embedded-select ) ( ?k . calc-keypad ) ( ?l . calc-load-everything ) ( ?m . read-kbd-macro ) ( ?n . calc-embedded-next ) ( ?o . calc-other-window ) ( ?p . calc-embedded-previous ) ( ?q . quick-calc ) ( ?r . calc-grab-rectangle ) ( ?s . calc-info-summary ) ( ?t . calc-tutorial ) ( ?u . calc-embedded-update-formula ) ( ?w . calc-embedded-word ) ( ?x . calc-quit ) ( ?y . calc-copy-to-buffer ) ( ?z . calc-user-invocation ) ( ?= . calc-embedded-update-formula ) ( ?\' . calc-embedded-new-formula ) ( ?\` . calc-embedded-edit ) ( ?: . calc-grab-sum-down ) ( ?_ . calc-grab-sum-across ) ( ?0 . calc-reset ) ( ?# . calc-same-interface ) ( ?? . calc-dispatch-help ) )) ) (autoload 'calc-extensions "calc-ext") (autoload 'calc-need-macros "calc-macs") ;;;; (Autoloads here) (mapcar (function (lambda (x) (mapcar (function (lambda (func) (autoload func (car x)))) (cdr x)))) '( ("calc-aent" calc-Need-calc-aent calc-alg-digit-entry calc-alg-entry calc-check-user-syntax calc-do-alg-entry calc-do-calc-eval calc-do-quick-calc calc-match-user-syntax math-build-parse-table math-find-user-tokens math-read-expr-list math-read-exprs math-read-if math-read-token math-remove-dashes) ("calc-misc" calc-Need-calc-misc calc-delete-windows-keep calc-do-handle-whys calc-do-refresh calc-num-prefix-name calc-record-list calc-record-why calc-report-bug calc-roll-down-stack calc-roll-up-stack calc-temp-minibuffer-message calcFunc-floor calcFunc-inv calcFunc-trunc math-concat math-constp math-div2 math-div2-bignum math-do-working math-evenp math-fixnatnump math-fixnump math-floor math-imod math-ipow math-looks-negp math-mod math-negp math-posp math-pow math-read-radix-digit math-reject-arg math-trunc math-zerop) )) (mapcar (function (lambda (x) (mapcar (function (lambda (cmd) (autoload cmd (car x) nil t))) (cdr x)))) '( ("calc-aent" calc-algebraic-entry calc-auto-algebraic-entry calcDigit-algebraic calcDigit-edit) ("calc-misc" another-calc calc-big-or-small calc-dispatch-help calc-help calc-info calc-info-summary calc-inv calc-last-args-stub calc-missing-key calc-mod calc-other-window calc-over calc-percent calc-pop-above calc-power calc-roll-down calc-roll-up calc-shift-Y-prefix-help calc-tutorial calcDigit-letter report-calc-bug) )) ) (calc-init-base) ;;;###autoload (global-set-key "\e#" 'calc-dispatch) ;;;###autoload (defun calc-dispatch (&optional arg) "Invoke the GNU Emacs Calculator. See calc-dispatch-help for details." (interactive "P") (sit-for echo-keystrokes) (condition-case err ; look for other keys bound to calc-dispatch (let ((keys (this-command-keys))) (or (not (stringp keys)) (string-match "\\`\C-u\\|\\`\e[-0-9#]\\|`[\M--\M-0-\M-9]" keys) (eq (lookup-key calc-dispatch-map keys) 'calc-same-interface) (progn (and (string-match "\\`[\C-@-\C-_]" keys) (symbolp (lookup-key calc-dispatch-map (substring keys 0 1))) (define-key calc-dispatch-map (substring keys 0 1) nil)) (define-key calc-dispatch-map keys 'calc-same-interface)))) (error nil)) (calc-do-dispatch arg) ) (defun calc-do-dispatch (arg) (let ((key (calc-read-key-sequence (if calc-dispatch-help "Calc options: Calc, Keypad, Quick, Embed; eXit; Info, Tutorial; Grab; ?=more" (format "%s (Type ? for a list of Calc options)" (key-description (this-command-keys)))) calc-dispatch-map))) (setq key (lookup-key calc-dispatch-map key)) (message "") (if key (progn (or (commandp key) (calc-extensions)) (call-interactively key)) (beep))) ) (setq calc-dispatch-help nil) (defun calc-read-key-sequence (prompt map) (let ((prompt2 (format "%s " (key-description (this-command-keys)))) (glob (current-global-map)) (loc (current-local-map))) (or (input-pending-p) (message prompt)) (let ((key (calc-read-key t))) (calc-unread-command (cdr key)) (unwind-protect (progn (use-global-map map) (use-local-map nil) (read-key-sequence (if (commandp (key-binding (if calc-emacs-type-19 (vector (cdr key)) (char-to-string (cdr key))))) "" prompt2))) (use-global-map glob) (use-local-map loc)))) ) (defun calc-mode () "Calculator major mode. This is an RPN calculator featuring arbitrary-precision integer, rational, floating-point, complex, matrix, and symbolic arithmetic. RPN calculation: 2 RET 3 + produces 5. Algebraic style: ' 2+3 RET produces 5. Basic operators are +, -, *, /, ^, & (reciprocal), % (modulo), n (change-sign). Press ? repeatedly for more complete help. Press `h i' to read the Calc manual on-line, `h s' to read the summary, or `h t' for the tutorial. Notations: 3.14e6 3.14 * 10^6 _23 negative number -23 (or type `23 n') 17:3 the fraction 17/3 5:2:3 the fraction 5 and 2/3 16#12C the integer 12C base 16 = 300 base 10 8#177:100 the fraction 177:100 base 8 = 127:64 base 10 (2, 4) complex number 2 + 4i (2; 4) polar complex number (r; theta) [1, 2, 3] vector ([[1, 2], [3, 4]] is a matrix) [1 .. 4) semi-open interval, 1 <= x < 4 2 +/- 3 (p key) number with mean 2, standard deviation 3 2 mod 3 (M key) number 2 computed modulo 3 <1 jan 91> Date form (enter using ' key) \\{calc-mode-map} " (interactive) (mapcar (function (lambda (v) (set-default v (symbol-value v)))) calc-local-var-list) (kill-all-local-variables) (use-local-map (if (eq calc-algebraic-mode 'total) (progn (calc-extensions) calc-alg-map) calc-mode-map)) (mapcar (function (lambda (v) (make-local-variable v))) calc-local-var-list) (make-local-variable 'overlay-arrow-position) (make-local-variable 'overlay-arrow-string) (setq truncate-lines t) (setq buffer-read-only t) (setq major-mode 'calc-mode) (setq mode-name "Calculator") (setq calc-stack-top (length (or (memq (assq 'top-of-stack calc-stack) calc-stack) (setq calc-stack (list (list 'top-of-stack 1 nil)))))) (setq calc-stack-top (- (length calc-stack) calc-stack-top -1)) (or calc-loaded-settings-file (string-match "\\.emacs" calc-settings-file) (progn (setq calc-loaded-settings-file t) (load calc-settings-file t))) ; t = missing-ok (if (and (eq window-system 'x) (boundp 'mouse-map)) (substitute-key-definition 'x-paste-text 'calc-x-paste-text mouse-map)) (let ((p command-line-args)) (while p (and (equal (car p) "-f") (string-match "calc" (nth 1 p)) (string-match "full" (nth 1 p)) (setq calc-standalone-flag t)) (setq p (cdr p)))) (run-hooks 'calc-mode-hook) (calc-refresh t) (calc-set-mode-line) ;; The calc-defs variable is a relic. Use calc-define properties instead. (if (and (boundp 'calc-defs) calc-defs) (progn (message "Evaluating calc-defs...") (calc-need-macros) (eval (cons 'progn calc-defs)) (setq calc-defs nil) (calc-set-mode-line))) (calc-check-defines) ) (defun calc-check-defines () (if (symbol-plist 'calc-define) (let ((plist (copy-sequence (symbol-plist 'calc-define)))) (while (and plist (null (nth 1 plist))) (setq plist (cdr (cdr plist)))) (if plist (save-excursion (calc-extensions) (calc-need-macros) (set-buffer "*Calculator*") (while plist (put 'calc-define (car plist) nil) (eval (nth 1 plist)) (setq plist (cdr (cdr plist)))) ;; See if this has added any more calc-define properties. (calc-check-defines)) (setplist 'calc-define nil)))) ) (setq calc-check-defines 'calc-check-defines) ; suitable for run-hooks (defun calc-trail-mode (&optional buf) "Calc Trail mode. This mode is used by the *Calc Trail* buffer, which records all results obtained by the GNU Emacs Calculator. Calculator commands beginning with the `t' key are used to manipulate the Trail. This buffer uses the same key map as the *Calculator* buffer; calculator commands given here will actually operate on the *Calculator* stack." (interactive) (fundamental-mode) (use-local-map calc-mode-map) (setq major-mode 'calc-trail-mode) (setq mode-name "Calc Trail") (setq truncate-lines t) (setq buffer-read-only t) (make-local-variable 'overlay-arrow-position) (make-local-variable 'overlay-arrow-string) (if buf (progn (make-local-variable 'calc-main-buffer) (setq calc-main-buffer buf))) (if (= (buffer-size) 0) (let ((buffer-read-only nil)) (insert "Emacs Calculator v" calc-version " by Dave Gillespie, " "installed " calc-installed-date "\n"))) (run-hooks 'calc-trail-mode-hook) ) (defun calc-create-buffer () (set-buffer (get-buffer-create "*Calculator*")) (or (eq major-mode 'calc-mode) (calc-mode)) (setq max-lisp-eval-depth (max max-lisp-eval-depth 1000)) (if calc-always-load-extensions (calc-extensions)) (if calc-language (progn (calc-extensions) (calc-set-language calc-language calc-language-option t))) ) ;;;###autoload (defun calc (&optional arg full-display interactive) "The Emacs Calculator. Full documentation is listed under \"calc-mode\"." (interactive "P") (if arg (or (eq arg 0) (progn (calc-extensions) (if (= (prefix-numeric-value arg) -1) (calc-grab-region (region-beginning) (region-end) nil) (if (= (prefix-numeric-value arg) -2) (calc-keypad))))) (if (get-buffer-window "*Calc Keypad*") (progn (calc-keypad) (set-buffer (window-buffer (selected-window))))) (if (eq major-mode 'calc-mode) (calc-quit) (let ((oldbuf (current-buffer))) (calc-create-buffer) (setq calc-was-keypad-mode nil) (if (or (eq full-display t) (and (null full-display) calc-full-mode)) (switch-to-buffer (current-buffer) t) (if (get-buffer-window (current-buffer)) (select-window (get-buffer-window (current-buffer))) (setq calc-was-split nil) (if (and (boundp 'calc-window-hook) calc-window-hook) (run-hooks 'calc-window-hook) (let ((w (get-largest-window))) (if (and pop-up-windows (> (window-height w) (+ window-min-height calc-window-height 2))) (progn (or (one-window-p) (setq calc-was-split (list w (window-height w) (selected-window)))) (setq w (split-window w (- (window-height w) calc-window-height 2) nil)) (set-window-buffer w (current-buffer)) (select-window w)) (pop-to-buffer (current-buffer))))))) (save-excursion (set-buffer (calc-trail-buffer)) (and calc-display-trail (= (window-width) (screen-width)) (calc-trail-display 1 t))) (message "Welcome to the GNU Emacs Calculator! Press `?' or `h' for help, `q' to quit.") (run-hooks 'calc-start-hook) (and (windowp full-display) (window-point full-display) (select-window full-display)) (calc-check-defines) (and calc-said-hello (or (interactive-p) interactive) (progn (sit-for 2) (message ""))) (setq calc-said-hello t)))) ) ;;;###autoload (defun full-calc () "Invoke the Calculator and give it a full-sized window." (interactive) (calc nil t (interactive-p)) ) (defun calc-same-interface (arg) "Invoke the Calculator using the most recent interface (calc or calc-keypad)." (interactive "P") (if (and (equal (buffer-name) "*Gnuplot Trail*") (> (recursion-depth) 0)) (exit-recursive-edit) (if (eq major-mode 'calc-edit-mode) (calc-edit-finish arg) (if (eq major-mode 'MacEdit-mode) (MacEdit-finish-edit) (if calc-was-keypad-mode (calc-keypad) (calc arg calc-full-mode t))))) ) (defun calc-quit (&optional non-fatal) (interactive) (and calc-standalone-flag (not non-fatal) (save-buffers-kill-emacs nil)) (if (and (equal (buffer-name) "*Gnuplot Trail*") (> (recursion-depth) 0)) (exit-recursive-edit)) (if (eq major-mode 'calc-edit-mode) (calc-edit-cancel) (if (eq major-mode 'MacEdit-mode) (MacEdit-cancel-edit) (if (and (interactive-p) calc-embedded-info (eq (current-buffer) (aref calc-embedded-info 0))) (calc-embedded nil) (or (eq major-mode 'calc-mode) (calc-create-buffer)) (run-hooks 'calc-end-hook) (setq calc-undo-list nil calc-redo-list nil) (mapcar (function (lambda (v) (set-default v (symbol-value v)))) calc-local-var-list) (let ((buf (current-buffer)) (win (get-buffer-window (current-buffer))) (kbuf (get-buffer "*Calc Keypad*"))) (delete-windows-on (calc-trail-buffer)) (if (and win (< (window-height win) (1- (screen-height))) (= (window-width win) (screen-width)) ; avoid calc-keypad (not (get-buffer-window "*Calc Keypad*"))) (setq calc-window-height (- (window-height win) 2))) (if calc-was-split (calc-delete-windows-keep buf kbuf) (delete-windows-on buf) (delete-windows-on kbuf)) (bury-buffer buf) (bury-buffer calc-trail-buffer) (and kbuf (bury-buffer kbuf)))))) ) ;;;###autoload (defun quick-calc () "Do a quick calculation in the minibuffer without invoking full Calculator." (interactive) (calc-do-quick-calc) ) ;;;###autoload (defun calc-eval (str &optional separator &rest args) "Do a quick calculation and return the result as a string. Return value will either be the formatted result in string form, or a list containing a character position and an error message in string form." (calc-do-calc-eval str separator args) ) ;;;###autoload (defun calc-keypad () "Invoke the Calculator in \"visual keypad\" mode. This is most useful in the X window system. In this mode, click on the Calc \"buttons\" using the left mouse button. Or, position the cursor manually and do M-x calc-keypad-press." (interactive) (calc-extensions) (calc-do-keypad calc-full-mode (interactive-p)) ) ;;;###autoload (defun full-calc-keypad () "Invoke the Calculator in full-screen \"visual keypad\" mode. See calc-keypad for details." (interactive) (calc-extensions) (calc-do-keypad t (interactive-p)) ) ;;; Note that modifications to this function may break calc-pass-errors. (defun calc-do (do-body &optional do-slow) (calc-check-defines) (let* ((calc-command-flags nil) (calc-start-time (and calc-timing (not calc-start-time) (calc-extensions) (current-time-string))) (gc-cons-threshold (max gc-cons-threshold (if calc-timing 2000000 100000)))) (setq calc-aborted-prefix "") (unwind-protect (condition-case err (save-excursion (if calc-embedded-info (calc-embedded-select-buffer) (calc-select-buffer)) (and (eq calc-algebraic-mode 'total) (calc-extensions) (use-local-map calc-alg-map)) (and do-slow calc-display-working-message (progn (message "Working...") (calc-set-command-flag 'clear-message))) (funcall do-body) (setq calc-aborted-prefix nil) (and (memq 'renum-stack calc-command-flags) (calc-renumber-stack)) (and (memq 'clear-message calc-command-flags) (message ""))) (error (if (and (eq (car err) 'error) (stringp (nth 1 err)) (string-match "max-specpdl-size\\|max-lisp-eval-depth" (nth 1 err))) (error "Computation got stuck or ran too long. Type `M' to increase the limit.") (setq calc-aborted-prefix nil) (signal (car err) (cdr err))))) (setq calc-old-aborted-prefix calc-aborted-prefix) (and calc-aborted-prefix (calc-record "" calc-aborted-prefix)) (and calc-start-time (let* ((calc-internal-prec 12) (calc-date-format nil) (end-time (current-time-string)) (time (if (equal calc-start-time end-time) 0 (math-sub (calcFunc-unixtime (math-parse-date end-time) 0) (calcFunc-unixtime (math-parse-date calc-start-time) 0))))) (if (math-lessp 1 time) (calc-record time "(t)")))) (or (memq 'no-align calc-command-flags) (eq major-mode 'calc-trail-mode) (calc-align-stack-window)) (and (memq 'position-point calc-command-flags) (if (eq major-mode 'calc-mode) (progn (goto-line calc-final-point-line) (move-to-column calc-final-point-column)) (save-excursion (calc-select-buffer) (goto-line calc-final-point-line) (move-to-column calc-final-point-column)))) (or (memq 'keep-flags calc-command-flags) (save-excursion (calc-select-buffer) (setq calc-inverse-flag nil calc-hyperbolic-flag nil calc-keep-args-flag nil))) (and (memq 'do-edit calc-command-flags) (switch-to-buffer (get-buffer-create "*Calc Edit*"))) (calc-set-mode-line) (and calc-embedded-info (calc-embedded-finish-command)))) (identity nil) ; allow a GC after timing is done ) (setq calc-aborted-prefix nil) (setq calc-start-time nil) (defun calc-set-command-flag (f) (if (not (memq f calc-command-flags)) (setq calc-command-flags (cons f calc-command-flags))) ) (defun calc-select-buffer () (or (eq major-mode 'calc-mode) (if calc-main-buffer (set-buffer calc-main-buffer) (let ((buf (get-buffer "*Calculator*"))) (if buf (set-buffer buf) (error "Calculator buffer not available"))))) ) (defun calc-cursor-stack-index (&optional index) (goto-char (point-max)) (forward-line (- (calc-substack-height (or index 1)))) ) (defun calc-stack-size () (- (length calc-stack) calc-stack-top) ) (defun calc-substack-height (n) (let ((sum 0) (stack calc-stack)) (setq n (+ n calc-stack-top)) (while (and (> n 0) stack) (setq sum (+ sum (nth 1 (car stack))) n (1- n) stack (cdr stack))) sum) ) (defun calc-set-mode-line () (save-excursion (calc-select-buffer) (let* ((fmt (car calc-float-format)) (figs (nth 1 calc-float-format)) (new-mode-string (format "Calc%s%s: %d %s %-14s" (if calc-embedded-info "Embed" "") (if (and (> (length (buffer-name)) 12) (equal (substring (buffer-name) 0 12) "*Calculator*")) (substring (buffer-name) 12) "") calc-internal-prec (capitalize (symbol-name calc-angle-mode)) (concat ;; Input-related modes (if (eq calc-algebraic-mode 'total) "Alg* " (if calc-algebraic-mode "Alg " (if calc-incomplete-algebraic-mode "Alg[( " ""))) ;; Computational modes (if calc-symbolic-mode "Symb " "") (cond ((eq calc-matrix-mode 'matrix) "Matrix ") ((integerp calc-matrix-mode) (format "Matrix%d " calc-matrix-mode)) ((eq calc-matrix-mode 'scalar) "Scalar ") (t "")) (if (eq calc-complex-mode 'polar) "Polar " "") (if calc-prefer-frac "Frac " "") (cond ((null calc-infinite-mode) "") ((eq calc-infinite-mode 1) "+Inf ") (t "Inf ")) (cond ((eq calc-simplify-mode 'none) "NoSimp ") ((eq calc-simplify-mode 'num) "NumSimp ") ((eq calc-simplify-mode 'binary) (format "BinSimp%d " calc-word-size)) ((eq calc-simplify-mode 'alg) "AlgSimp ") ((eq calc-simplify-mode 'ext) "ExtSimp ") ((eq calc-simplify-mode 'units) "UnitSimp ") (t "")) ;; Display modes (cond ((= calc-number-radix 10) "") ((= calc-number-radix 2) "Bin ") ((= calc-number-radix 8) "Oct ") ((= calc-number-radix 16) "Hex ") (t (format "Radix%d " calc-number-radix))) (if calc-leading-zeros "Zero " "") (cond ((null calc-language) "") ((eq calc-language 'tex) "TeX ") (t (concat (capitalize (symbol-name calc-language)) " "))) (cond ((eq fmt 'float) (if (zerop figs) "" (format "Norm%d " figs))) ((eq fmt 'fix) (format "Fix%d " figs)) ((eq fmt 'sci) (if (zerop figs) "Sci " (format "Sci%d " figs))) ((eq fmt 'eng) (if (zerop figs) "Eng " (format "Eng%d " figs)))) (cond ((not calc-display-just) (if calc-display-origin (format "Left%d " calc-display-origin) "")) ((eq calc-display-just 'right) (if calc-display-origin (format "Right%d " calc-display-origin) "Right ")) (t (if calc-display-origin (format "Center%d " calc-display-origin) "Center "))) (cond ((integerp calc-line-breaking) (format "Wid%d " calc-line-breaking)) (calc-line-breaking "") (t "Wide ")) ;; Miscellaneous other modes/indicators (if calc-assoc-selections "" "Break ") (cond ((eq calc-mode-save-mode 'save) "Save ") ((not calc-embedded-info) "") ((eq calc-mode-save-mode 'local) "Local ") ((eq calc-mode-save-mode 'edit) "LocEdit ") ((eq calc-mode-save-mode 'perm) "LocPerm ") ((eq calc-mode-save-mode 'global) "Global ") (t "")) (if calc-auto-recompute "" "Manual ") (if (and (fboundp 'calc-gnuplot-alive) (calc-gnuplot-alive)) "Graph " "") (if (and calc-embedded-info (> (calc-stack-size) 0) (calc-top 1 'sel)) "Sel " "") (if calc-display-dirty "Dirty " "") (if calc-inverse-flag "Inv " "") (if calc-hyperbolic-flag "Hyp " "") (if calc-keep-args-flag "Keep " "") (if (/= calc-stack-top 1) "Narrow " "") (apply 'concat calc-other-modes))))) (if (equal new-mode-string mode-line-buffer-identification) nil (setq mode-line-buffer-identification new-mode-string) (set-buffer-modified-p (buffer-modified-p)) (and calc-embedded-info (calc-embedded-mode-line-change))))) ) (defun calc-align-stack-window () (if (eq major-mode 'calc-mode) (progn (let ((win (get-buffer-window (current-buffer)))) (if win (progn (calc-cursor-stack-index 0) (vertical-motion (- 2 (window-height win))) (set-window-start win (point))))) (calc-cursor-stack-index 0) (if (looking-at " *\\.$") (goto-char (1- (match-end 0))))) (save-excursion (calc-select-buffer) (calc-align-stack-window))) ) (defun calc-check-stack (n) (if (> n (calc-stack-size)) (error "Too few elements on stack")) (if (< n 0) (error "Invalid argument")) ) (defun calc-push-list (vals &optional m sels) (while vals (if calc-executing-macro (calc-push-list-in-macro vals m sels) (save-excursion (calc-select-buffer) (let* ((val (car vals)) (entry (list val 1 (car sels))) (mm (+ (or m 1) calc-stack-top))) (calc-cursor-stack-index (1- (or m 1))) (if (> mm 1) (setcdr (nthcdr (- mm 2) calc-stack) (cons entry (nthcdr (1- mm) calc-stack))) (setq calc-stack (cons entry calc-stack))) (let ((buffer-read-only nil)) (insert (math-format-stack-value entry) "\n")) (calc-record-undo (list 'push mm)) (calc-set-command-flag 'renum-stack)))) (setq vals (cdr vals) sels (cdr sels))) ) (defun calc-pop-push-list (n vals &optional m sels) (if (and calc-any-selections (null sels)) (calc-replace-selections n vals m) (calc-pop-stack n m sels) (calc-push-list vals m sels)) ) (defun calc-pop-push-record-list (n prefix vals &optional m sels) (or (and (consp vals) (or (integerp (car vals)) (consp (car vals)))) (and vals (setq vals (list vals) sels (and sels (list sels))))) (calc-check-stack (+ n (or m 1) -1)) (if prefix (if (cdr vals) (calc-record-list vals prefix) (calc-record (car vals) prefix))) (calc-pop-push-list n vals m sels) ) (defun calc-enter-result (n prefix vals &optional m) (setq calc-aborted-prefix prefix) (if (and (consp vals) (or (integerp (car vals)) (consp (car vals)))) (setq vals (mapcar 'calc-normalize vals)) (setq vals (calc-normalize vals))) (or (and (consp vals) (or (integerp (car vals)) (consp (car vals)))) (setq vals (list vals))) (if (equal vals '((nil))) (setq vals nil)) (calc-pop-push-record-list n prefix vals m) (calc-handle-whys) ) (defun calc-normalize (val) (if (memq calc-simplify-mode '(nil none num)) (math-normalize val) (calc-extensions) (calc-normalize-fancy val)) ) (defun calc-handle-whys () (if calc-next-why (calc-do-handle-whys)) ) (defun calc-pop-stack (&optional n m sel-ok) ; pop N objs at level M of stack. (or n (setq n 1)) (or m (setq m 1)) (or calc-keep-args-flag (let ((mm (+ m calc-stack-top))) (if (and calc-any-selections (not sel-ok) (calc-top-selected n m)) (calc-sel-error)) (if calc-executing-macro (calc-pop-stack-in-macro n mm) (calc-record-undo (list 'pop mm (calc-top-list n m 'full))) (save-excursion (calc-select-buffer) (let ((buffer-read-only nil)) (if (> mm 1) (progn (calc-cursor-stack-index (1- m)) (let ((bot (point))) (calc-cursor-stack-index (+ n m -1)) (delete-region (point) bot)) (setcdr (nthcdr (- mm 2) calc-stack) (nthcdr (+ n mm -1) calc-stack))) (calc-cursor-stack-index n) (setq calc-stack (nthcdr n calc-stack)) (delete-region (point) (point-max)))) (calc-set-command-flag 'renum-stack))))) ) (defun calc-get-stack-element (x) (cond ((eq sel-mode 'entry) x) ((eq sel-mode 'sel) (nth 2 x)) ((or (null (nth 2 x)) (eq sel-mode 'full) (not calc-use-selections)) (car x)) (sel-mode (calc-sel-error)) (t (nth 2 x))) ) ;; Get the Nth element of the stack (N=1 is the top element). (defun calc-top (&optional n sel-mode) (or n (setq n 1)) (calc-check-stack n) (calc-get-stack-element (nth (+ n calc-stack-top -1) calc-stack)) ) (defun calc-top-n (&optional n sel-mode) ; in case precision has changed (math-check-complete (calc-normalize (calc-top n sel-mode))) ) (defun calc-top-list (&optional n m sel-mode) (or n (setq n 1)) (or m (setq m 1)) (calc-check-stack (+ n m -1)) (and (> n 0) (let ((top (copy-sequence (nthcdr (+ m calc-stack-top -1) calc-stack)))) (setcdr (nthcdr (1- n) top) nil) (nreverse (mapcar 'calc-get-stack-element top)))) ) (defun calc-top-list-n (&optional n m sel-mode) (mapcar 'math-check-complete (mapcar 'calc-normalize (calc-top-list n m sel-mode))) ) (defun calc-renumber-stack () (if calc-line-numbering (save-excursion (calc-cursor-stack-index 0) (let ((lnum 1) (buffer-read-only nil) (stack (nthcdr calc-stack-top calc-stack))) (if (re-search-forward "^[0-9]+[:*]" nil t) (progn (beginning-of-line) (while (re-search-forward "^[0-9]+[:*]" nil t) (let ((buffer-read-only nil)) (beginning-of-line) (delete-char 4) (insert " "))) (calc-cursor-stack-index 0))) (while (re-search-backward "^[0-9]+[:*]" nil t) (delete-char 4) (if (> lnum 999) (insert (format "%03d%s" (% lnum 1000) (if (and (nth 2 (car stack)) calc-use-selections) "*" ":"))) (let ((prefix (int-to-string lnum))) (insert prefix (if (and (nth 2 (car stack)) calc-use-selections) "*" ":") (make-string (- 3 (length prefix)) 32)))) (beginning-of-line) (setq lnum (1+ lnum) stack (cdr stack)))))) (and calc-embedded-info (calc-embedded-stack-change)) ) (defun calc-refresh (&optional align) (interactive) (and (eq major-mode 'calc-mode) (not calc-executing-macro) (let* ((buffer-read-only nil) (save-point (point)) (save-mark (condition-case err (mark) (error nil))) (save-aligned (looking-at "\\.$")) (thing calc-stack)) (setq calc-any-selections nil calc-any-evaltos nil) (erase-buffer) (insert "--- Emacs Calculator Mode ---\n") (while thing (goto-char (point-min)) (forward-line 1) (insert (math-format-stack-value (car thing)) "\n") (setq thing (cdr thing))) (calc-renumber-stack) (if calc-display-dirty (calc-wrapper (setq calc-display-dirty nil))) (and calc-any-evaltos calc-auto-recompute (calc-wrapper (calc-refresh-evaltos))) (if (or align save-aligned) (calc-align-stack-window) (goto-char save-point)) (if save-mark (set-mark save-mark)))) (and calc-embedded-info (not (eq major-mode 'calc-mode)) (save-excursion (set-buffer (aref calc-embedded-info 1)) (calc-refresh align))) (setq calc-refresh-count (1+ calc-refresh-count)) ) (defun calc-x-paste-text (arg) "Move point to mouse position and insert window system cut buffer contents. If mouse is pressed in Calc window, push cut buffer contents onto the stack." (x-mouse-select arg) (if (memq major-mode '(calc-mode calc-trail-mode)) (progn (calc-wrapper (calc-extensions) (let* ((buf (x-get-cut-buffer)) (val (math-read-exprs (calc-clean-newlines buf)))) (if (eq (car-safe val) 'error) (progn (setq val (math-read-exprs buf)) (if (eq (car-safe val) 'error) (error "%s in yanked data" (nth 2 val))))) (calc-enter-result 0 "Xynk" val)))) (x-paste-text arg)) ) ;;;; The Calc Trail buffer. (defun calc-check-trail-aligned () (save-excursion (let ((win (get-buffer-window (current-buffer)))) (and win (pos-visible-in-window-p (1- (point-max)) win)))) ) (defun calc-trail-buffer () (and (or (null calc-trail-buffer) (null (buffer-name calc-trail-buffer))) (save-excursion (setq calc-trail-buffer (get-buffer-create "*Calc Trail*")) (let ((buf (or (and (not (eq major-mode 'calc-mode)) (get-buffer "*Calculator*")) (current-buffer)))) (set-buffer calc-trail-buffer) (or (eq major-mode 'calc-trail-mode) (calc-trail-mode buf))))) (or (and calc-trail-pointer (eq (marker-buffer calc-trail-pointer) calc-trail-buffer)) (save-excursion (set-buffer calc-trail-buffer) (goto-line 2) (setq calc-trail-pointer (point-marker)))) calc-trail-buffer ) (defun calc-record (val &optional prefix) (setq calc-aborted-prefix nil) (or calc-executing-macro (let* ((mainbuf (current-buffer)) (buf (calc-trail-buffer)) (calc-display-raw nil) (calc-can-abbrev-vectors t) (fval (if val (if (stringp val) val (math-showing-full-precision (math-format-flat-expr val 0))) ""))) (save-excursion (set-buffer buf) (let ((aligned (calc-check-trail-aligned)) (buffer-read-only nil)) (goto-char (point-max)) (cond ((null prefix) (insert " ")) ((and (> (length prefix) 4) (string-match " " prefix 4)) (insert (substring prefix 0 4) " ")) (t (insert (format "%4s " prefix)))) (insert fval "\n") (let ((win (get-buffer-window buf))) (if (and aligned win (not (memq 'hold-trail calc-command-flags))) (calc-trail-here)) (goto-char (1- (point-max)))))))) val ) (defun calc-trail-display (flag &optional no-refresh) (interactive "P") (let ((win (get-buffer-window (calc-trail-buffer)))) (if (setq calc-display-trail (not (if flag (memq flag '(nil 0)) win))) (if (null win) (progn (if (and (boundp 'calc-trail-window-hook) calc-trail-window-hook) (run-hooks 'calc-trail-window-hook) (let ((w (split-window nil (/ (* (window-width) 2) 3) t))) (set-window-buffer w calc-trail-buffer))) (calc-wrapper (setq overlay-arrow-string calc-trail-overlay overlay-arrow-position calc-trail-pointer) (or no-refresh (if (interactive-p) (calc-do-refresh) (calc-refresh)))))) (if win (progn (delete-window win) (calc-wrapper (or no-refresh (if (interactive-p) (calc-do-refresh) (calc-refresh)))))))) calc-trail-buffer ) (defun calc-trail-here () (interactive) (if (eq major-mode 'calc-trail-mode) (progn (beginning-of-line) (if (bobp) (forward-line 1) (if (eobp) (forward-line -1))) (if (or (bobp) (eobp)) (setq overlay-arrow-position nil) ; trail is empty (set-marker calc-trail-pointer (point) (current-buffer)) (setq calc-trail-overlay (concat (buffer-substring (point) (+ (point) 4)) ">") overlay-arrow-string calc-trail-overlay overlay-arrow-position calc-trail-pointer) (forward-char 4) (let ((win (get-buffer-window (current-buffer)))) (if win (save-excursion (forward-line (/ (window-height win) 2)) (forward-line (- 1 (window-height win))) (set-window-start win (point)) (set-window-point win (+ calc-trail-pointer 4)) (set-buffer calc-main-buffer) (setq overlay-arrow-string calc-trail-overlay overlay-arrow-position calc-trail-pointer)))))) (error "Not in Calc Trail buffer")) ) ;;;; The Undo list. (defun calc-record-undo (rec) (or calc-executing-macro (if (memq 'undo calc-command-flags) (setq calc-undo-list (cons (cons rec (car calc-undo-list)) (cdr calc-undo-list))) (setq calc-undo-list (cons (list rec) calc-undo-list) calc-redo-list nil) (calc-set-command-flag 'undo))) ) ;;; Arithmetic commands. (defun calc-binary-op (name func arg &optional ident unary func2) (setq calc-aborted-prefix name) (if (null arg) (calc-enter-result 2 name (cons (or func2 func) (mapcar 'math-check-complete (calc-top-list 2)))) (calc-extensions) (calc-binary-op-fancy name func arg ident unary)) ) (defun calc-unary-op (name func arg &optional func2) (setq calc-aborted-prefix name) (if (null arg) (calc-enter-result 1 name (list (or func2 func) (math-check-complete (calc-top 1)))) (calc-extensions) (calc-unary-op-fancy name func arg)) ) (defun calc-plus (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "+" 'calcFunc-add arg 0 nil '+)) ) (defun calc-minus (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "-" 'calcFunc-sub arg 0 'neg '-)) ) (defun calc-times (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "*" 'calcFunc-mul arg 1 nil '*)) ) (defun calc-divide (arg) (interactive "P") (calc-slow-wrapper (calc-binary-op "/" 'calcFunc-div arg 0 'calcFunc-inv '/)) ) (defun calc-change-sign (arg) (interactive "P") (calc-wrapper (calc-unary-op "chs" 'neg arg)) ) ;;; Stack management commands. (defun calc-enter (n) (interactive "p") (calc-wrapper (cond ((< n 0) (calc-push-list (calc-top-list 1 (- n)))) ((= n 0) (calc-push-list (calc-top-list (calc-stack-size)))) (t (calc-push-list (calc-top-list n))))) ) (defun calc-pop (n) (interactive "P") (calc-wrapper (let* ((nn (prefix-numeric-value n)) (top (and (null n) (calc-top 1)))) (cond ((and (null n) (eq (car-safe top) 'incomplete) (> (length top) (if (eq (nth 1 top) 'intv) 3 2))) (calc-pop-push-list 1 (let ((tt (copy-sequence top))) (setcdr (nthcdr (- (length tt) 2) tt) nil) (list tt)))) ((< nn 0) (if (and calc-any-selections (calc-top-selected 1 (- nn))) (calc-delete-selection (- nn)) (calc-pop-stack 1 (- nn) t))) ((= nn 0) (calc-pop-stack (calc-stack-size) 1 t)) (t (if (and calc-any-selections (= nn 1) (calc-top-selected 1 1)) (calc-delete-selection 1) (calc-pop-stack nn)))))) ) ;;;; Reading a number using the minibuffer. (defun calcDigit-start () (interactive) (calc-wrapper (if (or calc-algebraic-mode (and (> calc-number-radix 14) (eq last-command-char ?e))) (calc-alg-digit-entry) (calc-unread-command) (setq calc-aborted-prefix nil) (let* ((calc-digit-value nil) (calc-prev-char nil) (calc-prev-prev-char nil) (calc-buffer (current-buffer)) (buf (if calc-emacs-type-lucid (catch 'calc-foo (catch 'execute-kbd-macro (throw 'calc-foo (read-from-minibuffer "Calc: " "" calc-digit-map))) (error "Lucid Emacs requires RET after %s" "digit entry in kbd macro")) (let ((old-esc (lookup-key global-map "\e"))) (unwind-protect (progn (define-key global-map "\e" nil) (read-from-minibuffer "Calc: " "" calc-digit-map)) (define-key global-map "\e" old-esc)))))) (or calc-digit-value (setq calc-digit-value (math-read-number buf))) (if (stringp calc-digit-value) (calc-alg-entry calc-digit-value) (if calc-digit-value (calc-push-list (list (calc-record (calc-normalize calc-digit-value)))))) (if (eq calc-prev-char 'dots) (progn (calc-extensions) (calc-dots)))))) ) (defun calcDigit-nondigit () (interactive) ;; Exercise for the reader: Figure out why this is a good precaution! (or (boundp 'calc-buffer) (use-local-map minibuffer-local-map)) (let ((str (buffer-string))) (setq calc-digit-value (save-excursion (set-buffer calc-buffer) (math-read-number str)))) (if (and (null calc-digit-value) (> (buffer-size) 0)) (progn (beep) (calc-temp-minibuffer-message " [Bad format]")) (or (memq last-command-char '(32 13)) (progn (setq prefix-arg current-prefix-arg) (calc-unread-command (if (and (eq last-command-char 27) (>= last-input-char 128)) last-input-char nil)))) (exit-minibuffer)) ) (defun calc-minibuffer-contains (rex) (save-excursion (goto-char (point-min)) (looking-at rex)) ) (defun calcDigit-key () (interactive) (goto-char (point-max)) (if (or (and (memq last-command-char '(?+ ?-)) (> (buffer-size) 0) (/= (preceding-char) ?e)) (and (memq last-command-char '(?m ?s)) (not (calc-minibuffer-contains "[-+]?[0-9]+\\.?0*[@oh].*")) (not (calc-minibuffer-contains "[-+]?\\(1[1-9]\\|[2-9][0-9]\\)#.*")))) (calcDigit-nondigit) (if (calc-minibuffer-contains "\\([-+]?\\|.* \\)\\'") (cond ((memq last-command-char '(?. ?@)) (insert "0")) ((and (memq last-command-char '(?o ?h ?m)) (not (calc-minibuffer-contains ".*#.*"))) (insert "0")) ((memq last-command-char '(?: ?e)) (insert "1")) ((eq last-command-char ?#) (insert (int-to-string calc-number-radix))))) (if (and (calc-minibuffer-contains "\\([-+]?[0-9]+#\\|[^:]*:\\)\\'") (eq last-command-char ?:)) (insert "1")) (if (and (calc-minibuffer-contains "[-+]?[0-9]+#\\'") (eq last-command-char ?.)) (insert "0")) (if (and (calc-minibuffer-contains "[-+]?0*\\([2-9]\\|1[0-4]\\)#\\'") (eq last-command-char ?e)) (insert "1")) (if (or (and (memq last-command-char '(?h ?o ?m ?s ?p)) (calc-minibuffer-contains ".*#.*")) (and (eq last-command-char ?e) (calc-minibuffer-contains "[-+]?\\(1[5-9]\\|[2-9][0-9]\\)#.*")) (and (eq last-command-char ?n) (calc-minibuffer-contains "[-+]?\\(2[4-9]\\|[3-9][0-9]\\)#.*"))) (setq last-command-char (upcase last-command-char))) (cond ((memq last-command-char '(?_ ?n)) (goto-char (point-min)) (if (and (search-forward " +/- " nil t) (not (search-forward "e" nil t))) (beep) (and (not (calc-minibuffer-contains "[-+]?\\(1[5-9]\\|[2-9][0-9]\\)#.*")) (search-forward "e" nil t)) (if (looking-at "+") (delete-char 1)) (if (looking-at "-") (delete-char 1) (insert "-"))) (goto-char (point-max))) ((eq last-command-char ?p) (if (or (calc-minibuffer-contains ".*\\+/-.*") (calc-minibuffer-contains ".*mod.*") (calc-minibuffer-contains ".*#.*") (calc-minibuffer-contains ".*[-+e:]\\'")) (beep) (if (not (calc-minibuffer-contains ".* \\'")) (insert " ")) (insert "+/- "))) ((and (eq last-command-char ?M) (not (calc-minibuffer-contains "[-+]?\\(2[3-9]\\|[3-9][0-9]\\)#.*"))) (if (or (calc-minibuffer-contains ".*\\+/-.*") (calc-minibuffer-contains ".*mod *[^ ]+") (calc-minibuffer-contains ".*[-+e:]\\'")) (beep) (if (calc-minibuffer-contains ".*mod \\'") (if calc-previous-modulo (insert (math-format-flat-expr calc-previous-modulo 0)) (beep)) (if (not (calc-minibuffer-contains ".* \\'")) (insert " ")) (insert "mod ")))) (t (insert (char-to-string last-command-char)) (if (or (and (calc-minibuffer-contains "[-+]?\\(.*\\+/- *\\|.*mod *\\)?\\([0-9][0-9]?\\)#[0-9a-zA-Z]*\\(:[0-9a-zA-Z]*\\(:[0-9a-zA-Z]*\\)?\\|.[0-9a-zA-Z]*\\(e[-+]?[0-9]*\\)?\\)?\\'") (let ((radix (string-to-int (buffer-substring (match-beginning 2) (match-end 2))))) (and (>= radix 2) (<= radix 36) (or (memq last-command-char '(?# ?: ?. ?e ?+ ?-)) (let ((dig (math-read-radix-digit (upcase last-command-char)))) (and dig (< dig radix))))))) (save-excursion (goto-char (point-min)) (looking-at "[-+]?\\(.*\\+/- *\\|.*mod *\\)?\\([0-9]+\\.?0*[@oh] *\\)?\\([0-9]+\\.?0*['m] *\\)?[0-9]*\\(\\.?[0-9]*\\(e[-+]?[0-3]?[0-9]?[0-9]?[0-9]?[0-9]?[0-9]?[0-9]?\\)?\\|[0-9]:\\([0-9]+:\\)?[0-9]*\\)?[\"s]?\\'"))) (if (and (memq last-command-char '(?@ ?o ?h ?\' ?m)) (string-match " " calc-hms-format)) (insert " ")) (if (and (eq this-command last-command) (eq last-command-char ?.)) (progn (calc-extensions) (calc-digit-dots)) (delete-backward-char 1) (beep) (calc-temp-minibuffer-message " [Bad format]")))))) (setq calc-prev-prev-char calc-prev-char calc-prev-char last-command-char) ) (defun calcDigit-backspace () (interactive) (goto-char (point-max)) (cond ((calc-minibuffer-contains ".* \\+/- \\'") (backward-delete-char 5)) ((calc-minibuffer-contains ".* mod \\'") (backward-delete-char 5)) ((calc-minibuffer-contains ".* \\'") (backward-delete-char 2)) ((eq last-command 'calcDigit-start) (erase-buffer)) (t (backward-delete-char 1))) (if (= (buffer-size) 0) (progn (setq last-command-char 13) (calcDigit-nondigit))) ) ;;;; Arithmetic routines. ;;; ;;; An object as manipulated by one of these routines may take any of the ;;; following forms: ;;; ;;; integer An integer. For normalized numbers, this format ;;; is used only for -999999 ... 999999. ;;; ;;; (bigpos N0 N1 N2 ...) A big positive integer, N0 + N1*1000 + N2*10^6 ... ;;; (bigneg N0 N1 N2 ...) A big negative integer, - N0 - N1*1000 ... ;;; Each digit N is in the range 0 ... 999. ;;; Normalized, always at least three N present, ;;; and the most significant N is nonzero. ;;; ;;; (frac NUM DEN) A fraction. NUM and DEN are small or big integers. ;;; Normalized, DEN > 1. ;;; ;;; (float NUM EXP) A floating-point number, NUM * 10^EXP; ;;; NUM is a small or big integer, EXP is a small int. ;;; Normalized, NUM is not a multiple of 10, and ;;; abs(NUM) < 10^calc-internal-prec. ;;; Normalized zero is stored as (float 0 0). ;;; ;;; (cplx REAL IMAG) A complex number; REAL and IMAG are any of above. ;;; Normalized, IMAG is nonzero. ;;; ;;; (polar R THETA) Polar complex number. Normalized, R > 0 and THETA ;;; is neither zero nor 180 degrees (pi radians). ;;; ;;; (vec A B C ...) Vector of objects A, B, C, ... A matrix is a ;;; vector of vectors. ;;; ;;; (hms H M S) Angle in hours-minutes-seconds form. All three ;;; components have the same sign; H and M must be ;;; numerically integers; M and S are expected to ;;; lie in the range [0,60). ;;; ;;; (date N) A date or date/time object. N is an integer to ;;; store a date only, or a fraction or float to ;;; store a date and time. ;;; ;;; (sdev X SIGMA) Error form, X +/- SIGMA. When normalized, ;;; SIGMA > 0. X is any complex number and SIGMA ;;; is real numbers; or these may be symbolic ;;; expressions where SIGMA is assumed real. ;;; ;;; (intv MASK LO HI) Interval form. MASK is 0=(), 1=(], 2=[), or 3=[]. ;;; LO and HI are any real numbers, or symbolic ;;; expressions which are assumed real, and LO < HI. ;;; For [LO..HI], if LO = HI normalization produces LO, ;;; and if LO > HI normalization produces [LO..LO). ;;; For other intervals, if LO > HI normalization ;;; sets HI equal to LO. ;;; ;;; (mod N M) Number modulo M. When normalized, 0 <= N < M. ;;; N and M are real numbers. ;;; ;;; (var V S) Symbolic variable. V is a Lisp symbol which ;;; represents the variable's visible name. S is ;;; the symbol which actually stores the variable's ;;; value: (var pi var-pi). ;;; ;;; In general, combining rational numbers in a calculation always produces ;;; a rational result, but if either argument is a float, result is a float. ;;; In the following comments, [x y z] means result is x, args must be y, z, ;;; respectively, where the code letters are: ;;; ;;; O Normalized object (vector or number) ;;; V Normalized vector ;;; N Normalized number of any type ;;; N Normalized complex number ;;; R Normalized real number (float or rational) ;;; F Normalized floating-point number ;;; T Normalized rational number ;;; I Normalized integer ;;; B Normalized big integer ;;; S Normalized small integer ;;; D Digit (small integer, 0..999) ;;; L Normalized bignum digit list (without "bigpos" or "bigneg" symbol) ;;; or normalized vector element list (without "vec") ;;; P Predicate (truth value) ;;; X Any Lisp object ;;; Z "nil" ;;; ;;; Lower-case letters signify possibly un-normalized values. ;;; "L.D" means a cons of an L and a D. ;;; [N N; n n] means result will be normalized if argument is. ;;; Also, [Public] marks routines intended to be called from outside. ;;; [This notation has been neglected in many recent routines.] ;;; Reduce an object to canonical (normalized) form. [O o; Z Z] [Public] (defun math-normalize (a) (cond ((not (consp a)) (if (integerp a) (if (or (>= a 1000000) (<= a -1000000)) (math-bignum a) a) a)) ((eq (car a) 'bigpos) (if (eq (nth (1- (length a)) a) 0) (let* ((last (setq a (copy-sequence a))) (digs a)) (while (setq digs (cdr digs)) (or (eq (car digs) 0) (setq last digs))) (setcdr last nil))) (if (cdr (cdr (cdr a))) a (cond ((cdr (cdr a)) (+ (nth 1 a) (* (nth 2 a) 1000))) ((cdr a) (nth 1 a)) (t 0)))) ((eq (car a) 'bigneg) (if (eq (nth (1- (length a)) a) 0) (let* ((last (setq a (copy-sequence a))) (digs a)) (while (setq digs (cdr digs)) (or (eq (car digs) 0) (setq last digs))) (setcdr last nil))) (if (cdr (cdr (cdr a))) a (cond ((cdr (cdr a)) (- (+ (nth 1 a) (* (nth 2 a) 1000)))) ((cdr a) (- (nth 1 a))) (t 0)))) ((eq (car a) 'float) (math-make-float (math-normalize (nth 1 a)) (nth 2 a))) ((or (memq (car a) '(frac cplx polar hms date mod sdev intv vec var quote special-const calcFunc-if calcFunc-lambda calcFunc-quote calcFunc-condition calcFunc-evalto)) (integerp (car a)) (and (consp (car a)) (not (eq (car (car a)) 'lambda)))) (calc-extensions) (math-normalize-fancy a)) (t (or (and calc-simplify-mode (calc-extensions) (math-normalize-nonstandard)) (let ((args (mapcar 'math-normalize (cdr a)))) (or (condition-case err (let ((func (assq (car a) '( ( + . math-add ) ( - . math-sub ) ( * . math-mul ) ( / . math-div ) ( % . math-mod ) ( ^ . math-pow ) ( neg . math-neg ) ( | . math-concat ) )))) (or (and var-EvalRules (progn (or (eq var-EvalRules math-eval-rules-cache-tag) (progn (calc-extensions) (math-recompile-eval-rules))) (and (or math-eval-rules-cache-other (assq (car a) math-eval-rules-cache)) (math-apply-rewrites (cons (car a) args) (cdr math-eval-rules-cache) nil math-eval-rules-cache)))) (if func (apply (cdr func) args) (and (or (consp (car a)) (fboundp (car a)) (and (not calc-extensions-loaded) (calc-extensions) (fboundp (car a)))) (apply (car a) args))))) (wrong-number-of-arguments (calc-record-why "*Wrong number of arguments" (cons (car a) args)) nil) (wrong-type-argument (or calc-next-why (calc-record-why "Wrong type of argument" (cons (car a) args))) nil) (args-out-of-range (calc-record-why "*Argument out of range" (cons (car a) args)) nil) (inexact-result (calc-record-why "No exact representation for result" (cons (car a) args)) nil) (math-overflow (calc-record-why "*Floating-point overflow occurred" (cons (car a) args)) nil) (math-underflow (calc-record-why "*Floating-point underflow occurred" (cons (car a) args)) nil) (void-variable (if (eq (nth 1 err) 'var-EvalRules) (progn (setq var-EvalRules nil) (math-normalize (cons (car a) args))) (calc-record-why "*Variable is void" (nth 1 err))))) (if (consp (car a)) (math-dimension-error) (cons (car a) args))))))) ) ;;; True if A is a floating-point real or complex number. [P x] [Public] (defun math-floatp (a) (cond ((eq (car-safe a) 'float) t) ((memq (car-safe a) '(cplx polar mod sdev intv)) (or (math-floatp (nth 1 a)) (math-floatp (nth 2 a)) (and (eq (car a) 'intv) (math-floatp (nth 3 a))))) ((eq (car-safe a) 'date) (math-floatp (nth 1 a)))) ) ;;; Verify that A is a complete object and return A. [x x] [Public] (defun math-check-complete (a) (cond ((integerp a) a) ((eq (car-safe a) 'incomplete) (calc-incomplete-error a)) ((consp a) a) (t (error "Invalid data object encountered"))) ) ;;; Coerce integer A to be a bignum. [B S] (defun math-bignum (a) (if (>= a 0) (cons 'bigpos (math-bignum-big a)) (cons 'bigneg (math-bignum-big (- a)))) ) (defun math-bignum-big (a) ; [L s] (if (= a 0) nil (cons (% a 1000) (math-bignum-big (/ a 1000)))) ) ;;; Build a normalized floating-point number. [F I S] (defun math-make-float (mant exp) (if (eq mant 0) '(float 0 0) (let* ((ldiff (- calc-internal-prec (math-numdigs mant)))) (if (< ldiff 0) (setq mant (math-scale-rounding mant ldiff) exp (- exp ldiff)))) (if (consp mant) (let ((digs (cdr mant))) (if (= (% (car digs) 10) 0) (progn (while (= (car digs) 0) (setq digs (cdr digs) exp (+ exp 3))) (while (= (% (car digs) 10) 0) (setq digs (math-div10-bignum digs) exp (1+ exp))) (setq mant (math-normalize (cons (car mant) digs)))))) (while (= (% mant 10) 0) (setq mant (/ mant 10) exp (1+ exp)))) (if (and (<= exp -4000000) (<= (+ exp (math-numdigs mant) -1) -4000000)) (signal 'math-underflow nil) (if (and (>= exp 3000000) (>= (+ exp (math-numdigs mant) -1) 4000000)) (signal 'math-overflow nil) (list 'float mant exp)))) ) (defun math-div10-bignum (a) ; [l l] (if (cdr a) (cons (+ (/ (car a) 10) (* (% (nth 1 a) 10) 100)) (math-div10-bignum (cdr a))) (list (/ (car a) 10))) ) ;;; Coerce A to be a float. [F N; V V] [Public] (defun math-float (a) (cond ((Math-integerp a) (math-make-float a 0)) ((eq (car a) 'frac) (math-div (math-float (nth 1 a)) (nth 2 a))) ((eq (car a) 'float) a) ((memq (car a) '(cplx polar vec hms date sdev mod)) (cons (car a) (mapcar 'math-float (cdr a)))) (t (math-float-fancy a))) ) (defun math-neg (a) (cond ((not (consp a)) (- a)) ((eq (car a) 'bigpos) (cons 'bigneg (cdr a))) ((eq (car a) 'bigneg) (cons 'bigpos (cdr a))) ((memq (car a) '(frac float)) (list (car a) (Math-integer-neg (nth 1 a)) (nth 2 a))) ((memq (car a) '(cplx vec hms date calcFunc-idn)) (cons (car a) (mapcar 'math-neg (cdr a)))) (t (math-neg-fancy a))) ) ;;; Compute the number of decimal digits in integer A. [S I] (defun math-numdigs (a) (if (consp a) (if (cdr a) (let* ((len (1- (length a))) (top (nth len a))) (+ (* len 3) (cond ((>= top 100) 0) ((>= top 10) -1) (t -2)))) 0) (cond ((>= a 100) (+ (math-numdigs (/ a 1000)) 3)) ((>= a 10) 2) ((>= a 1) 1) ((= a 0) 0) ((> a -10) 1) ((> a -100) 2) (t (math-numdigs (- a))))) ) ;;; Multiply (with truncation toward 0) the integer A by 10^N. [I i S] (defun math-scale-int (a n) (cond ((= n 0) a) ((> n 0) (math-scale-left a n)) (t (math-normalize (math-scale-right a (- n))))) ) (defun math-scale-left (a n) ; [I I S] (if (= n 0) a (if (consp a) (cons (car a) (math-scale-left-bignum (cdr a) n)) (if (>= n 3) (if (or (>= a 1000) (<= a -1000)) (math-scale-left (math-bignum a) n) (math-scale-left (* a 1000) (- n 3))) (if (= n 2) (if (or (>= a 10000) (<= a -10000)) (math-scale-left (math-bignum a) 2) (* a 100)) (if (or (>= a 100000) (<= a -100000)) (math-scale-left (math-bignum a) 1) (* a 10)))))) ) (defun math-scale-left-bignum (a n) (if (>= n 3) (while (>= (setq a (cons 0 a) n (- n 3)) 3))) (if (> n 0) (math-mul-bignum-digit a (if (= n 2) 100 10) 0) a) ) (defun math-scale-right (a n) ; [i i S] (if (= n 0) a (if (consp a) (cons (car a) (math-scale-right-bignum (cdr a) n)) (if (<= a 0) (if (= a 0) 0 (- (math-scale-right (- a) n))) (if (>= n 3) (while (and (> (setq a (/ a 1000)) 0) (>= (setq n (- n 3)) 3)))) (if (= n 2) (/ a 100) (if (= n 1) (/ a 10) a))))) ) (defun math-scale-right-bignum (a n) ; [L L S; l l S] (if (>= n 3) (setq a (nthcdr (/ n 3) a) n (% n 3))) (if (> n 0) (cdr (math-mul-bignum-digit a (if (= n 2) 10 100) 0)) a) ) ;;; Multiply (with rounding) the integer A by 10^N. [I i S] (defun math-scale-rounding (a n) (cond ((>= n 0) (math-scale-left a n)) ((consp a) (math-normalize (cons (car a) (let ((val (if (< n -3) (math-scale-right-bignum (cdr a) (- -3 n)) (if (= n -2) (math-mul-bignum-digit (cdr a) 10 0) (if (= n -1) (math-mul-bignum-digit (cdr a) 100 0) (cdr a)))))) ; n = -3 (if (and val (>= (car val) 500)) (if (cdr val) (if (eq (car (cdr val)) 999) (math-add-bignum (cdr val) '(1)) (cons (1+ (car (cdr val))) (cdr (cdr val)))) '(1)) (cdr val)))))) (t (if (< a 0) (- (math-scale-rounding (- a) n)) (if (= n -1) (/ (+ a 5) 10) (/ (+ (math-scale-right a (- -1 n)) 5) 10))))) ) ;;; Compute the sum of A and B. [O O O] [Public] (defun math-add (a b) (or (and (not (or (consp a) (consp b))) (progn (setq a (+ a b)) (if (or (<= a -1000000) (>= a 1000000)) (math-bignum a) a))) (and (Math-zerop a) (not (eq (car-safe a) 'mod)) (if (and (math-floatp a) (Math-ratp b)) (math-float b) b)) (and (Math-zerop b) (not (eq (car-safe b) 'mod)) (if (and (math-floatp b) (Math-ratp a)) (math-float a) a)) (and (Math-objvecp a) (Math-objvecp b) (or (and (Math-integerp a) (Math-integerp b) (progn (or (consp a) (setq a (math-bignum a))) (or (consp b) (setq b (math-bignum b))) (if (eq (car a) 'bigneg) (if (eq (car b) 'bigneg) (cons 'bigneg (math-add-bignum (cdr a) (cdr b))) (math-normalize (let ((diff (math-sub-bignum (cdr b) (cdr a)))) (if (eq diff 'neg) (cons 'bigneg (math-sub-bignum (cdr a) (cdr b))) (cons 'bigpos diff))))) (if (eq (car b) 'bigneg) (math-normalize (let ((diff (math-sub-bignum (cdr a) (cdr b)))) (if (eq diff 'neg) (cons 'bigneg (math-sub-bignum (cdr b) (cdr a))) (cons 'bigpos diff)))) (cons 'bigpos (math-add-bignum (cdr a) (cdr b))))))) (and (Math-ratp a) (Math-ratp b) (calc-extensions) (calc-add-fractions a b)) (and (Math-realp a) (Math-realp b) (progn (or (and (consp a) (eq (car a) 'float)) (setq a (math-float a))) (or (and (consp b) (eq (car b) 'float)) (setq b (math-float b))) (math-add-float a b))) (and (calc-extensions) (math-add-objects-fancy a b)))) (and (calc-extensions) (math-add-symb-fancy a b))) ) (defun math-add-bignum (a b) ; [L L L; l l l] (if a (if b (let* ((a (copy-sequence a)) (aa a) (carry nil) sum) (while (and aa b) (if carry (if (< (setq sum (+ (car aa) (car b))) 999) (progn (setcar aa (1+ sum)) (setq carry nil)) (setcar aa (+ sum -999))) (if (< (setq sum (+ (car aa) (car b))) 1000) (setcar aa sum) (setcar aa (+ sum -1000)) (setq carry t))) (setq aa (cdr aa) b (cdr b))) (if carry (if b (nconc a (math-add-bignum b '(1))) (while (eq (car aa) 999) (setcar aa 0) (setq aa (cdr aa))) (if aa (progn (setcar aa (1+ (car aa))) a) (nconc a '(1)))) (if b (nconc a b) a))) a) b) ) (defun math-sub-bignum (a b) ; [l l l] (if b (if a (let* ((a (copy-sequence a)) (aa a) (borrow nil) sum) (while (and aa b) (if borrow (if (>= (setq diff (- (car aa) (car b))) 1) (progn (setcar aa (1- diff)) (setq borrow nil)) (setcar aa (+ diff 999))) (if (>= (setq diff (- (car aa) (car b))) 0) (setcar aa diff) (setcar aa (+ diff 1000)) (setq borrow t))) (setq aa (cdr aa) b (cdr b))) (if borrow (progn (while (eq (car aa) 0) (setcar aa 999) (setq aa (cdr aa))) (if aa (progn (setcar aa (1- (car aa))) a) 'neg)) (while (eq (car b) 0) (setq b (cdr b))) (if b 'neg a))) (while (eq (car b) 0) (setq b (cdr b))) (and b 'neg)) a) ) (defun math-add-float (a b) ; [F F F] (let ((ediff (- (nth 2 a) (nth 2 b)))) (if (>= ediff 0) (if (>= ediff (+ calc-internal-prec calc-internal-prec)) a (math-make-float (math-add (nth 1 b) (if (eq ediff 0) (nth 1 a) (math-scale-left (nth 1 a) ediff))) (nth 2 b))) (if (>= (setq ediff (- ediff)) (+ calc-internal-prec calc-internal-prec)) b (math-make-float (math-add (nth 1 a) (math-scale-left (nth 1 b) ediff)) (nth 2 a))))) ) ;;; Compute the difference of A and B. [O O O] [Public] (defun math-sub (a b) (if (or (consp a) (consp b)) (math-add a (math-neg b)) (setq a (- a b)) (if (or (<= a -1000000) (>= a 1000000)) (math-bignum a) a)) ) (defun math-sub-float (a b) ; [F F F] (let ((ediff (- (nth 2 a) (nth 2 b)))) (if (>= ediff 0) (if (>= ediff (+ calc-internal-prec calc-internal-prec)) a (math-make-float (math-add (Math-integer-neg (nth 1 b)) (if (eq ediff 0) (nth 1 a) (math-scale-left (nth 1 a) ediff))) (nth 2 b))) (if (>= (setq ediff (- ediff)) (+ calc-internal-prec calc-internal-prec)) b (math-make-float (math-add (nth 1 a) (Math-integer-neg (math-scale-left (nth 1 b) ediff))) (nth 2 a))))) ) ;;; Compute the product of A and B. [O O O] [Public] (defun math-mul (a b) (or (and (not (consp a)) (not (consp b)) (< a 1000) (> a -1000) (< b 1000) (> b -1000) (* a b)) (and (Math-zerop a) (not (eq (car-safe b) 'mod)) (if (Math-scalarp b) (if (and (math-floatp b) (Math-ratp a)) (math-float a) a) (calc-extensions) (math-mul-zero a b))) (and (Math-zerop b) (not (eq (car-safe a) 'mod)) (if (Math-scalarp a) (if (and (math-floatp a) (Math-ratp b)) (math-float b) b) (calc-extensions) (math-mul-zero b a))) (and (Math-objvecp a) (Math-objvecp b) (or (and (Math-integerp a) (Math-integerp b) (progn (or (consp a) (setq a (math-bignum a))) (or (consp b) (setq b (math-bignum b))) (math-normalize (cons (if (eq (car a) (car b)) 'bigpos 'bigneg) (if (cdr (cdr a)) (if (cdr (cdr b)) (math-mul-bignum (cdr a) (cdr b)) (math-mul-bignum-digit (cdr a) (nth 1 b) 0)) (math-mul-bignum-digit (cdr b) (nth 1 a) 0)))))) (and (Math-ratp a) (Math-ratp b) (calc-extensions) (calc-mul-fractions a b)) (and (Math-realp a) (Math-realp b) (progn (or (and (consp a) (eq (car a) 'float)) (setq a (math-float a))) (or (and (consp b) (eq (car b) 'float)) (setq b (math-float b))) (math-make-float (math-mul (nth 1 a) (nth 1 b)) (+ (nth 2 a) (nth 2 b))))) (and (calc-extensions) (math-mul-objects-fancy a b)))) (and (calc-extensions) (math-mul-symb-fancy a b))) ) (defun math-infinitep (a &optional undir) (while (and (consp a) (memq (car a) '(* / neg))) (if (or (not (eq (car a) '*)) (math-infinitep (nth 1 a))) (setq a (nth 1 a)) (setq a (nth 2 a)))) (and (consp a) (eq (car a) 'var) (memq (nth 2 a) '(var-inf var-uinf var-nan)) (if (and undir (eq (nth 2 a) 'var-inf)) '(var uinf var-uinf) a)) ) ;;; Multiply digit lists A and B. [L L L; l l l] (defun math-mul-bignum (a b) (and a b (let* ((sum (if (<= (car b) 1) (if (= (car b) 0) (list 0) (copy-sequence a)) (math-mul-bignum-digit a (car b) 0))) (sump sum) c d aa ss prod) (while (setq b (cdr b)) (setq ss (setq sump (or (cdr sump) (setcdr sump (list 0)))) d (car b) c 0 aa a) (while (progn (setcar ss (% (setq prod (+ (+ (car ss) (* (car aa) d)) c)) 1000)) (setq aa (cdr aa))) (setq c (/ prod 1000) ss (or (cdr ss) (setcdr ss (list 0))))) (if (>= prod 1000) (if (cdr ss) (setcar (cdr ss) (+ (/ prod 1000) (car (cdr ss)))) (setcdr ss (list (/ prod 1000)))))) sum)) ) ;;; Multiply digit list A by digit D. [L L D D; l l D D] (defun math-mul-bignum-digit (a d c) (if a (if (<= d 1) (and (= d 1) a) (let* ((a (copy-sequence a)) (aa a) prod) (while (progn (setcar aa (% (setq prod (+ (* (car aa) d) c)) 1000)) (cdr aa)) (setq aa (cdr aa) c (/ prod 1000))) (if (>= prod 1000) (setcdr aa (list (/ prod 1000)))) a)) (and (> c 0) (list c))) ) ;;; Compute the integer (quotient . remainder) of A and B, which may be ;;; small or big integers. Type and consistency of truncation is undefined ;;; if A or B is negative. B must be nonzero. [I.I I I] [Public] (defun math-idivmod (a b) (if (eq b 0) (math-reject-arg a "*Division by zero")) (if (or (consp a) (consp b)) (if (and (natnump b) (< b 1000)) (let ((res (math-div-bignum-digit (cdr a) b))) (cons (math-normalize (cons (car a) (car res))) (cdr res))) (or (consp a) (setq a (math-bignum a))) (or (consp b) (setq b (math-bignum b))) (let ((res (math-div-bignum (cdr a) (cdr b)))) (cons (math-normalize (cons (if (eq (car a) (car b)) 'bigpos 'bigneg) (car res))) (math-normalize (cons (car a) (cdr res)))))) (cons (/ a b) (% a b))) ) (defun math-quotient (a b) ; [I I I] [Public] (if (and (not (consp a)) (not (consp b))) (if (= b 0) (math-reject-arg a "*Division by zero") (/ a b)) (if (and (natnump b) (< b 1000)) (if (= b 0) (math-reject-arg a "*Division by zero") (math-normalize (cons (car a) (car (math-div-bignum-digit (cdr a) b))))) (or (consp a) (setq a (math-bignum a))) (or (consp b) (setq b (math-bignum b))) (let* ((alen (1- (length a))) (blen (1- (length b))) (d (/ 1000 (1+ (nth (1- blen) (cdr b))))) (res (math-div-bignum-big (math-mul-bignum-digit (cdr a) d 0) (math-mul-bignum-digit (cdr b) d 0) alen blen))) (math-normalize (cons (if (eq (car a) (car b)) 'bigpos 'bigneg) (car res)))))) ) ;;; Divide a bignum digit list by another. [l.l l L] ;;; The following division algorithm is borrowed from Knuth vol. II, sec. 4.3.1 (defun math-div-bignum (a b) (if (cdr b) (let* ((alen (length a)) (blen (length b)) (d (/ 1000 (1+ (nth (1- blen) b)))) (res (math-div-bignum-big (math-mul-bignum-digit a d 0) (math-mul-bignum-digit b d 0) alen blen))) (if (= d 1) res (cons (car res) (car (math-div-bignum-digit (cdr res) d))))) (let ((res (math-div-bignum-digit a (car b)))) (cons (car res) (list (cdr res))))) ) ;;; Divide a bignum digit list by a digit. [l.D l D] (defun math-div-bignum-digit (a b) (if a (let* ((res (math-div-bignum-digit (cdr a) b)) (num (+ (* (cdr res) 1000) (car a)))) (cons (cons (/ num b) (car res)) (% num b))) '(nil . 0)) ) (defun math-div-bignum-big (a b alen blen) ; [l.l l L] (if (< alen blen) (cons nil a) (let* ((res (math-div-bignum-big (cdr a) b (1- alen) blen)) (num (cons (car a) (cdr res))) (res2 (math-div-bignum-part num b blen))) (cons (cons (car res2) (car res)) (cdr res2)))) ) (defun math-div-bignum-part (a b blen) ; a < b*1000 [D.l l L] (let* ((num (+ (* (or (nth blen a) 0) 1000) (or (nth (1- blen) a) 0))) (den (nth (1- blen) b)) (guess (min (/ num den) 999))) (math-div-bignum-try a b (math-mul-bignum-digit b guess 0) guess)) ) (defun math-div-bignum-try (a b c guess) ; [D.l l l D] (let ((rem (math-sub-bignum a c))) (if (eq rem 'neg) (math-div-bignum-try a b (math-sub-bignum c b) (1- guess)) (cons guess rem))) ) ;;; Compute the quotient of A and B. [O O N] [Public] (defun math-div (a b) (or (and (Math-zerop b) (calc-extensions) (math-div-by-zero a b)) (and (Math-zerop a) (not (eq (car-safe b) 'mod)) (if (Math-scalarp b) (if (and (math-floatp b) (Math-ratp a)) (math-float a) a) (calc-extensions) (math-div-zero a b))) (and (Math-objvecp a) (Math-objvecp b) (or (and (Math-integerp a) (Math-integerp b) (let ((q (math-idivmod a b))) (if (eq (cdr q) 0) (car q) (if calc-prefer-frac (progn (calc-extensions) (math-make-frac a b)) (math-div-float (math-make-float a 0) (math-make-float b 0)))))) (and (Math-ratp a) (Math-ratp b) (calc-extensions) (calc-div-fractions a b)) (and (Math-realp a) (Math-realp b) (progn (or (and (consp a) (eq (car a) 'float)) (setq a (math-float a))) (or (and (consp b) (eq (car b) 'float)) (setq b (math-float b))) (math-div-float a b))) (and (calc-extensions) (math-div-objects-fancy a b)))) (and (calc-extensions) (math-div-symb-fancy a b))) ) (defun math-div-float (a b) ; [F F F] (let ((ldiff (max (- (1+ calc-internal-prec) (- (math-numdigs (nth 1 a)) (math-numdigs (nth 1 b)))) 0))) (math-make-float (math-quotient (math-scale-int (nth 1 a) ldiff) (nth 1 b)) (- (- (nth 2 a) (nth 2 b)) ldiff))) ) ;;; Format the number A as a string. [X N; X Z] [Public] (defun math-format-stack-value (entry) (setq calc-selection-cache-entry calc-selection-cache-default-entry) (let* ((a (car entry)) (math-comp-selected (nth 2 entry)) (c (cond ((null a) "") ((eq calc-display-raw t) (format "%s" a)) ((stringp a) a) ((eq a 'top-of-stack) ".") (calc-prepared-composition calc-prepared-composition) ((and (Math-scalarp a) (memq calc-language '(nil flat unform)) (null math-comp-selected)) (math-format-number a)) (t (calc-extensions) (math-compose-expr a 0)))) (off (math-stack-value-offset c)) s w) (and math-comp-selected (setq calc-any-selections t)) (setq w (cdr off) off (car off)) (if (> off 0) (setq c (math-comp-concat (make-string off ? ) c))) (or (equal calc-left-label "") (setq c (math-comp-concat (if (eq a 'top-of-stack) (make-string (length calc-left-label) ? ) calc-left-label) c))) (if calc-line-numbering (setq c (math-comp-concat (if (eq calc-language 'big) (if math-comp-selected '(tag t "1: ") "1: ") " ") c))) (or (equal calc-right-label "") (eq a 'top-of-stack) (progn (calc-extensions) (setq c (list 'horiz c (make-string (max (- w (math-comp-width c) (length calc-right-label)) 0) ? ) '(break -1) calc-right-label)))) (setq s (if (stringp c) (if calc-display-raw (prin1-to-string c) c) (math-composition-to-string c w))) (if calc-language-output-filter (setq s (funcall calc-language-output-filter s))) (if (eq calc-language 'big) (setq s (concat s "\n")) (if calc-line-numbering (progn (aset s 0 ?1) (aset s 1 ?:)))) (setcar (cdr entry) (calc-count-lines s)) s) ) (defun math-stack-value-offset (c) (let* ((num (if calc-line-numbering 4 0)) (wid (calc-window-width)) off) (if calc-display-just (progn (calc-extensions) (math-stack-value-offset-fancy)) (setq off (or calc-display-origin 0)) (if (integerp calc-line-breaking) (setq wid calc-line-breaking))) (cons (max (- off (length calc-left-label)) 0) (+ wid num))) ) (defun calc-count-lines (s) (let ((pos 0) (num 1)) (while (setq newpos (string-match "\n" s pos)) (setq pos (1+ newpos) num (1+ num))) num) ) (defun math-format-value (a &optional w) (if (and (Math-scalarp a) (memq calc-language '(nil flat unform))) (math-format-number a) (calc-extensions) (let ((calc-line-breaking nil)) (math-composition-to-string (math-compose-expr a 0) w))) ) (defun calc-window-width () (if calc-embedded-info (let ((win (get-buffer-window (aref calc-embedded-info 0)))) (1- (if win (window-width win) (screen-width)))) (- (window-width (get-buffer-window (current-buffer))) (if calc-line-numbering 5 1))) ) (defun math-comp-concat (c1 c2) (if (and (stringp c1) (stringp c2)) (concat c1 c2) (list 'horiz c1 c2)) ) ;;; Format an expression as a one-line string suitable for re-reading. (defun math-format-flat-expr (a prec) (cond ((or (not (or (consp a) (integerp a))) (eq calc-display-raw t)) (let ((print-escape-newlines t)) (concat "'" (prin1-to-string a)))) ((Math-scalarp a) (let ((calc-group-digits nil) (calc-point-char ".") (calc-frac-format (if (> (length (car calc-frac-format)) 1) '("::" nil) '(":" nil))) (calc-complex-format nil) (calc-hms-format "%s@ %s' %s\"") (calc-language nil)) (math-format-number a))) (t (calc-extensions) (math-format-flat-expr-fancy a prec))) ) ;;; Format a number as a string. (defun math-format-number (a &optional prec) ; [X N] [Public] (cond ((eq calc-display-raw t) (format "%s" a)) ((and (nth 1 calc-frac-format) (Math-integerp a)) (calc-extensions) (math-format-number (math-adjust-fraction a))) ((integerp a) (if (not (or calc-group-digits calc-leading-zeros)) (if (= calc-number-radix 10) (int-to-string a) (if (< a 0) (concat "-" (math-format-number (- a))) (calc-extensions) (if math-radix-explicit-format (if calc-radix-formatter (funcall calc-radix-formatter calc-number-radix (if (= calc-number-radix 2) (math-format-binary a) (math-format-radix a))) (format "%d#%s" calc-number-radix (if (= calc-number-radix 2) (math-format-binary a) (math-format-radix a)))) (math-format-radix a)))) (math-format-number (math-bignum a)))) ((stringp a) a) ((not (consp a)) (prin1-to-string a)) ((eq (car a) 'bigpos) (math-format-bignum (cdr a))) ((eq (car a) 'bigneg) (concat "-" (math-format-bignum (cdr a)))) ((and (eq (car a) 'float) (= calc-number-radix 10)) (if (Math-integer-negp (nth 1 a)) (concat "-" (math-format-number (math-neg a))) (let ((mant (nth 1 a)) (exp (nth 2 a)) (fmt (car calc-float-format)) (figs (nth 1 calc-float-format)) (point calc-point-char) str) (if (and (eq fmt 'fix) (or (and (< figs 0) (setq figs (- figs))) (> (+ exp (math-numdigs mant)) (- figs)))) (progn (setq mant (math-scale-rounding mant (+ exp figs)) str (if (integerp mant) (int-to-string mant) (math-format-bignum-decimal (cdr mant)))) (if (<= (length str) figs) (setq str (concat (make-string (1+ (- figs (length str))) ?0) str))) (if (> figs 0) (setq str (concat (substring str 0 (- figs)) point (substring str (- figs)))) (setq str (concat str point))) (if calc-group-digits (setq str (math-group-float str)))) (if (< figs 0) (setq figs (+ calc-internal-prec figs))) (if (> figs 0) (let ((adj (- figs (math-numdigs mant)))) (if (< adj 0) (setq mant (math-scale-rounding mant adj) exp (- exp adj))))) (setq str (if (integerp mant) (int-to-string mant) (math-format-bignum-decimal (cdr mant)))) (let* ((len (length str)) (dpos (+ exp len))) (if (and (eq fmt 'float) (<= dpos (+ calc-internal-prec calc-display-sci-high)) (>= dpos (+ calc-display-sci-low 2))) (progn (cond ((= dpos 0) (setq str (concat "0" point str))) ((and (<= exp 0) (> dpos 0)) (setq str (concat (substring str 0 dpos) point (substring str dpos)))) ((> exp 0) (setq str (concat str (make-string exp ?0) point))) (t ; (< dpos 0) (setq str (concat "0" point (make-string (- dpos) ?0) str)))) (if calc-group-digits (setq str (math-group-float str)))) (let* ((eadj (+ exp len)) (scale (if (eq fmt 'eng) (1+ (math-mod (+ eadj 300002) 3)) 1))) (if (> scale (length str)) (setq str (concat str (make-string (- scale (length str)) ?0)))) (if (< scale (length str)) (setq str (concat (substring str 0 scale) point (substring str scale)))) (if calc-group-digits (setq str (math-group-float str))) (setq str (format (if (memq calc-language '(math maple)) (if (and prec (> prec 191)) "(%s*10.^%d)" "%s*10.^%d") "%se%d") str (- eadj scale))))))) str))) (t (calc-extensions) (math-format-number-fancy a prec))) ) (defun math-format-bignum (a) ; [X L] (if (and (= calc-number-radix 10) (not calc-leading-zeros) (not calc-group-digits)) (math-format-bignum-decimal a) (calc-extensions) (math-format-bignum-fancy a)) ) (defun math-format-bignum-decimal (a) ; [X L] (if a (let ((s "")) (while (cdr (cdr a)) (setq s (concat (format "%06d" (+ (* (nth 1 a) 1000) (car a))) s) a (cdr (cdr a)))) (concat (int-to-string (+ (* (or (nth 1 a) 0) 1000) (car a))) s)) "0") ) ;;; Parse a simple number in string form. [N X] [Public] (defun math-read-number (s) (math-normalize (cond ;; Integers (most common case) ((string-match "\\` *\\([0-9]+\\) *\\'" s) (let ((digs (math-match-substring s 1))) (if (and (eq calc-language 'c) (> (length digs) 1) (eq (aref digs 0) ?0)) (math-read-number (concat "8#" digs)) (if (<= (length digs) 6) (string-to-int digs) (cons 'bigpos (math-read-bignum digs)))))) ;; Clean up the string if necessary ((string-match "\\`\\(.*\\)[ \t\n]+\\([^\001]*\\)\\'" s) (math-read-number (concat (math-match-substring s 1) (math-match-substring s 2)))) ;; Plus and minus signs ((string-match "^[-_+]\\(.*\\)$" s) (let ((val (math-read-number (math-match-substring s 1)))) (and val (if (eq (aref s 0) ?+) val (math-neg val))))) ;; Forms that require extensions module ((string-match "[^-+0-9eE.]" s) (calc-extensions) (math-read-number-fancy s)) ;; Decimal point ((string-match "^\\([0-9]*\\)\\.\\([0-9]*\\)$" s) (let ((int (math-match-substring s 1)) (frac (math-match-substring s 2))) (let ((ilen (length int)) (flen (length frac))) (let ((int (if (> ilen 0) (math-read-number int) 0)) (frac (if (> flen 0) (math-read-number frac) 0))) (and int frac (or (> ilen 0) (> flen 0)) (list 'float (math-add (math-scale-int int flen) frac) (- flen))))))) ;; "e" notation ((string-match "^\\(.*\\)[eE]\\([-+]?[0-9]+\\)$" s) (let ((mant (math-match-substring s 1)) (exp (math-match-substring s 2))) (let ((mant (if (> (length mant) 0) (math-read-number mant) 1)) (exp (if (<= (length exp) (if (memq (aref exp 0) '(?+ ?-)) 8 7)) (string-to-int exp)))) (and mant exp (Math-realp mant) (> exp -4000000) (< exp 4000000) (let ((mant (math-float mant))) (list 'float (nth 1 mant) (+ (nth 2 mant) exp))))))) ;; Syntax error! (t nil))) ) (defun math-match-substring (s n) (if (match-beginning n) (substring s (match-beginning n) (match-end n)) "") ) (defun math-read-bignum (s) ; [l X] (if (> (length s) 3) (cons (string-to-int (substring s -3)) (math-read-bignum (substring s 0 -3))) (list (string-to-int s))) ) (defconst math-tex-ignore-words '( ("\\hbox") ("\\mbox") ("\\text") ("\\left") ("\\right") ("\\,") ("\\>") ("\\:") ("\\;") ("\\!") ("\\ ") ("\\quad") ("\\qquad") ("\\hfil") ("\\hfill") ("\\displaystyle") ("\\textstyle") ("\\dsize") ("\\tsize") ("\\scriptstyle") ("\\scriptscriptstyle") ("\\ssize") ("\\sssize") ("\\rm") ("\\bf") ("\\it") ("\\sl") ("\\roman") ("\\bold") ("\\italic") ("\\slanted") ("\\cal") ("\\mit") ("\\Cal") ("\\Bbb") ("\\frak") ("\\goth") ("\\evalto") ("\\matrix" mat) ("\\bmatrix" mat) ("\\pmatrix" mat) ("\\cr" punc ";") ("\\\\" punc ";") ("\\*" punc "*") ("\\{" punc "[") ("\\}" punc "]") )) (defconst math-eqn-ignore-words '( ("roman") ("bold") ("italic") ("mark") ("lineup") ("evalto") ("left" ("floor") ("ceil")) ("right" ("floor") ("ceil")) ("arc" ("sin") ("cos") ("tan") ("sinh") ("cosh") ("tanh")) ("size" n) ("font" n) ("fwd" n) ("back" n) ("up" n) ("down" n) ("above" punc ",") )) (defconst math-standard-opers '( ( "_" calcFunc-subscr 1200 1201 ) ( "%" calcFunc-percent 1100 -1 ) ( "u+" ident -1 1000 ) ( "u-" neg -1 1000 197 ) ( "u!" calcFunc-lnot -1 1000 ) ( "mod" mod 400 400 185 ) ( "+/-" sdev 300 300 185 ) ( "!!" calcFunc-dfact 210 -1 ) ( "!" calcFunc-fact 210 -1 ) ( "^" ^ 201 200 ) ( "**" ^ 201 200 ) ( "*" * 196 195 ) ( "2x" * 196 195 ) ( "/" / 190 191 ) ( "%" % 190 191 ) ( "\\" calcFunc-idiv 190 191 ) ( "+" + 180 181 ) ( "-" - 180 181 ) ( "|" | 170 171 ) ( "<" calcFunc-lt 160 161 ) ( ">" calcFunc-gt 160 161 ) ( "<=" calcFunc-leq 160 161 ) ( ">=" calcFunc-geq 160 161 ) ( "=" calcFunc-eq 160 161 ) ( "==" calcFunc-eq 160 161 ) ( "!=" calcFunc-neq 160 161 ) ( "&&" calcFunc-land 110 111 ) ( "||" calcFunc-lor 100 101 ) ( "?" (math-read-if) 91 90 ) ( "!!!" calcFunc-pnot -1 85 ) ( "&&&" calcFunc-pand 80 81 ) ( "|||" calcFunc-por 75 76 ) ( ":=" calcFunc-assign 51 50 ) ( "::" calcFunc-condition 45 46 ) ( "=>" calcFunc-evalto 40 41 ) ( "=>" calcFunc-evalto 40 -1 ) )) (setq math-expr-opers math-standard-opers) ;;;###autoload (defun calc-grab-region (top bot arg) "Parse the region as a vector of numbers and push it on the Calculator stack." (interactive "r\nP") (calc-extensions) (calc-do-grab-region top bot arg) ) ;;;###autoload (defun calc-grab-rectangle (top bot arg) "Parse a rectangle as a matrix of numbers and push it on the Calculator stack." (interactive "r\nP") (calc-extensions) (calc-do-grab-rectangle top bot arg) ) (defun calc-grab-sum-down (top bot arg) "Parse a rectangle as a matrix of numbers and sum its columns." (interactive "r\nP") (calc-extensions) (calc-do-grab-rectangle top bot arg 'calcFunc-reduced) ) (defun calc-grab-sum-across (top bot arg) "Parse a rectangle as a matrix of numbers and sum its rows." (interactive "r\nP") (calc-extensions) (calc-do-grab-rectangle top bot arg 'calcFunc-reducea) ) ;;;###autoload (defun calc-embedded (arg &optional end obeg oend) "Start Calc Embedded mode on the formula surrounding point." (interactive "P") (calc-extensions) (calc-do-embedded arg end obeg oend) ) ;;;###autoload (defun calc-embedded-activate (&optional arg cbuf) "Scan the current editing buffer for all embedded := and => formulas. Also looks for the equivalent TeX words, \\gets and \\evalto." (interactive "P") (calc-do-embedded-activate arg cbuf) ) (defun calc-user-invocation () (interactive) (or (stringp calc-invocation-macro) (error "Use `Z I' inside Calc to define a `M-# Z' keyboard macro")) (execute-kbd-macro calc-invocation-macro nil) ) ;;; User-programmability. ;;;###autoload (defmacro defmath (func args &rest body) ; [Public] (calc-extensions) (math-do-defmath func args body) ) ;;; Functions needed for Lucid Emacs support. (defun calc-read-key (&optional optkey) (cond (calc-emacs-type-lucid (let ((event (next-command-event))) (let ((key (event-to-character event t t))) (or key optkey (error "Expected a plain keystroke")) (cons key event)))) (calc-emacs-type-gnu19 (let ((key (read-event))) (cons key key))) (t (let ((key (read-char))) (cons key key)))) ) (defun calc-unread-command (&optional input) (cond (calc-emacs-type-gnu19 (setq unread-command-events (cons (or input last-command-event) unread-command-events))) (calc-emacs-type-lucid (setq unread-command-event (if (integerp input) (character-to-event input) (or input last-command-event)))) (t (setq unread-command-char (or input last-command-char)))) ) (defun calc-clear-unread-commands () (cond (calc-emacs-type-gnu19 (setq unread-command-events nil)) (calc-emacs-type-lucid (setq unread-command-event nil)) (t (setq unread-command-char -1))) ) (if calc-always-load-extensions (progn (calc-extensions) (calc-load-everything)) ) (run-hooks 'calc-load-hook) calc-2.02c/calc.texinfo100644 22403 13 5477455 5547406634 13446 0ustar daveguser\input texinfo @c -*-texinfo-*- @comment %**start of header (This is for running Texinfo on a region.) @c smallbook @setfilename calc.info @c [title] @settitle GNU Emacs Calc 2.02 Manual @setchapternewpage odd @comment %**end of header (This is for running Texinfo on a region.) @tex % Some special kludges to make TeX formatting prettier. % Because makeinfo.c exists, we can't just define new commands. % So instead, we take over little-used existing commands. % % Redefine @cite{text} to act like $text$ in regular TeX. % Info will typeset this same as @samp{text}. \gdef\goodtex{\tex \let\rm\goodrm \let\t\ttfont \turnoffactive} \gdef\goodrm{\fam0\tenrm} \gdef\cite{\goodtex$\citexxx} \gdef\citexxx#1{#1$\Etex} \global\let\oldxrefX=\xrefX \gdef\xrefX[#1]{\begingroup\let\cite=\dfn\oldxrefX[#1]\endgroup} % % Redefine @i{text} to be equivalent to @cite{text}, i.e., to use math mode. % This looks the same in TeX but omits the surrounding ` ' in Info. \global\let\i=\cite % % Redefine @c{tex-stuff} \n @whatever{info-stuff}. \gdef\c{\futurelet\next\mycxxx} \gdef\mycxxx{% \ifx\next\bgroup \goodtex\let\next\mycxxy \else\ifx\next\mindex \let\next\relax \else\ifx\next\kindex \let\next\relax \else\ifx\next\starindex \let\next\relax \else \let\next\comment \fi\fi\fi\fi \next } \gdef\mycxxy#1#2{#1\Etex\mycxxz} \gdef\mycxxz#1{} @end tex @c Fix some things to make math mode work properly. @iftex @textfont0=@tenrm @font@teni=cmmi10 scaled @magstephalf @textfont1=@teni @font@seveni=cmmi7 scaled @magstephalf @scriptfont1=@seveni @font@fivei=cmmi5 scaled @magstephalf @scriptscriptfont1=@fivei @font@tensy=cmsy10 scaled @magstephalf @textfont2=@tensy @font@sevensy=cmsy7 scaled @magstephalf @scriptfont2=@sevensy @font@fivesy=cmsy5 scaled @magstephalf @scriptscriptfont2=@fivesy @font@tenex=cmex10 scaled @magstephalf @textfont3=@tenex @scriptfont3=@tenex @scriptscriptfont3=@tenex @textfont7=@tentt @scriptfont7=@tentt @scriptscriptfont7=@tentt @end iftex @c Fix some other things specifically for this manual. @iftex @finalout @mathcode`@:=`@: @c Make Calc fractions come out right in math mode @tocindent=.5pc @c Indent subsections in table of contents less @rightskip=0pt plus 2pt @c Favor short lines rather than overfull hboxes @tex \gdef\coloneq{\mathrel{\mathord:\mathord=}} \ifdim\parskip>17pt \global\parskip=12pt % Standard parskip looks a bit too large \fi \gdef\internalBitem{\parskip=7pt\kyhpos=\tableindent\kyvpos=0pt \smallbreak\parsearg\itemzzy} \gdef\itemzzy#1{\itemzzz{#1}\relax\ifvmode\kern-7pt\fi} \gdef\trademark{${}^{\rm TM}$} \gdef\group{% \par\vskip8pt\begingroup \def\Egroup{\egroup\endgroup}% \let\aboveenvbreak=\relax % so that nothing gets between vtop and first box \def\singlespace{\baselineskip=\singlespaceskip}% \vtop\bgroup } % %\global\abovedisplayskip=0pt %\global\abovedisplayshortskip=-10pt %\global\belowdisplayskip=7pt %\global\belowdisplayshortskip=2pt \gdef\beforedisplay{\vskip-10pt} \gdef\afterdisplay{\vskip-5pt} \gdef\beforedisplayh{\vskip-25pt} \gdef\afterdisplayh{\vskip-10pt} % \gdef\printindex{\parsearg\calcprintindex} \gdef\calcprintindex#1{% \doprintindex{#1}% \openin1 \jobname.#1s \ifeof1{\let\s=\indexskip \csname indexsize#1\endcsname}\fi \closein1 } \gdef\indexskip{(This page intentionally left blank)\vfill\eject} \gdef\indexsizeky{\s\s\s\s\s\s\s\s} \gdef\indexsizepg{\s\s\s\s\s\s} \gdef\indexsizetp{\s\s\s\s\s\s} \gdef\indexsizecp{\s\s\s\s} \gdef\indexsizevr{} \gdef\indexsizefn{\s\s} \gdef\langle#1\rangle{\it XXX} % Avoid length mismatch with true expansion % % Ensure no indentation at beginning of sections, and avoid club paragraphs. \global\let\calcchapternofonts=\chapternofonts \gdef\chapternofonts{\aftergroup\calcfixclub\calcchapternofonts} \gdef\calcfixclub{\calcclubpenalty=10000\noindent} \global\let\calcdobreak=\dobreak \gdef\dobreak{{\penalty-9999\dimen0=\pagetotal\advance\dimen0by1.5in \ifdim\dimen0>\pagegoal\vfill\eject\fi}\calcdobreak} % \gdef\kindex{\def\indexname{ky}\futurelet\next\calcindexer} \gdef\tindex{\def\indexname{tp}\futurelet\next\calcindexer} \gdef\mindex{\let\indexname\relax\futurelet\next\calcindexer} \gdef\calcindexer{\catcode`\ =\active\parsearg\calcindexerxx} \gdef\calcindexerxx#1{% \catcode`\ =10% \ifvmode \indent \fi \setbox0=\lastbox \advance\kyhpos\wd0 \fixoddpages \box0 \setbox0=\hbox{\ninett #1}% \calcindexersh{\llap{\hbox to 4em{\bumpoddpages\lower\kyvpos\box0\hss}\hskip\kyhpos}}% \global\let\calcindexersh=\calcindexershow \advance\clubpenalty by 5000% \ifx\indexname\relax \else \singlecodeindexer{#1\indexstar}% \global\def\indexstar{}% \fi \futurelet\next\calcindexerxxx } \gdef\bumpoddpages{\ifodd\calcpageno\hskip7.3in\fi} %\gdef\bumpoddpages{\hskip7.3in} % for marginal notes on right side always %\gdef\bumpoddpages{} % for marginal notes on left side always \gdef\fixoddpages{% \global\calcpageno=\pageno {\dimen0=\pagetotal \advance\dimen0 by2\baselineskip \ifdim\dimen0>\pagegoal \global\advance\calcpageno by 1 \vfill\eject\noindent \fi}% } \gdef\calcindexershow#1{\smash{#1}\advance\kyvpos by 11pt} \gdef\calcindexernoshow#1{} \global\let\calcindexersh=\calcindexershow \gdef\calcindexerxxx{% \ifx\indexname\relax \ifx\next\kindex \global\let\calcindexersh=\calcindexernoshow \fi \ifx\next\tindex \global\let\calcindexersh=\calcindexernoshow \fi \fi \calcindexerxxxx } \gdef\calcindexerxxxx#1{\next} \gdef\indexstarxx{\thinspace{\rm *}} \gdef\starindex{\global\let\indexstar=\indexstarxx} \gdef\calceverypar{% \kyhpos=\leftskip\kyvpos=0pt\clubpenalty=\calcclubpenalty \calcclubpenalty=1000\relax } \gdef\idots{{\indrm...}} @end tex @newdimen@kyvpos @kyvpos=0pt @newdimen@kyhpos @kyhpos=0pt @newcount@calcclubpenalty @calcclubpenalty=1000 @newcount@calcpageno @newtoks@calcoldeverypar @calcoldeverypar=@everypar @everypar={@calceverypar@the@calcoldeverypar} @ifx@turnoffactive@undefinedzzz@def@turnoffactive{}@fi @ifx@ninett@undefinedzzz@font@ninett=cmtt9@fi @catcode`@\=0 \catcode`\@=11 \r@ggedbottomtrue \catcode`\@=0 @catcode`@\=@active @end iftex @ifinfo This file documents Calc, the GNU Emacs calculator. Copyright (C) 1990, 1991 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. @ignore Permission is granted to process this file through TeX and print the results, provided the printed document carries copying permission notice identical to this one except for the removal of this paragraph (this paragraph not being relevant to the printed manual). @end ignore Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the section entitled ``GNU General Public License'' is included exactly as in the original, and provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that the section entitled ``GNU General Public License'' may be included in a translation approved by the author instead of in the original English. @end ifinfo @titlepage @sp 6 @center @titlefont{Calc Manual} @sp 4 @center GNU Emacs Calc Version 2.02 @c [volume] @sp 1 @center January 1992 @sp 5 @center Dave Gillespie @center daveg@@synaptics.com @page @vskip 0pt plus 1filll Copyright @copyright{} 1990, 1991 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. @ignore Permission is granted to process this file through TeX and print the results, provided the printed document carries copying permission notice identical to this one except for the removal of this paragraph (this paragraph not being relevant to the printed manual). @end ignore Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the section entitled ``GNU General Public License'' is included exactly as in the original, and provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that the section entitled ``GNU General Public License'' may be included in a translation approved by the author instead of in the original English. @end titlepage @c [begin] @ifinfo @node Top, Getting Started,, (dir) @ichapter The GNU Emacs Calculator @noindent @dfn{Calc 2.02} is an advanced desk calculator and mathematical tool that runs as part of the GNU Emacs environment. This manual is divided into three major parts: "Getting Started," the "Calc Tutorial," and the "Calc Reference." The Tutorial introduces all the major aspects of Calculator use in an easy, hands-on way. The remainder of the manual is a complete reference to the features of the Calculator. For help in the Emacs Info system (which you are using to read this file), type @kbd{?}. (You can also type @kbd{h} to run through a longer Info tutorial.) @end ifinfo @menu * Copying:: How you can copy and share Calc. * Getting Started:: General description and overview. * Tutorial:: A step-by-step introduction for beginners. * Introduction:: Introduction to the Calc reference manual. * Data Types:: Types of objects manipulated by Calc. * Stack and Trail:: Manipulating the stack and trail buffers. * Mode Settings:: Adjusting display format and other modes. * Arithmetic:: Basic arithmetic functions. * Scientific Functions:: Transcendentals and other scientific functions. * Matrix Functions:: Operations on vectors and matrices. * Algebra:: Manipulating expressions algebraically. * Units:: Operations on numbers with units. * Store and Recall:: Storing and recalling variables. * Graphics:: Commands for making graphs of data. * Kill and Yank:: Moving data into and out of Calc. * Embedded Mode:: Working with formulas embedded in a file. * Programming:: Calc as a programmable calculator. * Installation:: Installing Calc as a part of GNU Emacs. * Reporting Bugs:: How to report bugs and make suggestions. * Summary:: Summary of Calc commands and functions. * Key Index:: The standard Calc key sequences. * Command Index:: The interactive Calc commands. * Function Index:: Functions (in algebraic formulas). * Concept Index:: General concepts. * Variable Index:: Variables used by Calc (both user and internal). * Lisp Function Index:: Internal Lisp math functions. @end menu @node Copying, Getting Started, Top, Top @unnumbered GNU GENERAL PUBLIC LICENSE @center Version 1, February 1989 @display Copyright @copyright{} 1989 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. @end display @unnumberedsec Preamble The license agreements of most software companies try to keep users at the mercy of those companies. By contrast, our General Public License is intended to guarantee your freedom to share and change free software---to make sure the software is free for all its users. The General Public License applies to the Free Software Foundation's software and to any other program whose authors commit to using it. You can use it for your programs, too. When we speak of free software, we are referring to freedom, not price. Specifically, the General Public License is designed to make sure that you have the freedom to give away or sell copies of free software, that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of a such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must tell them their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. The precise terms and conditions for copying, distribution and modification follow. @iftex @unnumberedsec TERMS AND CONDITIONS @end iftex @ifinfo @center TERMS AND CONDITIONS @end ifinfo @enumerate @item This License Agreement applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The ``Program'', below, refers to any such program or work, and a ``work based on the Program'' means either the Program or any work containing the Program or a portion of it, either verbatim or with modifications. Each licensee is addressed as ``you''. @item You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this General Public License and to the absence of any warranty; and give any other recipients of the Program a copy of this General Public License along with the Program. You may charge a fee for the physical act of transferring a copy. @item You may modify your copy or copies of the Program or any portion of it, and copy and distribute such modifications under the terms of Paragraph 1 above, provided that you also do the following: @itemize @bullet @item cause the modified files to carry prominent notices stating that you changed the files and the date of any change; and @item cause the whole of any work that you distribute or publish, that in whole or in part contains the Program or any part thereof, either with or without modifications, to be licensed at no charge to all third parties under the terms of this General Public License (except that you may choose to grant warranty protection to some or all third parties, at your option). @item If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the simplest and most usual way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this General Public License. @item You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. @end itemize Mere aggregation of another independent work with the Program (or its derivative) on a volume of a storage or distribution medium does not bring the other work under the scope of these terms. @item You may copy and distribute the Program (or a portion or derivative of it, under Paragraph 2) in object code or executable form under the terms of Paragraphs 1 and 2 above provided that you also do one of the following: @itemize @bullet @item accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Paragraphs 1 and 2 above; or, @item accompany it with a written offer, valid for at least three years, to give any third party free (except for a nominal charge for the cost of distribution) a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Paragraphs 1 and 2 above; or, @item accompany it with the information you received as to where the corresponding source code may be obtained. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form alone.) @end itemize Source code for a work means the preferred form of the work for making modifications to it. For an executable file, complete source code means all the source code for all modules it contains; but, as a special exception, it need not include source code for modules which are standard libraries that accompany the operating system on which the executable file runs, or for standard header files or definitions files that accompany that operating system. @item You may not copy, modify, sublicense, distribute or transfer the Program except as expressly provided under this General Public License. Any attempt otherwise to copy, modify, sublicense, distribute or transfer the Program is void, and will automatically terminate your rights to use the Program under this License. However, parties who have received copies, or rights to use copies, from you under this General Public License will not have their licenses terminated so long as such parties remain in full compliance. @item By copying, distributing or modifying the Program (or any work based on the Program) you indicate your acceptance of this license to do so, and all its terms and conditions. @item Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. @item The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of the license which applies to it and ``any later version'', you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the license, you may choose any version ever published by the Free Software Foundation. @item If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. @iftex @heading NO WARRANTY @end iftex @ifinfo @center NO WARRANTY @end ifinfo @item BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. @item IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. @end enumerate @node Getting Started, Tutorial, Top, Top @chapter Getting Started @noindent This chapter provides a general overview of Calc, the GNU Emacs Calculator: What it is, how to start it and how to exit from it, and what are the various ways that it can be used. @menu * What is Calc:: * About This Manual:: * Notations Used in This Manual:: * Using Calc:: * Demonstration of Calc:: * History and Acknowledgements:: @end menu @node What is Calc, About This Manual, Getting Started, Getting Started @section What is Calc? @noindent @dfn{Calc} is an advanced calculator and mathematical tool that runs as part of the GNU Emacs environment. Very roughly based on the HP-28/48 series of calculators, its many features include: @itemize @bullet @item Choice of algebraic or RPN (stack-based) entry of calculations. @item Arbitrary precision integers and floating-point numbers. @item Arithmetic on rational numbers, complex numbers (rectangular and polar), error forms with standard deviations, open and closed intervals, vectors and matrices, dates and times, infinities, sets, quantities with units, and algebraic formulas. @item Mathematical operations such as logarithms and trigonometric functions. @item Programmer's features (bitwise operations, non-decimal numbers). @item Financial functions such as future value and internal rate of return. @item Number theoretical features such as prime factorization and arithmetic modulo @i{M} for any @i{M}. @item Algebraic manipulation features, including symbolic calculus. @item Moving data to and from regular editing buffers. @item ``Embedded mode'' for manipulating Calc formulas and data directly inside any editing buffer. @item Graphics using GNUPLOT, a versatile (and free) plotting program. @item Easy programming using keyboard macros, algebraic formulas, algebraic rewrite rules, or extended Emacs Lisp. @end itemize Calc tries to include a little something for everyone; as a result it is large and might be intimidating to the first-time user. If you plan to use Calc only as a traditional desk calculator, all you really need to read is the ``Getting Started'' chapter of this manual and possibly the first few sections of the tutorial. As you become more comfortable with the program you can learn its additional features. In terms of efficiency, scope and depth, Calc cannot replace a powerful tool like Mathematica. @c Removed this per RMS' request: @c Mathematica@c{\trademark} @asis{ (tm)}. But Calc has the advantages of convenience, portability, and availability of the source code. And, of course, it's free! @node About This Manual, Notations Used in This Manual, What is Calc, Getting Started @section About This Manual @noindent This document serves as a complete description of the GNU Emacs Calculator. It works both as an introduction for novices, and as a reference for experienced users. While it helps to have some experience with GNU Emacs in order to get the most out of Calc, this manual ought to be readable even if you don't know or use Emacs regularly. @ifinfo The manual is divided into three major parts:@: the ``Getting Started'' chapter you are reading now, the Calc tutorial (chapter 2), and the Calc reference manual (the remaining chapters and appendices). @end ifinfo @iftex The manual is divided into three major parts:@: the ``Getting Started'' chapter you are reading now, the Calc tutorial (chapter 2), and the Calc reference manual (the remaining chapters and appendices). @c [when-split] @c This manual has been printed in two volumes, the @dfn{Tutorial} and the @c @dfn{Reference}. Both volumes include a copy of the ``Getting Started'' @c chapter. @end iftex If you are in a hurry to use Calc, there is a brief ``demonstration'' below which illustrates the major features of Calc in just a couple of pages. If you don't have time to go through the full tutorial, this will show you everything you need to know to begin. @xref{Demonstration of Calc}. The tutorial chapter walks you through the various parts of Calc with lots of hands-on examples and explanations. If you are new to Calc and you have some time, try going through at least the beginning of the tutorial. The tutorial includes about 70 exercises with answers. These exercises give you some guided practice with Calc, as well as pointing out some interesting and unusual ways to use its features. The reference section discusses Calc in complete depth. You can read the reference from start to finish if you want to learn every aspect of Calc. Or, you can look in the table of contents or the Concept Index to find the parts of the manual that discuss the things you need to know. @cindex Marginal notes Every Calc keyboard command is listed in the Calc Summary, and also in the Key Index. Algebraic functions, @kbd{M-x} commands, and variables also have their own indices. @c{Each} @asis{In the printed manual, each} paragraph that is referenced in the Key or Function Index is marked in the margin with its index entry. @c [fix-ref Help Commands] You can access this manual on-line at any time within Calc by pressing the @kbd{h i} key sequence. Outside of the Calc window, you can press @kbd{M-# i} to read the manual on-line. Also, you can jump directly to the Tutorial by pressing @kbd{h t} or @kbd{M-# t}, or to the Summary by pressing @kbd{h s} or @kbd{M-# s}. Within Calc, you can also go to the part of the manual describing any Calc key, function, or variable using @w{@kbd{h k}}, @kbd{h f}, or @kbd{h v}, respectively. @xref{Help Commands}. Printed copies of this manual are also available from the Free Software Foundation. @node Notations Used in This Manual, Demonstration of Calc, About This Manual, Getting Started @section Notations Used in This Manual @noindent This section describes the various notations that are used throughout the Calc manual. In keystroke sequences, uppercase letters mean you must hold down the shift key while typing the letter. Keys pressed with Control held down are shown as @kbd{C-x}. Keys pressed with Meta held down are shown as @kbd{M-x}. Other notations are @key{RET} for the Return key, @key{SPC} for the space bar, @key{TAB} for the Tab key, @key{DEL} for the Delete key, and @key{LFD} for the Line-Feed key. (If you don't have the @key{LFD} or @key{TAB} keys on your keyboard, the @kbd{C-j} and @kbd{C-i} keys are equivalent to them, respectively. If you don't have a Meta key, look for Alt or Extend Char. You can also press @key{ESC} or @key{C-[} first to get the same effect, so that @kbd{M-x}, @kbd{ESC x}, and @kbd{C-[ x} are all equivalent.) Sometimes the @key{RET} key is not shown when it is ``obvious'' that you must press @kbd{RET} to proceed. For example, the @key{RET} is usually omitted in key sequences like @kbd{M-x calc-keypad @key{RET}}. Commands are generally shown like this: @kbd{p} (@code{calc-precision}) or @kbd{M-# k} (@code{calc-keypad}). This means that the command is normally used by pressing the @kbd{p} key or @kbd{M-# k} key sequence, but it also has the full-name equivalent shown, e.g., @kbd{M-x calc-precision}. Commands that correspond to functions in algebraic notation are written: @kbd{C} (@code{calc-cos}) [@code{cos}]. This means the @kbd{C} key is equivalent to @kbd{M-x calc-cos}, and that the corresponding function in an algebraic-style formula would be @samp{cos(@var{x})}. A few commands don't have key equivalents: @code{calc-sincos} [@code{sincos}].@refill @node Demonstration of Calc, Using Calc, Notations Used in This Manual, Getting Started @section A Demonstration of Calc @noindent @cindex Demonstration of Calc This section will show some typical small problems being solved with Calc. The focus is more on demonstration than explanation, but everything you see here will be covered more thoroughly in the Tutorial. To begin, start Emacs if necessary (usually the command @code{emacs} does this), and type @kbd{M-# c} (or @kbd{ESC # c}) to start the Calculator. (@xref{Starting Calc}, if this doesn't work for you.) Be sure to type all the sample input exactly, especially noting the difference between lower-case and upper-case letters. Remember, @kbd{RET}, @kbd{TAB}, @kbd{DEL}, and @kbd{SPC} are the Return, Tab, Delete, and Space keys. @strong{RPN calculation.} In RPN, you type the input number(s) first, then the command to operate on the numbers. @noindent Type @kbd{2 RET 3 + Q} to compute @c{$\sqrt{2+3} = 2.2360679775$} @asis{the square root of 2+3, which is 2.2360679775}. @noindent Type @kbd{P 2 ^} to compute @c{$\pi^2 = 9.86960440109$} @asis{the value of `pi' squared, 9.86960440109}. @noindent Type @kbd{TAB} to exchange the order of these two results. @noindent Type @kbd{- I H S} to subtract these results and compute the Inverse Hyperbolic sine of the difference, 2.72996136574. @noindent Type @kbd{DEL} to erase this result. @strong{Algebraic calculation.} You can also enter calculations using conventional ``algebraic'' notation. To enter an algebraic formula, use the apostrophe key. @noindent Type @kbd{' sqrt(2+3) RET} to compute @c{$\sqrt{2+3}$} @asis{the square root of 2+3}. @noindent Type @kbd{' pi^2 RET} to enter @c{$\pi^2$} @asis{`pi' squared}. To evaluate this symbolic formula as a number, type @kbd{=}. @noindent Type @kbd{' arcsinh($ - $$) RET} to subtract the second-most-recent result from the most-recent and compute the Inverse Hyperbolic sine. @strong{Keypad mode.} If you are using the X window system, press @w{@kbd{M-# k}} to get Keypad mode. (If you don't use X, skip to the next section.) @noindent Click on the @key{2}, @key{ENTER}, @key{3}, @key{+}, and @key{SQRT} ``buttons'' using your left mouse button. @noindent Click on @key{PI}, @key{2}, and @t{y^x}. @noindent Click on @key{INV}, then @key{ENTER} to swap the two results. @noindent Click on @key{-}, @key{INV}, @key{HYP}, and @key{SIN}. @noindent Click on @key{<-} to erase the result, then click @key{OFF} to turn the Keypad Calculator off. @strong{Grabbing data.} Type @kbd{M-# x} if necessary to exit Calc. Now select the following numbers as an Emacs region: ``Mark'' the front of the list by typing control-@kbd{SPC} or control-@kbd{@@} there, then move to the other end of the list. (Either get this list from the on-line copy of this manual, accessed by @w{@kbd{M-# i}}, or just type these numbers into a scratch file.) Now type @kbd{M-# g} to ``grab'' these numbers into Calc. @group @example 1.23 1.97 1.6 2 1.19 1.08 @end example @end group @noindent The result @samp{[1.23, 1.97, 1.6, 2, 1.19, 1.08]} is a Calc ``vector.'' Type @w{@kbd{V R +}} to compute the sum of these numbers. @noindent Type @kbd{U} to Undo this command, then type @kbd{V R *} to compute the product of the numbers. @noindent You can also grab data as a rectangular matrix. Place the cursor on the upper-leftmost @samp{1} and set the mark, then move to just after the lower-right @samp{8} and press @kbd{M-# r}. @noindent Type @kbd{v t} to transpose this @c{$3\times2$} @asis{3x2} matrix into a @c{$2\times3$} @asis{2x3} matrix. Type @w{@kbd{v u}} to unpack the rows into two separate vectors. Now type @w{@kbd{V R + TAB V R +}} to compute the sums of the two original columns. (There is also a special grab-and-sum-columns command, @kbd{M-# :}.) @strong{Units conversion.} Units are entered algebraically. Type @w{@kbd{' 43 mi/hr RET}} to enter the quantity 43 miles-per-hour. Type @w{@kbd{u c km/hr RET}}. Type @w{@kbd{u c m/s RET}}. @strong{Date arithmetic.} Type @kbd{t N} to get the current date and time. Type @kbd{90 +} to find the date 90 days from now. Type @kbd{' <25 dec 87> RET} to enter a date, then @kbd{- 7 /} to see how many weeks have passed since then. @strong{Algebra.} Algebraic entries can also include formulas or equations involving variables. Type @kbd{@w{' [x + y} = a, x y = 1] RET} to enter a pair of equations involving three variables. (Note the leading apostrophe in this example; also, note that the space between @samp{x y} is required.) Type @w{@kbd{a S x,y RET}} to solve these equations for the variables @cite{x} and @cite{y}.@refill @noindent Type @kbd{d B} to view the solutions in more readable notation. Type @w{@kbd{d C}} to view them in C language notation, and @kbd{d T} to view them in the notation for the @TeX{} typesetting system. Type @kbd{d N} to return to normal notation. @noindent Type @kbd{7.5}, then @kbd{s l a RET} to let @cite{a = 7.5} in these formulas. (That's a letter @kbd{l}, not a numeral @kbd{1}.) @iftex @strong{Help functions.} You can read about any command in the on-line manual. Type @kbd{M-# c} to return to Calc after each of these commands: @kbd{h k t N} to read about the @kbd{t N} command, @kbd{h f sqrt RET} to read about the @code{sqrt} function, and @kbd{h s} to read the Calc summary. @end iftex @ifinfo @strong{Help functions.} You can read about any command in the on-line manual. Remember to type the letter @kbd{l}, then @kbd{M-# c}, to return here after each of these commands: @w{@kbd{h k t N}} to read about the @w{@kbd{t N}} command, @kbd{h f sqrt RET} to read about the @code{sqrt} function, and @kbd{h s} to read the Calc summary. @end ifinfo Press @kbd{DEL} repeatedly to remove any leftover results from the stack. To exit from Calc, press @kbd{q} or @kbd{M-# c} again. @node Using Calc, History and Acknowledgements, Demonstration of Calc, Getting Started @section Using Calc @noindent Calc has several user interfaces that are specialized for different kinds of tasks. As well as Calc's standard interface, there are Quick Mode, Keypad Mode, and Embedded Mode. @c [fix-ref Installation] Calc must be @dfn{installed} before it can be used. @xref{Installation}, for instructions on setting up and installing Calc. We will assume you or someone on your system has already installed Calc as described there. @menu * Starting Calc:: * The Standard Interface:: * Quick Mode Overview:: * Keypad Mode Overview:: * Standalone Operation:: * Embedded Mode Overview:: * Other M-# Commands:: @end menu @node Starting Calc, The Standard Interface, Using Calc, Using Calc @subsection Starting Calc @noindent On most systems, you can type @kbd{M-#} to start the Calculator. The notation @kbd{M-#} is short for Meta-@kbd{#}. On most keyboards this means holding down the Meta (or Alt) and Shift keys while typing @kbd{3}. @cindex META key Once again, if you don't have a Meta key on your keyboard you can type @key{ESC} first, then @kbd{#}, to accomplish the same thing. If you don't even have an @key{ESC} key, you can fake it by holding down Control or @key{CTRL} while typing a left square bracket (that's @kbd{C-[} in Emacs notation).@refill @kbd{M-#} is a @dfn{prefix key}; when you press it, Emacs waits for you to press a second key to complete the command. In this case, you will follow @kbd{M-#} with a letter (upper- or lower-case, it doesn't matter for @kbd{M-#}) that says which Calc interface you want to use. To get Calc's standard interface, type @kbd{M-# c}. To get Keypad Mode, type @kbd{M-# k}. Type @kbd{M-# ?} to get a brief list of the available options, and type a second @kbd{?} to get a complete list. To ease typing, @kbd{M-# M-#} (or @kbd{M-# #} if that's easier) also works to start Calc. It starts the same interface (either @kbd{M-# c} or @w{@kbd{M-# k}}) that you last used, selecting the @kbd{M-# c} interface by default. (If your installation has a special function key set up to act like @kbd{M-#}, hitting that function key twice is just like hitting @kbd{M-# M-#}.) If @kbd{M-#} doesn't work for you, you can always type explicit commands like @kbd{M-x calc} (for the standard user interface) or @w{@kbd{M-x calc-keypad}} (for Keypad Mode). First type @kbd{M-x} (that's Meta with the letter @kbd{x}), then, at the prompt, type the full command (like @kbd{calc-keypad}) and press Return. If you type @kbd{M-x calc} and Emacs still doesn't recognize the command (it will say @samp{[No match]} when you try to press @key{RET}), then Calc has not been properly installed. The same commands (like @kbd{M-# c} or @kbd{M-# M-#}) that start the Calculator also turn it off if it is already on. @node The Standard Interface, Quick Mode Overview, Starting Calc, Using Calc @subsection The Standard Calc Interface @noindent @cindex Standard user interface Calc's standard interface acts like a traditional RPN calculator, operated by the normal Emacs keyboard. When you type @kbd{M-# c} to start the Calculator, the Emacs screen splits into two windows with the file you were editing on top and Calc on the bottom. @group @iftex @advance@hsize20pt @end iftex @smallexample ... --**-Emacs: myfile (Fundamental)----All---------------------- --- Emacs Calculator Mode --- |Emacs Calc Mode v2.00... 2: 17.3 | 17.3 1: -5 | 3 . | 2 | 4 | * 8 | ->-5 | --%%-Calc: 12 Deg (Calculator)----All----- --%%-Emacs: *Calc Trail* @end smallexample @end group In this figure, the mode-line for @file{myfile} has moved up and the ``Calculator'' window has appeared below it. As you can see, Calc actually makes two windows side-by-side. The lefthand one is called the @dfn{stack window} and the righthand one is called the @dfn{trail window.} The stack holds the numbers involved in the calculation you are currently performing. The trail holds a complete record of all calculations you have done. In a desk calculator with a printer, the trail corresponds to the paper tape that records what you do. In this case, the trail shows that four numbers (17.3, 3, 2, and 4) were first entered into the Calculator, then the 2 and 4 were multiplied to get 8, then the 3 and 8 were subtracted to get @i{-5}. (The @samp{>} symbol shows that this was the most recent calculation.) The net result is the two numbers 17.3 and @i{-5} sitting on the stack. Most Calculator commands deal explicitly with the stack only, but there is a set of commands that allow you to search back through the trail and retrieve any previous result. Calc commands use the digits, letters, and punctuation keys. Shifted (i.e., upper-case) letters are different from lowercase letters. Some letters are @dfn{prefix} keys that begin two-letter commands. For example, @kbd{e} means ``enter exponent'' and shifted @kbd{E} means @cite{e^x}. With the @kbd{d} (``display modes'') prefix the letter ``e'' takes on very different meanings: @kbd{d e} means ``engineering notation'' and @kbd{d E} means ``@dfn{eqn} language mode.'' There is nothing stopping you from switching out of the Calc window and back into your editing window, say by using the Emacs @w{@kbd{C-x o}} (@code{other-window}) command. When the cursor is inside a regular window, Emacs acts just like normal. When the cursor is in the Calc stack or trail windows, keys are interpreted as Calc commands. When you quit by pressing @kbd{M-# c} a second time, the Calculator windows go away but the actual Stack and Trail are not gone, just hidden. When you press @kbd{M-# c} once again you will get the same stack and trail contents you had when you last used the Calculator. The Calculator does not remember its state between Emacs sessions. Thus if you quit Emacs and start it again, @kbd{M-# c} will give you a fresh stack and trail. There is a command (@kbd{m m}) that lets you save your favorite mode settings between sessions, though. One of the things it saves is which user interface (standard or Keypad) you last used; otherwise, a freshly started Emacs will always treat @kbd{M-# M-#} the same as @kbd{M-# c}. The @kbd{q} key is another equivalent way to turn the Calculator off. If you type @kbd{M-# b} first and then @kbd{M-# c}, you get a full-screen version of Calc (@code{full-calc}) in which the stack and trail windows are still side-by-side but are now as tall as the whole Emacs screen. When you press @kbd{q} or @kbd{M-# c} again to quit, the file you were editing before reappears. The @kbd{M-# b} key switches back and forth between ``big'' full-screen mode and the normal partial-screen mode. Finally, @kbd{M-# o} (@code{calc-other-window}) is like @kbd{M-# c} except that the Calc window is not selected. The buffer you were editing before remains selected instead. @kbd{M-# o} is a handy way to switch out of Calc momentarily to edit your file; type @kbd{M-# c} to switch back into Calc when you are done. @node Quick Mode Overview, Keypad Mode Overview, The Standard Interface, Using Calc @subsection Quick Mode (Overview) @noindent @dfn{Quick Mode} is a quick way to use Calc when you don't need the full complexity of the stack and trail. To use it, type @kbd{M-# q} (@code{quick-calc}) in any regular editing buffer. Quick Mode is very simple: It prompts you to type any formula in standard algebraic notation (like @samp{4 - 2/3}) and then displays the result at the bottom of the Emacs screen (@i{3.33333333333} in this case). You are then back in the same editing buffer you were in before, ready to continue editing or to type @kbd{M-# q} again to do another quick calculation. The result of the calculation will also be in the Emacs ``kill ring'' so that a @kbd{C-y} command at this point will yank the result into your editing buffer. Calc mode settings affect Quick Mode, too, though you will have to go into regular Calc (with @kbd{M-# c}) to change the mode settings. @c [fix-ref Quick Calculator mode] @xref{Quick Calculator}, for further information. @node Keypad Mode Overview, Standalone Operation, Quick Mode Overview, Using Calc @subsection Keypad Mode (Overview) @noindent @dfn{Keypad Mode} is a mouse-based interface to the Calculator. It is designed for use with the X window system. If you don't have X, you will have to operate keypad mode with your arrow keys (which is probably more trouble than it's worth). Keypad mode is currently not supported under Emacs 19. Type @kbd{M-# k} to turn Keypad Mode on or off. Once again you get two new windows, this time on the righthand side of the screen instead of at the bottom. The upper window is the familiar Calc Stack; the lower window is a picture of a typical calculator keypad. @tex \dimen0=\pagetotal% \advance \dimen0 by 24\baselineskip% \ifdim \dimen0>\pagegoal \vfill\eject \fi% \medskip @end tex @smallexample |--- Emacs Calculator Mode --- |2: 17.3 |1: -5 | . |--%%-Calc: 12 Deg (Calcul |----+-----Calc 2.00-----+----1 |FLR |CEIL|RND |TRNC|CLN2|FLT | |----+----+----+----+----+----| | LN |EXP | |ABS |IDIV|MOD | |----+----+----+----+----+----| |SIN |COS |TAN |SQRT|y^x |1/x | |----+----+----+----+----+----| | ENTER |+/- |EEX |UNDO| <- | |-----+---+-+--+--+-+---++----| | INV | 7 | 8 | 9 | / | |-----+-----+-----+-----+-----| | HYP | 4 | 5 | 6 | * | |-----+-----+-----+-----+-----| |EXEC | 1 | 2 | 3 | - | |-----+-----+-----+-----+-----| | OFF | 0 | . | PI | + | |-----+-----+-----+-----+-----+ @end smallexample @iftex @begingroup @ifdim@hsize=5in @vskip-3.7in @advance@hsize-2.2in @else @vskip-3.89in @advance@hsize-3.05in @advance@vsize.1in @fi @end iftex Keypad Mode is much easier for beginners to learn, because there is no need to memorize lots of obscure key sequences. But not all commands in regular Calc are available on the Keypad. You can always switch the cursor into the Calc stack window to use standard Calc commands if you need. Serious Calc users, though, often find they prefer the standard interface over Keypad Mode. To operate the Calculator, just click on the ``buttons'' of the keypad using your left mouse button. To enter the two numbers shown here you would click @w{@kbd{1 7 .@: 3 ENTER 5 +/- ENTER}}; to add them together you would then click @kbd{+} (to get 12.3 on the stack). If you click the right mouse button, the top three rows of the keypad change to show other sets of commands, such as advanced math functions, vector operations, and operations on binary numbers. @iftex @endgroup @end iftex Because Keypad Mode doesn't use the regular keyboard, Calc leaves the cursor in your original editing buffer. You can type in this buffer in the usual way while also clicking on the Calculator keypad. One advantage of Keypad Mode is that you don't need an explicit command to switch between editing and calculating. If you press @kbd{M-# b} first, you get a full-screen Keypad Mode (@code{full-calc-keypad}) with three windows: The keypad in the lower left, the stack in the lower right, and the trail on top. @c [fix-ref Keypad Mode] @xref{Keypad Mode}, for further information. @node Standalone Operation, Embedded Mode Overview, Keypad Mode Overview, Using Calc @subsection Standalone Operation @noindent @cindex Standalone Operation If you are not in Emacs at the moment but you wish to use Calc, you must start Emacs first. If all you want is to run Calc, you can give the commands: @example emacs -f full-calc @end example @noindent or @example emacs -f full-calc-keypad @end example @noindent which run a full-screen Calculator (as if by @kbd{M-# b M-# c}) or a full-screen X-based Calculator (as if by @kbd{M-# b M-# k}). In standalone operation, quitting the Calculator (by pressing @kbd{q} or clicking on the keypad @key{EXIT} button) quits Emacs itself. @node Embedded Mode Overview, Other M-# Commands, Standalone Operation, Using Calc @subsection Embedded Mode (Overview) @noindent @dfn{Embedded Mode} is a way to use Calc directly from inside an editing buffer. Suppose you have a formula written as part of a document like this: @group @smallexample The derivative of ln(ln(x)) is @end smallexample @end group @noindent and you wish to have Calc compute and format the derivative for you and store this derivative in the buffer automatically. To do this with Embedded Mode, first copy the formula down to where you want the result to be: @group @smallexample The derivative of ln(ln(x)) is ln(ln(x)) @end smallexample @end group Now, move the cursor onto this new formula and press @kbd{M-# e}. Calc will read the formula (using the surrounding blank lines to tell how much text to read), then push this formula (invisibly) onto the Calc stack. The cursor will stay on the formula in the editing buffer, but the buffer's mode line will change to look like the Calc mode line (with mode indicators like @samp{12 Deg} and so on). Even though you are still in your editing buffer, the keyboard now acts like the Calc keyboard, and any new result you get is copied from the stack back into the buffer. To take the derivative, you would type @kbd{a d x @key{RET}}. @group @smallexample The derivative of ln(ln(x)) is 1 / ln(x) x @end smallexample @end group To make this look nicer, you might want to press @kbd{d =} to center the formula, and even @kbd{d B} to use ``big'' display mode. @group @smallexample The derivative of ln(ln(x)) is % [calc-mode: justify: center] % [calc-mode: language: big] 1 ------- ln(x) x @end smallexample @end group Calc has added annotations to the file to help it remember the modes that were used for this formula. They are formatted like comments in the @TeX{} typesetting language, just in case you are using @TeX{}. (In this example @TeX{} is not being used, so you might want to move these comments up to the top of the file or otherwise put them out of the way.) As an extra flourish, we can add an equation number using a righthand label: Type @kbd{d @} (1) RET}. @group @smallexample % [calc-mode: justify: center] % [calc-mode: language: big] % [calc-mode: right-label: " (1)"] 1 ------- (1) ln(x) x @end smallexample @end group To leave Embedded Mode, type @kbd{M-# e} again. The mode line and keyboard will revert to the way they were before. (If you have actually been trying this as you read along, you'll want to press @kbd{M-# 0} [with the digit zero] now to reset the modes you changed.) The related command @kbd{M-# w} operates on a single word, which generally means a single number, inside text. It uses any non-numeric characters rather than blank lines to delimit the formula it reads. Here's an example of its use: @smallexample A slope of one-third corresponds to an angle of 1 degrees. @end smallexample Place the cursor on the @samp{1}, then type @kbd{M-# w} to enable Embedded Mode on that number. Now type @kbd{3 /} (to get one-third), and @kbd{I T} (the Inverse Tangent converts a slope into an angle), then @w{@kbd{M-# w}} again to exit Embedded mode. @smallexample A slope of one-third corresponds to an angle of 18.4349488229 degrees. @end smallexample @c [fix-ref Embedded Mode] @xref{Embedded Mode}, for full details. @node Other M-# Commands, , Embedded Mode Overview, Using Calc @subsection Other @kbd{M-#} Commands @noindent Two more Calc-related commands are @kbd{M-# g} and @kbd{M-# r}, which ``grab'' data from a selected region of a buffer into the Calculator. The region is defined in the usual Emacs way, by a ``mark'' placed at one end of the region, and the Emacs cursor or ``point'' placed at the other. The @kbd{M-# g} command reads the region in the usual left-to-right, top-to-bottom order. The result is packaged into a Calc vector of numbers and placed on the stack. Calc (in its standard user interface) is then started. Type @kbd{v u} if you want to unpack this vector into separate numbers on the stack. Also, @kbd{C-u M-# g} interprets the region as a single number or formula. The @kbd{M-# r} command reads a rectangle, with the point and mark defining opposite corners of the rectangle. The result is a matrix of numbers on the Calculator stack. Complementary to these is @kbd{M-# y}, which ``yanks'' the value at the top of the Calc stack back into an editing buffer. If you type @w{@kbd{M-# y}} while in such a buffer, the value is yanked at the current position. If you type @kbd{M-# y} while in the Calc buffer, Calc makes an educated guess as to which editing buffer you want to use. The Calc window does not have to be visible in order to use this command, as long as there is something on the Calc stack. Here, for reference, is the complete list of @kbd{M-#} commands. The shift, control, and meta keys are ignored for the keystroke following @kbd{M-#}. @noindent Commands for turning Calc on and off: @table @kbd @item # Turn Calc on or off, employing the same user interface as last time. @item C Turn Calc on or off using its standard bottom-of-the-screen interface. If Calc is already turned on but the cursor is not in the Calc window, move the cursor into the window. @item O Same as @kbd{C}, but don't select the new Calc window. If Calc is already turned on and the cursor is in the Calc window, move it out of that window. @item B Control whether @kbd{M-# c} and @kbd{M-# k} use the full screen. @item Q Use Quick Mode for a single short calculation. @item K Turn Calc Keypad mode on or off. @item E Turn Calc Embedded mode on or off at the current formula. @item J Turn Calc Embedded mode on or off, select the interesting part. @item W Turn Calc Embedded mode on or off at the current word (number). @item Z Turn Calc on in a user-defined way, as defined by a @kbd{Z I} command. @item X Quit Calc; turn off standard, Keypad, or Embedded mode if on. (This is like @kbd{q} or @key{OFF} inside of Calc.) @end table @iftex @sp 2 @end iftex @group @noindent Commands for moving data into and out of the Calculator: @table @kbd @item G Grab the region into the Calculator as a vector. @item R Grab the rectangular region into the Calculator as a matrix. @item : Grab the rectangular region and compute the sums of its columns. @item _ Grab the rectangular region and compute the sums of its rows. @item Y Yank a value from the Calculator into the current editing buffer. @end table @iftex @sp 2 @end iftex @end group @group @noindent Commands for use with Embedded Mode: @table @kbd @item A ``Activate'' the current buffer. Locate all formulas that contain @samp{:=} or @samp{=>} symbols and record their locations so that they can be updated automatically as variables are changed. @item D Duplicate the current formula immediately below and select the duplicate. @item F Insert a new formula at the current point. @item N Move the cursor to the next active formula in the buffer. @item P Move the cursor to the previous active formula in the buffer. @item U Update (i.e., as if by the @kbd{=} key) the formula at the current point. @item ` Edit (as if by @code{calc-edit}) the formula at the current point. @end table @iftex @sp 2 @end iftex @end group @group @noindent Miscellaneous commands: @table @kbd @item I Run the Emacs Info system to read the Calc manual. (This is the same as @kbd{h i} inside of Calc.) @item T Run the Emacs Info system to read the Calc Tutorial. @item S Run the Emacs Info system to read the Calc Summary. @item L Load Calc entirely into memory. (Normally the various parts are loaded only as they are needed.) @item M Read a region of written keystroke names (like @samp{C-n a b c RET}) and record them as the current keyboard macro. @item 0 (This is the ``zero'' digit key.) Reset the Calculator to its default state: Empty stack, and default mode settings. With any prefix argument, reset everything but the stack. @end table @end group @node History and Acknowledgements, , Using Calc, Getting Started @section History and Acknowledgements @noindent Calc was originally started as a two-week project to occupy a lull in the author's schedule. Basically, a friend asked if I remembered the value of @c{$2^{32}$} @cite{2^32}. I didn't offhand, but I said, ``that's easy, just call up an @code{xcalc}.'' @code{Xcalc} duly reported that the answer to our question was @samp{4.294967e+09}---with no way to see the full ten digits even though we knew they were there in the program's memory! I was so annoyed, I vowed to write a calculator of my own, once and for all. I chose Emacs Lisp, a) because I had always been curious about it and b) because, being only a text editor extension language after all, Emacs Lisp would surely reach its limits long before the project got too far out of hand. To make a long story short, Emacs Lisp turned out to be a distressingly solid implementation of Lisp, and the humble task of calculating turned out to be more open-ended than one might have expected. Emacs Lisp doesn't have built-in floating point math, so it had to be simulated in software. In fact, Emacs integers will only comfortably fit six decimal digits or so---not enough for a decent calculator. So I had to write my own high-precision integer code as well, and once I had this I figured that arbitrary-size integers were just as easy as large integers. Arbitrary floating-point precision was the logical next step. Also, since the large integer arithmetic was there anyway it seemed only fair to give the user direct access to it, which in turn made it practical to support fractions as well as floats. All these features inspired me to look around for other data types that might be worth having. Around this time, my friend Rick Koshi showed me his nifty new HP-28 calculator. It allowed the user to manipulate formulas as well as numerical quantities, and it could also operate on matrices. I decided that these would be good for Calc to have, too. And once things had gone this far, I figured I might as well take a look at serious algebra systems like Mathematica, Macsyma, and Maple for further ideas. Since these systems did far more than I could ever hope to implement, I decided to focus on rewrite rules and other programming features so that users could implement what they needed for themselves. Rick complained that matrices were hard to read, so I put in code to format them in a 2D style. Once these routines were in place, Big mode was obligatory. Gee, what other language modes would be useful? Scott Hemphill and Allen Knutson, two friends with a strong mathematical bent, contributed ideas and algorithms for a number of Calc features including modulo forms, primality testing, and float-to-fraction conversion. Units were added at the eager insistence of Mass Sivilotti. Later, Ulrich Mueller at CERN and Przemek Klosowski at NIST provided invaluable expert assistance with the units table. As far as I can remember, the idea of using algebraic formulas and variables to represent units dates back to an ancient article in Byte magazine about muMath, an early algebra system for microcomputers. Many people have contributed to Calc by reporting bugs and suggesting features, large and small. A few deserve special mention: Tim Peters, who helped develop the ideas that led to the selection commands, rewrite rules, and many other algebra features; @c{Fran\c cois} @asis{Francois} Pinard, who contributed an early prototype of the Calc Summary appendix as well as providing valuable suggestions in many other areas of Calc; Carl Witty, whose eagle eyes discovered many typographical and factual errors in the Calc manual; Tim Kay, who drove the development of Embedded mode; Ove Ewerlid, who made many suggestions relating to the algebra commands and contributed some code for polynomial operations; Randal Schwartz, who suggested the @code{calc-eval} function; Robert J. Chassell, who suggested the Calc Tutorial and exercises; and Juha Sarlin, who first worked out how to split Calc into quickly-loading parts. Bob Weiner helped immensely with the Lucid Emacs port. @cindex Bibliography @cindex Knuth, Art of Computer Programming @cindex Numerical Recipes @c Should these be expanded into more complete references? Among the books used in the development of Calc were Knuth's @emph{Art of Computer Programming} (especially volume II, @emph{Seminumerical Algorithms}); @emph{Numerical Recipes} by Press, Flannery, Teukolsky, and Vetterling; Bevington's @emph{Data Reduction and Error Analysis for the Physical Sciences}; @emph{Concrete Mathematics} by Graham, Knuth, and Patashnik; Steele's @emph{Common Lisp, the Language}; the @emph{CRC Standard Math Tables} (William H. Beyer, ed.); and Abramowitz and Stegun's venerable @emph{Handbook of Mathematical Functions}. I consulted the user's manuals for the HP-28 and HP-48 calculators, as well as for the programs Mathematica, SMP, Macsyma, Maple, MathCAD, Gnuplot, and others. Also, of course, Calc could not have been written without the excellent @emph{GNU Emacs Lisp Reference Manual}, by Bil Lewis and Dan LaLiberte. Final thanks go to Richard Stallman, without whose fine implementations of the Emacs editor, language, and environment, Calc would have been finished in two weeks. @c [tutorial] @ifinfo @c This node is accessed by the `M-# t' command. @node Interactive Tutorial, , , Top @chapter Tutorial @noindent Some brief instructions on using the Emacs Info system for this tutorial: Press the space bar and Delete keys to go forward and backward in a section by screenfuls (or use the regular Emacs scrolling commands for this). Press @kbd{n} or @kbd{p} to go to the Next or Previous section. If the section has a @dfn{menu}, press a digit key like @kbd{1} or @kbd{2} to go to a sub-section from the menu. Press @kbd{u} to go back up from a sub-section to the menu it is part of. Exercises in the tutorial all have cross-references to the appropriate page of the ``answers'' section. Press @kbd{f}, then the exercise number, to see the answer to an exercise. After you have followed a cross-reference, you can press the letter @kbd{l} to return to where you were before. You can press @kbd{?} at any time for a brief summary of Info commands. Press @kbd{1} now to enter the first section of the Tutorial. @menu * Tutorial:: @end menu @end ifinfo @node Tutorial, Introduction, Getting Started, Top @chapter Tutorial @noindent This chapter explains how to use Calc and its many features, in a step-by-step, tutorial way. You are encouraged to run Calc and work along with the examples as you read (@pxref{Starting Calc}). If you are already familiar with advanced calculators, you may wish @c [not-split] to skip on to the rest of this manual. @c [when-split] @c to skip on to volume II of this manual, the @dfn{Calc Reference}. @c [fix-ref Embedded Mode] This tutorial describes the standard user interface of Calc only. The ``Quick Mode'' and ``Keypad Mode'' interfaces are fairly self-explanatory. @xref{Embedded Mode}, for a description of the ``Embedded Mode'' interface. @ifinfo The easiest way to read this tutorial on-line is to have two windows on your Emacs screen, one with Calc and one with the Info system. (If you have a printed copy of the manual you can use that instead.) Press @kbd{M-# c} to turn Calc on or to switch into the Calc window, and press @kbd{M-# i} to start the Info system or to switch into its window. Or, you may prefer to use the tutorial in printed form. @end ifinfo @iftex The easiest way to read this tutorial on-line is to have two windows on your Emacs screen, one with Calc and one with the Info system. (If you have a printed copy of the manual you can use that instead.) Press @kbd{M-# c} to turn Calc on or to switch into the Calc window, and press @kbd{M-# i} to start the Info system or to switch into its window. @end iftex This tutorial is designed to be done in sequence. But the rest of this manual does not assume you have gone through the tutorial. The tutorial does not cover everything in the Calculator, but it touches on most general areas. @ifinfo You may wish to print out a copy of the Calc Summary and keep notes on it as you learn Calc. @xref{Installation}, to see how to make a printed summary. @xref{Summary}. @end ifinfo @iftex The Calc Summary at the end of the reference manual includes some blank space for your own use. You may wish to keep notes there as you learn Calc. @end iftex @menu * Basic Tutorial:: * Arithmetic Tutorial:: * Vector/Matrix Tutorial:: * Types Tutorial:: * Algebra Tutorial:: * Programming Tutorial:: * Answers to Exercises:: @end menu @node Basic Tutorial, Arithmetic Tutorial, Tutorial, Tutorial @section Basic Tutorial @noindent In this section, we learn how RPN and algebraic-style calculations work, how to undo and redo an operation done by mistake, and how to control various modes of the Calculator. @menu * RPN Tutorial:: Basic operations with the stack. * Algebraic Tutorial:: Algebraic entry; variables. * Undo Tutorial:: If you make a mistake: Undo and the trail. * Modes Tutorial:: Common mode-setting commands. @end menu @node RPN Tutorial, Algebraic Tutorial, Basic Tutorial, Basic Tutorial @subsection RPN Calculations and the Stack @cindex RPN notation @ifinfo @noindent Calc normally uses RPN notation. You may be familiar with the RPN system from Hewlett-Packard calculators, FORTH, or PostScript. (Reverse Polish Notation, RPN, is named after the Polish mathematician Jan Lukasiewicz.) @end ifinfo @tex \noindent Calc normally uses RPN notation. You may be familiar with the RPN system from Hewlett-Packard calculators, FORTH, or PostScript. (Reverse Polish Notation, RPN, is named after the Polish mathematician Jan \L ukasiewicz.) @end tex The central component of an RPN calculator is the @dfn{stack}. A calculator stack is like a stack of dishes. New dishes (numbers) are added at the top of the stack, and numbers are normally only removed from the top of the stack. @cindex Operators @cindex Operands In an operation like @cite{2+3}, the 2 and 3 are called the @dfn{operands} and the @cite{+} is the @dfn{operator}. In an RPN calculator you always enter the operands first, then the operator. Each time you type a number, Calc adds or @dfn{pushes} it onto the top of the Stack. When you press an operator key like @kbd{+}, Calc @dfn{pops} the appropriate number of operands from the stack and pushes back the result. Thus we could add the numbers 2 and 3 in an RPN calculator by typing: @kbd{2 @key{RET} 3 @key{RET} +}. (The @key{RET} key, Return, corresponds to the @key{ENTER} key on traditional RPN calculators.) Try this now if you wish; type @kbd{M-# c} to switch into the Calc window (you can type @kbd{M-# c} again or @kbd{M-# o} to switch back to the Tutorial window). The first four keystrokes ``push'' the numbers 2 and 3 onto the stack. The @kbd{+} key ``pops'' the top two numbers from the stack, adds them, and pushes the result (5) back onto the stack. Here's how the stack will look at various points throughout the calculation:@refill @group @smallexample . 1: 2 2: 2 1: 5 . . 1: 3 . . M-# c 2 RET 3 RET + DEL @end smallexample @end group The @samp{.} symbol is a marker that represents the top of the stack. Note that the ``top'' of the stack is really shown at the bottom of the Stack window. This may seem backwards, but it turns out to be less distracting in regular use. @cindex Stack levels @cindex Levels of stack The numbers @samp{1:} and @samp{2:} on the left are @dfn{stack level numbers}. Old RPN calculators always had four stack levels called @cite{x}, @cite{y}, @cite{z}, and @cite{t}. Calc's stack can grow as large as you like, so it uses numbers instead of letters. Some stack-manipulation commands accept a numeric argument that says which stack level to work on. Normal commands like @kbd{+} always work on the top few levels of the stack.@refill @c [fix-ref Truncating the Stack] The Stack buffer is just an Emacs buffer, and you can move around in it using the regular Emacs motion commands. But no matter where the cursor is, even if you have scrolled the @samp{.} marker out of view, most Calc commands always move the cursor back down to level 1 before doing anything. It is possible to move the @samp{.} marker upwards through the stack, temporarily ``hiding'' some numbers from commands like @kbd{+}. This is called @dfn{stack truncation} and we will not cover it in this tutorial; @pxref{Truncating the Stack}, if you are interested. You don't really need the second @key{RET} in @kbd{2 @key{RET} 3 @key{RET} +}. That's because if you type any operator name or other non-numeric key when you are entering a number, the Calculator automatically enters that number and then does the requested command. Thus @kbd{2 @key{RET} 3 +} will work just as well.@refill Examples in this tutorial will often omit @key{RET} even when the stack displays shown would only happen if you did press @key{RET}: @group @smallexample 1: 2 2: 2 1: 5 . 1: 3 . . 2 RET 3 + @end smallexample @end group @noindent Here, after pressing @kbd{3} the stack would really show @samp{1: 2} with @samp{Calc:@: 3} in the minibuffer. In these situations, you can press the optional @key{RET} to see the stack as the figure shows. (@bullet{}) @strong{Exercise 1.} (This tutorial will include exercises at various points. Try them if you wish. Answers to all the exercises are located at the end of the Tutorial chapter. Each exercise will include a cross-reference to its particular answer. If you are reading with the Emacs Info system, press @kbd{f} and the exercise number to go to the answer, then the letter @kbd{l} to return to where you were.) @noindent Here's the first exercise: What will the keystrokes @kbd{1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -} compute? (@samp{*} is the symbol for multiplication.) Figure it out by hand, then try it with Calc to see if you're right. @xref{RPN Answer 1, 1}. (@bullet{}) (@bullet{}) @strong{Exercise 2.} Compute @c{$(2\times4) + (7\times9.4) + {5\over4}$} @cite{2*4 + 7*9.5 + 5/4} using the stack. @xref{RPN Answer 2, 2}. (@bullet{}) The @key{DEL} key is called Backspace on some keyboards. It is whatever key you would use to correct a simple typing error when regularly using Emacs. The @key{DEL} key pops and throws away the top value on the stack. (You can still get that value back from the Trail if you should need it later on.) There are many places in this tutorial where we assume you have used @key{DEL} to erase the results of the previous example at the beginning of a new example. In the few places where it is really important to use @key{DEL} to clear away old results, the text will remind you to do so. (It won't hurt to let things accumulate on the stack, except that whenever you give a display-mode-changing command Calc will have to spend a long time reformatting such a large stack.) Since the @kbd{-} key is also an operator (it subtracts the top two stack elements), how does one enter a negative number? Calc uses the @kbd{_} (underscore) key to act like the minus sign in a number. So, typing @kbd{-5 @key{RET}} won't work because the @kbd{-} key will try to do a subtraction, but @kbd{_5 @key{RET}} works just fine. You can also press @kbd{n}, which means ``change sign.'' It changes the number at the top of the stack (or the number being entered) from positive to negative or vice-versa: @kbd{5 n @key{RET}}. @cindex Duplicating a stack entry If you press @key{RET} when you're not entering a number, the effect is to duplicate the top number on the stack. Consider this calculation: @group @smallexample 1: 3 2: 3 1: 9 2: 9 1: 81 . 1: 3 . 1: 9 . . . 3 RET RET * RET * @end smallexample @end group @noindent (Of course, an easier way to do this would be @kbd{3 @key{RET} 4 ^}, to raise 3 to the fourth power.) The space-bar key (denoted @key{SPC} here) performs the same function as @key{RET}; you could replace all three occurrences of @key{RET} in the above example with @key{SPC} and the effect would be the same. @cindex Exchanging stack entries Another stack manipulation key is @key{TAB}. This exchanges the top two stack entries. Suppose you have computed @kbd{2 @key{RET} 3 +} to get 5, and then you realize what you really wanted to compute was @cite{20 / (2+3)}. @group @smallexample 1: 5 2: 5 2: 20 1: 4 . 1: 20 1: 5 . . . 2 RET 3 + 20 TAB / @end smallexample @end group @noindent Planning ahead, the calculation would have gone like this: @group @smallexample 1: 20 2: 20 3: 20 2: 20 1: 4 . 1: 2 2: 2 1: 5 . . 1: 3 . . 20 RET 2 RET 3 + / @end smallexample @end group A related stack command is @kbd{M-@key{TAB}} (hold @key{META} and type @key{TAB}). It rotates the top three elements of the stack upward, bringing the object in level 3 to the top. @group @smallexample 1: 10 2: 10 3: 10 3: 20 3: 30 . 1: 20 2: 20 2: 30 2: 10 . 1: 30 1: 10 1: 20 . . . 10 RET 20 RET 30 RET M-TAB M-TAB @end smallexample @end group (@bullet{}) @strong{Exercise 3.} Suppose the numbers 10, 20, and 30 are on the stack. Figure out how to add one to the number in level 2 without affecting the rest of the stack. Also figure out how to add one to the number in level 3. @xref{RPN Answer 3, 3}. (@bullet{}) Operations like @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, and @kbd{^} pop two arguments from the stack and push a result. Operations like @kbd{n} and @kbd{Q} (square root) pop a single number and push the result. You can think of them as simply operating on the top element of the stack. @group @smallexample 1: 3 1: 9 2: 9 1: 25 1: 5 . . 1: 16 . . . 3 RET RET * 4 RET RET * + Q @end smallexample @end group @noindent (Note that capital @kbd{Q} means to hold down the Shift key while typing @kbd{q}. Remember, plain unshifted @kbd{q} is the Quit command.) @cindex Pythagorean Theorem Here we've used the Pythagorean Theorem to determine the hypotenuse of a right triangle. Calc actually has a built-in command for that called @kbd{f h}, but let's suppose we can't remember the necessary keystrokes. We can still enter it by its full name using @kbd{M-x} notation: @group @smallexample 1: 3 2: 3 1: 5 . 1: 4 . . 3 RET 4 RET M-x calc-hypot @end smallexample @end group All Calculator commands begin with the word @samp{calc-}. Since it gets tiring to type this, Calc provides an @kbd{x} key which is just like the regular Emacs @kbd{M-x} key except that it types the @samp{calc-} prefix for you: @group @smallexample 1: 3 2: 3 1: 5 . 1: 4 . . 3 RET 4 RET x hypot @end smallexample @end group What happens if you take the square root of a negative number? @group @smallexample 1: 4 1: -4 1: (0, 2) . . . 4 RET n Q @end smallexample @end group @noindent The notation @cite{(a, b)} represents a complex number. Complex numbers are more traditionally written @c{$a + b i$} @cite{a + b i}; Calc can display in this format, too, but for now we'll stick to the @cite{(a, b)} notation. If you don't know how complex numbers work, you can safely ignore this feature. Complex numbers only arise from operations that would be errors in a calculator that didn't have complex numbers. (For example, taking the square root or logarithm of a negative number produces a complex result.) Complex numbers are entered in the notation shown. The @kbd{(} and @kbd{,} and @kbd{)} keys manipulate ``incomplete complex numbers.'' @group @smallexample 1: ( ... 2: ( ... 1: (2, ... 1: (2, ... 1: (2, 3) . 1: 2 . 3 . . . ( 2 , 3 ) @end smallexample @end group You can perform calculations while entering parts of incomplete objects. However, an incomplete object cannot actually participate in a calculation: @group @smallexample 1: ( ... 2: ( ... 3: ( ... 1: ( ... 1: ( ... . 1: 2 2: 2 5 5 . 1: 3 . . . (error) ( 2 RET 3 + + @end smallexample @end group @noindent Adding 5 to an incomplete object makes no sense, so the last command produces an error message and leaves the stack the same. Incomplete objects can't participate in arithmetic, but they can be moved around by the regular stack commands. @group @smallexample 2: 2 3: 2 3: 3 1: ( ... 1: (2, 3) 1: 3 2: 3 2: ( ... 2 . . 1: ( ... 1: 2 3 . . . 2 RET 3 RET ( M-TAB M-TAB ) @end smallexample @end group @noindent Note that the @kbd{,} (comma) key did not have to be used here. When you press @kbd{)} all the stack entries between the incomplete entry and the top are collected, so there's never really a reason to use the comma. It's up to you. (@bullet{}) @strong{Exercise 4.} To enter the complex number @cite{(2, 3)}, your friend Joe typed @kbd{( 2 , @key{SPC} 3 )}. What happened? (Joe thought of a clever way to correct his mistake in only two keystrokes, but it didn't quite work. Try it to find out why.) @xref{RPN Answer 4, 4}. (@bullet{}) Vectors are entered the same way as complex numbers, but with square brackets in place of parentheses. We'll meet vectors again later in the tutorial. Any Emacs command can be given a @dfn{numeric prefix argument} by typing a series of @key{META}-digits beforehand. If @key{META} is awkward for you, you can instead type @kbd{C-u} followed by the necessary digits. Numeric prefix arguments can be negative, as in @kbd{M-- M-3 M-5} or @w{@kbd{C-u - 3 5}}. Calc commands use numeric prefix arguments in a variety of ways. For example, a numeric prefix on the @kbd{+} operator adds any number of stack entries at once: @group @smallexample 1: 10 2: 10 3: 10 3: 10 1: 60 . 1: 20 2: 20 2: 20 . . 1: 30 1: 30 . . 10 RET 20 RET 30 RET C-u 3 + @end smallexample @end group For stack manipulation commands like @key{RET}, a positive numeric prefix argument operates on the top @var{n} stack entries at once. A negative argument operates on the entry in level @var{n} only. An argument of zero operates on the entire stack. In this example, we copy the second-to-top element of the stack: @group @smallexample 1: 10 2: 10 3: 10 3: 10 4: 10 . 1: 20 2: 20 2: 20 3: 20 . 1: 30 1: 30 2: 30 . . 1: 20 . 10 RET 20 RET 30 RET C-u -2 RET @end smallexample @end group @cindex Clearing the stack @cindex Emptying the stack Another common idiom is @kbd{M-0 DEL}, which clears the stack. (The @kbd{M-0} numeric prefix tells @key{DEL} to operate on the entire stack.) @node Algebraic Tutorial, Undo Tutorial, RPN Tutorial, Basic Tutorial @subsection Algebraic-Style Calculations @noindent If you are not used to RPN notation, you may prefer to operate the Calculator in ``algebraic mode,'' which is closer to the way non-RPN calculators work. In algebraic mode, you enter formulas in traditional @cite{2+3} notation. You don't really need any special ``mode'' to enter algebraic formulas. You can enter a formula at any time by pressing the apostrophe (@kbd{'}) key. Answer the prompt with the desired formula, then press @key{RET}. The formula is evaluated and the result is pushed onto the RPN stack. If you don't want to think in RPN at all, you can enter your whole computation as a formula, read the result from the stack, then press @key{DEL} to delete it from the stack. Try pressing the apostrophe key, then @kbd{2+3+4}, then @key{RET}. The result should be the number 9. Algebraic formulas use the operators @samp{+}, @samp{-}, @samp{*}, @samp{/}, and @samp{^}. You can use parentheses to make the order of evaluation clear. In the absence of parentheses, @samp{^} is evaluated first, then @samp{*}, then @samp{/}, then finally @samp{+} and @samp{-}. For example, the expression @example 2 + 3*4*5 / 6*7^8 - 9 @end example @noindent is equivalent to @example 2 + ((3*4*5) / (6*(7^8)) - 9 @end example @noindent or, in large mathematical notation, @ifinfo @group @example 3 * 4 * 5 2 + --------- - 9 8 6 * 7 @end example @end group @end ifinfo @tex \turnoffactive \beforedisplay $$ 2 + { 3 \times 4 \times 5 \over 6 \times 7^8 } - 9 $$ \afterdisplay @end tex @noindent The result of this expression will be the number @i{-6.99999826533}. Calc's order of evaluation is the same as for most computer languages, except that @samp{*} binds more strongly than @samp{/}, as the above example shows. As in normal mathematical notation, the @samp{*} symbol can often be omitted: @samp{2 a} is the same as @samp{2*a}. Operators at the same level are evaluated from left to right, except that @samp{^} is evaluated from right to left. Thus, @samp{2-3-4} is equivalent to @samp{(2-3)-4} or @i{-5}, whereas @samp{2^3^4} is equivalent to @samp{2^(3^4)} (a very large integer; try it!). If you tire of typing the apostrophe all the time, there is an ``algebraic mode'' you can select in which Calc automatically senses when you are about to type an algebraic expression. To enter this mode, press the two letters @w{@kbd{m a}}. (An @samp{Alg} indicator should appear in the Calc window's mode line.) Press @kbd{m a}, then @kbd{2+3+4} with no apostrophe, then @key{RET}. In algebraic mode, when you press any key that would normally begin entering a number (such as a digit, a decimal point, or the @kbd{_} key), or if you press @kbd{(} or @kbd{[}, Calc automatically begins an algebraic entry. Functions which do not have operator symbols like @samp{+} and @samp{*} must be entered in formulas using function-call notation. For example, the function name corresponding to the square-root key @kbd{Q} is @code{sqrt}. To compute a square root in a formula, you would use the notation @samp{sqrt(@var{x})}. Press the apostrophe, then type @kbd{sqrt(5*2) - 3}. The result should be @cite{0.16227766017}. Note that if the formula begins with a function name, you need to use the apostrophe even if you are in algebraic mode. If you type @kbd{arcsin} out of the blue, the @kbd{a r} will be taken as an Algebraic Rewrite command, and the @kbd{csin} will be taken as the name of the rewrite rule to use! Some people prefer to enter complex numbers and vectors in algebraic form because they find RPN entry with incomplete objects to be too distracting, even though they otherwise use Calc as an RPN calculator. Still in algebraic mode, type: @group @smallexample 1: (2, 3) 2: (2, 3) 1: (8, -1) 2: (8, -1) 1: (9, -1) . 1: (1, -2) . 1: 1 . . . (2,3) RET (1,-2) RET * 1 RET + @end smallexample @end group Algebraic mode allows us to enter complex numbers without pressing an apostrophe first, but it also means we need to press @key{RET} after every entry, even for a simple number like @cite{1}. (You can type @kbd{C-u m a} to enable a special ``incomplete algebraic mode'' in which the @kbd{(} and @kbd{[} keys use algebraic entry even though regular numeric keys still use RPN numeric entry. There is also a ``total algebraic mode,'' started by typing @kbd{m t}, in which all normal keys begin algebraic entry. You must then use the @key{META} key to type Calc commands: @kbd{M-m t} to get back out of total algebraic mode, @kbd{M-q} to quit, etc. Total algebraic mode is not supported under Emacs 19.) If you're still in algebraic mode, press @kbd{m a} again to turn it off. Actual non-RPN calculators use a mixture of algebraic and RPN styles. In general, operators of two numbers (like @kbd{+} and @kbd{*}) use algebraic form, but operators of one number (like @kbd{n} and @kbd{Q}) use RPN form. Also, a non-RPN calculator allows you to see the intermediate results of a calculation as you go along. You can accomplish this in Calc by performing your calculation as a series of algebraic entries, using the @kbd{$} sign to tie them together. In an algebraic formula, @kbd{$} represents the number on the top of the stack. Here, we perform the calculation @c{$\sqrt{2\times4+1}$} @cite{sqrt(2*4+1)}, which on a traditional calculator would be done by pressing @kbd{2 * 4 + 1 =} and then the square-root key. @group @smallexample 1: 8 1: 9 1: 3 . . . ' 2*4 RET $+1 RET Q @end smallexample @end group @noindent Notice that we didn't need to press an apostrophe for the @kbd{$+1}, because the dollar sign always begins an algebraic entry. (@bullet{}) @strong{Exercise 1.} How could you get the same effect as pressing @kbd{Q} but using an algebraic entry instead? How about if the @kbd{Q} key on your keyboard were broken? @xref{Algebraic Answer 1, 1}. (@bullet{}) The notations @kbd{$$}, @kbd{$$$}, and so on stand for higher stack entries. For example, @kbd{' $$+$ RET} is just like typing @kbd{+}. Algebraic formulas can include @dfn{variables}. To store in a variable, press @kbd{s s}, then type the variable name, then press @key{RET}. (There are actually two flavors of store command: @kbd{s s} stores a number in a variable but also leaves the number on the stack, while @w{@kbd{s t}} removes a number from the stack and stores it in the variable.) A variable name should consist of one or more letters or digits, beginning with a letter. @group @smallexample 1: 17 . 1: a + a^2 1: 306 . . . 17 s t a RET ' a+a^2 RET = @end smallexample @end group @noindent The @kbd{=} key @dfn{evaluates} a formula by replacing all its variables by the values that were stored in them. For RPN calculations, you can recall a variable's value on the stack either by entering its name as a formula and pressing @kbd{=}, or by using the @kbd{s r} command. @group @smallexample 1: 17 2: 17 3: 17 2: 17 1: 306 . 1: 17 2: 17 1: 289 . . 1: 2 . . s r a RET ' a RET = 2 ^ + @end smallexample @end group If you press a single digit for a variable name (as in @kbd{s t 3}, you get one of ten @dfn{quick variables} @code{q0} through @code{q9}. They are ``quick'' simply because you don't have to type the letter @code{q} or the @key{RET} after their names. In fact, you can type simply @kbd{s 3} as a shorthand for @kbd{s s 3}, and likewise for @kbd{t 3} and @w{@kbd{r 3}}. Any variables in an algebraic formula for which you have not stored values are left alone, even when you evaluate the formula. @group @smallexample 1: 2 a + 2 b 1: 34 + 2 b . . ' 2a+2b RET = @end smallexample @end group Calls to function names which are undefined in Calc are also left alone, as are calls for which the value is undefined. @group @smallexample 1: 2 + log10(0) + log10(x) + log10(5, 6) + foo(3) . ' log10(100) + log10(0) + log10(x) + log10(5,6) + foo(3) RET @end smallexample @end group @noindent In this example, the first call to @code{log10} works, but the other calls are not evaluated. In the second call, the logarithm is undefined for that value of the argument; in the third, the argument is symbolic, and in the fourth, there are too many arguments. In the fifth case, there is no function called @code{foo}. You will see a ``Wrong number of arguments'' message referring to @samp{log10(5,6)}. Press the @kbd{w} (``why'') key to see any other messages that may have arisen from the last calculation. In this case you will get ``logarithm of zero,'' then ``number expected: @code{x}''. Calc automatically displays the first message only if the message is sufficiently important; for example, Calc considers ``wrong number of arguments'' and ``logarithm of zero'' to be important enough to report automatically, while a message like ``number expected: @code{x}'' will only show up if you explicitly press the @kbd{w} key. (@bullet{}) @strong{Exercise 2.} Joe entered the formula @samp{2 x y}, stored 5 in @code{x}, pressed @kbd{=}, and got the expected result, @samp{10 y}. He then tried the same for the formula @samp{2 x (1+y)}, expecting @samp{10 (1+y)}, but it didn't work. Why not? @xref{Algebraic Answer 2, 2}. (@bullet{}) (@bullet{}) @strong{Exercise 3.} What result would you expect @kbd{1 @key{RET} 0 /} to give? What if you then type @kbd{0 *}? @xref{Algebraic Answer 3, 3}. (@bullet{}) One interesting way to work with variables is to use the @dfn{evaluates-to} (@samp{=>}) operator. It works like this: Enter a formula algebraically in the usual way, but follow the formula with an @samp{=>} symbol. (There is also an @kbd{s =} command which builds an @samp{=>} formula using the stack.) On the stack, you will see two copies of the formula with an @samp{=>} between them. The lefthand formula is exactly like you typed it; the righthand formula has been evaluated as if by typing @kbd{=}. @group @smallexample 2: 2 + 3 => 5 2: 2 + 3 => 5 1: 2 a + 2 b => 34 + 2 b 1: 2 a + 2 b => 20 + 2 b . . ' 2+3 => RET ' 2a+2b RET s = 10 s t a RET @end smallexample @end group @noindent Notice that the instant we stored a new value in @code{a}, all @samp{=>} operators already on the stack that referred to @cite{a} were updated to use the new value. With @samp{=>}, you can push a set of formulas on the stack, then change the variables experimentally to see the effects on the formulas' values. You can also ``unstore'' a variable when you are through with it: @group @smallexample 2: 2 + 5 => 5 1: 2 a + 2 b => 2 a + 2 b . s u a RET @end smallexample @end group We will encounter formulas involving variables and functions again when we discuss the algebra and calculus features of the Calculator. @node Undo Tutorial, Modes Tutorial, Algebraic Tutorial, Basic Tutorial @subsection Undo and Redo @noindent If you make a mistake, you can usually correct it by pressing shift-@kbd{U}, the ``undo'' command. First, clear the stack (@kbd{M-0 DEL}) and exit and restart Calc (@kbd{M-# M-# M-# M-#}) to make sure things start off with a clean slate. Now: @group @smallexample 1: 2 2: 2 1: 8 2: 2 1: 6 . 1: 3 . 1: 3 . . . 2 RET 3 ^ U * @end smallexample @end group You can undo any number of times. Calc keeps a complete record of all you have done since you last opened the Calc window. After the above example, you could type: @group @smallexample 1: 6 2: 2 1: 2 . . . 1: 3 . . (error) U U U U @end smallexample @end group You can also type @kbd{D} to ``redo'' a command that you have undone mistakenly. @group @smallexample . 1: 2 2: 2 1: 6 1: 6 . 1: 3 . . . (error) D D D D @end smallexample @end group @noindent It was not possible to redo past the @cite{6}, since that was placed there by something other than an undo command. @cindex Time travel You can think of undo and redo as a sort of ``time machine.'' Press @kbd{U} to go backward in time, @kbd{D} to go forward. If you go backward and do something (like @kbd{*}) then, as any science fiction reader knows, you have changed your future and you cannot go forward again. Thus, the inability to redo past the @cite{6} even though there was an earlier undo command. You can always recall an earlier result using the Trail. We've ignored the trail so far, but it has been faithfully recording everything we did since we loaded the Calculator. If the Trail is not displayed, press @kbd{t d} now to turn it on. Let's try grabbing an earlier result. The @cite{8} we computed was undone by a @kbd{U} command, and was lost even to Redo when we pressed @kbd{*}, but it's still there in the trail. There should be a little @samp{>} arrow (the @dfn{trail pointer}) resting on the last trail entry. If there isn't, press @kbd{t ]} to reset the trail pointer. Now, press @w{@kbd{t p}} to move the arrow onto the line containing @cite{8}, and press @w{@kbd{t y}} to ``yank'' that number back onto the stack. If you press @kbd{t ]} again, you will see that even our Yank command went into the trail. Let's go further back in time. Earlier in the tutorial we computed a huge integer using the formula @samp{2^3^4}. We don't remember what it was, but the first digits were ``241''. Press @kbd{t r} (which stands for trail-search-reverse), then type @kbd{241}. The trail cursor will jump back to the next previous occurrence of the string ``241'' in the trail. This is just a regular Emacs incremental search; you can now press @kbd{C-s} or @kbd{C-r} to continue the search forwards or backwards as you like. To finish the search, press @key{RET}. This halts the incremental search and leaves the trail pointer at the thing we found. Now we can type @kbd{t y} to yank that number onto the stack. If we hadn't remembered the ``241'', we could simply have searched for @kbd{2^3^4}, then pressed @kbd{@key{RET} t n} to halt and then move to the next item. You may have noticed that all the trail-related commands begin with the letter @kbd{t}. (The store-and-recall commands, on the other hand, all began with @kbd{s}.) Calc has so many commands that there aren't enough keys for all of them, so various commands are grouped into two-letter sequences where the first letter is called the @dfn{prefix} key. If you type a prefix key by accident, you can press @kbd{C-g} to cancel it. (In fact, you can press @kbd{C-g} to cancel almost anything in Emacs.) To get help on a prefix key, press that key followed by @kbd{?}. Some prefixes have several lines of help, so you need to press @kbd{?} repeatedly to see them all. This may not work under Lucid Emacs, but you can also type @kbd{h h} to see all the help at once. Try pressing @kbd{t ?} now. You will see a line of the form, @smallexample trail/time: Display; Fwd, Back; Next, Prev, Here, [, ]; Yank: [MORE] t- @end smallexample @noindent The word ``trail'' indicates that the @kbd{t} prefix key contains trail-related commands. Each entry on the line shows one command, with a single capital letter showing which letter you press to get that command. We have used @kbd{t n}, @kbd{t p}, @kbd{t ]}, and @kbd{t y} so far. The @samp{[MORE]} means you can press @kbd{?} again to see more @kbd{t}-prefix comands. Notice that the commands are roughly divided (by semicolons) into related groups. When you are in the help display for a prefix key, the prefix is still active. If you press another key, like @kbd{y} for example, it will be interpreted as a @kbd{t y} command. If all you wanted was to look at the help messages, press @kbd{C-g} afterwards to cancel the prefix. One more way to correct an error is by editing the stack entries. The actual Stack buffer is marked read-only and must not be edited directly, but you can press @kbd{`} (the backquote or accent grave) to edit a stack entry. Try entering @samp{3.141439} now. If this is supposed to represent @c{$\pi$} @cite{pi}, it's got several errors. Press @kbd{`} to edit this number. Now use the normal Emacs cursor motion and editing keys to change the second 4 to a 5, and to transpose the 3 and the 9. When you press @key{RET}, the number on the stack will be replaced by your new number. This works for formulas, vectors, and all other types of values you can put on the stack. The @kbd{`} key also works during entry of a number or algebraic formula. @node Modes Tutorial, , Undo Tutorial, Basic Tutorial @subsection Mode-Setting Commands @noindent Calc has many types of @dfn{modes} that affect the way it interprets your commands or the way it displays data. We have already seen one mode, namely algebraic mode. There are many others, too; we'll try some of the most common ones here. Perhaps the most fundamental mode in Calc is the current @dfn{precision}. Notice the @samp{12} on the Calc window's mode line: @smallexample --%%-Calc: 12 Deg (Calculator)----All------ @end smallexample @noindent Most of the symbols there are Emacs things you don't need to worry about, but the @samp{12} and the @samp{Deg} are mode indicators. The @samp{12} means that calculations should always be carried to 12 significant figures. That is why, when we type @kbd{1 @key{RET} 7 /}, we get @cite{0.142857142857} with exactly 12 digits, not counting leading and trailing zeros. You can set the precision to anything you like by pressing @kbd{p}, then entering a suitable number. Try pressing @kbd{p 30 @key{RET}}, then doing @kbd{1 @key{RET} 7 /} again: @group @smallexample 1: 0.142857142857 2: 0.142857142857142857142857142857 . @end smallexample @end group Although the precision can be set arbitrarily high, Calc always has to have @emph{some} value for the current precision. After all, the true value @cite{1/7} is an infinitely repeating decimal; Calc has to stop somewhere. Of course, calculations are slower the more digits you request. Press @w{@kbd{p 12}} now to set the precision back down to the default. Calculations always use the current precision. For example, even though we have a 30-digit value for @cite{1/7} on the stack, if we use it in a calculation in 12-digit mode it will be rounded down to 12 digits before it is used. Try it; press @key{RET} to duplicate the number, then @w{@kbd{1 +}}. Notice that the @key{RET} key didn't round the number, because it doesn't do any calculation. But the instant we pressed @kbd{+}, the number was rounded down. @group @smallexample 1: 0.142857142857 2: 0.142857142857142857142857142857 3: 1.14285714286 . @end smallexample @end group @noindent In fact, since we added a digit on the left, we had to lose one digit on the right from even the 12-digit value of @cite{1/7}. How did we get more than 12 digits when we computed @samp{2^3^4}? The answer is that Calc makes a distinction between @dfn{integers} and @dfn{floating-point} numbers, or @dfn{floats}. An integer is a number that does not contain a decimal point. There is no such thing as an ``infinitely repeating fraction integer,'' so Calc doesn't have to limit itself. If you asked for @samp{2^10000} (don't try this!), you would have to wait a long time but you would eventually get an exact answer. If you ask for @samp{2.^10000}, you will quickly get an answer which is correct only to 12 places. The decimal point tells Calc that it should use floating-point arithmetic to get the answer, not exact integer arithmetic. You can use the @kbd{F} (@code{calc-floor}) command to convert a floating-point value to an integer, and @kbd{c f} (@code{calc-float}) to convert an integer to floating-point form. Let's try entering that last calculation: @group @smallexample 1: 2. 2: 2. 1: 1.99506311689e3010 . 1: 10000 . . 2.0 RET 10000 RET ^ @end smallexample @end group @noindent @cindex Scientific notation, entry of Notice the letter @samp{e} in there. It represents ``times ten to the power of,'' and is used by Calc automatically whenever writing the number out fully would introduce more extra zeros than you probably want to see. You can enter numbers in this notation, too. @group @smallexample 1: 2. 2: 2. 1: 1.99506311678e3010 . 1: 10000. . . 2.0 RET 1e4 RET ^ @end smallexample @end group @cindex Round-off errors @noindent Hey, the answer is different! Look closely at the middle columns of the two examples. In the first, the stack contained the exact integer @cite{10000}, but in the second it contained a floating-point value with a decimal point. When you raise a number to an integer power, Calc uses repeated squaring and multiplication to get the answer. When you use a floating-point power, Calc uses logarithms and exponentials. As you can see, a slight error crept in during one of these methods. Which one should we trust? Let's raise the precision a bit and find out: @group @smallexample . 1: 2. 2: 2. 1: 1.995063116880828e3010 . 1: 10000. . . p 16 RET 2. RET 1e4 ^ p 12 RET @end smallexample @end group @noindent @cindex Guard digits Presumably, it doesn't matter whether we do this higher-precision calculation using an integer or floating-point power, since we have added enough ``guard digits'' to trust the first 12 digits no matter what. And the verdict is@dots{} Integer powers were more accurate; in fact, the result was only off by one unit in the last place. @cindex Guard digits Calc does many of its internal calculations to a slightly higher precision, but it doesn't always bump the precision up enough. In each case, Calc added about two digits of precision during its calculation and then rounded back down to 12 digits afterward. In one case, it was enough; in the the other, it wasn't. If you really need @var{x} digits of precision, it never hurts to do the calculation with a few extra guard digits. What if we want guard digits but don't want to look at them? We can set the @dfn{float format}. Calc supports four major formats for floating-point numbers, called @dfn{normal}, @dfn{fixed-point}, @dfn{scientific notation}, and @dfn{engineering notation}. You get them by pressing @w{@kbd{d n}}, @kbd{d f}, @kbd{d s}, and @kbd{d e}, respectively. In each case, you can supply a numeric prefix argument which says how many digits should be displayed. As an example, let's put a few numbers onto the stack and try some different display modes. First, use @kbd{M-0 DEL} to clear the stack, then enter the four numbers shown here: @group @smallexample 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345 3: 12345. 3: 12300. 3: 1.2345e4 3: 1.23e4 3: 12345.000 2: 123.45 2: 123. 2: 1.2345e2 2: 1.23e2 2: 123.450 1: 12.345 1: 12.3 1: 1.2345e1 1: 1.23e1 1: 12.345 . . . . . d n M-3 d n d s M-3 d s M-3 d f @end smallexample @end group @noindent Notice that when we typed @kbd{M-3 d n}, the numbers were rounded down to three significant digits, but then when we typed @kbd{d s} all five significant figures reappeared. The float format does not affect how numbers are stored, it only affects how they are displayed. Only the current precision governs the actual rounding of numbers in the Calculator's memory. Engineering notation, not shown here, is like scientific notation except the exponent (the power-of-ten part) is always adjusted to be a multiple of three (as in ``kilo,'' ``micro,'' etc.). As a result there will be one, two, or three digits before the decimal point. Whenever you change a display-related mode, Calc redraws everything in the stack. This may be slow if there are many things on the stack, so Calc allows you to type shift-@kbd{H} before any mode command to prevent it from updating the stack. Anything Calc displays after the mode-changing command will appear in the new format. @group @smallexample 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345 3: 12345.000 3: 12345.000 3: 12345.000 3: 1.2345e4 3: 12345. 2: 123.450 2: 123.450 2: 1.2345e1 2: 1.2345e1 2: 123.45 1: 12.345 1: 1.2345e1 1: 1.2345e2 1: 1.2345e2 1: 12.345 . . . . . H d s DEL U TAB d SPC d n @end smallexample @end group @noindent Here the @kbd{H d s} command changes to scientific notation but without updating the screen. Deleting the top stack entry and undoing it back causes it to show up in the new format; swapping the top two stack entries reformats both entries. The @kbd{d SPC} command refreshes the whole stack. The @kbd{d n} command changes back to the normal float format; since it doesn't have an @kbd{H} prefix, it also updates all the stack entries to be in @kbd{d n} format. Notice that the integer @cite{12345} was not affected by any of the float formats. Integers are integers, and are always displayed exactly. @cindex Large numbers, readability Large integers have their own problems. Let's look back at the result of @kbd{2^3^4}. @example 2417851639229258349412352 @end example @noindent Quick---how many digits does this have? Try typing @kbd{d g}: @example 2,417,851,639,229,258,349,412,352 @end example @noindent Now how many digits does this have? It's much easier to tell! We can actually group digits into clumps of any size. Some people prefer @kbd{M-5 d g}: @example 24178,51639,22925,83494,12352 @end example Let's see what happens to floating-point numbers when they are grouped. First, type @kbd{p 25 @key{RET}} to make sure we have enough precision to get ourselves into trouble. Now, type @kbd{1e13 /}: @example 24,17851,63922.9258349412352 @end example @noindent The integer part is grouped but the fractional part isn't. Now try @kbd{M-- M-5 d g} (that's meta-minus-sign, meta-five): @example 24,17851,63922.92583,49412,352 @end example If you find it hard to tell the decimal point from the commas, try changing the grouping character to a space with @kbd{d , @key{SPC}}: @example 24 17851 63922.92583 49412 352 @end example Type @kbd{d , ,} to restore the normal grouping character, then @kbd{d g} again to turn grouping off. Also, press @kbd{p 12} to restore the default precision. Press @kbd{U} enough times to get the original big integer back. (Notice that @kbd{U} does not undo each mode-setting command; if you want to undo a mode-setting command, you have to do it yourself.) Now, type @kbd{d r 16 @key{RET}}: @example 16#200000000000000000000 @end example @noindent The number is now displayed in @dfn{hexadecimal}, or ``base-16'' form. Suddenly it looks pretty simple; this should be no surprise, since we got this number by computing a power of two, and 16 is a power of 2. In fact, we can use @w{@kbd{d r 2 @key{RET}}} to see it in actual binary form: @example 2#1000000000000000000000000000000000000000000000000000000 @dots{} @end example @noindent We don't have enough space here to show all the zeros! They won't fit on a typical screen, either, so you will have to use horizontal scrolling to see them all. Press @kbd{<} and @kbd{>} to scroll the stack window left and right by half its width. Another way to view something large is to press @kbd{`} (back-quote) to edit the top of stack in a separate window. (Press @kbd{M-# M-#} when you are done.) You can enter non-decimal numbers using the @kbd{#} symbol, too. Let's see what the hexadecimal number @samp{5FE} looks like in binary. Type @kbd{16#5FE} (the letters can be typed in upper or lower case; they will always appear in upper case). It will also help to turn grouping on with @kbd{d g}: @example 2#101,1111,1110 @end example Notice that @kbd{d g} groups by fours by default if the display radix is binary or hexadecimal, but by threes if it is decimal, octal, or any other radix. Now let's see that number in decimal; type @kbd{d r 10}: @example 1,534 @end example Numbers are not @emph{stored} with any particular radix attached. They're just numbers; they can be entered in any radix, and are always displayed in whatever radix you've chosen with @kbd{d r}. The current radix applies to integers, fractions, and floats. @cindex Roundoff errors, in non-decimal numbers (@bullet{}) @strong{Exercise 1.} Your friend Joe tried to enter one-third as @samp{3#0.1} in @kbd{d r 3} mode with a precision of 12. He got @samp{3#0.0222222...} (with 25 2's) in the display. When he multiplied that by three, he got @samp{3#0.222222...} instead of the expected @samp{3#1}. Next, Joe entered @samp{3#0.2} and, to his great relief, saw @samp{3#0.2} on the screen. But when he typed @kbd{2 /}, he got @samp{3#0.10000001} (some zeros omitted). What's going on here? @xref{Modes Answer 1, 1}. (@bullet{}) @cindex Scientific notation, in non-decimal numbers (@bullet{}) @strong{Exercise 2.} Scientific notation works in non-decimal modes in the natural way (the exponent is a power of the radix instead of a power of ten, although the exponent itself is always written in decimal). Thus @samp{8#1.23e3 = 8#1230.0}. Suppose we have the hexadecimal number @samp{f.e8f} times 16 to the 15th power: We write @samp{16#f.e8fe15}. What is wrong with this picture? What could we write instead that would work better? @xref{Modes Answer 2, 2}. (@bullet{}) The @kbd{m} prefix key has another set of modes, relating to the way Calc interprets your inputs and does computations. Whereas @kbd{d}-prefix modes generally affect the way things look, @kbd{m}-prefix modes affect the way they are actually computed. The most popular @kbd{m}-prefix mode is the @dfn{angular mode}. Notice the @samp{Deg} indicator in the mode line. This means that if you use a command that interprets a number as an angle, it will assume the angle is measured in degrees. For example, @group @smallexample 1: 45 1: 0.707106781187 1: 0.500000000001 1: 0.5 . . . . 45 S 2 ^ c 1 @end smallexample @end group @noindent The shift-@kbd{S} command computes the sine of an angle. The sine of 45 degrees is @c{$\sqrt{2}/2$} @cite{sqrt(2)/2}; squaring this yields @cite{2/4 = 0.5}. However, there has been a slight roundoff error because the representation of @c{$\sqrt{2}/2$} @cite{sqrt(2)/2} wasn't exact. The @kbd{c 1} command is a handy way to clean up numbers in this case; it temporarily reduces the precision by one digit while it re-rounds the number on the top of the stack. @cindex Roundoff errors, examples (@bullet{}) @strong{Exercise 3.} Your friend Joe computed the sine of 45 degrees as shown above, then, hoping to avoid an inexact result, he increased the precision to 16 digits before squaring. What happened? @xref{Modes Answer 3, 3}. (@bullet{}) To do this calculation in radians, we would type @kbd{m r} first. (The indicator changes to @samp{Rad}.) 45 degrees corresponds to @c{$\pi\over4$} @cite{pi/4} radians. To get @c{$\pi$} @cite{pi}, press the @kbd{P} key. (Once again, this is a shifted capital @kbd{P}. Remember, unshifted @kbd{p} sets the precision.) @group @smallexample 1: 3.14159265359 1: 0.785398163398 1: 0.707106781187 . . . P 4 / m r S @end smallexample @end group Likewise, inverse trigonometric functions generate results in either radians or degrees, depending on the current angular mode. @group @smallexample 1: 0.707106781187 1: 0.785398163398 1: 45. . . . .5 Q m r I S m d U I S @end smallexample @end group @noindent Here we compute the Inverse Sine of @c{$\sqrt{0.5}$} @cite{sqrt(0.5)}, first in radians, then in degrees. Use @kbd{c d} and @kbd{c r} to convert a number from radians to degrees and vice-versa. @group @smallexample 1: 45 1: 0.785398163397 1: 45. . . . 45 c r c d @end smallexample @end group Another interesting mode is @dfn{fraction mode}. Normally, dividing two integers produces a floating-point result if the quotient can't be expressed as an exact integer. Fraction mode causes integer division to produce a fraction, i.e., a rational number, instead. @group @smallexample 2: 12 1: 1.33333333333 1: 4:3 1: 9 . . . 12 RET 9 / m f U / m f @end smallexample @end group @noindent In the first case, we get an approximate floating-point result. In the second case, we get an exact fractional result (four-thirds). You can enter a fraction at any time using @kbd{:} notation. (Calc uses @kbd{:} instead of @kbd{/} as the fraction separator because @kbd{/} is already used to divide the top two stack elements.) Calculations involving fractions will always produce exact fractional results; fraction mode only says what to do when dividing two integers. @cindex Fractions vs. floats @cindex Floats vs. fractions (@bullet{}) @strong{Exercise 4.} If fractional arithmetic is exact, why would you ever use floating-point numbers instead? @xref{Modes Answer 4, 4}. (@bullet{}) Typing @kbd{m f} doesn't change any existing values in the stack. In the above example, we had to Undo the division and do it over again when we changed to fraction mode. But if you use the evaluates-to operator you can get commands like @kbd{m f} to recompute for you. @group @smallexample 1: 12 / 9 => 1.33333333333 1: 12 / 9 => 1.333 1: 12 / 9 => 4:3 . . . ' 12/9 => RET p 4 RET m f @end smallexample @end group @noindent In this example, the righthand side of the @samp{=>} operator on the stack is recomputed when we change the precision, then again when we change to fraction mode. All @samp{=>} expressions on the stack are recomputed every time you change any mode that might affect their values. @node Arithmetic Tutorial, Vector/Matrix Tutorial, Basic Tutorial, Tutorial @section Arithmetic Tutorial @noindent In this section, we explore the arithmetic and scientific functions available in the Calculator. The standard arithmetic commands are @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, and @kbd{^}. Each normally takes two numbers from the top of the stack and pushes back a result. The @kbd{n} and @kbd{&} keys perform change-sign and reciprocal operations, respectively. @group @smallexample 1: 5 1: 0.2 1: 5. 1: -5. 1: 5. . . . . . 5 & & n n @end smallexample @end group @cindex Binary operators You can apply a ``binary operator'' like @kbd{+} across any number of stack entries by giving it a numeric prefix. You can also apply it pairwise to several stack elements along with the top one if you use a negative prefix. @group @smallexample 3: 2 1: 9 3: 2 4: 2 3: 12 2: 3 . 2: 3 3: 3 2: 13 1: 4 1: 4 2: 4 1: 14 . . 1: 10 . . 2 RET 3 RET 4 M-3 + U 10 M-- M-3 + @end smallexample @end group @cindex Unary operators You can apply a ``unary operator'' like @kbd{&} to the top @var{n} stack entries with a numeric prefix, too. @group @smallexample 3: 2 3: 0.5 3: 0.5 2: 3 2: 0.333333333333 2: 3. 1: 4 1: 0.25 1: 4. . . . 2 RET 3 RET 4 M-3 & M-2 & @end smallexample @end group Notice that the results here are left in floating-point form. We can convert them back to integers by pressing @kbd{F}, the ``floor'' function. This function rounds down to the next lower integer. There is also @kbd{R}, which rounds to the nearest integer. @group @smallexample 7: 2. 7: 2 7: 2 6: 2.4 6: 2 6: 2 5: 2.5 5: 2 5: 3 4: 2.6 4: 2 4: 3 3: -2. 3: -2 3: -2 2: -2.4 2: -3 2: -2 1: -2.6 1: -3 1: -3 . . . M-7 F U M-7 R @end smallexample @end group Since dividing-and-flooring (i.e., ``integer quotient'') is such a common operation, Calc provides a special command for that purpose, the backslash @kbd{\}. Another common arithmetic operator is @kbd{%}, which computes the remainder that would arise from a @kbd{\} operation, i.e., the ``modulo'' of two numbers. For example, @group @smallexample 2: 1234 1: 12 2: 1234 1: 34 1: 100 . 1: 100 . . . 1234 RET 100 \ U % @end smallexample @end group These commands actually work for any real numbers, not just integers. @group @smallexample 2: 3.1415 1: 3 2: 3.1415 1: 0.1415 1: 1 . 1: 1 . . . 3.1415 RET 1 \ U % @end smallexample @end group (@bullet{}) @strong{Exercise 1.} The @kbd{\} command would appear to be a frill, since you could always do the same thing with @kbd{/ F}. Think of a situation where this is not true---@kbd{/ F} would be inadequate. Now think of a way you could get around the problem if Calc didn't provide a @kbd{\} command. @xref{Arithmetic Answer 1, 1}. (@bullet{}) We've already seen the @kbd{Q} (square root) and @kbd{S} (sine) commands. Other commands along those lines are @kbd{C} (cosine), @kbd{T} (tangent), @kbd{E} (@cite{e^x}) and @kbd{L} (natural logarithm). These can be modified by the @kbd{I} (inverse) and @kbd{H} (hyperbolic) prefix keys. Let's compute the sine and cosine of an angle, and verify the identity @c{$\sin^2x + \cos^2x = 1$} @cite{sin(x)^2 + cos(x)^2 = 1}. We'll arbitrarily pick @i{-64} degrees as a good value for @cite{x}. With the angular mode set to degrees (type @w{@kbd{m d}}), do: @group @smallexample 2: -64 2: -64 2: -0.89879 2: -0.89879 1: 1. 1: -64 1: -0.89879 1: -64 1: 0.43837 . . . . . 64 n RET RET S TAB C f h @end smallexample @end group @noindent (For brevity, we're showing only five digits of the results here. You can of course do these calculations to any precision you like.) Remember, @kbd{f h} is the @code{calc-hypot}, or square-root of sum of squares, command. Another identity is @c{$\displaystyle\tan x = {\sin x \over \cos x}$} @cite{tan(x) = sin(x) / cos(x)}. @group @smallexample 2: -0.89879 1: -2.0503 1: -64. 1: 0.43837 . . . U / I T @end smallexample @end group A physical interpretation of this calculation is that if you move @cite{0.89879} units downward and @cite{0.43837} units to the right, your direction of motion is @i{-64} degrees from horizontal. Suppose we move in the opposite direction, up and to the left: @group @smallexample 2: -0.89879 2: 0.89879 1: -2.0503 1: -64. 1: 0.43837 1: -0.43837 . . . . U U M-2 n / I T @end smallexample @end group @noindent How can the angle be the same? The answer is that the @kbd{/} operation loses information about the signs of its inputs. Because the quotient is negative, we know exactly one of the inputs was negative, but we can't tell which one. There is an @kbd{f T} [@code{arctan2}] function which computes the inverse tangent of the quotient of a pair of numbers. Since you feed it the two original numbers, it has enough information to give you a full 360-degree answer. @group @smallexample 2: 0.89879 1: 116. 3: 116. 2: 116. 1: 180. 1: -0.43837 . 2: -0.89879 1: -64. . . 1: 0.43837 . . U U f T M-RET M-2 n f T - @end smallexample @end group @noindent The resulting angles differ by 180 degrees; in other words, they point in opposite directions, just as we would expect. The @key{META}-@key{RET} we used in the third step is the ``last-arguments'' command. It is sort of like Undo, except that it restores the arguments of the last command to the stack without removing the command's result. It is useful in situations like this one, where we need to do several operations on the same inputs. We could have accomplished the same thing by using @kbd{M-2 @key{RET}} to duplicate the top two stack elements right after the @kbd{U U}, then a pair of @kbd{M-@key{TAB}} commands to cycle the 116 up around the duplicates. A similar identity is supposed to hold for hyperbolic sines and cosines, except that it is the @emph{difference} @c{$\cosh^2x - \sinh^2x$} @cite{cosh(x)^2 - sinh(x)^2} that always equals one. Let's try to verify this identity.@refill @group @smallexample 2: -64 2: -64 2: -64 2: 9.7192e54 2: 9.7192e54 1: -64 1: -3.1175e27 1: 9.7192e54 1: -64 1: 9.7192e54 . . . . . 64 n RET RET H C 2 ^ TAB H S 2 ^ @end smallexample @end group @noindent @cindex Roundoff errors, examples Something's obviously wrong, because when we subtract these numbers the answer will clearly be zero! But if you think about it, if these numbers @emph{did} differ by one, it would be in the 55th decimal place. The difference we seek has been lost entirely to roundoff error. We could verify this hypothesis by doing the actual calculation with, say, 60 decimal places of precision. This will be slow, but not enormously so. Try it if you wish; sure enough, the answer is 0.99999, reasonably close to 1. Of course, a more reasonable way to verify the identity is to use a more reasonable value for @cite{x}! @cindex Common logarithm Some Calculator commands use the Hyperbolic prefix for other purposes. The logarithm and exponential functions, for example, work to the base @cite{e} normally but use base-10 instead if you use the Hyperbolic prefix. @group @smallexample 1: 1000 1: 6.9077 1: 1000 1: 3 . . . . 1000 L U H L @end smallexample @end group @noindent First, we mistakenly compute a natural logarithm. Then we undo and compute a common logarithm instead. The @kbd{B} key computes a general base-@var{b} logarithm for any value of @var{b}. @group @smallexample 2: 1000 1: 3 1: 1000. 2: 1000. 1: 6.9077 1: 10 . . 1: 2.71828 . . . 1000 RET 10 B H E H P B @end smallexample @end group @noindent Here we first use @kbd{B} to compute the base-10 logarithm, then use the ``hyperbolic'' exponential as a cheap hack to recover the number 1000, then use @kbd{B} again to compute the natural logarithm. Note that @kbd{P} with the hyperbolic prefix pushes the constant @cite{e} onto the stack. You may have noticed that both times we took the base-10 logarithm of 1000, we got an exact integer result. Calc always tries to give an exact rational result for calculations involving rational numbers where possible. But when we used @kbd{H E}, the result was a floating-point number for no apparent reason. In fact, if we had computed @kbd{10 @key{RET} 3 ^} we @emph{would} have gotten an exact integer 1000. But the @kbd{H E} command is rigged to generate a floating-point result all of the time so that @kbd{1000 H E} will not waste time computing a thousand-digit integer when all you probably wanted was @samp{1e1000}. (@bullet{}) @strong{Exercise 2.} Find a pair of integer inputs to the @kbd{B} command for which Calc could find an exact rational result but doesn't. @xref{Arithmetic Answer 2, 2}. (@bullet{}) The Calculator also has a set of functions relating to combinatorics and statistics. You may be familiar with the @dfn{factorial} function, which computes the product of all the integers up to a given number. @group @smallexample 1: 100 1: 93326215443... 1: 100. 1: 9.3326e157 . . . . 100 ! U c f ! @end smallexample @end group @noindent Recall, the @kbd{c f} command converts the integer or fraction at the top of the stack to floating-point format. If you take the factorial of a floating-point number, you get a floating-point result accurate to the current precision. But if you give @kbd{!} an exact integer, you get an exact integer result (158 digits long in this case). If you take the factorial of a non-integer, Calc uses a generalized factorial function defined in terms of Euler's Gamma function @c{$\Gamma(n)$} @cite{gamma(n)} (which is itself available as the @kbd{f g} command). @group @smallexample 3: 4. 3: 24. 1: 5.5 1: 52.342777847 2: 4.5 2: 52.3427777847 . . 1: 5. 1: 120. . . M-3 ! M-0 DEL 5.5 f g @end smallexample @end group @noindent Here we verify the identity @c{$n! = \Gamma(n+1)$} @cite{@var{n}!@: = gamma(@var{n}+1)}. The binomial coefficient @var{n}-choose-@var{m}@c{ or $\displaystyle {n \choose m}$} @asis{} is defined by @c{$\displaystyle {n! \over m! \, (n-m)!}$} @cite{n!@: / m!@: (n-m)!} for all reals @cite{n} and @cite{m}. The intermediate results in this formula can become quite large even if the final result is small; the @kbd{k c} command computes a binomial coefficient in a way that avoids large intermediate values. The @kbd{k} prefix key defines several common functions out of combinatorics and number theory. Here we compute the binomial coefficient 30-choose-20, then determine its prime factorization. @group @smallexample 2: 30 1: 30045015 1: [3, 3, 5, 7, 11, 13, 23, 29] 1: 20 . . . 30 RET 20 k c k f @end smallexample @end group @noindent You can verify these prime factors by using @kbd{v u} to ``unpack'' this vector into 8 separate stack entries, then @kbd{M-8 *} to multiply them back together. The result is the original number, 30045015. @cindex Hash tables Suppose a program you are writing needs a hash table with at least 10000 entries. It's best to use a prime number as the actual size of a hash table. Calc can compute the next prime number after 10000: @group @smallexample 1: 10000 1: 10007 1: 9973 . . . 10000 k n I k n @end smallexample @end group @noindent Just for kicks we've also computed the next prime @emph{less} than 10000. @c [fix-ref Financial Functions] @xref{Financial Functions}, for a description of the Calculator commands that deal with business and financial calculations (functions like @code{pv}, @code{rate}, and @code{sln}). @c [fix-ref Binary Number Functions] @xref{Binary Functions}, to read about the commands for operating on binary numbers (like @code{and}, @code{xor}, and @code{lsh}). @node Vector/Matrix Tutorial, Types Tutorial, Arithmetic Tutorial, Tutorial @section Vector/Matrix Tutorial @noindent A @dfn{vector} is a list of numbers or other Calc data objects. Calc provides a large set of commands that operate on vectors. Some are familiar operations from vector analysis. Others simply treat a vector as a list of objects. @menu * Vector Analysis Tutorial:: * Matrix Tutorial:: * List Tutorial:: @end menu @node Vector Analysis Tutorial, Matrix Tutorial, Vector/Matrix Tutorial, Vector/Matrix Tutorial @subsection Vector Analysis @noindent If you add two vectors, the result is a vector of the sums of the elements, taken pairwise. @group @smallexample 1: [1, 2, 3] 2: [1, 2, 3] 1: [8, 8, 3] . 1: [7, 6, 0] . . [1,2,3] s 1 [7 6 0] s 2 + @end smallexample @end group @noindent Note that we can separate the vector elements with either commas or spaces. This is true whether we are using incomplete vectors or algebraic entry. The @kbd{s 1} and @kbd{s 2} commands save these vectors so we can easily reuse them later. If you multiply two vectors, the result is the sum of the products of the elements taken pairwise. This is called the @dfn{dot product} of the vectors. @group @smallexample 2: [1, 2, 3] 1: 19 1: [7, 6, 0] . . r 1 r 2 * @end smallexample @end group @cindex Dot product The dot product of two vectors is equal to the product of their lengths times the cosine of the angle between them. (Here the vector is interpreted as a line from the origin @cite{(0,0,0)} to the specified point in three-dimensional space.) The @kbd{A} (absolute value) command can be used to compute the length of a vector. @group @smallexample 3: 19 3: 19 1: 0.550782 1: 56.579 2: [1, 2, 3] 2: 3.741657 . . 1: [7, 6, 0] 1: 9.219544 . . M-RET M-2 A * / I C @end smallexample @end group @noindent First we recall the arguments to the dot product command, then we compute the absolute values of the top two stack entries to obtain the lengths of the vectors, then we divide the dot product by the product of the lengths to get the cosine of the angle. The inverse cosine finds that the angle between the vectors is about 56 degrees. @cindex Cross product @cindex Perpendicular vectors The @dfn{cross product} of two vectors is a vector whose length is the product of the lengths of the inputs times the sine of the angle between them, and whose direction is perpendicular to both input vectors. Unlike the dot product, the cross product is defined only for three-dimensional vectors. Let's double-check our computation of the angle using the cross product. @group @smallexample 2: [1, 2, 3] 3: [-18, 21, -8] 1: [-0.52, 0.61, -0.23] 1: 56.579 1: [7, 6, 0] 2: [1, 2, 3] . . . 1: [7, 6, 0] . r 1 r 2 V C s 3 M-RET M-2 A * / A I S @end smallexample @end group @noindent First we recall the original vectors and compute their cross product, which we also store for later reference. Now we divide the vector by the product of the lengths of the original vectors. The length of this vector should be the sine of the angle; sure enough, it is! @c [fix-ref General Mode Commands] Vector-related commands generally begin with the @kbd{v} prefix key. Some are uppercase letters and some are lowercase. To make it easier to type these commands, the shift-@kbd{V} prefix key acts the same as the @kbd{v} key. (@xref{General Mode Commands}, for a way to make all prefix keys have this property.) If we take the dot product of two perpendicular vectors we expect to get zero, since the cosine of 90 degrees is zero. Let's check that the cross product is indeed perpendicular to both inputs: @group @smallexample 2: [1, 2, 3] 1: 0 2: [7, 6, 0] 1: 0 1: [-18, 21, -8] . 1: [-18, 21, -8] . . . r 1 r 3 * DEL r 2 r 3 * @end smallexample @end group @cindex Normalizing a vector @cindex Unit vectors (@bullet{}) @strong{Exercise 1.} Given a vector on the top of the stack, what keystrokes would you use to @dfn{normalize} the vector, i.e., to reduce its length to one without changing its direction? @xref{Vector Answer 1, 1}. (@bullet{}) (@bullet{}) @strong{Exercise 2.} Suppose a certain particle can be at any of several positions along a ruler. You have a list of those positions in the form of a vector, and another list of the probabilities for the particle to be at the corresponding positions. Find the average position of the particle. @xref{Vector Answer 2, 2}. (@bullet{}) @node Matrix Tutorial, List Tutorial, Vector Analysis Tutorial, Vector/Matrix Tutorial @subsection Matrices @noindent A @dfn{matrix} is just a vector of vectors, all the same length. This means you can enter a matrix using nested brackets. You can also use the semicolon character to enter a matrix. We'll show both methods here: @group @smallexample 1: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ] [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] . . [[1 2 3] [4 5 6]] ' [1 2 3; 4 5 6] RET @end smallexample @end group @noindent We'll be using this matrix again, so type @kbd{s 4} to save it now. Note that semicolons work with incomplete vectors, but they work better in algebraic entry. That's why we use the apostrophe in the second example. When two matrices are multiplied, the lefthand matrix must have the same number of columns as the righthand matrix has rows. Row @cite{i}, column @cite{j} of the result is effectively the dot product of row @cite{i} of the left matrix by column @cite{j} of the right matrix. If we try to duplicate this matrix and multiply it by itself, the dimensions are wrong and the multiplication cannot take place: @group @smallexample 1: [ [ 1, 2, 3 ] * [ [ 1, 2, 3 ] [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] . RET * @end smallexample @end group @noindent Though rather hard to read, this is a formula which shows the product of two matrices. The @samp{*} function, having invalid arguments, has been left in symbolic form. We can multiply the matrices if we @dfn{transpose} one of them first. @group @smallexample 2: [ [ 1, 2, 3 ] 1: [ [ 14, 32 ] 1: [ [ 17, 22, 27 ] [ 4, 5, 6 ] ] [ 32, 77 ] ] [ 22, 29, 36 ] 1: [ [ 1, 4 ] . [ 27, 36, 45 ] ] [ 2, 5 ] . [ 3, 6 ] ] . U v t * U TAB * @end smallexample @end group Matrix multiplication is not commutative; indeed, switching the order of the operands can even change the dimensions of the result matrix, as happened here! If you multiply a plain vector by a matrix, it is treated as a single row or column depending on which side of the matrix it is on. The result is a plain vector which should also be interpreted as a row or column as appropriate. @group @smallexample 2: [ [ 1, 2, 3 ] 1: [14, 32] [ 4, 5, 6 ] ] . 1: [1, 2, 3] . r 4 r 1 * @end smallexample @end group Multiplying in the other order wouldn't work because the number of rows in the matrix is different from the number of elements in the vector. (@bullet{}) @strong{Exercise 1.} Use @samp{*} to sum along the rows of the above @c{$2\times3$} @asis{2x3} matrix to get @cite{[6, 15]}. Now use @samp{*} to sum along the columns to get @cite{[5, 7, 9]}. @xref{Matrix Answer 1, 1}. (@bullet{}) @cindex Identity matrix An @dfn{identity matrix} is a square matrix with ones along the diagonal and zeros elsewhere. It has the property that multiplication by an identity matrix, on the left or on the right, always produces the original matrix. @group @smallexample 1: [ [ 1, 2, 3 ] 2: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ] [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] . 1: [ [ 1, 0, 0 ] . [ 0, 1, 0 ] [ 0, 0, 1 ] ] . r 4 v i 3 RET * @end smallexample @end group If a matrix is square, it is often possible to find its @dfn{inverse}, that is, a matrix which, when multiplied by the original matrix, yields an identity matrix. The @kbd{&} (reciprocal) key also computes the inverse of a matrix. @group @smallexample 1: [ [ 1, 2, 3 ] 1: [ [ -2.4, 1.2, -0.2 ] [ 4, 5, 6 ] [ 2.8, -1.4, 0.4 ] [ 7, 6, 0 ] ] [ -0.73333, 0.53333, -0.2 ] ] . . r 4 r 2 | s 5 & @end smallexample @end group @noindent The vertical bar @kbd{|} @dfn{concatenates} numbers, vectors, and matrices together. Here we have used it to add a new row onto our matrix to make it square. We can multiply these two matrices in either order to get an identity. @group @smallexample 1: [ [ 1., 0., 0. ] 1: [ [ 1., 0., 0. ] [ 0., 1., 0. ] [ 0., 1., 0. ] [ 0., 0., 1. ] ] [ 0., 0., 1. ] ] . . M-RET * U TAB * @end smallexample @end group @cindex Systems of linear equations @cindex Linear equations, systems of Matrix inverses are related to systems of linear equations in algebra. Suppose we had the following set of equations: @ifinfo @group @example a + 2b + 3c = 6 4a + 5b + 6c = 2 7a + 6b = 3 @end example @end group @end ifinfo @tex \turnoffactive \beforedisplayh $$ \openup1\jot \tabskip=0pt plus1fil \halign to\displaywidth{\tabskip=0pt $\hfil#$&$\hfil{}#{}$& $\hfil#$&$\hfil{}#{}$& $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr a&+&2b&+&3c&=6 \cr 4a&+&5b&+&6c&=2 \cr 7a&+&6b& & &=3 \cr} $$ \afterdisplayh @end tex @noindent This can be cast into the matrix equation, @ifinfo @group @example [ [ 1, 2, 3 ] [ [ a ] [ [ 6 ] [ 4, 5, 6 ] * [ b ] = [ 2 ] [ 7, 6, 0 ] ] [ c ] ] [ 3 ] ] @end example @end group @end ifinfo @tex \turnoffactive \beforedisplay $$ \pmatrix{ 1 & 2 & 3 \cr 4 & 5 & 6 \cr 7 & 6 & 0 } \times \pmatrix{ a \cr b \cr c } = \pmatrix{ 6 \cr 2 \cr 3 } $$ \afterdisplay @end tex We can solve this system of equations by multiplying both sides by the inverse of the matrix. Calc can do this all in one step: @group @smallexample 2: [6, 2, 3] 1: [-12.6, 15.2, -3.93333] 1: [ [ 1, 2, 3 ] . [ 4, 5, 6 ] [ 7, 6, 0 ] ] . [6,2,3] r 5 / @end smallexample @end group @noindent The result is the @cite{[a, b, c]} vector that solves the equations. (Dividing by a square matrix is equivalent to multiplying by its inverse.) Let's verify this solution: @group @smallexample 2: [ [ 1, 2, 3 ] 1: [6., 2., 3.] [ 4, 5, 6 ] . [ 7, 6, 0 ] ] 1: [-12.6, 15.2, -3.93333] . r 5 TAB * @end smallexample @end group @noindent Note that we had to be careful about the order in which we multiplied the matrix and vector. If we multiplied in the other order, Calc would assume the vector was a row vector in order to make the dimensions come out right, and the answer would be incorrect. If you don't feel safe letting Calc take either interpretation of your vectors, use explicit @c{$N\times1$} @asis{Nx1} or @c{$1\times N$} @asis{1xN} matrices instead. In this case, you would enter the original column vector as @samp{[[6], [2], [3]]} or @samp{[6; 2; 3]}. (@bullet{}) @strong{Exercise 2.} Algebraic entry allows you to make vectors and matrices that include variables. Solve the following system of equations to get expressions for @cite{x} and @cite{y} in terms of @cite{a} and @cite{b}. @ifinfo @group @example x + a y = 6 x + b y = 10 @end example @end group @end ifinfo @tex \turnoffactive \beforedisplay $$ \eqalign{ x &+ a y = 6 \cr x &+ b y = 10} $$ \afterdisplay @end tex @noindent @xref{Matrix Answer 2, 2}. (@bullet{}) @cindex Least-squares for over-determined systems @cindex Over-determined systems of equations (@bullet{}) @strong{Exercise 3.} A system of equations is ``over-determined'' if it has more equations than variables. It is often the case that there are no values for the variables that will satisfy all the equations at once, but it is still useful to find a set of values which ``nearly'' satisfy all the equations. In terms of matrix equations, you can't solve @cite{A X = B} directly because the matrix @cite{A} is not square for an over-determined system. Matrix inversion works only for square matrices. One common trick is to multiply both sides on the left by the transpose of @cite{A}: @ifinfo @samp{trn(A)*A*X = trn(A)*B}. @end ifinfo @tex \turnoffactive $A^T A \, X = A^T B$, where $A^T$ is the transpose \samp{trn(A)}. @end tex Now @c{$A^T A$} @cite{trn(A)*A} is a square matrix so a solution is possible. It turns out that the @cite{X} vector you compute in this way will be a ``least-squares'' solution, which can be regarded as the ``closest'' solution to the set of equations. Use Calc to solve the following over-determined system:@refill @ifinfo @group @example a + 2b + 3c = 6 4a + 5b + 6c = 2 7a + 6b = 3 2a + 4b + 6c = 11 @end example @end group @end ifinfo @tex \turnoffactive \beforedisplayh $$ \openup1\jot \tabskip=0pt plus1fil \halign to\displaywidth{\tabskip=0pt $\hfil#$&$\hfil{}#{}$& $\hfil#$&$\hfil{}#{}$& $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr a&+&2b&+&3c&=6 \cr 4a&+&5b&+&6c&=2 \cr 7a&+&6b& & &=3 \cr 2a&+&4b&+&6c&=11 \cr} $$ \afterdisplayh @end tex @noindent @xref{Matrix Answer 3, 3}. (@bullet{}) @node List Tutorial, , Matrix Tutorial, Vector/Matrix Tutorial @subsection Vectors as Lists @noindent @cindex Lists Although Calc has a number of features for manipulating vectors and matrices as mathematical objects, you can also treat vectors as simple lists of values. For example, we saw that the @kbd{k f} command returns a vector which is a list of the prime factors of a number. You can pack and unpack stack entries into vectors: @group @smallexample 3: 10 1: [10, 20, 30] 3: 10 2: 20 . 2: 20 1: 30 1: 30 . . M-3 v p v u @end smallexample @end group You can also build vectors out of consecutive integers, or out of many copies of a given value: @group @smallexample 1: [1, 2, 3, 4] 2: [1, 2, 3, 4] 2: [1, 2, 3, 4] . 1: 17 1: [17, 17, 17, 17] . . v x 4 RET 17 v b 4 RET @end smallexample @end group You can apply an operator to every element of a vector using the @dfn{map} command. @group @smallexample 1: [17, 34, 51, 68] 1: [289, 1156, 2601, 4624] 1: [17, 34, 51, 68] . . . V M * 2 V M ^ V M Q @end smallexample @end group @noindent In the first step, we multiply the vector of integers by the vector of 17's elementwise. In the second step, we raise each element to the power two. (The general rule is that both operands must be vectors of the same length, or else one must be a vector and the other a plain number.) In the final step, we take the square root of each element. (@bullet{}) @strong{Exercise 1.} Compute a vector of powers of two from @c{$2^{-4}$} @cite{2^-4} to @cite{2^4}. @xref{List Answer 1, 1}. (@bullet{}) You can also @dfn{reduce} a binary operator across a vector. For example, reducing @samp{*} computes the product of all the elements in the vector: @group @smallexample 1: 123123 1: [3, 7, 11, 13, 41] 1: 123123 . . . 123123 k f V R * @end smallexample @end group @noindent In this example, we decompose 123123 into its prime factors, then multiply those factors together again to yield the original number. We could compute a dot product ``by hand'' using mapping and reduction: @group @smallexample 2: [1, 2, 3] 1: [7, 12, 0] 1: 19 1: [7, 6, 0] . . . r 1 r 2 V M * V R + @end smallexample @end group @noindent Recalling two vectors from the previous section, we compute the sum of pairwise products of the elements to get the same answer for the dot product as before. A slight variant of vector reduction is the @dfn{accumulate} operation, @kbd{V U}. This produces a vector of the intermediate results from a corresponding reduction. Here we compute a table of factorials: @group @smallexample 1: [1, 2, 3, 4, 5, 6] 1: [1, 2, 6, 24, 120, 720] . . v x 6 RET V U * @end smallexample @end group Calc allows vectors to grow as large as you like, although it gets rather slow if vectors have more than about a hundred elements. Actually, most of the time is spent formatting these large vectors for display, not calculating on them. Try the following experiment (if your computer is very fast you may need to substitute a larger vector size). @group @smallexample 1: [1, 2, 3, 4, ... 1: [2, 3, 4, 5, ... . . v x 500 RET 1 V M + @end smallexample @end group Now press @kbd{v .} (the letter @kbd{v}, then a period) and try the experiment again. In @kbd{v .} mode, long vectors are displayed ``abbreviated'' like this: @group @smallexample 1: [1, 2, 3, ..., 500] 1: [2, 3, 4, ..., 501] . . v x 500 RET 1 V M + @end smallexample @end group @noindent (where now the @samp{...} is actually part of the Calc display). You will find both operations are now much faster. But notice that even in @w{@kbd{v .}} mode, the full vectors are still shown in the Trail. Type @w{@kbd{t .}} to cause the trail to abbreviate as well, and try the experiment one more time. Operations on long vectors are now quite fast! (But of course if you use @kbd{t .} you will lose the ability to get old vectors back using the @kbd{t y} command.) An easy way to view a full vector when @kbd{v .} mode is active is to press @kbd{`} (back-quote) to edit the vector; editing always works with the full, unabbreviated value. @cindex Least-squares for fitting a straight line @cindex Fitting data to a line @cindex Line, fitting data to @cindex Data, extracting from buffers @cindex Columns of data, extracting As a larger example, let's try to fit a straight line to some data, using the method of least squares. (Calc has a built-in command for least-squares curve fitting, but we'll do it by hand here just to practice working with vectors.) Suppose we have the following list of values in a file we have loaded into Emacs: @smallexample x y --- --- 1.34 0.234 1.41 0.298 1.49 0.402 1.56 0.412 1.64 0.466 1.73 0.473 1.82 0.601 1.91 0.519 2.01 0.603 2.11 0.637 2.22 0.645 2.33 0.705 2.45 0.917 2.58 1.009 2.71 0.971 2.85 1.062 3.00 1.148 3.15 1.157 3.32 1.354 @end smallexample @noindent If you are reading this tutorial in printed form, you will find it easiest to press @kbd{M-# i} to enter the on-line Info version of the manual and find this table there. (Press @kbd{g}, then type @kbd{List Tutorial}, to jump straight to this section.) Position the cursor at the upper-left corner of this table, just to the left of the @cite{1.34}. Press @kbd{C-@@} to set the mark. (On your system this may be @kbd{C-2}, @kbd{C-SPC}, or @kbd{NUL}.) Now position the cursor to the lower-right, just after the @cite{1.354}. You have now defined this region as an Emacs ``rectangle.'' Still in the Info buffer, type @kbd{M-# r}. This command (@code{calc-grab-rectangle}) will pop you back into the Calculator, with the contents of the rectangle you specified in the form of a matrix.@refill @group @smallexample 1: [ [ 1.34, 0.234 ] [ 1.41, 0.298 ] @dots{} @end smallexample @end group @noindent (You may wish to use @kbd{v .} mode to abbreviate the display of this large matrix.) We want to treat this as a pair of lists. The first step is to transpose this matrix into a pair of rows. Remember, a matrix is just a vector of vectors. So we can unpack the matrix into a pair of row vectors on the stack. @group @smallexample 1: [ [ 1.34, 1.41, 1.49, ... ] 2: [1.34, 1.41, 1.49, ... ] [ 0.234, 0.298, 0.402, ... ] ] 1: [0.234, 0.298, 0.402, ... ] . . v t v u @end smallexample @end group @noindent Let's store these in quick variables 1 and 2, respectively. @group @smallexample 1: [1.34, 1.41, 1.49, ... ] . . t 2 t 1 @end smallexample @end group @noindent (Recall that @kbd{t 2} is a variant of @kbd{s 2} that removes the stored value from the stack.) In a least squares fit, the slope @cite{m} is given by the formula @ifinfo @example m = (N sum(x y) - sum(x) sum(y)) / (N sum(x^2) - sum(x)^2) @end example @end ifinfo @tex \turnoffactive \beforedisplay $$ m = {N \sum x y - \sum x \sum y \over N \sum x^2 - \left( \sum x \right)^2} $$ \afterdisplay @end tex @noindent where @c{$\sum x$} @cite{sum(x)} represents the sum of all the values of @cite{x}. While there is an actual @code{sum} function in Calc, it's easier to sum a vector using a simple reduction. First, let's compute the four different sums that this formula uses. @group @smallexample 1: 41.63 1: 98.0003 . . r 1 V R + t 3 r 1 2 V M ^ V R + t 4 @end smallexample @end group @noindent @group @smallexample 1: 13.613 1: 33.36554 . . r 2 V R + t 5 r 1 r 2 V M * V R + t 6 @end smallexample @end group @ifinfo @noindent These are @samp{sum(x)}, @samp{sum(x^2)}, @samp{sum(y)}, and @samp{sum(x y)}, respectively. (We could have used @kbd{*} to compute @samp{sum(x^2)} and @samp{sum(x y)}.) @end ifinfo @tex \turnoffactive These are $\sum x$, $\sum x^2$, $\sum y$, and $\sum x y$, respectively. (We could have used \kbd{*} to compute $\sum x^2$ and $\sum x y$.) @end tex Finally, we also need @cite{N}, the number of data points. This is just the length of either of our lists. @group @smallexample 1: 19 . r 1 v l t 7 @end smallexample @end group @noindent (That's @kbd{v} followed by a lower-case @kbd{l}.) Now we grind through the formula: @group @smallexample 1: 633.94526 2: 633.94526 1: 67.23607 . 1: 566.70919 . . r 7 r 6 * r 3 r 5 * - @end smallexample @end group @noindent @group @smallexample 2: 67.23607 3: 67.23607 2: 67.23607 1: 0.52141679 1: 1862.0057 2: 1862.0057 1: 128.9488 . . 1: 1733.0569 . . r 7 r 4 * r 3 2 ^ - / t 8 @end smallexample @end group That gives us the slope @cite{m}. The y-intercept @cite{b} can now be found with the simple formula, @ifinfo @example b = (sum(y) - m sum(x)) / N @end example @end ifinfo @tex \turnoffactive \beforedisplay $$ b = {\sum y - m \sum x \over N} $$ \afterdisplay \vskip10pt @end tex @group @smallexample 1: 13.613 2: 13.613 1: -8.09358 1: -0.425978 . 1: 21.70658 . . . r 5 r 8 r 3 * - r 7 / t 9 @end smallexample @end group Let's ``plot'' this straight line approximation, @c{$y \approx m x + b$} @cite{m x + b}, and compare it with the original data.@refill @group @smallexample 1: [0.699, 0.735, ... ] 1: [0.273, 0.309, ... ] . . r 1 r 8 * r 9 + s 0 @end smallexample @end group @noindent Notice that multiplying a vector by a constant, and adding a constant to a vector, can be done without mapping commands since these are common operations from vector algebra. As far as Calc is concerned, we've just been doing geometry in 19-dimensional space! We can subtract this vector from our original @cite{y} vector to get a feel for the error of our fit. Let's find the maximum error: @group @smallexample 1: [0.0387, 0.0112, ... ] 1: [0.0387, 0.0112, ... ] 1: 0.0897 . . . r 2 - V M A V R X @end smallexample @end group @noindent First we compute a vector of differences, then we take the absolute values of these differences, then we reduce the @code{max} function across the vector. (The @code{max} function is on the two-key sequence @kbd{f x}; because it is so common to use @code{max} in a vector operation, the letters @kbd{X} and @kbd{N} are also accepted for @code{max} and @code{min} in this context. In general, you answer the @kbd{V M} or @kbd{V R} prompt with the actual key sequence that invokes the function you want. You could have typed @kbd{V R f x} or even @kbd{V R x max @key{RET}} if you had preferred.) If your system has the GNUPLOT program, you can see graphs of your data and your straight line to see how well they match. (If you have GNUPLOT 3.0, the following instructions will work regardless of the kind of display you have. Some GNUPLOT 2.0, non-X-windows systems may require additional steps to view the graphs.) Let's start by plotting the original data. Recall the ``@i{x}'' and ``@i{y}'' vectors onto the stack and press @kbd{g f}. This ``fast'' graphing command does everything you need to do for simple, straightforward plotting of data. @group @smallexample 2: [1.34, 1.41, 1.49, ... ] 1: [0.234, 0.298, 0.402, ... ] . r 1 r 2 g f @end smallexample @end group If all goes well, you will shortly get a new window containing a graph of the data. (If not, contact your GNUPLOT or Calc installer to find out what went wrong.) In the X window system, this will be a separate graphics window. For other kinds of displays, the default is to display the graph in Emacs itself using rough character graphics. Press @kbd{q} when you are done viewing the character graphics. Next, let's add the line we got from our least-squares fit: @group @smallexample 2: [1.34, 1.41, 1.49, ... ] 1: [0.273, 0.309, 0.351, ... ] . DEL r 0 g a g p @end smallexample @end group It's not very useful to get symbols to mark the data points on this second curve; you can type @kbd{g S g p} to remove them. Type @kbd{g q} when you are done to remove the X graphics window and terminate GNUPLOT. (@bullet{}) @strong{Exercise 2.} An earlier exercise showed how to do least squares fitting to a general system of equations. Our 19 data points are really 19 equations of the form @cite{y_i = m x_i + b} for different pairs of @cite{(x_i,y_i)}. Use the matrix-transpose method to solve for @cite{m} and @cite{b}, duplicating the above result. @xref{List Answer 2, 2}. (@bullet{}) @cindex Geometric mean (@bullet{}) @strong{Exercise 3.} If the input data do not form a rectangle, you can use @w{@kbd{M-# g}} (@code{calc-grab-region}) to grab the data the way Emacs normally works with regions---it reads left-to-right, top-to-bottom, treating line breaks the same as spaces. Use this command to find the geometric mean of the following numbers. (The geometric mean is the @var{n}th root of the product of @var{n} numbers.) @example 2.3 6 22 15.1 7 15 14 7.5 2.5 @end example @noindent The @kbd{M-# g} command accepts numbers separated by spaces or commas, with or without surrounding vector brackets. @xref{List Answer 3, 3}. (@bullet{}) @ifinfo As another example, a theorem about binomial coefficients tells us that the alternating sum of binomial coefficients @var{n}-choose-0 minus @var{n}-choose-1 plus @var{n}-choose-2, and so on up to @var{n}-choose-@var{n}, always comes out to zero. Let's verify this for @cite{n=6}.@refill @end ifinfo @tex As another example, a theorem about binomial coefficients tells us that the alternating sum of binomial coefficients ${n \choose 0} - {n \choose 1} + {n \choose 2} - \cdots \pm {n \choose n}$ always comes out to zero. Let's verify this for \cite{n=6}. @end tex @group @smallexample 1: [1, 2, 3, 4, 5, 6, 7] 1: [0, 1, 2, 3, 4, 5, 6] . . v x 7 RET 1 - @end smallexample @end group @noindent @group @smallexample 1: [1, -6, 15, -20, 15, -6, 1] 1: 0 . . V M ' (-1)^$ choose(6,$) RET V R + @end smallexample @end group The @kbd{V M '} command prompts you to enter any algebraic expression to define the function to map over the vector. The symbol @samp{$} inside this expression represents the argument to the function. The Calculator applies this formula to each element of the vector, substituting each element's value for the @samp{$} sign(s) in turn. To define a two-argument function, use @samp{$$} for the first argument and @samp{$} for the second: @kbd{V M ' $$-$ RET} is equivalent to @kbd{V M -}. This is analogous to regular algebraic entry, where @samp{$$} would refer to the next-to-top stack entry and @samp{$} would refer to the top stack entry, and @kbd{' $$-$ RET} would act exactly like @kbd{-}. Notice that the @kbd{V M '} command has recorded two things in the trail: The result, as usual, and also a funny-looking thing marked @samp{oper} that represents the operator function you typed in. The function is enclosed in @samp{< >} brackets, and the argument is denoted by a @samp{#} sign. If there were several arguments, they would be shown as @samp{#1}, @samp{#2}, and so on. (For example, @kbd{V M ' $$-$} will put the function @samp{<#1 - #2>} on the trail.) This object is a ``nameless function''; you can use nameless @w{@samp{< >}} notation to answer the @kbd{V M '} prompt if you like. Nameless function notation has the interesting, occasionally useful property that a nameless function is not actually evaluated until it is used. For example, @kbd{V M ' $+random(2.0)} evaluates @samp{random(2.0)} once and adds that random number to all elements of the vector, but @kbd{V M ' <#+random(2.0)>} evaluates the @samp{random(2.0)} separately for each vector element. Another group of operators that are often useful with @kbd{V M} are the relational operators: @kbd{a =}, for example, compares two numbers and gives the result 1 if they are equal, or 0 if not. Similarly, @w{@kbd{a <}} checks for one number being less than another. Other useful vector operations include @kbd{v v}, to reverse a vector end-for-end; @kbd{V S}, to sort the elements of a vector into increasing order; and @kbd{v r} and @w{@kbd{v c}}, to extract one row or column of a matrix, or (in both cases) to extract one element of a plain vector. With a negative argument, @kbd{v r} and @kbd{v c} instead delete one row, column, or vector element. @cindex Divisor functions (@bullet{}) @strong{Exercise 4.} The @cite{k}th @dfn{divisor function} @tex $\sigma_k(n)$ @end tex is the sum of the @cite{k}th powers of all the divisors of an integer @cite{n}. Figure out a method for computing the divisor function for reasonably small values of @cite{n}. As a test, the 0th and 1st divisor functions of 30 are 8 and 72, respectively. @xref{List Answer 4, 4}. (@bullet{}) @cindex Square-free numbers @cindex Duplicate values in a list (@bullet{}) @strong{Exercise 5.} The @kbd{k f} command produces a list of prime factors for a number. Sometimes it is important to know that a number is @dfn{square-free}, i.e., that no prime occurs more than once in its list of prime factors. Find a sequence of keystrokes to tell if a number is square-free; your method should leave 1 on the stack if it is, or 0 if it isn't. @xref{List Answer 5, 5}. (@bullet{}) @cindex Triangular lists (@bullet{}) @strong{Exercise 6.} Build a list of lists that looks like the following diagram. (You may wish to use the @kbd{v /} command to enable multi-line display of vectors.) @group @smallexample 1: [ [1], [1, 2], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6] ] @end smallexample @end group @noindent @xref{List Answer 6, 6}. (@bullet{}) (@bullet{}) @strong{Exercise 7.} Build the following list of lists. @group @smallexample 1: [ [0], [1, 2], [3, 4, 5], [6, 7, 8, 9], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19, 20] ] @end smallexample @end group @noindent @xref{List Answer 7, 7}. (@bullet{}) @cindex Maximizing a function over a list of values @c [fix-ref Numerical Solutions] (@bullet{}) @strong{Exercise 8.} Compute a list of values of Bessel's @c{$J_1(x)$} @cite{J1} function @samp{besJ(1,x)} for @cite{x} from 0 to 5 in steps of 0.25. Find the value of @cite{x} (from among the above set of values) for which @samp{besJ(1,x)} is a maximum. Use an ``automatic'' method, i.e., just reading along the list by hand to find the largest value is not allowed! (There is an @kbd{a X} command which does this kind of thing automatically; @pxref{Numerical Solutions}.) @xref{List Answer 8, 8}. (@bullet{})@refill @cindex Digits, vectors of (@bullet{}) @strong{Exercise 9.} You are given an integer in the range @c{$0 \le N < 10^m$} @cite{0 <= N < 10^m} for @cite{m=12} (i.e., an integer of less than twelve digits). Convert this integer into a vector of @cite{m} digits, each in the range from 0 to 9. In vector-of-digits notation, add one to this integer to produce a vector of @cite{m+1} digits (since there could be a carry out of the most significant digit). Convert this vector back into a regular integer. A good integer to try is 25129925999. @xref{List Answer 9, 9}. (@bullet{}) (@bullet{}) @strong{Exercise 10.} Your friend Joe tried to use @kbd{V R a =} to test if all numbers in a list were equal. What happened? How would you do this test? @xref{List Answer 10, 10}. (@bullet{}) (@bullet{}) @strong{Exercise 11.} The area of a circle of radius one is @c{$\pi$} @cite{pi}. The area of the @c{$2\times2$} @asis{2x2} square that encloses that circle is 4. So if we throw @i{N} darts at random points in the square, about @c{$\pi/4$} @cite{pi/4} of them will land inside the circle. This gives us an entertaining way to estimate the value of @c{$\pi$} @cite{pi}. The @w{@kbd{k r}} command picks a random number between zero and the value on the stack. We could get a random floating-point number between @i{-1} and 1 by typing @w{@kbd{2.0 k r 1 -}}. Build a vector of 100 random @cite{(x,y)} points in this square, then use vector mapping and reduction to count how many points lie inside the unit circle. Hint: Use the @kbd{v b} command. @xref{List Answer 11, 11}. (@bullet{}) @cindex Matchstick problem (@bullet{}) @strong{Exercise 12.} The @dfn{matchstick problem} provides another way to calculate @c{$\pi$} @cite{pi}. Say you have an infinite field of vertical lines with a spacing of one inch. Toss a one-inch matchstick onto the field. The probability that the matchstick will land crossing a line turns out to be @c{$2/\pi$} @cite{2/pi}. Toss 100 matchsticks to estimate @c{$\pi$} @cite{pi}. (If you want still more fun, the probability that the GCD (@w{@kbd{k g}}) of two large integers is one turns out to be @c{$6/\pi^2$} @cite{6/pi^2}. That provides yet another way to estimate @c{$\pi$} @cite{pi}.) @xref{List Answer 12, 12}. (@bullet{}) (@bullet{}) @strong{Exercise 13.} An algebraic entry of a string in double-quote marks, @samp{"hello"}, creates a vector of the numerical (ASCII) codes of the characters (here, @cite{[104, 101, 108, 108, 111]}). Sometimes it is convenient to compute a @dfn{hash code} of a string, which is just an integer that represents the value of that string. Two equal strings have the same hash code; two different strings @dfn{probably} have different hash codes. (For example, Calc has over 400 function names, but Emacs can quickly find the definition for any given name because it has sorted the functions into ``buckets'' by their hash codes. Sometimes a few names will hash into the same bucket, but it is easier to search among a few names than among all the names.) One popular hash function is computed as follows: First set @cite{h = 0}. Then, for each character from the string in turn, set @cite{h = 3h + c_i} where @cite{c_i} is the character's ASCII code. If we have 511 buckets, we then take the hash code modulo 511 to get the bucket number. Develop a simple command or commands for converting string vectors into hash codes. The hash code for @samp{"Testing, 1, 2, 3"} is 1960915098, which modulo 511 is 121. @xref{List Answer 13, 13}. (@bullet{}) (@bullet{}) @strong{Exercise 14.} The @kbd{H V R} and @kbd{H V U} commands do nested function evaluations. @kbd{H V U} takes a starting value and a number of steps @var{n} from the stack; it then applies the function you give to the starting value 0, 1, 2, up to @var{n} times and returns a vector of the results. Use this command to create a ``random walk'' of 50 steps. Start with the two-dimensional point @cite{(0,0)}; then take one step a random distance between @i{-1} and 1 in both @cite{x} and @cite{y}; then take another step, and so on. Use the @kbd{g f} command to display this random walk. Now modify your random walk to walk a unit distance, but in a random direction, at each step. (Hint: The @code{sincos} function returns a vector of the cosine and sine of an angle.) @xref{List Answer 14, 14}. (@bullet{}) @node Types Tutorial, Algebra Tutorial, Vector/Matrix Tutorial, Tutorial @section Types Tutorial @noindent Calc understands a variety of data types as well as simple numbers. In this section, we'll experiment with each of these types in turn. The numbers we've been using so far have mainly been either @dfn{integers} or @dfn{floats}. We saw that floats are usually a good approximation to the mathematical concept of real numbers, but they are only approximations and are susceptible to roundoff error. Calc also supports @dfn{fractions}, which can exactly represent any rational number. @group @smallexample 1: 3628800 2: 3628800 1: 518400:7 1: 518414:7 1: 7:518414 . 1: 49 . . . . 10 ! 49 RET : 2 + & @end smallexample @end group @noindent The @kbd{:} command divides two integers to get a fraction; @kbd{/} would normally divide integers to get a floating-point result. Notice we had to type @key{RET} between the @kbd{49} and the @kbd{:} since the @kbd{:} would otherwise be interpreted as part of a fraction beginning with 49. You can convert between floating-point and fractional format using @kbd{c f} and @kbd{c F}: @group @smallexample 1: 1.35027217629e-5 1: 7:518414 . . c f c F @end smallexample @end group The @kbd{c F} command replaces a floating-point number with the ``simplest'' fraction whose floating-point representation is the same, to within the current precision. @group @smallexample 1: 3.14159265359 1: 1146408:364913 1: 3.1416 1: 355:113 . . . . P c F DEL p 5 RET P c F @end smallexample @end group (@bullet{}) @strong{Exercise 1.} A calculation has produced the result 1.26508260337. You suspect it is the square root of the product of @c{$\pi$} @cite{pi} and some rational number. Is it? (Be sure to allow for roundoff error!) @xref{Types Answer 1, 1}. (@bullet{}) @dfn{Complex numbers} can be stored in both rectangular and polar form. @group @smallexample 1: -9 1: (0, 3) 1: (3; 90.) 1: (6; 90.) 1: (2.4495; 45.) . . . . . 9 n Q c p 2 * Q @end smallexample @end group @noindent The square root of @i{-9} is by default rendered in rectangular form (@w{@cite{0 + 3i}}), but we can convert it to polar form (3 with a phase angle of 90 degrees). All the usual arithmetic and scientific operations are defined on both types of complex numbers. Another generalized kind of number is @dfn{infinity}. Infinity isn't really a number, but it can sometimes be treated like one. Calc uses the symbol @code{inf} to represent positive infinity, i.e., a value greater than any real number. Naturally, you can also write @samp{-inf} for minus infinity, a value less than any real number. The word @code{inf} can only be input using algebraic entry. @group @smallexample 2: inf 2: -inf 2: -inf 2: -inf 1: nan 1: -17 1: -inf 1: -inf 1: inf . . . . . ' inf RET 17 n * RET 72 + A + @end smallexample @end group @noindent Since infinity is infinitely large, multiplying it by any finite number (like @i{-17}) has no effect, except that since @i{-17} is negative, it changes a plus infinity to a minus infinity. (``A huge positive number, multiplied by @i{-17}, yields a huge negative number.'') Adding any finite number to infinity also leaves it unchanged. Taking an absolute value gives us plus infinity again. Finally, we add this plus infinity to the minus infinity we had earlier. If you work it out, you might expect the answer to be @i{-72} for this. But the 72 has been completely lost next to the infinities; by the time we compute @w{@samp{inf - inf}} the finite difference between them, if any, is indetectable. So we say the result is @dfn{indeterminate}, which Calc writes with the symbol @code{nan} (for Not A Number). Dividing by zero is normally treated as an error, but you can get Calc to write an answer in terms of infinity by pressing @kbd{m i} to turn on ``infinite mode.'' @group @smallexample 3: nan 2: nan 2: nan 2: nan 1: nan 2: 1 1: 1 / 0 1: uinf 1: uinf . 1: 0 . . . . 1 RET 0 / m i U / 17 n * + @end smallexample @end group @noindent Dividing by zero normally is left unevaluated, but after @kbd{m i} it instead gives an infinite result. The answer is actually @code{uinf}, ``undirected infinity.'' If you look at a graph of @cite{1 / x} around @w{@cite{x = 0}}, you'll see that it goes toward plus infinity as you approach zero from above, but toward minus infinity as you approach from below. Since we said only @cite{1 / 0}, Calc knows that the answer is infinite but not in which direction. That's what @code{uinf} means. Notice that multiplying @code{uinf} by a negative number still leaves plain @code{uinf}; there's no point in saying @samp{-uinf} because the sign of @code{uinf} is unknown anyway. Finally, we add @code{uinf} to our @code{nan}, yielding @code{nan} again. It's easy to see that, because @code{nan} means ``totally unknown'' while @code{uinf} means ``unknown sign but known to be infinite,'' the more mysterious @code{nan} wins out when it is combined with @code{uinf}, or, for that matter, with anything else. (@bullet{}) @strong{Exercise 2.} Predict what Calc will answer for each of these formulas: @samp{inf / inf}, @samp{exp(inf)}, @samp{exp(-inf)}, @samp{sqrt(-inf)}, @samp{sqrt(uinf)}, @samp{abs(uinf)}, @samp{ln(0)}. @xref{Types Answer 2, 2}. (@bullet{}) (@bullet{}) @strong{Exercise 3.} We saw that @samp{inf - inf = nan}, which stands for an unknown value. Can @code{nan} stand for a complex number? Can it stand for infinity? @xref{Types Answer 3, 3}. (@bullet{}) @dfn{HMS forms} represent a value in terms of hours, minutes, and seconds. @group @smallexample 1: 2@@ 30' 0" 1: 3@@ 30' 0" 2: 3@@ 30' 0" 1: 2. . . 1: 1@@ 45' 0." . . 2@@ 30' RET 1 + RET 2 / / @end smallexample @end group HMS forms can also be used to hold angles in degrees, minutes, and seconds. @group @smallexample 1: 0.5 1: 26.56505 1: 26@@ 33' 54.18" 1: 0.44721 . . . . 0.5 I T c h S @end smallexample @end group @noindent First we convert the inverse tangent of 0.5 to degrees-minutes-seconds form, then we take the sine of that angle. Note that the trigonometric functions will accept HMS forms directly as input. @cindex Beatles (@bullet{}) @strong{Exercise 4.} The Beatles' @emph{Abbey Road} is 47 minutes and 26 seconds long, and contains 17 songs. What is the average length of a song on @emph{Abbey Road}? If the Extended Disco Version of @emph{Abbey Road} added 20 seconds to the length of each song, how long would the album be? @xref{Types Answer 4, 4}. (@bullet{}) A @dfn{date form} represents a date, or a date and time. Dates must be entered using algebraic entry. Date forms are surrounded by @samp{< >} symbols; most standard formats for dates are recognized. @group @smallexample 2: 1: 2.25 1: <6:00pm Thu Jan 10, 1991> . . ' <13 Jan 1991>, <1/10/91, 6pm> RET - @end smallexample @end group @noindent In this example, we enter two dates, then subtract to find the number of days between them. It is also possible to add an HMS form or a number (of days) to a date form to get another date form. @group @smallexample 1: <4:45:59pm Mon Jan 14, 1991> 1: <2:50:59am Thu Jan 17, 1991> . . t N 2 + 10@@ 5' + @end smallexample @end group @c [fix-ref Date Arithmetic] @noindent The @kbd{t N} (``now'') command pushes the current date and time on the stack; then we add two days, ten hours and five minutes to the date and time. Other date-and-time related commands include @kbd{t J}, which does Julian day conversions, @kbd{t W}, which finds the beginning of the week in which a date form lies, and @kbd{t I}, which increments a date by one or several months. @xref{Date Arithmetic}, for more. (@bullet{}) @strong{Exercise 5.} How many days until the next Friday the 13th? @xref{Types Answer 5, 5}. (@bullet{}) (@bullet{}) @strong{Exercise 6.} How many leap years will there be between now and the year 10001 A.D.? @xref{Types Answer 6, 6}. (@bullet{}) @cindex Slope and angle of a line @cindex Angle and slope of a line An @dfn{error form} represents a mean value with an attached standard deviation, or error estimate. Suppose our measurements indicate that a certain telephone pole is about 30 meters away, with an estimated error of 1 meter, and 8 meters tall, with an estimated error of 0.2 meters. What is the slope of a line from here to the top of the pole, and what is the equivalent angle in degrees? @group @smallexample 1: 8 +/- 0.2 2: 8 +/- 0.2 1: 0.266 +/- 0.011 1: 14.93 +/- 0.594 . 1: 30 +/- 1 . . . 8 p .2 RET 30 p 1 / I T @end smallexample @end group @noindent This means that the angle is about 15 degrees, and, assuming our original error estimates were valid standard deviations, there is about a 60% chance that the result is correct within 0.59 degrees. @cindex Torus, volume of (@bullet{}) @strong{Exercise 7.} The volume of a torus (a donut shape) is @c{$2 \pi^2 R r^2$} @w{@cite{2 pi^2 R r^2}} where @cite{R} is the radius of the circle that defines the center of the tube and @cite{r} is the radius of the tube itself. Suppose @cite{R} is 20 cm and @cite{r} is 4 cm, each known to within 5 percent. What is the volume and the relative uncertainty of the volume? @xref{Types Answer 7, 7}. (@bullet{}) An @dfn{interval form} represents a range of values. While an error form is best for making statistical estimates, intervals give you exact bounds on an answer. Suppose we additionally know that our telephone pole is definitely between 28 and 31 meters away, and that it is between 7.7 and 8.1 meters tall. @group @smallexample 1: [7.7 .. 8.1] 2: [7.7 .. 8.1] 1: [0.24 .. 0.28] 1: [13.9 .. 16.1] . 1: [28 .. 31] . . . [ 7.7 .. 8.1 ] [ 28 .. 31 ] / I T @end smallexample @end group @noindent If our bounds were correct, then the angle to the top of the pole is sure to lie in the range shown. The square brackets around these intervals indicate that the endpoints themselves are allowable values. In other words, the distance to the telephone pole is between 28 and 31, @emph{inclusive}. You can also make an interval that is exclusive of its endpoints by writing parentheses instead of square brackets. You can even make an interval which is inclusive (``closed'') on one end and exclusive (``open'') on the other. @group @smallexample 1: [1 .. 10) 1: (0.1 .. 1] 2: (0.1 .. 1] 1: (0.2 .. 3) . . 1: [2 .. 3) . . [ 1 .. 10 ) & [ 2 .. 3 ) * @end smallexample @end group @noindent The Calculator automatically keeps track of which end values should be open and which should be closed. You can also make infinite or semi-infinite intervals by using @samp{-inf} or @samp{inf} for one or both endpoints. (@bullet{}) @strong{Exercise 8.} What answer would you expect from @samp{@w{1 /} @w{(0 .. 10)}}? What about @samp{@w{1 /} @w{(-10 .. 0)}}? What about @samp{@w{1 /} @w{[0 .. 10]}} (where the interval actually includes zero)? What about @samp{@w{1 /} @w{(-10 .. 10)}}? @xref{Types Answer 8, 8}. (@bullet{}) (@bullet{}) @strong{Exercise 9.} Two easy ways of squaring a number are @kbd{RET *} and @w{@kbd{2 ^}}. Normally these produce the same answer. Would you expect this still to hold true for interval forms? If not, which of these will result in a larger interval? @xref{Types Answer 9, 9}. (@bullet{}) A @dfn{modulo form} is used for performing arithmetic modulo @i{M}. For example, arithmetic involving time is generally done modulo 12 or 24 hours. @group @smallexample 1: 17 mod 24 1: 3 mod 24 1: 21 mod 24 1: 9 mod 24 . . . . 17 M 24 RET 10 + n 5 / @end smallexample @end group @noindent In this last step, Calc has found a new number which, when multiplied by 5 modulo 24, produces the original number, 21. If @i{M} is prime it is always possible to find such a number. For non-prime @i{M} like 24, it is only sometimes possible. @group @smallexample 1: 10 mod 24 1: 16 mod 24 1: 1000000... 1: 16 . . . . 10 M 24 RET 100 ^ 10 RET 100 ^ 24 % @end smallexample @end group @noindent These two calculations get the same answer, but the first one is much more efficient because it avoids the huge intermediate value that arises in the second one. @cindex Fermat, primality test of (@bullet{}) @strong{Exercise 10.} A theorem of Pierre de Fermat says that @c{\w{$x^{n-1} \bmod n = 1$}} @cite{x^(n-1) mod n = 1} if @cite{n} is a prime number and @cite{x} is an integer less than @cite{n}. If @cite{n} is @emph{not} a prime number, this will @emph{not} be true for most values of @cite{x}. Thus we can test informally if a number is prime by trying this formula for several values of @cite{x}. Use this test to tell whether the following numbers are prime: 811749613, 15485863. @xref{Types Answer 10, 10}. (@bullet{}) It is possible to use HMS forms as parts of error forms, intervals, modulo forms, or as the phase part of a polar complex number. For example, the @code{calc-time} command pushes the current time of day on the stack as an HMS/modulo form. @group @smallexample 1: 17@@ 34' 45" mod 24@@ 0' 0" 1: 6@@ 22' 15" mod 24@@ 0' 0" . . x time RET n @end smallexample @end group @noindent This calculation tells me it is six hours and 22 minutes until midnight. (@bullet{}) @strong{Exercise 11.} A rule of thumb is that one year is about @c{$\pi \times 10^7$} @w{@cite{pi * 10^7}} seconds. What time will it be that many seconds from right now? @xref{Types Answer 11, 11}. (@bullet{}) (@bullet{}) @strong{Exercise 12.} You are preparing to order packaging for the CD release of the Extended Disco Version of @emph{Abbey Road}. You are told that the songs will actually be anywhere from 20 to 60 seconds longer than the originals. One CD can hold about 75 minutes of music. Should you order single or double packages? @xref{Types Answer 12, 12}. (@bullet{}) Another kind of data the Calculator can manipulate is numbers with @dfn{units}. This isn't strictly a new data type; it's simply an application of algebraic expressions, where we use variables with suggestive names like @samp{cm} and @samp{in} to represent units like centimeters and inches. @group @smallexample 1: 2 in 1: 5.08 cm 1: 0.027778 fath 1: 0.0508 m . . . . ' 2in RET u c cm RET u c fath RET u b @end smallexample @end group @noindent We enter the quantity ``2 inches'' (actually an algebraic expression which means two times the variable @samp{in}), then we convert it first to centimeters, then to fathoms, then finally to ``base'' units, which in this case means meters. @group @smallexample 1: 9 acre 1: 3 sqrt(acre) 1: 190.84 m 1: 190.84 m + 30 cm . . . . ' 9 acre RET Q u s ' $+30 cm RET @end smallexample @end group @noindent @group @smallexample 1: 191.14 m 1: 36536.3046 m^2 1: 365363046 cm^2 . . . u s 2 ^ u c cgs @end smallexample @end group @noindent Since units expressions are really just formulas, taking the square root of @samp{acre} is undefined. After all, @code{acre} might be an algebraic variable that you will someday assign a value. We use the ``units-simplify'' command to simplify the expression with variables being interpreted as unit names. In the final step, we have converted not to a particular unit, but to a units system. The ``cgs'' system uses centimeters instead of meters as its standard unit of length. There is a wide variety of units defined in the Calculator. @group @smallexample 1: 55 mph 1: 88.5139 kph 1: 88.5139 km / hr 1: 8.201407e-8 c . . . . ' 55 mph RET u c kph RET u c km/hr RET u c c RET @end smallexample @end group @noindent We express a speed first in miles per hour, then in kilometers per hour, then again using a slightly more explicit notation, then finally in terms of fractions of the speed of light. Temperature conversions are a bit more tricky. There are two ways to interpret ``20 degrees Fahrenheit''---it could mean an actual temperature, or it could mean a change in temperature. For normal units there is no difference, but temperature units have an offset as well as a scale factor and so there must be two explicit commands for them. @group @smallexample 1: 20 degF 1: 11.1111 degC 1: -20:3 degC 1: -6.666 degC . . . . ' 20 degF RET u c degC RET U u t degC RET c f @end smallexample @end group @noindent First we convert a change of 20 degrees Fahrenheit into an equivalent change in degrees Celsius (or Centigrade). Then, we convert the absolute temperature 20 degrees Fahrenheit into Celsius. Since this comes out as an exact fraction, we then convert to floating-point for easier comparison with the other result. For simple unit conversions, you can put a plain number on the stack. Then @kbd{u c} and @kbd{u t} will prompt for both old and new units. When you use this method, you're responsible for remembering which numbers are in which units: @group @smallexample 1: 55 1: 88.5139 1: 8.201407e-8 . . . 55 u c mph RET kph RET u c km/hr RET c RET @end smallexample @end group To see a complete list of built-in units, type @kbd{u v}. Press @w{@kbd{M-# c}} again to re-enter the Calculator when you're done looking at the units table. (@bullet{}) @strong{Exercise 13.} How many seconds are there really in a year? @xref{Types Answer 13, 13}. (@bullet{}) @cindex Speed of light (@bullet{}) @strong{Exercise 14.} Supercomputer designs are limited by the speed of light (and of electricity, which is nearly as fast). Suppose a computer has a 4.1 ns (nanosecond) clock cycle, and its cabinet is one meter across. Is speed of light going to be a significant factor in its design? @xref{Types Answer 14, 14}. (@bullet{}) (@bullet{}) @strong{Exercise 15.} Sam the Slug normally travels about five yards in an hour. He has obtained a supply of Power Pills; each Power Pill he eats doubles his speed. How many Power Pills can he swallow and still travel legally on most US highways? @xref{Types Answer 15, 15}. (@bullet{}) @node Algebra Tutorial, Programming Tutorial, Types Tutorial, Tutorial @section Algebra and Calculus Tutorial @noindent This section shows how to use Calc's algebra facilities to solve equations, do simple calculus problems, and manipulate algebraic formulas. @menu * Basic Algebra Tutorial:: * Rewrites Tutorial:: @end menu @node Basic Algebra Tutorial, Rewrites Tutorial, Algebra Tutorial, Algebra Tutorial @subsection Basic Algebra @noindent If you enter a formula in algebraic mode that refers to variables, the formula itself is pushed onto the stack. You can manipulate formulas as regular data objects. @group @smallexample 1: 2 x^2 - 6 1: 6 - 2 x^2 1: (6 - 2 x^2) (3 x^2 + y) . . . ' 2x^2-6 RET n ' 3x^2+y RET * @end smallexample @end group (@bullet{}) @strong{Exercise 1.} Do @kbd{' x RET Q 2 ^} and @kbd{' x RET 2 ^ Q} both wind up with the same result (@samp{x})? Why or why not? @xref{Algebra Answer 1, 1}. (@bullet{}) There are also commands for doing common algebraic operations on formulas. Continuing with the formula from the last example, @group @smallexample 1: 18 x^2 + 6 y - 6 x^4 - 2 x^2 y 1: (18 - 2 y) x^2 - 6 x^4 + 6 y . . a x a c x RET @end smallexample @end group @noindent First we ``expand'' using the distributive law, then we ``collect'' terms involving like powers of @cite{x}. Let's find the value of this expression when @cite{x} is 2 and @cite{y} is one-half. @group @smallexample 1: 17 x^2 - 6 x^4 + 3 1: -25 . . 1:2 s l y RET 2 s l x RET @end smallexample @end group @noindent The @kbd{s l} command means ``let''; it takes a number from the top of the stack and temporarily assigns it as the value of the variable you specify. It then evaluates (as if by the @kbd{=} key) the next expression on the stack. After this command, the variable goes back to its original value, if any. (An earlier exercise in this tutorial involved storing a value in the variable @code{x}; if this value is still there, you will have to unstore it with @kbd{s u x RET} before the above example will work properly.) @cindex Maximum of a function using Calculus Let's find the maximum value of our original expression when @cite{y} is one-half and @cite{x} ranges over all possible values. We can do this by taking the derivative with respect to @cite{x} and examining values of @cite{x} for which the derivative is zero. If the second derivative of the function at that value of @cite{x} is negative, the function has a local maximum there. @group @smallexample 1: 17 x^2 - 6 x^4 + 3 1: 34 x - 24 x^3 . . U DEL s 1 a d x RET s 2 @end smallexample @end group @noindent Well, the derivative is clearly zero when @cite{x} is zero. To find the other root(s), let's divide through by @cite{x} and then solve: @group @smallexample 1: (34 x - 24 x^3) / x 1: 34 x / x - 24 x^3 / x 1: 34 - 24 x^2 . . . ' x RET / a x a s @end smallexample @end group @noindent @group @smallexample 1: 34 - 24 x^2 = 0 1: x = 1.19023 . . 0 a = s 3 a S x RET @end smallexample @end group @noindent Notice the use of @kbd{a s} to ``simplify'' the formula. When the default algebraic simplifications don't do enough, you can use @kbd{a s} to tell Calc to spend more time on the job. Now we compute the second derivative and plug in our values of @cite{x}: @group @smallexample 1: 1.19023 2: 1.19023 2: 1.19023 . 1: 34 x - 24 x^3 1: 34 - 72 x^2 . . a . r 2 a d x RET s 4 @end smallexample @end group @noindent (The @kbd{a .} command extracts just the righthand side of an equation. Another method would have been to use @kbd{v u} to unpack the equation @w{@samp{x = 1.19}} to @samp{x} and @samp{1.19}, then use @kbd{M-- M-2 DEL} to delete the @samp{x}.) @group @smallexample 2: 34 - 72 x^2 1: -68. 2: 34 - 72 x^2 1: 34 1: 1.19023 . 1: 0 . . . TAB s l x RET U DEL 0 s l x RET @end smallexample @end group @noindent The first of these second derivatives is negative, so we know the function has a maximum value at @cite{x = 1.19023}. (The function also has a local @emph{minimum} at @cite{x = 0}.) When we solved for @cite{x}, we got only one value even though @cite{34 - 24 x^2 = 0} is a quadratic equation that ought to have two solutions. The reason is that @w{@kbd{a S}} normally returns a single ``principal'' solution. If it needs to come up with an arbitrary sign (as occurs in the quadratic formula) it picks @cite{+}. If it needs an arbitrary integer, it picks zero. We can get a full solution by pressing @kbd{H} (the Hyperbolic flag) before @kbd{a S}. @group @smallexample 1: 34 - 24 x^2 = 0 1: x = 1.19023 s1 1: x = -1.19023 . . . r 3 H a S x RET s 5 1 n s l s1 RET @end smallexample @end group @noindent Calc has invented the variable @samp{s1} to represent an unknown sign; it is supposed to be either @i{+1} or @i{-1}. Here we have used the ``let'' command to evaluate the expression when the sign is negative. If we plugged this into our second derivative we would get the same, negative, answer, so @cite{x = -1.19023} is also a maximum. To find the actual maximum value, we must plug our two values of @cite{x} into the original formula. @group @smallexample 2: 17 x^2 - 6 x^4 + 3 1: 24.08333 s1^2 - 12.04166 s1^4 + 3 1: x = 1.19023 s1 . . r 1 r 5 s l RET @end smallexample @end group @noindent (Here we see another way to use @kbd{s l}; if its input is an equation with a variable on the lefthand side, then @kbd{s l} treats the equation like an assignment to that variable if you don't give a variable name.) It's clear that this will have the same value for either sign of @code{s1}, but let's work it out anyway, just for the exercise: @group @smallexample 2: [-1, 1] 1: [15.04166, 15.04166] 1: 24.08333 s1^2 ... . . [ 1 n , 1 ] TAB V M $ RET @end smallexample @end group @noindent Here we have used a vector mapping operation to evaluate the function at several values of @samp{s1} at once. @kbd{V M $} is like @kbd{V M '} except that it takes the formula from the top of the stack. The formula is interpreted as a function to apply across the vector at the next-to-top stack level. Since a formula on the stack can't contain @samp{$} signs, Calc assumes the variables in the formula stand for different arguments. It prompts you for an @dfn{argument list}, giving the list of all variables in the formula in alphabetical order as the default list. In this case the default is @samp{(s1)}, which is just what we want so we simply press @key{RET} at the prompt. If there had been several different values, we could have used @w{@kbd{V R X}} to find the global maximum. Calc has a built-in @kbd{a P} command that solves an equation using @w{@kbd{H a S}} and returns a vector of all the solutions. It simply automates the job we just did by hand. Applied to our original cubic polynomial, it would produce the vector of solutions @cite{[1.19023, -1.19023, 0]}. (There is also an @kbd{a X} command which finds a local maximum of a function. It uses a numerical search method rather than examining the derivatives, and thus requires you to provide some kind of initial guess to show it where to look.) (@bullet{}) @strong{Exercise 2.} Given a vector of the roots of a polynomial (such as the output of an @kbd{a P} command), what sequence of commands would you use to reconstruct the original polynomial? (The answer will be unique to within a constant multiple; choose the solution where the leading coefficient is one.) @xref{Algebra Answer 2, 2}. (@bullet{}) The @kbd{m s} command enables ``symbolic mode,'' in which formulas like @samp{sqrt(5)} that can't be evaluated exactly are left in symbolic form rather than giving a floating-point approximate answer. Fraction mode (@kbd{m f}) is also useful when doing algebra. @group @smallexample 2: 34 x - 24 x^3 2: 34 x - 24 x^3 1: 34 x - 24 x^3 1: [sqrt(51) / 6, sqrt(51) / -6, 0] . . r 2 RET m s m f a P x RET @end smallexample @end group One more mode that makes reading formulas easier is ``Big mode.'' @group @smallexample 3 2: 34 x - 24 x ____ ____ V 51 V 51 1: [-----, -----, 0] 6 -6 . d B @end smallexample @end group Here things like powers, square roots, and quotients and fractions are displayed in a two-dimensional pictorial form. Calc has other language modes as well, such as C mode, FORTRAN mode, and @TeX{} mode. @group @smallexample 2: 34*x - 24*pow(x, 3) 2: 34*x - 24*x**3 1: @{sqrt(51) / 6, sqrt(51) / -6, 0@} 1: /sqrt(51) / 6, sqrt(51) / -6, 0/ . . d C d F @end smallexample @end group @noindent @group @smallexample 3: 34 x - 24 x^3 2: [@{\sqrt@{51@} \over 6@}, @{\sqrt@{51@} \over -6@}, 0] 1: @{2 \over 3@} \sqrt@{5@} . d T ' 2 \sqrt@{5@} \over 3 RET @end smallexample @end group @noindent As you can see, language modes affect both entry and display of formulas. They affect such things as the names used for built-in functions, the set of arithmetic operators and their precedences, and notations for vectors and matrices. Notice that @samp{sqrt(51)} may cause problems with older implementations of C and FORTRAN, which would require something more like @samp{sqrt(51.0)}. It is always wise to check over the formulas produced by the various language modes to make sure they are fully correct. Type @kbd{m s}, @kbd{m f}, and @kbd{d N} to reset these modes. (You may prefer to remain in Big mode, but all the examples in the tutorial are shown in normal mode.) @cindex Area under a curve What is the area under the portion of this curve from @cite{x = 1} to @cite{2}? This is simply the integral of the function: @group @smallexample 1: 17 x^2 - 6 x^4 + 3 1: 5.6666 x^3 - 1.2 x^5 + 3 x . . r 1 a i x @end smallexample @end group @noindent We want to evaluate this at our two values for @cite{x} and subtract. One way to do it is again with vector mapping and reduction: @group @smallexample 2: [2, 1] 1: [12.93333, 7.46666] 1: 5.46666 1: 5.6666 x^3 ... . . [ 2 , 1 ] TAB V M $ RET V R - @end smallexample @end group (@bullet{}) @strong{Exercise 3.} Find the integral from 1 to @cite{y} of @c{$x \sin \pi x$} @w{@cite{x sin(pi x)}} (where the sine is calculated in radians). Find the values of the integral for integers @cite{y} from 1 to 5. @xref{Algebra Answer 3, 3}. (@bullet{}) Calc's integrator can do many simple integrals symbolically, but many others are beyond its capabilities. Suppose we wish to find the area under the curve @c{$\sin x \ln x$} @cite{sin(x) ln(x)} over the same range of @cite{x}. If you entered this formula and typed @kbd{a i x RET} (don't bother to try this), Calc would work for a long time but would be unable to find a solution. In fact, there is no closed-form solution to this integral. Now what do we do? @cindex Integration, numerical @cindex Numerical integration One approach would be to do the integral numerically. It is not hard to do this by hand using vector mapping and reduction. It is rather slow, though, since the sine and logarithm functions take a long time. We can save some time by reducing the working precision. @group @smallexample 3: 10 1: [1, 1.1, 1.2, ... , 1.8, 1.9] 2: 1 . 1: 0.1 . 10 RET 1 RET .1 RET C-u v x @end smallexample @end group @noindent (Note that we have used the extended version of @kbd{v x}; we could also have used plain @kbd{v x} as follows: @kbd{v x 10 RET 9 + .1 *}.) @group @smallexample 2: [1, 1.1, ... ] 1: [0., 0.084941, 0.16993, ... ] 1: sin(x) ln(x) . . ' sin(x) ln(x) RET s 1 m r p 5 RET V M $ RET @end smallexample @end group @noindent @group @smallexample 1: 3.4195 0.34195 . . V R + 0.1 * @end smallexample @end group @noindent (If you got wildly different results, did you remember to switch to radians mode?) Here we have divided the curve into ten segments of equal width; approximating these segments as rectangular boxes (i.e., assuming the curve is nearly flat at that resolution), we compute the areas of the boxes (height times width), then sum the areas. (It is faster to sum first, then multiply by the width, since the width is the same for every box.) The true value of this integral turns out to be about 0.374, so we're not doing too well. Let's try another approach. @group @smallexample 1: sin(x) ln(x) 1: 0.84147 x - 0.84147 + 0.11957 (x - 1)^2 - ... . . r 1 a t x=1 RET 4 RET @end smallexample @end group @noindent Here we have computed the Taylor series expansion of the function about the point @cite{x=1}. We can now integrate this polynomial approximation, since polynomials are easy to integrate. @group @smallexample 1: 0.42074 x^2 + ... 1: [-0.0446, -0.42073] 1: 0.3761 . . . a i x RET [ 2 , 1 ] TAB V M $ RET V R - @end smallexample @end group @noindent Better! By increasing the precision and/or asking for more terms in the Taylor series, we can get a result as accurate as we like. (Taylor series converge better away from singularities in the function such as the one at @code{ln(0)}, so it would also help to expand the series about the points @cite{x=2} or @cite{x=1.5} instead of @cite{x=1}.) @cindex Simpson's rule @cindex Integration by Simpson's rule (@bullet{}) @strong{Exercise 4.} Our first method approximated the curve by stairsteps of width 0.1; the total area was then the sum of the areas of the rectangles under these stairsteps. Our second method approximated the function by a polynomial, which turned out to be a better approximation than stairsteps. A third method is @dfn{Simpson's rule}, which is like the stairstep method except that the steps are not required to be flat. Simpson's rule boils down to the formula, @ifinfo @example (h/3) * (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + ... + 2 f(a+(n-2)*h) + 4 f(a+(n-1)*h) + f(a+n*h)) @end example @end ifinfo @tex \turnoffactive \beforedisplay $$ \displaylines{ \qquad {h \over 3} (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + \cdots \hfill \cr \hfill {} + 2 f(a+(n-2)h) + 4 f(a+(n-1)h) + f(a+n h)) \qquad } $$ \afterdisplay @end tex @noindent where @cite{n} (which must be even) is the number of slices and @cite{h} is the width of each slice. These are 10 and 0.1 in our example. For reference, here is the corresponding formula for the stairstep method: @ifinfo @example h * (f(a) + f(a+h) + f(a+2h) + f(a+3h) + ... + f(a+(n-2)*h) + f(a+(n-1)*h)) @end example @end ifinfo @tex \turnoffactive \beforedisplay $$ h (f(a) + f(a+h) + f(a+2h) + f(a+3h) + \cdots + f(a+(n-2)h) + f(a+(n-1)h)) $$ \afterdisplay @end tex Compute the integral from 1 to 2 of @c{$\sin x \ln x$} @cite{sin(x) ln(x)} using Simpson's rule with 10 slices. @xref{Algebra Answer 4, 4}. (@bullet{}) Calc has a built-in @kbd{a I} command for doing numerical integration. It uses @dfn{Romberg's method}, which is a more sophisticated cousin of Simpson's rule. In particular, it knows how to keep refining the result until the current precision is satisfied. @c [fix-ref Selecting Sub-Formulas] Aside from the commands we've seen so far, Calc also provides a large set of commands for operating on parts of formulas. You indicate the desired sub-formula by placing the cursor on any part of the formula before giving a @dfn{selection} command. Selections won't be covered in the tutorial; @pxref{Selecting Subformulas}, for details and examples. @c hard exercise: simplify (2^(n r) - 2^(r*(n - 1))) / (2^r - 1) 2^(n - 1) @c to 2^((n-1)*(r-1)). @node Rewrites Tutorial, , Basic Algebra Tutorial, Algebra Tutorial @subsection Rewrite Rules @noindent No matter how many built-in commands Calc provided for doing algebra, there would always be something you wanted to do that Calc didn't have in its repertoire. So Calc also provides a @dfn{rewrite rule} system that you can use to define your own algebraic manipulations. Suppose we want to simplify this trigonometric formula: @group @smallexample 1: 1 / cos(x) - sin(x) tan(x) . ' 1/cos(x) - sin(x) tan(x) RET s 1 @end smallexample @end group @noindent If we were simplifying this by hand, we'd probably replace the @samp{tan} with a @samp{sin/cos} first, then combine over a common denominator. There is no Calc command to do the former; the @kbd{a n} algebra command will do the latter but we'll do both with rewrite rules just for practice. Rewrite rules are written with the @samp{:=} symbol. @group @smallexample 1: 1 / cos(x) - sin(x)^2 / cos(x) . a r tan(a) := sin(a)/cos(a) RET @end smallexample @end group @noindent (The ``assignment operator'' @samp{:=} has several uses in Calc. All by itself the formula @samp{tan(a) := sin(a)/cos(a)} doesn't do anything, but when it is given to the @kbd{a r} command, that command interprets it as a rewrite rule.) The lefthand side, @samp{tan(a)}, is called the @dfn{pattern} of the rewrite rule. Calc searches the formula on the stack for parts that match the pattern. Variables in a rewrite pattern are called @dfn{meta-variables}, and when matching the pattern each meta-variable can match any sub-formula. Here, the meta-variable @samp{a} matched the actual variable @samp{x}. When the pattern part of a rewrite rule matches a part of the formula, that part is replaced by the righthand side with all the meta-variables substituted with the things they matched. So the result is @samp{sin(x) / cos(x)}. Calc's normal algebraic simplifications then mix this in with the rest of the original formula. To merge over a common denominator, we can use another simple rule: @group @smallexample 1: (1 - sin(x)^2) / cos(x) . a r a/x + b/x := (a+b)/x RET @end smallexample @end group This rule points out several interesting features of rewrite patterns. First, if a meta-variable appears several times in a pattern, it must match the same thing everywhere. This rule detects common denominators because the same meta-variable @samp{x} is used in both of the denominators. Second, meta-variable names are independent from variables in the target formula. Notice that the meta-variable @samp{x} here matches the subformula @samp{cos(x)}; Calc never confuses the two meanings of @samp{x}. And third, rewrite patterns know a little bit about the algebraic properties of formulas. The pattern called for a sum of two quotients; Calc was able to match a difference of two quotients by matching @samp{a = 1}, @samp{b = -sin(x)^2}, and @samp{x = cos(x)}. @c [fix-ref Algebraic Properties of Rewrite Rules] We could just as easily have written @samp{a/x - b/x := (a-b)/x} for the rule. It would have worked just the same in all cases. (If we really wanted the rule to apply only to @samp{+} or only to @samp{-}, we could have used the @code{plain} symbol. @xref{Algebraic Properties of Rewrite Rules}, for some examples of this.) One more rewrite will complete the job. We want to use the identity @samp{sin(x)^2 + cos(x)^2 = 1}, but of course we must first rearrange the identity in a way that matches our formula. The obvious rule would be @samp{@w{1 - sin(x)^2} := cos(x)^2}, but a little thought shows that the rule @samp{sin(x)^2 := 1 - cos(x)^2} will also work. The latter rule has a more general pattern so it will work in many other situations, too. @group @smallexample 1: (1 + cos(x)^2 - 1) / cos(x) 1: cos(x) . . a r sin(x)^2 := 1 - cos(x)^2 RET a s @end smallexample @end group You may ask, what's the point of using the most general rule if you have to type it in every time anyway? The answer is that Calc allows you to store a rewrite rule in a variable, then give the variable name in the @kbd{a r} command. In fact, this is the preferred way to use rewrites. For one, if you need a rule once you'll most likely need it again later. Also, if the rule doesn't work quite right you can simply Undo, edit the variable, and run the rule again without having to retype it. @group @smallexample ' tan(x) := sin(x)/cos(x) RET s t tsc RET ' a/x + b/x := (a+b)/x RET s t merge RET ' sin(x)^2 := 1 - cos(x)^2 RET s t sinsqr RET 1: 1 / cos(x) - sin(x) tan(x) 1: cos(x) . . r 1 a r tsc RET a r merge RET a r sinsqr RET a s @end smallexample @end group To edit a variable, type @kbd{s e} and the variable name, use regular Emacs editing commands as necessary, then type @kbd{M-# M-#} or @kbd{C-c C-c} to store the edited value back into the variable. You can also use @w{@kbd{s e}} to create a new variable if you wish. Notice that the first time you use each rule, Calc puts up a ``compiling'' message briefly. The pattern matcher converts rules into a special optimized pattern-matching language rather than using them directly. This allows @kbd{a r} to apply even rather complicated rules very efficiently. If the rule is stored in a variable, Calc compiles it only once and stores the compiled form along with the variable. That's another good reason to store your rules in variables rather than entering them on the fly. (@bullet{}) @strong{Exercise 1.} Type @kbd{m s} to get symbolic mode, then enter the formula @samp{@w{(2 + sqrt(2))} / @w{(1 + sqrt(2))}}. Using a rewrite rule, simplify this formula by multiplying both sides by the conjugate @w{@samp{1 - sqrt(2)}}. The result will have to be expanded by the distributive law; do this with another rewrite. @xref{Rewrites Answer 1, 1}. (@bullet{}) The @kbd{a r} command can also accept a vector of rewrite rules, or a variable containing a vector of rules. @group @smallexample 1: [tsc, merge, sinsqr] 1: [tan(x) := sin(x) / cos(x), ... ] . . ' [tsc,merge,sinsqr] RET = @end smallexample @end group @noindent @group @smallexample 1: 1 / cos(x) - sin(x) tan(x) 1: cos(x) . . s t trig RET r 1 a r trig RET a s @end smallexample @end group @c [fix-ref Nested Formulas with Rewrite Rules] Calc tries all the rules you give against all parts of the formula, repeating until no further change is possible. (The exact order in which things are tried is rather complex, but for simple rules like the ones we've used here the order doesn't really matter. @xref{Nested Formulas with Rewrite Rules}.) Calc actually repeats only up to 100 times, just in case your rule set has gotten into an infinite loop. You can give a numeric prefix argument to @kbd{a r} to specify any limit. In particular, @kbd{M-1 a r} does only one rewrite at a time. @group @smallexample 1: 1 / cos(x) - sin(x)^2 / cos(x) 1: (1 - sin(x)^2) / cos(x) . . r 1 M-1 a r trig RET M-1 a r trig RET @end smallexample @end group You can type @kbd{M-0 a r} if you want no limit at all on the number of rewrites that occur. Rewrite rules can also be @dfn{conditional}. Simply follow the rule with a @samp{::} symbol and the desired condition. For example, @group @smallexample 1: exp(2 pi i) + exp(3 pi i) + exp(4 pi i) . ' exp(2 pi i) + exp(3 pi i) + exp(4 pi i) RET @end smallexample @end group @noindent @group @smallexample 1: 1 + exp(3 pi i) + 1 . a r exp(k pi i) := 1 :: k % 2 = 0 RET @end smallexample @end group @noindent (Recall, @samp{k % 2} is the remainder from dividing @samp{k} by 2, which will be zero only when @samp{k} is an even integer.) An interesting point is that the variables @samp{pi} and @samp{i} were matched literally rather than acting as meta-variables. This is because they are special-constant variables. The special constants @samp{e}, @samp{phi}, and so on also match literally. A common error with rewrite rules is to write, say, @samp{f(a,b,c,d,e) := g(a+b+c+d+e)}, expecting to match any @samp{f} with five arguments but in fact matching only when the fifth argument is literally @samp{e}!@refill @cindex Fibonacci numbers @c @starindex @tindex fib Rewrite rules provide an interesting way to define your own functions. Suppose we want to define @samp{fib(n)} to produce the @var{n}th Fibonacci number. The first two Fibonacci numbers are each 1; later numbers are formed by summing the two preceding numbers in the sequence. This is easy to express in a set of three rules: @group @smallexample ' [fib(1) := 1, fib(2) := 1, fib(n) := fib(n-1) + fib(n-2)] RET s t fib 1: fib(7) 1: 13 . . ' fib(7) RET a r fib RET @end smallexample @end group One thing that is guaranteed about the order that rewrites are tried is that, for any given subformula, earlier rules in the rule set will be tried for that subformula before later ones. So even though the first and third rules both match @samp{fib(1)}, we know the first will be used preferentially. This rule set has one dangerous bug: Suppose we apply it to the formula @samp{fib(x)}? (Don't actually try this.) The third rule will match @samp{fib(x)} and replace it with @w{@samp{fib(x-1) + fib(x-2)}}. Each of these will then be replaced to get @samp{fib(x-2) + 2 fib(x-3) + fib(x-4)}, and so on, expanding forever. What we really want is to apply the third rule only when @samp{n} is an integer greater than two. Type @w{@kbd{s e fib RET}}, then edit the third rule to: @smallexample fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 @end smallexample @noindent Now: @group @smallexample 1: fib(6) + fib(x) + fib(0) 1: 8 + fib(x) + fib(0) . . ' fib(6)+fib(x)+fib(0) RET a r fib RET @end smallexample @end group @noindent We've created a new function, @code{fib}, and a new command, @w{@kbd{a r fib RET}}, which means ``evaluate all @code{fib} calls in this formula.'' To make things easier still, we can tell Calc to apply these rules automatically by storing them in the special variable @code{EvalRules}. @group @smallexample 1: [fib(1) := ...] . 1: [8, 13] . . s r fib RET s t EvalRules RET ' [fib(6), fib(7)] RET @end smallexample @end group It turns out that this rule set has the problem that it does far more work than it needs to when @samp{n} is large. Consider the first few steps of the computation of @samp{fib(6)}: @group @smallexample fib(6) = fib(5) + fib(4) = fib(4) + fib(3) + fib(3) + fib(2) = fib(3) + fib(2) + fib(2) + fib(1) + fib(2) + fib(1) + 1 = ... @end smallexample @end group @noindent Note that @samp{fib(3)} appears three times here. Unless Calc's algebraic simplifier notices the multiple @samp{fib(3)}s and combines them (and, as it happens, it doesn't), this rule set does lots of needless recomputation. To cure the problem, type @code{s e EvalRules} to edit the rules (or just @kbd{s E}, a shorthand command for editing @code{EvalRules}) and add another condition: @smallexample fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 :: remember @end smallexample @noindent If a @samp{:: remember} condition appears anywhere in a rule, then if that rule succeeds Calc will add another rule that describes that match to the front of the rule set. (Remembering works in any rule set, but for technical reasons it is most effective in @code{EvalRules}.) For example, if the rule rewrites @samp{fib(7)} to something that evaluates to 13, then the rule @samp{fib(7) := 13} will be added to the rule set. Type @kbd{' fib(8) RET} to compute the eighth Fibonacci number, then type @kbd{s E} again to see what has happened to the rule set. With the @code{remember} feature, our rule set can now compute @samp{fib(@var{n})} in just @var{n} steps. In the process it builds up a table of all Fibonacci numbers up to @var{n}. After we have computed the result for a particular @var{n}, we can get it back (and the results for all smaller @var{n}) later in just one step. All Calc operations will run somewhat slower whenever @code{EvalRules} contains any rules. You should type @kbd{s u EvalRules RET} now to un-store the variable. (@bullet{}) @strong{Exercise 2.} Sometimes it is possible to reformulate a problem to reduce the amount of recursion necessary to solve it. Create a rule that, in about @var{n} simple steps and without recourse to the @code{remember} option, replaces @samp{fib(@var{n}, 1, 1)} with @samp{fib(1, @var{x}, @var{y})} where @var{x} and @var{y} are the @var{n}th and @var{n+1}st Fibonacci numbers, respectively. This rule is rather clunky to use, so add a couple more rules to make the ``user interface'' the same as for our first version: enter @samp{fib(@var{n})}, get back a plain number. @xref{Rewrites Answer 2, 2}. (@bullet{}) There are many more things that rewrites can do. For example, there are @samp{&&&} and @samp{|||} pattern operators that create ``and'' and ``or'' combinations of rules. As one really simple example, we could combine our first two Fibonacci rules thusly: @example [fib(1 ||| 2) := 1, fib(n) := ... ] @end example @noindent That means ``@code{fib} of something matching either 1 or 2 rewrites to 1.'' You can also make meta-variables optional by enclosing them in @code{opt}. For example, the pattern @samp{a + b x} matches @samp{2 + 3 x} but not @samp{2 + x} or @samp{3 x} or @samp{x}. The pattern @samp{opt(a) + opt(b) x} matches all of these forms, filling in a default of zero for @samp{a} and one for @samp{b}. (@bullet{}) @strong{Exercise 3.} Your friend Joe had @samp{2 + 3 x} on the stack and tried to use the rule @samp{opt(a) + opt(b) x := f(a, b, x)}. What happened? @xref{Rewrites Answer 3, 3}. (@bullet{}) (@bullet{}) @strong{Exercise 4.} Starting with a positive integer @cite{a}, divide @cite{a} by two if it is even, otherwise compute @cite{3 a + 1}. Now repeat this step over and over. A famous unproved conjecture is that for any starting @cite{a}, the sequence always eventually reaches 1. Given the formula @samp{seq(@var{a}, 0)}, write a set of rules that convert this into @samp{seq(1, @var{n})} where @var{n} is the number of steps it took the sequence to reach the value 1. Now enhance the rules to accept @samp{seq(@var{a})} as a starting configuration, and to stop with just the number @var{n} by itself. Now make the result be a vector of values in the sequence, from @var{a} to 1. (The formula @samp{@var{x}|@var{y}} appends the vectors @var{x} and @var{y}.) For example, rewriting @samp{seq(6)} should yield the vector @cite{[6, 3, 10, 5, 16, 8, 4, 2, 1]}. @xref{Rewrites Answer 4, 4}. (@bullet{}) (@bullet{}) @strong{Exercise 5.} Define, using rewrite rules, a function @samp{nterms(@var{x})} that returns the number of terms in the sum @var{x}, or 1 if @var{x} is not a sum. (A @dfn{sum} for our purposes is one or more non-sum terms separated by @samp{+} or @samp{-} signs, so that @cite{2 - 3 (x + y) + x y} is a sum of three terms.) @xref{Rewrites Answer 5, 5}. (@bullet{}) (@bullet{}) @strong{Exercise 6.} Calc considers the form @cite{0^0} to be ``indeterminate,'' and leaves it unevaluated (assuming infinite mode is not enabled). Some people prefer to define @cite{0^0 = 1}, so that the identity @cite{x^0 = 1} can safely be used for all @cite{x}. Find a way to make Calc follow this convention. What happens if you now type @kbd{m i} to turn on infinite mode? @xref{Rewrites Answer 6, 6}. (@bullet{}) (@bullet{}) @strong{Exercise 7.} A Taylor series for a function is an infinite series that exactly equals the value of that function at values of @cite{x} near zero. @ifinfo @example cos(x) = 1 - x^2 / 2! + x^4 / 4! - x^6 / 6! + ... @end example @end ifinfo @tex \turnoffactive \let\rm\goodrm \beforedisplay $$ \cos x = 1 - {x^2 \over 2!} + {x^4 \over 4!} - {x^6 \over 6!} + \cdots $$ \afterdisplay @end tex The @kbd{a t} command produces a @dfn{truncated Taylor series} which is obtained by dropping all the terms higher than, say, @cite{x^2}. Calc represents the truncated Taylor series as a polynomial in @cite{x}. Mathematicians often write a truncated series using a ``big-O'' notation that records what was the lowest term that was truncated. @ifinfo @example cos(x) = 1 - x^2 / 2! + O(x^3) @end example @end ifinfo @tex \turnoffactive \let\rm\goodrm \beforedisplay $$ \cos x = 1 - {x^2 \over 2!} + O(x^3) $$ \afterdisplay @end tex @noindent The meaning of @cite{O(x^3)} is ``a quantity which is negligibly small if @cite{x^3} is considered negligibly small as @cite{x} goes to zero.'' The exercise is to create rewrite rules that simplify sums and products of power series represented as @samp{@var{polynomial} + O(@var{var}^@var{n})}. For example, given @samp{1 - x^2 / 2 + O(x^3)} and @samp{x - x^3 / 6 + O(x^4)} on the stack, we want to be able to type @kbd{*} and get the result @samp{x - 2:3 x^3 + O(x^4)}. Don't worry if the terms of the sum are rearranged or if @kbd{a s} needs to be typed after rewriting. (This one is rather tricky; the solution at the end of this chapter uses 6 rewrite rules. Hint: The @samp{constant(x)} condition tests whether @samp{x} is a number.) @xref{Rewrites Answer 7, 7}. (@bullet{}) @c [fix-ref Rewrite Rules] @xref{Rewrite Rules}, for the whole story on rewrite rules. @node Programming Tutorial, Answers to Exercises, Algebra Tutorial, Tutorial @section Programming Tutorial @noindent The Calculator is written entirely in Emacs Lisp, a highly extensible language. If you know Lisp, you can program the Calculator to do anything you like. Rewrite rules also work as a powerful programming system. But Lisp and rewrite rules take a while to master, and often all you want to do is define a new function or repeat a command a few times. Calc has features that allow you to do these things easily. (Note that the programming commands relating to user-defined keys are not yet supported under Lucid Emacs 19.) One very limited form of programming is defining your own functions. Calc's @kbd{Z F} command allows you to define a function name and key sequence to correspond to any formula. Programming commands use the shift-@kbd{Z} prefix; the user commands they create use the lower case @kbd{z} prefix. @group @smallexample 1: 1 + x + x^2 / 2 + x^3 / 6 1: 1 + x + x^2 / 2 + x^3 / 6 . . ' 1 + x + x^2/2! + x^3/3! RET Z F e myexp RET RET RET y @end smallexample @end group This polynomial is a Taylor series approximation to @samp{exp(x)}. The @kbd{Z F} command asks a number of questions. The above answers say that the key sequence for our function should be @kbd{z e}; the @kbd{M-x} equivalent should be @code{calc-myexp}; the name of the function in algebraic formulas should also be @code{myexp}; the default argument list @samp{(x)} is acceptable; and finally @kbd{y} answers the question ``leave it in symbolic form for non-constant arguments?'' @group @smallexample 1: 1.3495 2: 1.3495 3: 1.3495 . 1: 1.34986 2: 1.34986 . 1: myexp(a + 1) . .3 z e .3 E ' a+1 RET z e @end smallexample @end group @noindent First we call our new @code{exp} approximation with 0.3 as an argument, and compare it with the true @code{exp} function. Then we note that, as requested, if we try to give @kbd{z e} an argument that isn't a plain number, it leaves the @code{myexp} function call in symbolic form. If we had answered @kbd{n} to the final question, @samp{myexp(a + 1)} would have evaluated by plugging in @samp{a + 1} for @samp{x} in the defining formula. @cindex Sine integral Si(x) @c @starindex @tindex Si (@bullet{}) @strong{Exercise 1.} The ``sine integral'' function @c{${\rm Si}(x)$} @cite{Si(x)} is defined as the integral of @samp{sin(t)/t} for @cite{t = 0} to @cite{x} in radians. (It was invented because this integral has no solution in terms of basic functions; if you give it to Calc's @kbd{a i} command, it will ponder it for a long time and then give up.) We can use the numerical integration command, however, which in algebraic notation is written like @samp{ninteg(f(t), t, 0, x)} with any integrand @samp{f(t)}. Define a @kbd{z s} command and @code{Si} function that implement this. You will need to edit the default argument list a bit. As a test, @samp{Si(1)} should return 0.946083. (Hint: @code{ninteg} will run a lot faster if you reduce the precision to, say, six digits beforehand.) @xref{Programming Answer 1, 1}. (@bullet{}) The simplest way to do real ``programming'' of Emacs is to define a @dfn{keyboard macro}. A keyboard macro is simply a sequence of keystrokes which Emacs has stored away and can play back on demand. For example, if you find yourself typing @kbd{H a S x @key{RET}} often, you may wish to program a keyboard macro to type this for you. @group @smallexample 1: y = sqrt(x) 1: x = y^2 . . ' y=sqrt(x) RET C-x ( H a S x RET C-x ) 1: y = cos(x) 1: x = s1 arccos(y) + 2 pi n1 . . ' y=cos(x) RET X @end smallexample @end group @noindent When you type @kbd{C-x (}, Emacs begins recording. But it is also still ready to execute your keystrokes, so you're really ``training'' Emacs by walking it through the procedure once. When you type @w{@kbd{C-x )}}, the macro is recorded. You can now type @kbd{X} to re-execute the same keystrokes. You can give a name to your macro by typing @kbd{Z K}. @group @smallexample 1: . 1: y = x^4 1: x = s2 sqrt(s1 sqrt(y)) . . Z K x RET ' y=x^4 RET z x @end smallexample @end group @noindent Notice that we use shift-@kbd{Z} to define the command, and lower-case @kbd{z} to call it up. Keyboard macros can call other macros. @group @smallexample 1: abs(x) 1: x = s1 y 1: 2 / x 1: x = 2 / y . . . . ' abs(x) RET C-x ( ' y RET a = z x C-x ) ' 2/x RET X @end smallexample @end group (@bullet{}) @strong{Exercise 2.} Define a keyboard macro to negate the item in level 3 of the stack, without disturbing the rest of the stack. @xref{Programming Answer 2, 2}. (@bullet{}) (@bullet{}) @strong{Exercise 3.} Define keyboard macros to compute the following functions: @enumerate @item Compute @c{$\displaystyle{\sin x \over x}$} @cite{sin(x) / x}, where @cite{x} is the number on the top of the stack. @item Compute the base-@cite{b} logarithm, just like the @kbd{B} key except the arguments are taken in the opposite order. @item Produce a vector of integers from 1 to the integer on the top of the stack. @end enumerate @noindent @xref{Programming Answer 3, 3}. (@bullet{}) (@bullet{}) @strong{Exercise 4.} Define a keyboard macro to compute the average (mean) value of a list of numbers. @xref{Programming Answer 4, 4}. (@bullet{}) In many programs, some of the steps must execute several times. Calc has @dfn{looping} commands that allow this. Loops are useful inside keyboard macros, but actually work at any time. @group @smallexample 1: x^6 2: x^6 1: 360 x^2 . 1: 4 . . ' x^6 RET 4 Z < a d x RET Z > @end smallexample @end group @noindent Here we have computed the fourth derivative of @cite{x^6} by enclosing a derivative command in a ``repeat loop'' structure. This structure pops a repeat count from the stack, then executes the body of the loop that many times. If you make a mistake while entering the body of the loop, type @w{@kbd{Z C-g}} to cancel the loop command. @cindex Fibonacci numbers Here's another example: @group @smallexample 3: 1 2: 10946 2: 1 1: 17711 1: 20 . . 1 RET RET 20 Z < TAB C-j + Z > @end smallexample @end group @noindent The numbers in levels 2 and 1 should be the 21st and 22nd Fibonacci numbers, respectively. (To see what's going on, try a few repetitions of the loop body by hand; @kbd{C-j}, also on the Line-Feed or @key{LFD} key if you have one, makes a copy of the number in level 2.) @cindex Golden ratio @cindex Phi, golden ratio A fascinating property of the Fibonacci numbers is that the @cite{n}th Fibonacci number can be found directly by computing @c{$\phi^n / \sqrt{5}$} @cite{phi^n / sqrt(5)} and then rounding to the nearest integer, where @c{$\phi$ (``phi'')} @cite{phi}, the ``golden ratio,'' is @c{$(1 + \sqrt{5}) / 2$} @cite{(1 + sqrt(5)) / 2}. (For convenience, this constant is available from the @code{phi} variable, or the @kbd{I H P} command.) @group @smallexample 1: 1.61803 1: 24476.0000409 1: 10945.9999817 1: 10946 . . . . I H P 21 ^ 5 Q / R @end smallexample @end group @cindex Continued fractions (@bullet{}) @strong{Exercise 5.} The @dfn{continued fraction} representation of @c{$\phi$} @cite{phi} is @c{$1 + 1/(1 + 1/(1 + 1/( \ldots )))$} @cite{1 + 1/(1 + 1/(1 + 1/( ...@: )))}. We can compute an approximate value by carrying this however far and then replacing the innermost @c{$1/( \ldots )$} @cite{1/( ...@: )} by 1. Approximate @c{$\phi$} @cite{phi} using a twenty-term continued fraction. @xref{Programming Answer 5, 5}. (@bullet{}) (@bullet{}) @strong{Exercise 6.} Linear recurrences like the one for Fibonacci numbers can be expressed in terms of matrices. Given a vector @w{@cite{[a, b]}} determine a matrix which, when multiplied by this vector, produces the vector @cite{[b, c]}, where @cite{a}, @cite{b} and @cite{c} are three successive Fibonacci numbers. Now write a program that, given an integer @cite{n}, computes the @cite{n}th Fibonacci number using matrix arithmetic. @xref{Programming Answer 6, 6}. (@bullet{}) @cindex Harmonic numbers A more sophisticated kind of loop is the @dfn{for} loop. Suppose we wish to compute the 20th ``harmonic'' number, which is equal to the sum of the reciprocals of the integers from 1 to 20. @group @smallexample 3: 0 1: 3.597739 2: 1 . 1: 20 . 0 RET 1 RET 20 Z ( & + 1 Z ) @end smallexample @end group @noindent The ``for'' loop pops two numbers, the lower and upper limits, then repeats the body of the loop as an internal counter increases from the lower limit to the upper one. Just before executing the loop body, it pushes the current loop counter. When the loop body finishes, it pops the ``step,'' i.e., the amount by which to increment the loop counter. As you can see, our loop always uses a step of one. This harmonic number function uses the stack to hold the running total as well as for the various loop housekeeping functions. If you find this disorienting, you can sum in a variable instead: @group @smallexample 1: 0 2: 1 . 1: 3.597739 . 1: 20 . . 0 t 7 1 RET 20 Z ( & s + 7 1 Z ) r 7 @end smallexample @end group @noindent The @kbd{s +} command adds the top-of-stack into the value in a variable (and removes that value from the stack). It's worth noting that many jobs that call for a ``for'' loop can also be done more easily by Calc's high-level operations. Two other ways to compute harmonic numbers are to use vector mapping and reduction (@kbd{v x 20}, then @w{@kbd{V M &}}, then @kbd{V R +}), or to use the summation command @kbd{a +}. Both of these are probably easier than using loops. However, there are some situations where loops really are the way to go: (@bullet{}) @strong{Exercise 7.} Use a ``for'' loop to find the first harmonic number which is greater than 4.0. @xref{Programming Answer 7, 7}. (@bullet{}) Of course, if we're going to be using variables in our programs, we have to worry about the programs clobbering values that the caller was keeping in those same variables. This is easy to fix, though: @group @smallexample . 1: 0.6667 1: 0.6667 3: 0.6667 . . 2: 3.597739 1: 0.6667 . Z ` p 4 RET 2 RET 3 / s 7 s s a RET Z ' r 7 s r a RET @end smallexample @end group @noindent When we type @kbd{Z `} (that's a back-quote character), Calc saves its mode settings and the contents of the ten ``quick variables'' for later reference. When we type @kbd{Z '} (that's an apostrophe now), Calc restores those saved values. Thus the @kbd{p 4} and @kbd{s 7} commands have no effect outside this sequence. Wrapping this around the body of a keyboard macro ensures that it doesn't interfere with what the user of the macro was doing. Notice that the contents of the stack, and the values of named variables, survive past the @kbd{Z '} command. @cindex Bernoulli numbers, approximate The @dfn{Bernoulli numbers} are a sequence with the interesting property that all of the odd Bernoulli numbers are zero, and the even ones, while difficult to compute, can be roughly approximated by the formula @c{$\displaystyle{2 n! \over (2 \pi)^n}$} @cite{2 n!@: / (2 pi)^n}. Let's write a keyboard macro to compute (approximate) Bernoulli numbers. (Calc has a command, @kbd{k b}, to compute exact Bernoulli numbers, but this command is very slow for large @cite{n} since the higher Bernoulli numbers are very large fractions.) @group @smallexample 1: 10 1: 0.0756823 . . 10 C-x ( RET 2 % Z [ DEL 0 Z : ' 2 $! / (2 pi)^$ RET = Z ] C-x ) @end smallexample @end group @noindent You can read @kbd{Z [} as ``then,'' @kbd{Z :} as ``else,'' and @kbd{Z ]} as ``end-if.'' There is no need for an explicit ``if'' command. For the purposes of @w{@kbd{Z [}}, the condition is ``true'' if the value it pops from the stack is a nonzero number, or ``false'' if it pops zero or something that is not a number (like a formula). Here we take our integer argument modulo 2; this will be nonzero if we're asking for an odd Bernoulli number. The actual tenth Bernoulli number is @cite{5/66}. @group @smallexample 3: 0.0756823 1: 0 1: 0.25305 1: 0 1: 1.16659 2: 5:66 . . . . 1: 0.0757575 . 10 k b RET c f M-0 DEL 11 X DEL 12 X DEL 13 X DEL 14 X @end smallexample @end group Just to exercise loops a bit more, let's compute a table of even Bernoulli numbers. @group @smallexample 3: [] 1: [0.10132, 0.03079, 0.02340, 0.033197, ...] 2: 2 . 1: 30 . [ ] 2 RET 30 Z ( X | 2 Z ) @end smallexample @end group @noindent The vertical-bar @kbd{|} is the vector-concatenation command. When we execute it, the list we are building will be in stack level 2 (initially this is an empty list), and the next Bernoulli number will be in level 1. The effect is to append the Bernoulli number onto the end of the list. (To create a table of exact fractional Bernoulli numbers, just replace @kbd{X} with @kbd{k b} in the above sequence of keystrokes.) With loops and conditionals, you can program essentially anything in Calc. One other command that makes looping easier is @kbd{Z /}, which takes a condition from the stack and breaks out of the enclosing loop if the condition is true (non-zero). You can use this to make ``while'' and ``until'' style loops. If you make a mistake when entering a keyboard macro, you can edit it using @kbd{Z E}. First, you must attach it to a key with @kbd{Z K}. One technique is to enter a throwaway dummy definition for the macro, then enter the real one in the edit command. @group @smallexample 1: 3 1: 3 Keyboard Macro Editor. . . Original keys: 1 RET 2 + type "1\r" type "2" calc-plus C-x ( 1 RET 2 + C-x ) Z K h RET Z E h @end smallexample @end group @noindent This shows the screen display assuming you have the @file{macedit} keyboard macro editing package installed, which is usually the case since a copy of @file{macedit} comes bundled with Calc. A keyboard macro is stored as a pure keystroke sequence. The @file{macedit} package (invoked by @kbd{Z E}) scans along the macro and tries to decode it back into human-readable steps. If a key or keys are simply shorthand for some command with a @kbd{M-x} name, that name is shown. Anything that doesn't correspond to a @kbd{M-x} command is written as a @samp{type} command. Let's edit in a new definition, for computing harmonic numbers. First, erase the three lines of the old definition. Then, type in the new definition (or use Emacs @kbd{M-w} and @kbd{C-y} commands to copy it from this page of the Info file; you can skip typing the comments that begin with @samp{#}). @smallexample calc-kbd-push # Save local values (Z `) type "0" # Push a zero calc-store-into # Store it in variable 1 type "1" type "1" # Initial value for loop calc-roll-down # This is the TAB key; swap initial & final calc-kbd-for # Begin "for" loop... calc-inv # Take reciprocal calc-store-plus # Add to accumulator type "1" type "1" # Loop step is 1 calc-kbd-end-for # End "for" loop calc-recall # Now recall final accumulated value type "1" calc-kbd-pop # Restore values (Z ') @end smallexample @noindent Press @kbd{M-# M-#} to finish editing and return to the Calculator. @group @smallexample 1: 20 1: 3.597739 . . 20 z h @end smallexample @end group If you don't know how to write a particular command in @file{macedit} format, you can always write it as keystrokes in a @code{type} command. There is also a @code{keys} command which interprets the rest of the line as standard Emacs keystroke names. In fact, @file{macedit} defines a handy @code{read-kbd-macro} command which reads the current region of the current buffer as a sequence of keystroke names, and defines that sequence on the @kbd{X} (and @kbd{C-x e}) key. Because this is so useful, Calc puts this command on the @kbd{M-# m} key. Try reading in this macro in the following form: Press @kbd{C-@@} (or @kbd{C-SPC}) at one end of the text below, then type @kbd{M-# m} at the other. @group @example Z ` 0 t 1 1 TAB Z ( & s + 1 1 Z ) r 1 Z ' @end example @end group (@bullet{}) @strong{Exercise 8.} A general algorithm for solving equations numerically is @dfn{Newton's Method}. Given the equation @cite{f(x) = 0} for any function @cite{f}, and an initial guess @cite{x_0} which is reasonably close to the desired solution, apply this formula over and over: @ifinfo @example new_x = x - f(x)/f'(x) @end example @end ifinfo @tex \beforedisplay $$ x_{\goodrm new} = x - {f(x) \over f'(x)} $$ \afterdisplay @end tex @noindent where @cite{f'(x)} is the derivative of @cite{f}. The @cite{x} values will quickly converge to a solution, i.e., eventually @c{$x_{\rm new}$} @cite{new_x} and @cite{x} will be equal to within the limits of the current precision. Write a program which takes a formula involving the variable @cite{x}, and an initial guess @cite{x_0}, on the stack, and produces a value of @cite{x} for which the formula is zero. Use it to find a solution of @c{$\sin(\cos x) = 0.5$} @cite{sin(cos(x)) = 0.5} near @cite{x = 4.5}. (Use angles measured in radians.) Note that the built-in @w{@kbd{a R}} (@code{calc-find-root}) command uses Newton's method when it is able. @xref{Programming Answer 8, 8}. (@bullet{}) @cindex Digamma function @cindex Gamma constant, Euler's @cindex Euler's gamma constant (@bullet{}) @strong{Exercise 9.} The @dfn{digamma} function @c{$\psi(z)$ (``psi'')} @cite{psi(z)} is defined as the derivative of @c{$\ln \Gamma(z)$} @cite{ln(gamma(z))}. For large values of @cite{z}, it can be approximated by the infinite sum @ifinfo @example psi(z) ~= ln(z) - 1/2z - sum(bern(2 n) / 2 n z^(2 n), n, 1, inf) @end example @end ifinfo @tex \let\rm\goodrm \beforedisplay $$ \psi(z) \approx \ln z - {1\over2z} - \sum_{n=1}^\infty {\code{bern}(2 n) \over 2 n z^{2n}} $$ \afterdisplay @end tex @noindent where @c{$\sum$} @cite{sum} represents the sum over @cite{n} from 1 to infinity (or to some limit high enough to give the desired accuracy), and the @code{bern} function produces (exact) Bernoulli numbers. While this sum is not guaranteed to converge, in practice it is safe. An interesting mathematical constant is Euler's gamma, which is equal to about 0.5772. One way to compute it is by the formula, @c{$\gamma = -\psi(1)$} @cite{gamma = -psi(1)}. Unfortunately, 1 isn't a large enough argument for the above formula to work (5 is a much safer value for @cite{z}). Fortunately, we can compute @c{$\psi(1)$} @cite{psi(1)} from @c{$\psi(5)$} @cite{psi(5)} using the recurrence @c{$\psi(z+1) = \psi(z) + {1 \over z}$} @cite{psi(z+1) = psi(z) + 1/z}. Your task: Develop a program to compute @c{$\psi(z)$} @cite{psi(z)}; it should ``pump up'' @cite{z} if necessary to be greater than 5, then use the above summation formula. Use looping commands to compute the sum. Use your function to compute @c{$\gamma$} @cite{gamma} to twelve decimal places. (Calc has a built-in command for Euler's constant, @kbd{I P}, which you can use to check your answer.) @xref{Programming Answer 9, 9}. (@bullet{}) @cindex Polynomial, list of coefficients (@bullet{}) @strong{Exercise 10.} Given a polynomial in @cite{x} and a number @cite{m} on the stack, where the polynomial is of degree @cite{m} or less (i.e., does not have any terms higher than @cite{x^m}), write a program to convert the polynomial into a list-of-coefficients notation. For example, @cite{5 x^4 + (x + 1)^2} with @cite{m = 6} should produce the list @cite{[1, 2, 1, 0, 5, 0, 0]}. Also develop a way to convert from this form back to the standard algebraic form. @xref{Programming Answer 10, 10}. (@bullet{}) @cindex Recursion (@bullet{}) @strong{Exercise 11.} The @dfn{Stirling numbers of the first kind} are defined by the recurrences, @ifinfo @example s(n,n) = 1 for n >= 0, s(n,0) = 0 for n > 0, s(n+1,m) = s(n,m-1) - n s(n,m) for n >= m >= 1. @end example @end ifinfo @tex \turnoffactive \beforedisplay $$ \eqalign{ s(n,n) &= 1 \qquad \hbox{for } n \ge 0, \cr s(n,0) &= 0 \qquad \hbox{for } n > 0, \cr s(n+1,m) &= s(n,m-1) - n \, s(n,m) \qquad \hbox{for } n \ge m \ge 1.} $$ \afterdisplay \vskip5pt (These numbers are also sometimes written $\displaystyle{n \brack m}$.) @end tex This can be implemented using a @dfn{recursive} program in Calc; the program must invoke itself in order to calculate the two righthand terms in the general formula. Since it always invokes itself with ``simpler'' arguments, it's easy to see that it must eventually finish the computation. Recursion is a little difficult with Emacs keyboard macros since the macro is executed before its definition is complete. So here's the recommended strategy: Create a ``dummy macro'' and assign it to a key with, e.g., @kbd{Z K s}. Now enter the true definition, using the @kbd{z s} command to call itself recursively, then assign it to the same key with @kbd{Z K s}. Now the @kbd{z s} command will run the complete recursive program. (Another way is to use @w{@kbd{Z E}} or @kbd{M-# m} (@code{read-kbd-macro}) to read the whole macro at once, thus avoiding the ``training'' phase.) The task: Write a program that computes Stirling numbers of the first kind, given @cite{n} and @cite{m} on the stack. Test it with @emph{small} inputs like @cite{s(4,2)}. (There is a built-in command for Stirling numbers, @kbd{k s}, which you can use to check your answers.) @xref{Programming Answer 11, 11}. (@bullet{}) The programming commands we've seen in this part of the tutorial are low-level, general-purpose operations. Often you will find that a higher-level function, such as vector mapping or rewrite rules, will do the job much more easily than a detailed, step-by-step program can: (@bullet{}) @strong{Exercise 12.} Write another program for computing Stirling numbers of the first kind, this time using rewrite rules. Once again, @cite{n} and @cite{m} should be taken from the stack. @xref{Programming Answer 12, 12}. (@bullet{}) @example @end example This ends the tutorial section of the Calc manual. Now you know enough about Calc to use it effectively for many kinds of calculations. But Calc has many features that were not even touched upon in this tutorial. @c [not-split] The rest of this manual tells the whole story. @c [when-split] @c Volume II of this manual, the @dfn{Calc Reference}, tells the whole story. @page @node Answers to Exercises, , Programming Tutorial, Tutorial @section Answers to Exercises @noindent This section includes answers to all the exercises in the Calc tutorial. @menu * RPN Answer 1:: 1 RET 2 RET 3 RET 4 + * - * RPN Answer 2:: 2*4 + 7*9.5 + 5/4 * RPN Answer 3:: Operating on levels 2 and 3 * RPN Answer 4:: Joe's complex problems * Algebraic Answer 1:: Simulating Q command * Algebraic Answer 2:: Joe's algebraic woes * Algebraic Answer 3:: 1 / 0 * Modes Answer 1:: 3#0.1 = 3#0.0222222? * Modes Answer 2:: 16#f.e8fe15 * Modes Answer 3:: Joe's rounding bug * Modes Answer 4:: Why floating point? * Arithmetic Answer 1:: Why the \ command? * Arithmetic Answer 2:: Tripping up the B command * Vector Answer 1:: Normalizing a vector * Vector Answer 2:: Average position * Matrix Answer 1:: Row and column sums * Matrix Answer 2:: Symbolic system of equations * Matrix Answer 3:: Over-determined system * List Answer 1:: Powers of two * List Answer 2:: Least-squares fit with matrices * List Answer 3:: Geometric mean * List Answer 4:: Divisor function * List Answer 5:: Duplicate factors * List Answer 6:: Triangular list * List Answer 7:: Another triangular list * List Answer 8:: Maximum of Bessel function * List Answer 9:: Integers the hard way * List Answer 10:: All elements equal * List Answer 11:: Estimating pi with darts * List Answer 12:: Estimating pi with matchsticks * List Answer 13:: Hash codes * List Answer 14:: Random walk * Types Answer 1:: Square root of pi times rational * Types Answer 2:: Infinities * Types Answer 3:: What can "nan" be? * Types Answer 4:: Abbey Road * Types Answer 5:: Friday the 13th * Types Answer 6:: Leap years * Types Answer 7:: Erroneous donut * Types Answer 8:: Dividing intervals * Types Answer 9:: Squaring intervals * Types Answer 10:: Fermat's primality test * Types Answer 11:: pi * 10^7 seconds * Types Answer 12:: Abbey Road on CD * Types Answer 13:: Not quite pi * 10^7 seconds * Types Answer 14:: Supercomputers and c * Types Answer 15:: Sam the Slug * Algebra Answer 1:: Squares and square roots * Algebra Answer 2:: Building polynomial from roots * Algebra Answer 3:: Integral of x sin(pi x) * Algebra Answer 4:: Simpson's rule * Rewrites Answer 1:: Multiplying by conjugate * Rewrites Answer 2:: Alternative fib rule * Rewrites Answer 3:: Rewriting opt(a) + opt(b) x * Rewrites Answer 4:: Sequence of integers * Rewrites Answer 5:: Number of terms in sum * Rewrites Answer 6:: Defining 0^0 = 1 * Rewrites Answer 7:: Truncated Taylor series * Programming Answer 1:: Fresnel's C(x) * Programming Answer 2:: Negate third stack element * Programming Answer 3:: Compute sin(x) / x, etc. * Programming Answer 4:: Average value of a list * Programming Answer 5:: Continued fraction phi * Programming Answer 6:: Matrix Fibonacci numbers * Programming Answer 7:: Harmonic number greater than 4 * Programming Answer 8:: Newton's method * Programming Answer 9:: Digamma function * Programming Answer 10:: Unpacking a polynomial * Programming Answer 11:: Recursive Stirling numbers * Programming Answer 12:: Stirling numbers with rewrites @end menu @c The following kludgery prevents the individual answers from @c being entered on the table of contents. @tex \global\let\oldwrite=\write \gdef\skipwrite#1#2{\let\write=\oldwrite} \global\let\oldchapternofonts=\chapternofonts \gdef\chapternofonts{\let\write=\skipwrite\oldchapternofonts} @end tex @node RPN Answer 1, RPN Answer 2, Answers to Exercises, Answers to Exercises @subsection RPN Tutorial Exercise 1 @noindent @kbd{1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -} The result is @c{$1 - (2 \times (3 + 4)) = -13$} @cite{1 - (2 * (3 + 4)) = -13}. @node RPN Answer 2, RPN Answer 3, RPN Answer 1, Answers to Exercises @subsection RPN Tutorial Exercise 2 @noindent @c{$2\times4 + 7\times9.5 + {5\over4} = 75.75$} @cite{2*4 + 7*9.5 + 5/4 = 75.75} After computing the intermediate term @c{$2\times4 = 8$} @cite{2*4 = 8}, you can leave that result on the stack while you compute the second term. With both of these results waiting on the stack you can then compute the final term, then press @kbd{+ +} to add everything up. @group @smallexample 2: 2 1: 8 3: 8 2: 8 1: 4 . 2: 7 1: 66.5 . 1: 9.5 . . 2 RET 4 * 7 RET 9.5 * @end smallexample @end group @noindent @group @smallexample 4: 8 3: 8 2: 8 1: 75.75 3: 66.5 2: 66.5 1: 67.75 . 2: 5 1: 1.25 . 1: 4 . . 5 RET 4 / + + @end smallexample @end group Alternatively, you could add the first two terms before going on with the third term. @group @smallexample 2: 8 1: 74.5 3: 74.5 2: 74.5 1: 75.75 1: 66.5 . 2: 5 1: 1.25 . . 1: 4 . . ... + 5 RET 4 / + @end smallexample @end group On an old-style RPN calculator this second method would have the advantage of using only three stack levels. But since Calc's stack can grow arbitrarily large this isn't really an issue. Which method you choose is purely a matter of taste. @node RPN Answer 3, RPN Answer 4, RPN Answer 2, Answers to Exercises @subsection RPN Tutorial Exercise 3 @noindent The @key{TAB} key provides a way to operate on the number in level 2. @group @smallexample 3: 10 3: 10 4: 10 3: 10 3: 10 2: 20 2: 30 3: 30 2: 30 2: 21 1: 30 1: 20 2: 20 1: 21 1: 30 . . 1: 1 . . . TAB 1 + TAB @end smallexample @end group Similarly, @key{M-TAB} gives you access to the number in level 3. @group @smallexample 3: 10 3: 21 3: 21 3: 30 3: 11 2: 21 2: 30 2: 30 2: 11 2: 21 1: 30 1: 10 1: 11 1: 21 1: 30 . . . . . M-TAB 1 + M-TAB M-TAB @end smallexample @end group @node RPN Answer 4, Algebraic Answer 1, RPN Answer 3, Answers to Exercises @subsection RPN Tutorial Exercise 4 @noindent Either @kbd{( 2 , 3 )} or @kbd{( 2 @key{SPC} 3 )} would have worked, but using both the comma and the space at once yields: @group @smallexample 1: ( ... 2: ( ... 1: (2, ... 2: (2, ... 2: (2, ... . 1: 2 . 1: (2, ... 1: (2, 3) . . . ( 2 , SPC 3 ) @end smallexample @end group Joe probably tried to type @kbd{@key{TAB} @key{DEL}} to swap the extra incomplete object to the top of the stack and delete it. But a feature of Calc is that @key{DEL} on an incomplete object deletes just one component out of that object, so he had to press @key{DEL} twice to finish the job. @group @smallexample 2: (2, ... 2: (2, 3) 2: (2, 3) 1: (2, 3) 1: (2, 3) 1: (2, ... 1: ( ... . . . . TAB DEL DEL @end smallexample @end group (As it turns out, deleting the second-to-top stack entry happens often enough that Calc provides a special key, @kbd{M-DEL}, to do just that. @kbd{M-DEL} is just like @kbd{TAB DEL}, except that it doesn't exhibit the ``feature'' that tripped poor Joe.) @node Algebraic Answer 1, Algebraic Answer 2, RPN Answer 4, Answers to Exercises @subsection Algebraic Entry Tutorial Exercise 1 @noindent Type @kbd{' sqrt($) @key{RET}}. If the @kbd{Q} key is broken, you could use @kbd{' $^0.5 @key{RET}}. Or, RPN style, @kbd{0.5 ^}. (Actually, @samp{$^1:2}, using the fraction one-half as the power, is a closer equivalent, since @samp{9^0.5} yields @cite{3.0} whereas @samp{sqrt(9)} and @samp{9^1:2} yield the exact integer @cite{3}.) @node Algebraic Answer 2, Algebraic Answer 3, Algebraic Answer 1, Answers to Exercises @subsection Algebraic Entry Tutorial Exercise 2 @noindent In the formula @samp{2 x (1+y)}, @samp{x} was interpreted as a function name with @samp{1+y} as its argument. Assigning a value to a variable has no relation to a function by the same name. Joe needed to use an explicit @samp{*} symbol here: @samp{2 x*(1+y)}. @node Algebraic Answer 3, Modes Answer 1, Algebraic Answer 2, Answers to Exercises @subsection Algebraic Entry Tutorial Exercise 3 @noindent The result from @kbd{1 @key{RET} 0 /} will be the formula @cite{1 / 0}. The ``function'' @samp{/} cannot be evaluated when its second argument is zero, so it is left in symbolic form. When you now type @kbd{0 *}, the result will be zero because Calc uses the general rule that ``zero times anything is zero.'' @c [fix-ref Infinities] The @kbd{m i} command enables an @dfn{infinite mode} in which @cite{1 / 0} results in a special symbol that represents ``infinity.'' If you multiply infinity by zero, Calc uses another special new symbol to show that the answer is ``indeterminate.'' @xref{Infinities}, for further discussion of infinite and indeterminate values. @node Modes Answer 1, Modes Answer 2, Algebraic Answer 3, Answers to Exercises @subsection Modes Tutorial Exercise 1 @noindent Calc always stores its numbers in decimal, so even though one-third has an exact base-3 representation (@samp{3#0.1}), it is still stored as 0.3333333 (chopped off after 12 or however many decimal digits) inside the calculator's memory. When this inexact number is converted back to base 3 for display, it may still be slightly inexact. When we multiply this number by 3, we get 0.999999, also an inexact value. When Calc displays a number in base 3, it has to decide how many digits to show. If the current precision is 12 (decimal) digits, that corresponds to @samp{12 / log10(3) = 25.15} base-3 digits. Because 25.15 is not an exact integer, Calc shows only 25 digits, with the result that stored numbers carry a little bit of extra information that may not show up on the screen. When Joe entered @samp{3#0.2}, the stored number 0.666666 happened to round to a pleasing value when it lost that last 0.15 of a digit, but it was still inexact in Calc's memory. When he divided by 2, he still got the dreaded inexact value 0.333333. (Actually, he divided 0.666667 by 2 to get 0.333334, which is why he got something a little higher than @code{3#0.1} instead of a little lower.) If Joe didn't want to be bothered with all this, he could have typed @kbd{M-24 d n} to display with one less digit than the default. (If you give @kbd{d n} a negative argument, it uses default-minus-that, so @kbd{M-- d n} would be an easier way to get the same effect.) Those inexact results would still be lurking there, but they would now be rounded to nice, natural-looking values for display purposes. (Remember, @samp{0.022222} in base 3 is like @samp{0.099999} in base 10; rounding off one digit will round the number up to @samp{0.1}.) Depending on the nature of your work, this hiding of the inexactness may be a benefit or a danger. With the @kbd{d n} command, Calc gives you the choice. Incidentally, another consequence of all this is that if you type @kbd{M-30 d n} to display more digits than are ``really there,'' you'll see garbage digits at the end of the number. (In decimal display mode, with decimally-stored numbers, these garbage digits are always zero so they vanish and you don't notice them.) Because Calc rounds off that 0.15 digit, there is the danger that two numbers could be slightly different internally but still look the same. If you feel uneasy about this, set the @kbd{d n} precision to be a little higher than normal; you'll get ugly garbage digits, but you'll always be able to tell two distinct numbers apart. An interesting side note is that most computers store their floating-point numbers in binary, and convert to decimal for display. Thus everyday programs have the same problem: Decimal 0.1 cannot be represented exactly in binary (try it: @kbd{0.1 d 2}), so @samp{0.1 * 10} comes out as an inexact approximation to 1 on some machines (though they generally arrange to hide it from you by rounding off one digit as we did above). Because Calc works in decimal instead of binary, you can be sure that numbers that look exact @emph{are} exact as long as you stay in decimal display mode. It's not hard to show that any number that can be represented exactly in binary, octal, or hexadecimal is also exact in decimal, so the kinds of problems we saw in this exercise are likely to be severe only when you use a relatively unusual radix like 3. @node Modes Answer 2, Modes Answer 3, Modes Answer 1, Answers to Exercises @subsection Modes Tutorial Exercise 2 If the radix is 15 or higher, we can't use the letter @samp{e} to mark the exponent because @samp{e} is interpreted as a digit. When Calc needs to display scientific notation in a high radix, it writes @samp{16#F.E8F*16.^15}. You can enter a number like this as an algebraic entry. Also, pressing @kbd{e} without any digits before it normally types @kbd{1e}, but in a high radix it types @kbd{16.^} and puts you in algebraic entry: @kbd{16#f.e8f RET e 15 RET *} is another way to enter this number. The reason Calc puts a decimal point in the @samp{16.^} is to prevent huge integers from being generated if the exponent is large (consider @samp{16#1.23*16^1000}, where we compute @samp{16^1000} as a giant exact integer and then throw away most of the digits when we multiply it by the floating-point @samp{16#1.23}). While this wouldn't normally matter for display purposes, it could give you a nasty surprise if you copied that number into a file and later moved it back into Calc. @node Modes Answer 3, Modes Answer 4, Modes Answer 2, Answers to Exercises @subsection Modes Tutorial Exercise 3 @noindent The answer he got was @cite{0.5000000000006399}. The problem is not that the square operation is inexact, but that the sine of 45 that was already on the stack was accurate to only 12 places. Arbitrary-precision calculations still only give answers as good as their inputs. The real problem is that there is no 12-digit number which, when squared, comes out to 0.5 exactly. The @kbd{f [} and @kbd{f ]} commands decrease or increase a number by one unit in the last place (according to the current precision). They are useful for determining facts like this. @group @smallexample 1: 0.707106781187 1: 0.500000000001 . . 45 S 2 ^ @end smallexample @end group @noindent @group @smallexample 1: 0.707106781187 1: 0.707106781186 1: 0.499999999999 . . . U DEL f [ 2 ^ @end smallexample @end group A high-precision calculation must be carried out in high precision all the way. The only number in the original problem which was known exactly was the quantity 45 degrees, so the precision must be raised before anything is done after the number 45 has been entered in order for the higher precision to be meaningful. @node Modes Answer 4, Arithmetic Answer 1, Modes Answer 3, Answers to Exercises @subsection Modes Tutorial Exercise 4 @noindent Many calculations involve real-world quantities, like the width and height of a piece of wood or the volume of a jar. Such quantities can't be measured exactly anyway, and if the data that is input to a calculation is inexact, doing exact arithmetic on it is a waste of time. Fractions become unwieldy after too many calculations have been done with them. For example, the sum of the reciprocals of the integers from 1 to 10 is 7381:2520. The sum from 1 to 30 is 9304682830147:2329089562800. After a point it will take a long time to add even one more term to this sum, but a floating-point calculation of the sum will not have this problem. Also, rational numbers cannot express the results of all calculations. There is no fractional form for the square root of two, so if you type @w{@kbd{2 Q}}, Calc has no choice but to give you a floating-point answer. @node Arithmetic Answer 1, Arithmetic Answer 2, Modes Answer 4, Answers to Exercises @subsection Arithmetic Tutorial Exercise 1 @noindent Dividing two integers that are larger than the current precision may give a floating-point result that is inaccurate even when rounded down to an integer. Consider @cite{123456789 / 2} when the current precision is 6 digits. The true answer is @cite{61728394.5}, but with a precision of 6 this will be rounded to @c{$12345700.0/2.0 = 61728500.0$} @cite{12345700.@: / 2.@: = 61728500.}. The result, when converted to an integer, will be off by 106. Here are two solutions: Raise the precision enough that the floating-point round-off error is strictly to the right of the decimal point. Or, convert to fraction mode so that @cite{123456789 / 2} produces the exact fraction @cite{123456789:2}, which can be rounded down by the @kbd{F} command without ever switching to floating-point format. @node Arithmetic Answer 2, Vector Answer 1, Arithmetic Answer 1, Answers to Exercises @subsection Arithmetic Tutorial Exercise 2 @noindent @kbd{27 @key{RET} 9 B} could give the exact result @cite{3:2}, but it does a floating-point calculation instead and produces @cite{1.5}. Calc will find an exact result for a logarithm if the result is an integer or the reciprocal of an integer. But there is no efficient way to search the space of all possible rational numbers for an exact answer, so Calc doesn't try. @node Vector Answer 1, Vector Answer 2, Arithmetic Answer 2, Answers to Exercises @subsection Vector Tutorial Exercise 1 @noindent Duplicate the vector, compute its length, then divide the vector by its length: @kbd{@key{RET} A /}. @group @smallexample 1: [1, 2, 3] 2: [1, 2, 3] 1: [0.27, 0.53, 0.80] 1: 1. . 1: 3.74165738677 . . . r 1 RET A / A @end smallexample @end group The final @kbd{A} command shows that the normalized vector does indeed have unit length. @node Vector Answer 2, Matrix Answer 1, Vector Answer 1, Answers to Exercises @subsection Vector Tutorial Exercise 2 @noindent The average position is equal to the sum of the products of the positions times their corresponding probabilities. This is the definition of the dot product operation. So all you need to do is to put the two vectors on the stack and press @kbd{*}. @node Matrix Answer 1, Matrix Answer 2, Vector Answer 2, Answers to Exercises @subsection Matrix Tutorial Exercise 1 @noindent The trick is to multiply by a vector of ones. Use @kbd{r 4 [1 1 1] *} to get the row sum. Similarly, use @kbd{[1 1] r 4 *} to get the column sum. @node Matrix Answer 2, Matrix Answer 3, Matrix Answer 1, Answers to Exercises @subsection Matrix Tutorial Exercise 2 @ifinfo @group @example x + a y = 6 x + b y = 10 @end example @end group @end ifinfo @tex \turnoffactive \beforedisplay $$ \eqalign{ x &+ a y = 6 \cr x &+ b y = 10} $$ \afterdisplay @end tex Just enter the righthand side vector, then divide by the lefthand side matrix as usual. @group @smallexample 1: [6, 10] 2: [6, 10] 1: [6 - 4 a / (b - a), 4 / (b - a) ] . 1: [ [ 1, a ] . [ 1, b ] ] . ' [6 10] RET ' [1 a; 1 b] RET / @end smallexample @end group This can be made more readable using @kbd{d B} to enable ``big'' display mode: @group @smallexample 4 a 4 1: [6 - -----, -----] b - a b - a @end smallexample @end group Type @kbd{d N} to return to ``normal'' display mode afterwards. @node Matrix Answer 3, List Answer 1, Matrix Answer 2, Answers to Exercises @subsection Matrix Tutorial Exercise 3 @noindent To solve @c{$A^T A \, X = A^T B$} @cite{trn(A) * A * X = trn(A) * B}, first we compute @c{$A' = A^T A$} @cite{A2 = trn(A) * A} and @c{$B' = A^T B$} @cite{B2 = trn(A) * B}; now, we have a system @c{$A' X = B'$} @cite{A2 * X = B2} which we can solve using Calc's @samp{/} command. @ifinfo @group @example a + 2b + 3c = 6 4a + 5b + 6c = 2 7a + 6b = 3 2a + 4b + 6c = 11 @end example @end group @end ifinfo @tex \turnoffactive \beforedisplayh $$ \openup1\jot \tabskip=0pt plus1fil \halign to\displaywidth{\tabskip=0pt $\hfil#$&$\hfil{}#{}$& $\hfil#$&$\hfil{}#{}$& $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr a&+&2b&+&3c&=6 \cr 4a&+&5b&+&6c&=2 \cr 7a&+&6b& & &=3 \cr 2a&+&4b&+&6c&=11 \cr} $$ \afterdisplayh @end tex The first step is to enter the coefficient matrix. We'll store it in quick variable number 7 for later reference. Next, we compute the @c{$B'$} @cite{B2} vector. @group @smallexample 1: [ [ 1, 2, 3 ] 2: [ [ 1, 4, 7, 2 ] 1: [57, 84, 96] [ 4, 5, 6 ] [ 2, 5, 6, 4 ] . [ 7, 6, 0 ] [ 3, 6, 0, 6 ] ] [ 2, 4, 6 ] ] 1: [6, 2, 3, 11] . . ' [1 2 3; 4 5 6; 7 6 0; 2 4 6] RET s 7 v t [6 2 3 11] * @end smallexample @end group @noindent Now we compute the matrix @c{$A'$} @cite{A2} and divide. @group @smallexample 2: [57, 84, 96] 1: [-11.64, 14.08, -3.64] 1: [ [ 70, 72, 39 ] . [ 72, 81, 60 ] [ 39, 60, 81 ] ] . r 7 v t r 7 * / @end smallexample @end group @noindent (The actual computed answer will be slightly inexact due to round-off error.) Notice that the answers are similar to those for the @c{$3\times3$} @asis{3x3} system solved in the text. That's because the fourth equation that was added to the system is almost identical to the first one multiplied by two. (If it were identical, we would have gotten the exact same answer since the @c{$4\times3$} @asis{4x3} system would be equivalent to the original @c{$3\times3$} @asis{3x3} system.) Since the first and fourth equations aren't quite equivalent, they can't both be satisfied at once. Let's plug our answers back into the original system of equations to see how well they match. @group @smallexample 2: [-11.64, 14.08, -3.64] 1: [5.6, 2., 3., 11.2] 1: [ [ 1, 2, 3 ] . [ 4, 5, 6 ] [ 7, 6, 0 ] [ 2, 4, 6 ] ] . r 7 TAB * @end smallexample @end group @noindent This is reasonably close to our original @cite{B} vector, @cite{[6, 2, 3, 11]}. @node List Answer 1, List Answer 2, Matrix Answer 3, Answers to Exercises @subsection List Tutorial Exercise 1 @noindent We can use @kbd{v x} to build a vector of integers. This needs to be adjusted to get the range of integers we desire. Mapping @samp{-} across the vector will accomplish this, although it turns out the plain @samp{-} key will work just as well. @group @smallexample 2: 2 2: 2 1: [1, 2, 3, 4, 5, 6, 7, 8, 9] 1: [-4, -3, -2, -1, 0, 1, 2, 3, 4] . . 2 v x 9 RET 5 V M - or 5 - @end smallexample @end group @noindent Now we use @kbd{V M ^} to map the exponentiation operator across the vector. @group @smallexample 1: [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16] . V M ^ @end smallexample @end group @node List Answer 2, List Answer 3, List Answer 1, Answers to Exercises @subsection List Tutorial Exercise 2 @noindent Given @cite{x} and @cite{y} vectors in quick variables 1 and 2 as before, the first job is to form the matrix that describes the problem. @ifinfo @example m*x + b*1 = y @end example @end ifinfo @tex \turnoffactive \beforedisplay $$ m \times x + b \times 1 = y $$ \afterdisplay @end tex Thus we want a @c{$19\times2$} @asis{19x2} matrix with our @cite{x} vector as one column and ones as the other column. So, first we build the column of ones, then we combine the two columns to form our @cite{A} matrix. @group @smallexample 2: [1.34, 1.41, 1.49, ... ] 1: [ [ 1.34, 1 ] 1: [1, 1, 1, ...] [ 1.41, 1 ] . [ 1.49, 1 ] @dots{} r 1 1 v b 19 RET M-2 v p v t s 3 @end smallexample @end group @noindent Now we compute @c{$A^T y$} @cite{trn(A) * y} and @c{$A^T A$} @cite{trn(A) * A} and divide. @group @smallexample 1: [33.36554, 13.613] 2: [33.36554, 13.613] . 1: [ [ 98.0003, 41.63 ] [ 41.63, 19 ] ] . v t r 2 * r 3 v t r 3 * @end smallexample @end group @noindent (Hey, those numbers look familiar!) @group @smallexample 1: [0.52141679, -0.425978] . / @end smallexample @end group Since we were solving equations of the form @c{$m \times x + b \times 1 = y$} @cite{m*x + b*1 = y}, these numbers should be @cite{m} and @cite{b}, respectively. Sure enough, they agree exactly with the result computed using @kbd{V M} and @kbd{V R}! The moral of this story: @kbd{V M} and @kbd{V R} will probably solve your problem, but there is often an easier way using the higher-level arithmetic functions! @c [fix-ref Curve Fitting] In fact, there is a built-in @kbd{a F} command that does least-squares fits. @xref{Curve Fitting}. @node List Answer 3, List Answer 4, List Answer 2, Answers to Exercises @subsection List Tutorial Exercise 3 @noindent Move to one end of the list and press @kbd{C-@@} (or @kbd{C-SPC} or whatever) to set the mark, then move to the other end of the list and type @w{@kbd{M-# g}}. @group @smallexample 1: [2.3, 6, 22, 15.1, 7, 15, 14, 7.5, 2.5] . @end smallexample @end group To make things interesting, let's assume we don't know at a glance how many numbers are in this list. Then we could type: @group @smallexample 2: [2.3, 6, 22, ... ] 2: [2.3, 6, 22, ... ] 1: [2.3, 6, 22, ... ] 1: 126356422.5 . . RET V R * @end smallexample @end group @noindent @group @smallexample 2: 126356422.5 2: 126356422.5 1: 7.94652913734 1: [2.3, 6, 22, ... ] 1: 9 . . . TAB v l I ^ @end smallexample @end group @noindent (The @kbd{I ^} command computes the @var{n}th root of a number. You could also type @kbd{& ^} to take the reciprocal of 9 and then raise the number to that power.) @node List Answer 4, List Answer 5, List Answer 3, Answers to Exercises @subsection List Tutorial Exercise 4 @noindent A number @cite{j} is a divisor of @cite{n} if @c{$n \mathbin{\hbox{\code{\%}}} j = 0$} @samp{n % j = 0}. The first step is to get a vector that identifies the divisors. @group @smallexample 2: 30 2: [0, 0, 0, 2, ...] 1: [1, 1, 1, 0, ...] 1: [1, 2, 3, 4, ...] 1: 0 . . . 30 RET v x 30 RET s 1 V M % 0 V M a = s 2 @end smallexample @end group @noindent This vector has 1's marking divisors of 30 and 0's marking non-divisors. The zeroth divisor function is just the total number of divisors. The first divisor function is the sum of the divisors. @group @smallexample 1: 8 3: 8 2: 8 2: 8 2: [1, 2, 3, 4, ...] 1: [1, 2, 3, 0, ...] 1: 72 1: [1, 1, 1, 0, ...] . . . V R + r 1 r 2 V M * V R + @end smallexample @end group @noindent Once again, the last two steps just compute a dot product for which a simple @kbd{*} would have worked equally well. @node List Answer 5, List Answer 6, List Answer 4, Answers to Exercises @subsection List Tutorial Exercise 5 @noindent The obvious first step is to obtain the list of factors with @kbd{k f}. This list will always be in sorted order, so if there are duplicates they will be right next to each other. A suitable method is to compare the list with a copy of itself shifted over by one. @group @smallexample 1: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19, 0] . 1: [3, 7, 7, 7, 19, 0] 1: [0, 3, 7, 7, 7, 19] . . 19551 k f RET 0 | TAB 0 TAB | @end smallexample @end group @noindent @group @smallexample 1: [0, 0, 1, 1, 0, 0] 1: 2 1: 0 . . . V M a = V R + 0 a = @end smallexample @end group @noindent Note that we have to arrange for both vectors to have the same length so that the mapping operation works; no prime factor will ever be zero, so adding zeros on the left and right is safe. From then on the job is pretty straightforward. Incidentally, Calc provides the @c{\dfn{M\"obius} $\mu$} @dfn{Moebius mu} function which is zero if and only if its argument is square-free. It would be a much more convenient way to do the above test in practice. @node List Answer 6, List Answer 7, List Answer 5, Answers to Exercises @subsection List Tutorial Exercise 6 @noindent First use @kbd{v x 6 RET} to get a list of integers, then @kbd{V M v x} to get a list of lists of integers! @node List Answer 7, List Answer 8, List Answer 6, Answers to Exercises @subsection List Tutorial Exercise 7 @noindent Here's one solution. First, compute the triangular list from the previous exercise and type @kbd{1 -} to subtract one from all the elements. @group @smallexample 1: [ [0], [0, 1], [0, 1, 2], @dots{} 1 - @end smallexample @end group The numbers down the lefthand edge of the list we desire are called the ``triangular numbers'' (now you know why!). The @cite{n}th triangular number is the sum of the integers from 1 to @cite{n}, and can be computed directly by the formula @c{$n (n+1) \over 2$} @cite{n * (n+1) / 2}. @group @smallexample 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ] 1: [0, 1, 2, 3, 4, 5] 1: [0, 1, 3, 6, 10, 15] . . v x 6 RET 1 - V M ' $ ($+1)/2 RET @end smallexample @end group @noindent Adding this list to the above list of lists produces the desired result: @group @smallexample 1: [ [0], [1, 2], [3, 4, 5], [6, 7, 8, 9], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19, 20] ] . V M + @end smallexample @end group If we did not know the formula for triangular numbers, we could have computed them using a @kbd{V U +} command. We could also have gotten them the hard way by mapping a reduction across the original triangular list. @group @smallexample 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ] 1: [ [0], [0, 1], ... ] 1: [0, 1, 3, 6, 10, 15] . . RET V M V R + @end smallexample @end group @noindent (This means ``map a @kbd{V R +} command across the vector,'' and since each element of the main vector is itself a small vector, @kbd{V R +} computes the sum of its elements.) @node List Answer 8, List Answer 9, List Answer 7, Answers to Exercises @subsection List Tutorial Exercise 8 @noindent The first step is to build a list of values of @cite{x}. @group @smallexample 1: [1, 2, 3, ..., 21] 1: [0, 1, 2, ..., 20] 1: [0, 0.25, 0.5, ..., 5] . . . v x 21 RET 1 - 4 / s 1 @end smallexample @end group Next, we compute the Bessel function values. @group @smallexample 1: [0., 0.124, 0.242, ..., -0.328] . V M ' besJ(1,$) RET @end smallexample @end group @noindent (Another way to do this would be @kbd{1 TAB V M f j}.) A way to isolate the maximum value is to compute the maximum using @kbd{V R X}, then compare all the Bessel values with that maximum. @group @smallexample 2: [0., 0.124, 0.242, ... ] 1: [0, 0, 0, ... ] 2: [0, 0, 0, ... ] 1: 0.5801562 . 1: 1 . . RET V R X V M a = RET V R + DEL @end smallexample @end group @noindent It's a good idea to verify, as in the last step above, that only one value is equal to the maximum. (After all, a plot of @c{$\sin x$} @cite{sin(x)} might have many points all equal to the maximum value, 1.) The vector we have now has a single 1 in the position that indicates the maximum value of @cite{x}. Now it is a simple matter to convert this back into the corresponding value itself. @group @smallexample 2: [0, 0, 0, ... ] 1: [0, 0., 0., ... ] 1: 1.75 1: [0, 0.25, 0.5, ... ] . . . r 1 V M * V R + @end smallexample @end group If @kbd{a =} had produced more than one @cite{1} value, this method would have given the sum of all maximum @cite{x} values; not very useful! In this case we could have used @kbd{v m} (@code{calc-mask-vector}) instead. This command deletes all elements of a ``data'' vector that correspond to zeros in a ``mask'' vector, leaving us with, in this example, a vector of maximum @cite{x} values. The built-in @kbd{a X} command maximizes a function using more efficient methods. Just for illustration, let's use @kbd{a X} to maximize @samp{besJ(1,x)} over this same interval. @group @smallexample 2: besJ(1, x) 1: [1.84115, 0.581865] 1: [0 .. 5] . . ' besJ(1,x), [0..5] RET a X x RET @end smallexample @end group @noindent The output from @kbd{a X} is a vector containing the value of @cite{x} that maximizes the function, and the function's value at that maximum. As you can see, our simple search got quite close to the right answer. @node List Answer 9, List Answer 10, List Answer 8, Answers to Exercises @subsection List Tutorial Exercise 9 @noindent Step one is to convert our integer into vector notation. @group @smallexample 1: 25129925999 3: 25129925999 . 2: 10 1: [11, 10, 9, ..., 1, 0] . 25129925999 RET 10 RET 12 RET v x 12 RET - @end smallexample @end group @noindent @group @smallexample 1: 25129925999 1: [0, 2, 25, 251, 2512, ... ] 2: [100000000000, ... ] . . V M ^ s 1 V M \ @end smallexample @end group @noindent (Recall, the @kbd{\} command computes an integer quotient.) @group @smallexample 1: [0, 2, 5, 1, 2, 9, 9, 2, 5, 9, 9, 9] . 10 V M % s 2 @end smallexample @end group Next we must increment this number. This involves adding one to the last digit, plus handling carries. There is a carry to the left out of a digit if that digit is a nine and all the digits to the right of it are nines. @group @smallexample 1: [0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1] 1: [1, 1, 1, 0, 0, 1, ... ] . . 9 V M a = v v @end smallexample @end group @noindent @group @smallexample 1: [1, 1, 1, 0, 0, 0, ... ] 1: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1] . . V U * v v 1 | @end smallexample @end group @noindent Accumulating @kbd{*} across a vector of ones and zeros will preserve only the initial run of ones. These are the carries into all digits except the rightmost digit. Concatenating a one on the right takes care of aligning the carries properly, and also adding one to the rightmost digit. @group @smallexample 2: [0, 0, 0, 0, ... ] 1: [0, 0, 2, 5, 1, 2, 9, 9, 2, 6, 0, 0, 0] 1: [0, 0, 2, 5, ... ] . . 0 r 2 | V M + 10 V M % @end smallexample @end group @noindent Here we have concatenated 0 to the @emph{left} of the original number; this takes care of shifting the carries by one with respect to the digits that generated them. Finally, we must convert this list back into an integer. @group @smallexample 3: [0, 0, 2, 5, ... ] 2: [0, 0, 2, 5, ... ] 2: 1000000000000 1: [1000000000000, 100000000000, ... ] 1: [100000000000, ... ] . . 10 RET 12 ^ r 1 | @end smallexample @end group @noindent @group @smallexample 1: [0, 0, 20000000000, 5000000000, ... ] 1: 25129926000 . . V M * V R + @end smallexample @end group @noindent Another way to do this final step would be to reduce the formula @w{@samp{10 $$ + $}} across the vector of digits. @group @smallexample 1: [0, 0, 2, 5, ... ] 1: 25129926000 . . V R ' 10 $$ + $ RET @end smallexample @end group @node List Answer 10, List Answer 11, List Answer 9, Answers to Exercises @subsection List Tutorial Exercise 10 @noindent For the list @cite{[a, b, c, d]}, the result is @cite{((a = b) = c) = d}, which will compare @cite{a} and @cite{b} to produce a 1 or 0, which is then compared with @cite{c} to produce another 1 or 0, which is then compared with @cite{d}. This is not at all what Joe wanted. Here's a more correct method: @group @smallexample 1: [7, 7, 7, 8, 7] 2: [7, 7, 7, 8, 7] . 1: 7 . ' [7,7,7,8,7] RET RET v r 1 RET @end smallexample @end group @noindent @group @smallexample 1: [1, 1, 1, 0, 1] 1: 0 . . V M a = V R * @end smallexample @end group @node List Answer 11, List Answer 12, List Answer 10, Answers to Exercises @subsection List Tutorial Exercise 11 @noindent The circle of unit radius consists of those points @cite{(x,y)} for which @cite{x^2 + y^2 < 1}. We start by generating a vector of @cite{x^2} and a vector of @cite{y^2}. We can make this go a bit faster by using the @kbd{v .} and @kbd{t .} commands. @group @smallexample 2: [2., 2., ..., 2.] 2: [2., 2., ..., 2.] 1: [2., 2., ..., 2.] 1: [1.16, 1.98, ..., 0.81] . . v . t . 2. v b 100 RET RET V M k r @end smallexample @end group @noindent @group @smallexample 2: [2., 2., ..., 2.] 1: [0.026, 0.96, ..., 0.036] 1: [0.026, 0.96, ..., 0.036] 2: [0.53, 0.81, ..., 0.094] . . 1 - 2 V M ^ TAB V M k r 1 - 2 V M ^ @end smallexample @end group Now we sum the @cite{x^2} and @cite{y^2} values, compare with 1 to get a vector of 1/0 truth values, then sum the truth values. @group @smallexample 1: [0.56, 1.78, ..., 0.13] 1: [1, 0, ..., 1] 1: 84 . . . + 1 V M a < V R + @end smallexample @end group @noindent The ratio @cite{84/100} should approximate the ratio @c{$\pi/4$} @cite{pi/4}. @group @smallexample 1: 0.84 1: 3.36 2: 3.36 1: 1.0695 . . 1: 3.14159 . 100 / 4 * P / @end smallexample @end group @noindent Our estimate, 3.36, is off by about 7%. We could get a better estimate by taking more points (say, 1000), but it's clear that this method is not very efficient! (Naturally, since this example uses random numbers your own answer will be slightly different from the one shown here!) If you typed @kbd{v .} and @kbd{t .} before, type them again to return to full-sized display of vectors. @node List Answer 12, List Answer 13, List Answer 11, Answers to Exercises @subsection List Tutorial Exercise 12 @noindent This problem can be made a lot easier by taking advantage of some symmetries. First of all, after some thought it's clear that the @cite{y} axis can be ignored altogether. Just pick a random @cite{x} component for one end of the match, pick a random direction @c{$\theta$} @cite{theta}, and see if @cite{x} and @c{$x + \cos \theta$} @cite{x + cos(theta)} (which is the @cite{x} coordinate of the other endpoint) cross a line. The lines are at integer coordinates, so this happens when the two numbers surround an integer. Since the two endpoints are equivalent, we may as well choose the leftmost of the two endpoints as @cite{x}. Then @cite{theta} is an angle pointing to the right, in the range -90 to 90 degrees. (We could use radians, but it would feel like cheating to refer to @c{$\pi/2$} @cite{pi/2} radians while trying to estimate @c{$\pi$} @cite{pi}!) In fact, since the field of lines is infinite we can choose the coordinates 0 and 1 for the lines on either side of the leftmost endpoint. The rightmost endpoint will be between 0 and 1 if the match does not cross a line, or between 1 and 2 if it does. So: Pick random @cite{x} and @c{$\theta$} @cite{theta}, compute @c{$x + \cos \theta$} @cite{x + cos(theta)}, and count how many of the results are greater than one. Simple! We can make this go a bit faster by using the @kbd{v .} and @kbd{t .} commands. @group @smallexample 1: [0.52, 0.71, ..., 0.72] 2: [0.52, 0.71, ..., 0.72] . 1: [78.4, 64.5, ..., -42.9] . v . t . 1. v b 100 RET V M k r 180. v b 100 RET V M k r 90 - @end smallexample @end group @noindent (The next step may be slow, depending on the speed of your computer.) @group @smallexample 2: [0.52, 0.71, ..., 0.72] 1: [0.72, 1.14, ..., 1.45] 1: [0.20, 0.43, ..., 0.73] . . m d V M C + @end smallexample @end group @noindent @group @smallexample 1: [0, 1, ..., 1] 1: 0.64 1: 3.125 . . . 1 V M a > V R + 100 / 2 TAB / @end smallexample @end group Let's try the third method, too. We'll use random integers up to one million. The @kbd{k r} command with an integer argument picks a random integer. @group @smallexample 2: [1000000, 1000000, ..., 1000000] 2: [78489, 527587, ..., 814975] 1: [1000000, 1000000, ..., 1000000] 1: [324014, 358783, ..., 955450] . . 1000000 v b 100 RET RET V M k r TAB V M k r @end smallexample @end group @noindent @group @smallexample 1: [1, 1, ..., 25] 1: [1, 1, ..., 0] 1: 0.56 . . . V M k g 1 V M a = V R + 100 / @end smallexample @end group @noindent @group @smallexample 1: 10.714 1: 3.273 . . 6 TAB / Q @end smallexample @end group For a proof of this property of the GCD function, see section 4.5.2, exercise 10, of Knuth's @emph{Art of Computer Programming}, volume II. If you typed @kbd{v .} and @kbd{t .} before, type them again to return to full-sized display of vectors. @node List Answer 13, List Answer 14, List Answer 12, Answers to Exercises @subsection List Tutorial Exercise 13 @noindent First, we put the string on the stack as a vector of ASCII codes. @group @smallexample 1: [84, 101, 115, ..., 51] . "Testing, 1, 2, 3 RET @end smallexample @end group @noindent Note that the @kbd{"} key, like @kbd{$}, initiates algebraic entry so there was no need to type an apostrophe. Also, Calc didn't mind that we omitted the closing @kbd{"}. (The same goes for all closing delimiters like @kbd{)} and @kbd{]} at the end of a formula. We'll show two different approaches here. In the first, we note that if the input vector is @cite{[a, b, c, d]}, then the hash code is @cite{3 (3 (3a + b) + c) + d = 27a + 9b + 3c + d}. In other words, it's a sum of descending powers of three times the ASCII codes. @group @smallexample 2: [84, 101, 115, ..., 51] 2: [84, 101, 115, ..., 51] 1: 16 1: [15, 14, 13, ..., 0] . . RET v l v x 16 RET - @end smallexample @end group @noindent @group @smallexample 2: [84, 101, 115, ..., 51] 1: 1960915098 1: 121 1: [14348907, ..., 1] . . . 3 TAB V M ^ * 511 % @end smallexample @end group @noindent Once again, @kbd{*} elegantly summarizes most of the computation. But there's an even more elegant approach: Reduce the formula @kbd{3 $$ + $} across the vector. Recall that this represents a function of two arguments that computes its first argument times three plus its second argument. @group @smallexample 1: [84, 101, 115, ..., 51] 1: 1960915098 . . "Testing, 1, 2, 3 RET V R ' 3$$+$ RET @end smallexample @end group @noindent If you did the decimal arithmetic exercise, this will be familiar. Basically, we're turning a base-3 vector of digits into an integer, except that our ``digits'' are much larger than real digits. Instead of typing @kbd{511 %} again to reduce the result, we can be cleverer still and notice that rather than computing a huge integer and taking the modulo at the end, we can take the modulo at each step without affecting the result. While this means there are more arithmetic operations, the numbers we operate on remain small so the operations are faster. @group @smallexample 1: [84, 101, 115, ..., 51] 1: 121 . . "Testing, 1, 2, 3 RET V R ' (3$$+$)%511 RET @end smallexample @end group Why does this work? Think about a two-step computation: @w{@cite{3 (3a + b) + c}}. Taking a result modulo 511 basically means subtracting off enough 511's to put the result in the desired range. So the result when we take the modulo after every step is, @ifinfo @example 3 (3 a + b - 511 m) + c - 511 n @end example @end ifinfo @tex \turnoffactive \beforedisplay $$ 3 (3 a + b - 511 m) + c - 511 n $$ \afterdisplay @end tex @noindent for some suitable integers @cite{m} and @cite{n}. Expanding out by the distributive law yields @ifinfo @example 9 a + 3 b + c - 511*3 m - 511 n @end example @end ifinfo @tex \turnoffactive \beforedisplay $$ 9 a + 3 b + c - 511\times3 m - 511 n $$ \afterdisplay @end tex @noindent The @cite{m} term in the latter formula is redundant because any contribution it makes could just as easily be made by the @cite{n} term. So we can take it out to get an equivalent formula with @cite{n' = 3m + n}, @ifinfo @example 9 a + 3 b + c - 511 n' @end example @end ifinfo @tex \turnoffactive \beforedisplay $$ 9 a + 3 b + c - 511 n' $$ \afterdisplay @end tex @noindent which is just the formula for taking the modulo only at the end of the calculation. Therefore the two methods are essentially the same. Later in the tutorial we will encounter @dfn{modulo forms}, which basically automate the idea of reducing every intermediate result modulo some value @i{M}. @node List Answer 14, Types Answer 1, List Answer 13, Answers to Exercises @subsection List Tutorial Exercise 14 We want to use @kbd{H V U} to nest a function which adds a random step to an @cite{(x,y)} coordinate. The function is a bit long, but otherwise the problem is quite straightforward. @group @smallexample 2: [0, 0] 1: [ [ 0, 0 ] 1: 50 [ 0.4288, -0.1695 ] . [ -0.4787, -0.9027 ] ... [0,0] 50 H V U ' <# + [random(2.0)-1, random(2.0)-1]> RET @end smallexample @end group Just as the text recommended, we used @samp{< >} nameless function notation to keep the two @code{random} calls from being evaluated before nesting even begins. We now have a vector of @cite{[x, y]} sub-vectors, which by Calc's rules acts like a matrix. We can transpose this matrix and unpack to get a pair of vectors, @cite{x} and @cite{y}, suitable for graphing. @group @smallexample 2: [ 0, 0.4288, -0.4787, ... ] 1: [ 0, -0.1696, -0.9027, ... ] . v t v u g f @end smallexample @end group Incidentally, because the @cite{x} and @cite{y} are completely independent in this case, we could have done two separate commands to create our @cite{x} and @cite{y} vectors of numbers directly. To make a random walk of unit steps, we note that @code{sincos} of a random direction exactly gives us an @cite{[x, y]} step of unit length; in fact, the new nesting function is even briefer, though we might want to lower the precision a bit for it. @group @smallexample 2: [0, 0] 1: [ [ 0, 0 ] 1: 50 [ 0.1318, 0.9912 ] . [ -0.5965, 0.3061 ] ... [0,0] 50 m d p 6 RET H V U ' <# + sincos(random(360.0))> RET @end smallexample @end group Another @kbd{v t v u g f} sequence will graph this new random walk. An interesting twist on these random walk functions would be to use complex numbers instead of 2-vectors to represent points on the plane. In the first example, we'd use something like @samp{random + random*(0,1)}, and in the second we could use polar complex numbers with random phase angles. (This exercise was first suggested in this form by Randal Schwartz.) @node Types Answer 1, Types Answer 2, List Answer 14, Answers to Exercises @subsection Types Tutorial Exercise 1 @noindent If the number is the square root of @c{$\pi$} @cite{pi} times a rational number, then its square, divided by @c{$\pi$} @cite{pi}, should be a rational number. @group @smallexample 1: 1.26508260337 1: 0.509433962268 1: 2486645810:4881193627 . . . 2 ^ P / c F @end smallexample @end group @noindent Technically speaking this is a rational number, but not one that is likely to have arisen in the original problem. More likely, it just happens to be the fraction which most closely represents some irrational number to within 12 digits. But perhaps our result was not quite exact. Let's reduce the precision slightly and try again: @group @smallexample 1: 0.509433962268 1: 27:53 . . U p 10 RET c F @end smallexample @end group @noindent Aha! It's unlikely that an irrational number would equal a fraction this simple to within ten digits, so our original number was probably @c{$\sqrt{27 \pi / 53}$} @cite{sqrt(27 pi / 53)}. Notice that we didn't need to re-round the number when we reduced the precision. Remember, arithmetic operations always round their inputs to the current precision before they begin. @node Types Answer 2, Types Answer 3, Types Answer 1, Answers to Exercises @subsection Types Tutorial Exercise 2 @noindent @samp{inf / inf = nan}. Perhaps @samp{1} is the ``obvious'' answer. But if @w{@samp{17 inf = inf}}, then @samp{17 inf / inf = inf / inf = 17}, too. @samp{exp(inf) = inf}. It's tempting to say that the exponential of infinity must be ``bigger'' than ``regular'' infinity, but as far as Calc is concerned all infinities are as just as big. In other words, as @cite{x} goes to infinity, @cite{e^x} also goes to infinity, but the fact the @cite{e^x} grows much faster than @cite{x} is not relevant here. @samp{exp(-inf) = 0}. Here we have a finite answer even though the input is infinite. @samp{sqrt(-inf) = (0, 1) inf}. Remember that @cite{(0, 1)} represents the imaginary number @cite{i}. Here's a derivation: @samp{sqrt(-inf) = @w{sqrt((-1) * inf)} = sqrt(-1) * sqrt(inf)}. The first part is, by definition, @cite{i}; the second is @code{inf} because, once again, all infinities are the same size. @samp{sqrt(uinf) = uinf}. In fact, we do know something about the direction because @code{sqrt} is defined to return a value in the right half of the complex plane. But Calc has no notation for this, so it settles for the conservative answer @code{uinf}. @samp{abs(uinf) = inf}. No matter which direction @cite{x} points, @samp{abs(x)} always points along the positive real axis. @samp{ln(0) = -inf}. Here we have an infinite answer to a finite input. As in the @cite{1 / 0} case, Calc will only use infinities here if you have turned on ``infinite'' mode. Otherwise, it will treat @samp{ln(0)} as an error. @node Types Answer 3, Types Answer 4, Types Answer 2, Answers to Exercises @subsection Types Tutorial Exercise 3 @noindent We can make @samp{inf - inf} be any real number we like, say, @cite{a}, just by claiming that we added @cite{a} to the first infinity but not to the second. This is just as true for complex values of @cite{a}, so @code{nan} can stand for a complex number. (And, similarly, @code{uinf} can stand for an infinity that points in any direction in the complex plane, such as @samp{(0, 1) inf}). In fact, we can multiply the first @code{inf} by two. Surely @w{@samp{2 inf - inf = inf}}, but also @samp{2 inf - inf = inf - inf = nan}. So @code{nan} can even stand for infinity. Obviously it's just as easy to make it stand for minus infinity as for plus infinity. The moral of this story is that ``infinity'' is a slippery fish indeed, and Calc tries to handle it by having a very simple model for infinities (only the direction counts, not the ``size''); but Calc is careful to write @code{nan} any time this simple model is unable to tell what the true answer is. @node Types Answer 4, Types Answer 5, Types Answer 3, Answers to Exercises @subsection Types Tutorial Exercise 4 @group @smallexample 2: 0@@ 47' 26" 1: 0@@ 2' 47.411765" 1: 17 . . 0@@ 47' 26" RET 17 / @end smallexample @end group @noindent The average song length is two minutes and 47.4 seconds. @group @smallexample 2: 0@@ 2' 47.411765" 1: 0@@ 3' 7.411765" 1: 0@@ 53' 6.000005" 1: 0@@ 0' 20" . . . 20" + 17 * @end smallexample @end group @noindent The album would be 53 minutes and 6 seconds long. @node Types Answer 5, Types Answer 6, Types Answer 4, Answers to Exercises @subsection Types Tutorial Exercise 5 @noindent Let's suppose it's January 14, 1991. The easiest thing to do is to keep trying 13ths of months until Calc reports a Friday. We can do this by manually entering dates, or by using @kbd{t I}: @group @smallexample 1: 1: 1: . . . ' <2/13> RET DEL ' <3/13> RET t I @end smallexample @end group @noindent (Calc assumes the current year if you don't say otherwise.) This is getting tedious---we can keep advancing the date by typing @kbd{t I} over and over again, but let's automate the job by using vector mapping. The @kbd{t I} command actually takes a second ``how-many-months'' argument, which defaults to one. This argument is exactly what we want to map over: @group @smallexample 2: 1: [, , 1: [1, 2, 3, 4, 5, 6] , , . , ] . v x 6 RET V M t I @end smallexample @end group @ifinfo @noindent Et voila, September 13, 1991 is a Friday. @end ifinfo @tex \noindent {\it Et voil{\accent"12 a}}, September 13, 1991 is a Friday. @end tex @group @smallexample 1: 242 . ' - RET @end smallexample @end group @noindent And the answer to our original question: 242 days to go. @node Types Answer 6, Types Answer 7, Types Answer 5, Answers to Exercises @subsection Types Tutorial Exercise 6 @noindent The full rule for leap years is that they occur in every year divisible by four, except that they don't occur in years divisible by 100, except that they @emph{do} in years divisible by 400. We could work out the answer by carefully counting the years divisible by four and the exceptions, but there is a much simpler way that works even if we don't know the leap year rule. Let's assume the present year is 1991. Years have 365 days, except that leap years (whenever they occur) have 366 days. So let's count the number of days between now and then, and compare that to the number of years times 365. The number of extra days we find must be equal to the number of leap years there were. @group @smallexample 1: 2: 1: 2925593 . 1: . . ' RET ' RET - @end smallexample @end group @noindent @group @smallexample 3: 2925593 2: 2925593 2: 2925593 1: 1943 2: 10001 1: 8010 1: 2923650 . 1: 1991 . . . 10001 RET 1991 - 365 * - @end smallexample @end group @c [fix-ref Date Forms] @noindent There will be 1943 leap years before the year 10001. (Assuming, of course, that the algorithm for computing leap years remains unchanged for that long. @xref{Date Forms}, for some interesting background information in that regard.) @node Types Answer 7, Types Answer 8, Types Answer 6, Answers to Exercises @subsection Types Tutorial Exercise 7 @noindent The relative errors must be converted to absolute errors so that @samp{+/-} notation may be used. @group @smallexample 1: 1. 2: 1. . 1: 0.2 . 20 RET .05 * 4 RET .05 * @end smallexample @end group Now we simply chug through the formula. @group @smallexample 1: 19.7392088022 1: 394.78 +/- 19.739 1: 6316.5 +/- 706.21 . . . 2 P 2 ^ * 20 p 1 * 4 p .2 RET 2 ^ * @end smallexample @end group It turns out the @kbd{v u} command will unpack an error form as well as a vector. This saves us some retyping of numbers. @group @smallexample 3: 6316.5 +/- 706.21 2: 6316.5 +/- 706.21 2: 6316.5 1: 0.1118 1: 706.21 . . RET v u TAB / @end smallexample @end group @noindent Thus the volume is 6316 cubic centimeters, within about 11 percent. @node Types Answer 8, Types Answer 9, Types Answer 7, Answers to Exercises @subsection Types Tutorial Exercise 8 @noindent The first answer is pretty simple: @samp{1 / (0 .. 10) = (0.1 .. inf)}. Since a number in the interval @samp{(0 .. 10)} can get arbitrarily close to zero, its reciprocal can get arbitrarily large, so the answer is an interval that effectively means, ``any number greater than 0.1'' but with no upper bound. The second answer, similarly, is @samp{1 / (-10 .. 0) = (-inf .. -0.1)}. Calc normally treats division by zero as an error, so that the formula @w{@samp{1 / 0}} is left unsimplified. Our third problem, @w{@samp{1 / [0 .. 10]}}, also (potentially) divides by zero because zero is now a member of the interval. So Calc leaves this one unevaluated, too. If you turn on ``infinite'' mode by pressing @kbd{m i}, you will instead get the answer @samp{[0.1 .. inf]}, which includes infinity as a possible value. The fourth calculation, @samp{1 / (-10 .. 10)}, has the same problem. Zero is buried inside the interval, but it's still a possible value. It's not hard to see that the actual result of @samp{1 / (-10 .. 10)} will be either greater than @i{0.1}, or less than @i{-0.1}. Thus the interval goes from minus infinity to plus infinity, with a ``hole'' in it from @i{-0.1} to @i{0.1}. Calc doesn't have any way to represent this, so it just reports @samp{[-inf .. inf]} as the answer. It may be disappointing to hear ``the answer lies somewhere between minus infinity and plus infinity, inclusive,'' but that's the best that interval arithmetic can do in this case. @node Types Answer 9, Types Answer 10, Types Answer 8, Answers to Exercises @subsection Types Tutorial Exercise 9 @group @smallexample 1: [-3 .. 3] 2: [-3 .. 3] 2: [0 .. 9] . 1: [0 .. 9] 1: [-9 .. 9] . . [ 3 n .. 3 ] RET 2 ^ TAB RET * @end smallexample @end group @noindent In the first case the result says, ``if a number is between @i{-3} and 3, its square is between 0 and 9.'' The second case says, ``the product of two numbers each between @i{-3} and 3 is between @i{-9} and 9.'' An interval form is not a number; it is a symbol that can stand for many different numbers. Two identical-looking interval forms can stand for different numbers. The same issue arises when you try to square an error form. @node Types Answer 10, Types Answer 11, Types Answer 9, Answers to Exercises @subsection Types Tutorial Exercise 10 @noindent Testing the first number, we might arbitrarily choose 17 for @cite{x}. @group @smallexample 1: 17 mod 811749613 2: 17 mod 811749613 1: 533694123 mod 811749613 . 811749612 . . 17 M 811749613 RET 811749612 ^ @end smallexample @end group @noindent Since 533694123 is (considerably) different from 1, the number 811749613 must not be prime. It's awkward to type the number in twice as we did above. There are various ways to avoid this, and algebraic entry is one. In fact, using a vector mapping operation we can perform several tests at once. Let's use this method to test the second number. @group @smallexample 2: [17, 42, 100000] 1: [1 mod 15485863, 1 mod ... ] 1: 15485863 . . [17 42 100000] 15485863 RET V M ' ($$ mod $)^($-1) RET @end smallexample @end group @noindent The result is three ones (modulo @cite{n}), so it's very probable that 15485863 is prime. (In fact, this number is the millionth prime.) Note that the functions @samp{($$^($-1)) mod $} or @samp{$$^($-1) % $} would have been hopelessly inefficient, since they would have calculated the power using full integer arithmetic. Calc has a @kbd{k p} command that does primality testing. For small numbers it does an exact test; for large numbers it uses a variant of the Fermat test we used here. You can use @kbd{k p} repeatedly to prove that a large integer is prime with any desired probability. @node Types Answer 11, Types Answer 12, Types Answer 10, Answers to Exercises @subsection Types Tutorial Exercise 11 @noindent There are several ways to insert a calculated number into an HMS form. One way to convert a number of seconds to an HMS form is simply to multiply the number by an HMS form representing one second: @group @smallexample 1: 31415926.5359 2: 31415926.5359 1: 8726@@ 38' 46.5359" . 1: 0@@ 0' 1" . . P 1e7 * 0@@ 0' 1" * @end smallexample @end group @noindent @group @smallexample 2: 8726@@ 38' 46.5359" 1: 6@@ 6' 2.5359" mod 24@@ 0' 0" 1: 15@@ 27' 16" mod 24@@ 0' 0" . . x time RET + @end smallexample @end group @noindent It will be just after six in the morning. The algebraic @code{hms} function can also be used to build an HMS form: @group @smallexample 1: hms(0, 0, 10000000. pi) 1: 8726@@ 38' 46.5359" . . ' hms(0, 0, 1e7 pi) RET = @end smallexample @end group @noindent The @kbd{=} key is necessary to evaluate the symbol @samp{pi} to the actual number 3.14159... @node Types Answer 12, Types Answer 13, Types Answer 11, Answers to Exercises @subsection Types Tutorial Exercise 12 @noindent As we recall, there are 17 songs of about 2 minutes and 47 seconds each. @group @smallexample 2: 0@@ 2' 47" 1: [0@@ 3' 7" .. 0@@ 3' 47"] 1: [0@@ 0' 20" .. 0@@ 1' 0"] . . [ 0@@ 20" .. 0@@ 1' ] + @end smallexample @end group @noindent @group @smallexample 1: [0@@ 52' 59." .. 1@@ 4' 19."] . 17 * @end smallexample @end group @noindent No matter how long it is, the album will fit nicely on one CD. @node Types Answer 13, Types Answer 14, Types Answer 12, Answers to Exercises @subsection Types Tutorial Exercise 13 @noindent Type @kbd{' 1 yr RET u c s RET}. The answer is 31557600 seconds. @node Types Answer 14, Types Answer 15, Types Answer 13, Answers to Exercises @subsection Types Tutorial Exercise 14 @noindent How long will it take for a signal to get from one end of the computer to the other? @group @smallexample 1: m / c 1: 3.3356 ns . . ' 1 m / c RET u c ns RET @end smallexample @end group @noindent (Recall, @samp{c} is a ``unit'' corresponding to the speed of light.) @group @smallexample 1: 3.3356 ns 1: 0.81356 ns / ns 1: 0.81356 2: 4.1 ns . . . ' 4.1 ns RET / u s @end smallexample @end group @noindent Thus a signal could take up to 81 percent of a clock cycle just to go from one place to another inside the computer, assuming the signal could actually attain the full speed of light. Pretty tight! @node Types Answer 15, Algebra Answer 1, Types Answer 14, Answers to Exercises @subsection Types Tutorial Exercise 15 @noindent The speed limit is 55 miles per hour on most highways. We want to find the ratio of Sam's speed to the US speed limit. @group @smallexample 1: 55 mph 2: 55 mph 3: 11 hr mph / yd . 1: 5 yd / hr . . ' 55 mph RET ' 5 yd/hr RET / @end smallexample @end group The @kbd{u s} command cancels out these units to get a plain number. Now we take the logarithm base two to find the final answer, assuming that each successive pill doubles his speed. @group @smallexample 1: 19360. 2: 19360. 1: 14.24 . 1: 2 . . u s 2 B @end smallexample @end group @noindent Thus Sam can take up to 14 pills without a worry. @node Algebra Answer 1, Algebra Answer 2, Types Answer 15, Answers to Exercises @subsection Algebra Tutorial Exercise 1 @noindent @c [fix-ref Declarations] The result @samp{sqrt(x)^2} is simplified back to @cite{x} by the Calculator, but @samp{sqrt(x^2)} is not. (Consider what happens if @w{@cite{x = -4}}.) If @cite{x} is real, this formula could be simplified to @samp{abs(x)}, but for general complex arguments even that is not safe. (@xref{Declarations}, for a way to tell Calc that @cite{x} is known to be real.) @node Algebra Answer 2, Algebra Answer 3, Algebra Answer 1, Answers to Exercises @subsection Algebra Tutorial Exercise 2 @noindent Suppose our roots are @cite{[a, b, c]}. We want a polynomial which is zero when @cite{x} is any of these values. The trivial polynomial @cite{x-a} is zero when @cite{x=a}, so the product @cite{(x-a)(x-b)(x-c)} will do the job. We can use @kbd{a c x} to write this in a more familiar form. @group @smallexample 1: 34 x - 24 x^3 1: [1.19023, -1.19023, 0] . . r 2 a P x RET @end smallexample @end group @noindent @group @smallexample 1: [x - 1.19023, x + 1.19023, x] 1: (x - 1.19023) (x + 1.19023) x . . V M ' x-$ RET V R * @end smallexample @end group @noindent @group @smallexample 1: x^3 - 1.41666 x 1: 34 x - 24 x^3 . . a c x RET 24 n * a x @end smallexample @end group @noindent Sure enough, our answer (multiplied by a suitable constant) is the same as the original polynomial. @node Algebra Answer 3, Algebra Answer 4, Algebra Answer 2, Answers to Exercises @subsection Algebra Tutorial Exercise 3 @group @smallexample 1: x sin(pi x) 1: (sin(pi x) - pi x cos(pi x)) / pi^2 . . ' x sin(pi x) RET m r a i x RET @end smallexample @end group @noindent @group @smallexample 1: [y, 1] 2: (sin(pi x) - pi x cos(pi x)) / pi^2 . ' [y,1] RET TAB @end smallexample @end group @noindent @group @smallexample 1: [(sin(pi y) - pi y cos(pi y)) / pi^2, (sin(pi) - pi cos(pi)) / pi^2] . V M $ RET @end smallexample @end group @noindent @group @smallexample 1: (sin(pi y) - pi y cos(pi y)) / pi^2 + (pi cos(pi) - sin(pi)) / pi^2 . V R - @end smallexample @end group @noindent @group @smallexample 1: (sin(3.14159 y) - 3.14159 y cos(3.14159 y)) / 9.8696 - 0.3183 . = @end smallexample @end group @noindent @group @smallexample 1: [0., -0.95493, 0.63662, -1.5915, 1.2732] . v x 5 RET TAB V M $ RET @end smallexample @end group @node Algebra Answer 4, Rewrites Answer 1, Algebra Answer 3, Answers to Exercises @subsection Algebra Tutorial Exercise 4 @noindent The hard part is that @kbd{V R +} is no longer sufficient to add up all the contributions from the slices, since the slices have varying coefficients. So first we must come up with a vector of these coefficients. Here's one way: @group @smallexample 2: -1 2: 3 1: [4, 2, ..., 4] 1: [1, 2, ..., 9] 1: [-1, 1, ..., -1] . . . 1 n v x 9 RET V M ^ 3 TAB - @end smallexample @end group @noindent @group @smallexample 1: [4, 2, ..., 4, 1] 1: [1, 4, 2, ..., 4, 1] . . 1 | 1 TAB | @end smallexample @end group @noindent Now we compute the function values. Note that for this method we need eleven values, including both endpoints of the desired interval. @group @smallexample 2: [1, 4, 2, ..., 4, 1] 1: [1, 1.1, 1.2, ... , 1.8, 1.9, 2.] . 11 RET 1 RET .1 RET C-u v x @end smallexample @end group @noindent @group @smallexample 2: [1, 4, 2, ..., 4, 1] 1: [0., 0.084941, 0.16993, ... ] . ' sin(x) ln(x) RET m r p 5 RET V M $ RET @end smallexample @end group @noindent Once again this calls for @kbd{V M * V R +}; a simple @kbd{*} does the same thing. @group @smallexample 1: 11.22 1: 1.122 1: 0.374 . . . * .1 * 3 / @end smallexample @end group @noindent Wow! That's even better than the result from the Taylor series method. @node Rewrites Answer 1, Rewrites Answer 2, Algebra Answer 4, Answers to Exercises @subsection Rewrites Tutorial Exercise 1 @noindent We'll use Big mode to make the formulas more readable. @group @smallexample ___ 2 + V 2 1: (2 + sqrt(2)) / (1 + sqrt(2)) 1: -------- . ___ 1 + V 2 . ' (2+sqrt(2)) / (1+sqrt(2)) RET d B @end smallexample @end group @noindent Multiplying by the conjugate helps because @cite{(a+b) (a-b) = a^2 - b^2}. @group @smallexample ___ ___ 1: (2 + V 2 ) (V 2 - 1) . a r a/(b+c) := a*(b-c) / (b^2-c^2) RET @end smallexample @end group @noindent @group @smallexample ___ ___ 1: 2 + V 2 - 2 1: V 2 . . a r a*(b+c) := a*b + a*c a s @end smallexample @end group @noindent (We could have used @kbd{a x} instead of a rewrite rule for the second step.) The multiply-by-conjugate rule turns out to be useful in many different circumstances, such as when the denominator involves sines and cosines or the imaginary constant @code{i}. @node Rewrites Answer 2, Rewrites Answer 3, Rewrites Answer 1, Answers to Exercises @subsection Rewrites Tutorial Exercise 2 @noindent Here is the rule set: @group @smallexample [ fib(n) := fib(n, 1, 1) :: integer(n) :: n >= 1, fib(1, x, y) := x, fib(n, x, y) := fib(n-1, y, x+y) ] @end smallexample @end group @noindent The first rule turns a one-argument @code{fib} that people like to write into a three-argument @code{fib} that makes computation easier. The second rule converts back from three-argument form once the computation is done. The third rule does the computation itself. It basically says that if @cite{x} and @cite{y} are two consecutive Fibonacci numbers, then @cite{y} and @cite{x+y} are the next (overlapping) pair of Fibonacci numbers. Notice that because the number @cite{n} was ``validated'' by the conditions on the first rule, there is no need to put conditions on the other rules because the rule set would never get that far unless the input were valid. That further speeds computation, since no extra conditions need to be checked at every step. Actually, a user with a nasty sense of humor could enter a bad three-argument @code{fib} call directly, say, @samp{fib(0, 1, 1)}, which would get the rules into an infinite loop. One thing that would help keep this from happening by accident would be to use something like @samp{ZzFib} instead of @code{fib} as the name of the three-argument function. @node Rewrites Answer 3, Rewrites Answer 4, Rewrites Answer 2, Answers to Exercises @subsection Rewrites Tutorial Exercise 3 @noindent He got an infinite loop. First, Calc did as expected and rewrote @w{@samp{2 + 3 x}} to @samp{f(2, 3, x)}. Then it looked for ways to apply the rule again, and found that @samp{f(2, 3, x)} looks like @samp{a + b x} with @w{@samp{a = 0}} and @samp{b = 1}, so it rewrote to @samp{f(0, 1, f(2, 3, x))}. It then wrapped another @samp{f(0, 1, ...)} around that, and so on, ad infinitum. Joe should have used @kbd{M-1 a r} to make sure the rule applied only once. (Actually, even the first step didn't work as he expected. What Calc really gives for @kbd{M-1 a r} in this situation is @samp{f(3 x, 1, 2)}, treating 2 as the ``variable,'' and @samp{3 x} as a constant being added to it. While this may seem odd, it's just as valid a solution as the ``obvious'' one. One way to fix this would be to add the condition @samp{:: variable(x)} to the rule, to make sure the thing that matches @samp{x} is indeed a variable, or to change @samp{x} to @samp{quote(x)} on the lefthand side, so that the rule matches the actual variable @samp{x} rather than letting @samp{x} stand for something else.) @node Rewrites Answer 4, Rewrites Answer 5, Rewrites Answer 3, Answers to Exercises @subsection Rewrites Tutorial Exercise 4 @noindent @c @starindex @tindex seq Here is a suitable set of rules to solve the first part of the problem: @group @smallexample [ seq(n, c) := seq(n/2, c+1) :: n%2 = 0, seq(n, c) := seq(3n+1, c+1) :: n%2 = 1 :: n > 1 ] @end smallexample @end group Given the initial formula @samp{seq(6, 0)}, application of these rules produces the following sequence of formulas: @example seq( 3, 1) seq(10, 2) seq( 5, 3) seq(16, 4) seq( 8, 5) seq( 4, 6) seq( 2, 7) seq( 1, 8) @end example @noindent whereupon neither of the rules match, and rewriting stops. We can pretty this up a bit with a couple more rules: @group @smallexample [ seq(n) := seq(n, 0), seq(1, c) := c, ... ] @end smallexample @end group @noindent Now, given @samp{seq(6)} as the starting configuration, we get 8 as the result. The change to return a vector is quite simple: @group @smallexample [ seq(n) := seq(n, []) :: integer(n) :: n > 0, seq(1, v) := v | 1, seq(n, v) := seq(n/2, v | n) :: n%2 = 0, seq(n, v) := seq(3n+1, v | n) :: n%2 = 1 ] @end smallexample @end group @noindent Given @samp{seq(6)}, the result is @samp{[6, 3, 10, 5, 16, 8, 4, 2, 1]}. Notice that the @cite{n > 1} guard is no longer necessary on the last rule since the @cite{n = 1} case is now detected by another rule. But a guard has been added to the initial rule to make sure the initial value is suitable before the computation begins. While still a good idea, this guard is not as vitally important as it was for the @code{fib} function, since calling, say, @samp{seq(x, [])} will not get into an infinite loop. Calc will not be able to prove the symbol @samp{x} is either even or odd, so none of the rules will apply and the rewrites will stop right away. @node Rewrites Answer 5, Rewrites Answer 6, Rewrites Answer 4, Answers to Exercises @subsection Rewrites Tutorial Exercise 5 @noindent @c @starindex @tindex nterms If @cite{x} is the sum @cite{a + b}, then `@t{nterms(}@i{x}@t{)}' must be `@t{nterms(}@i{a}@t{)}' plus `@t{nterms(}@i{b}@t{)}'. If @cite{x} is not a sum, then `@t{nterms(}@i{x}@t{)}' = 1. @group @smallexample [ nterms(a + b) := nterms(a) + nterms(b), nterms(x) := 1 ] @end smallexample @end group @noindent Here we have taken advantage of the fact that earlier rules always match before later rules; @samp{nterms(x)} will only be tried if we already know that @samp{x} is not a sum. @node Rewrites Answer 6, Rewrites Answer 7, Rewrites Answer 5, Answers to Exercises @subsection Rewrites Tutorial Exercise 6 Just put the rule @samp{0^0 := 1} into @code{EvalRules}. For example, before making this definition we have: @group @smallexample 2: [-2, -1, 0, 1, 2] 1: [1, 1, 0^0, 1, 1] 1: 0 . . v x 5 RET 3 - 0 V M ^ @end smallexample @end group @noindent But then: @group @smallexample 2: [-2, -1, 0, 1, 2] 1: [1, 1, 1, 1, 1] 1: 0 . . U ' 0^0:=1 RET s t EvalRules RET V M ^ @end smallexample @end group Perhaps more surprisingly, this rule still works with infinite mode turned on. Calc tries @code{EvalRules} before any built-in rules for a function. This allows you to override the default behavior of any Calc feature: Even though Calc now wants to evaluate @cite{0^0} to @code{nan}, your rule gets there first and evaluates it to 1 instead. Just for kicks, try adding the rule @code{2+3 := 6} to @code{EvalRules}. What happens? (Be sure to remove this rule afterward, or you might get a nasty surprise when you use Calc to balance your checkbook!) @node Rewrites Answer 7, Programming Answer 1, Rewrites Answer 6, Answers to Exercises @subsection Rewrites Tutorial Exercise 7 @noindent Here is a rule set that will do the job: @group @smallexample [ a*(b + c) := a*b + a*c, opt(a) O(x^n) + opt(b) O(x^m) := O(x^n) :: n <= m :: constant(a) :: constant(b), opt(a) O(x^n) + opt(b) x^m := O(x^n) :: n <= m :: constant(a) :: constant(b), a O(x^n) := O(x^n) :: constant(a), x^opt(m) O(x^n) := O(x^(n+m)), O(x^n) O(x^m) := O(x^(n+m)) ] @end smallexample @end group If we really want the @kbd{+} and @kbd{*} keys to operate naturally on power series, we should put these rules in @code{EvalRules}. For testing purposes, it is better to put them in a different variable, say, @code{O}, first. The first rule just expands products of sums so that the rest of the rules can assume they have an expanded-out polynomial to work with. Note that this rule does not mention @samp{O} at all, so it will apply to any product-of-sum it encounters---this rule may surprise you if you put it into @code{EvalRules}! In the second rule, the sum of two O's is changed to the smaller O. The optional constant coefficients are there mostly so that @samp{O(x^2) - O(x^3)} and @samp{O(x^3) - O(x^2)} are handled as well as @samp{O(x^2) + O(x^3)}. The third rule absorbs higher powers of @samp{x} into O's. The fourth rule says that a constant times a negligible quantity is still negligible. (This rule will also match @samp{O(x^3) / 4}, with @samp{a = 1/4}.) The fifth rule rewrites, for example, @samp{x^2 O(x^3)} to @samp{O(x^5)}. (It is easy to see that if one of these forms is negligible, the other is, too.) Notice the @samp{x^opt(m)} to pick up terms like @w{@samp{x O(x^3)}}. Optional powers will match @samp{x} as @samp{x^1} but not 1 as @samp{x^0}. This turns out to be exactly what we want here. The sixth rule is the corresponding rule for products of two O's. Another way to solve this problem would be to create a new ``data type'' that represents truncated power series. We might represent these as function calls @samp{series(@var{coefs}, @var{x})} where @var{coefs} is a vector of coefficients for @cite{x^0}, @cite{x^1}, @cite{x^2}, and so on. Rules would exist for sums and products of such @code{series} objects, and as an optional convenience could also know how to combine a @code{series} object with a normal polynomial. (With this, and with a rule that rewrites @samp{O(x^n)} to the equivalent @code{series} form, you could still enter power series in exactly the same notation as before.) Operations on such objects would probably be more efficient, although the objects would be a bit harder to read. @c [fix-ref Compositions] Some other symbolic math programs provide a power series data type similar to this. Mathematica, for example, has an object that looks like @samp{PowerSeries[@var{x}, @var{x0}, @var{coefs}, @var{nmin}, @var{nmax}, @var{den}]}, where @var{x0} is the point about which the power series is taken (we've been assuming this was always zero), and @var{nmin}, @var{nmax}, and @var{den} allow pseudo-power-series with fractional or negative powers. Also, the @code{PowerSeries} objects have a special display format that makes them look like @samp{2 x^2 + O(x^4)} when they are printed out. (@xref{Compositions}, for a way to do this in Calc, although for something as involved as this it would probably be better to write the formatting routine in Lisp.) @node Programming Answer 1, Programming Answer 2, Rewrites Answer 7, Answers to Exercises @subsection Programming Tutorial Exercise 1 @noindent Just enter the formula @samp{ninteg(sin(t)/t, t, 0, x)}, type @kbd{Z F}, and answer the questions. Since this formula contains two variables, the default argument list will be @samp{(t x)}. We want to change this to @samp{(x)} since @cite{t} is really a dummy variable to be used within @code{ninteg}. The exact keystrokes are @kbd{Z F s Si RET RET C-b C-b DEL DEL RET y}. (The @kbd{C-b C-b DEL DEL} are what fix the argument list.) @node Programming Answer 2, Programming Answer 3, Programming Answer 1, Answers to Exercises @subsection Programming Tutorial Exercise 2 @noindent One way is to move the number to the top of the stack, operate on it, then move it back: @kbd{C-x ( M-TAB n M-TAB M-TAB C-x )}. Another way is to negate the top three stack entries, then negate again the top two stack entries: @kbd{C-x ( M-3 n M-2 n C-x )}. Finally, it turns out that a negative prefix argument causes a command like @kbd{n} to operate on the specified stack entry only, which is just what we want: @kbd{C-x ( M-- 3 n C-x )}. Just for kicks, let's also do it algebraically: @w{@kbd{C-x ( ' -$$$, $$, $ RET C-x )}}. @node Programming Answer 3, Programming Answer 4, Programming Answer 2, Answers to Exercises @subsection Programming Tutorial Exercise 3 @noindent Each of these functions can be computed using the stack, or using algebraic entry, whichever way you prefer: @noindent Computing @c{$\displaystyle{\sin x \over x}$} @cite{sin(x) / x}: Using the stack: @kbd{C-x ( RET S TAB / C-x )}. Using algebraic entry: @kbd{C-x ( ' sin($)/$ RET C-x )}. @noindent Computing the logarithm: Using the stack: @kbd{C-x ( TAB B C-x )} Using algebraic entry: @kbd{C-x ( ' log($,$$) RET C-x )}. @noindent Computing the vector of integers: Using the stack: @kbd{C-x ( 1 RET 1 C-u v x C-x )}. (Recall that @kbd{C-u v x} takes the vector size, starting value, and increment from the stack.) Alternatively: @kbd{C-x ( ~ v x C-x )}. (The @kbd{~} key pops a number from the stack and uses it as the prefix argument for the next command.) Using algebraic entry: @kbd{C-x ( ' index($) RET C-x )}. @node Programming Answer 4, Programming Answer 5, Programming Answer 3, Answers to Exercises @subsection Programming Tutorial Exercise 4 @noindent Here's one way: @kbd{C-x ( RET V R + TAB v l / C-x )}. @node Programming Answer 5, Programming Answer 6, Programming Answer 4, Answers to Exercises @subsection Programming Tutorial Exercise 5 @group @smallexample 2: 1 1: 1.61803398502 2: 1.61803398502 1: 20 . 1: 1.61803398875 . . 1 RET 20 Z < & 1 + Z > I H P @end smallexample @end group @noindent This answer is quite accurate. @node Programming Answer 6, Programming Answer 7, Programming Answer 5, Answers to Exercises @subsection Programming Tutorial Exercise 6 @noindent Here is the matrix: @example [ [ 0, 1 ] * [a, b] = [b, a + b] [ 1, 1 ] ] @end example @noindent Thus @samp{[0, 1; 1, 1]^n * [1, 1]} computes Fibonacci numbers @cite{n+1} and @cite{n+2}. Here's one program that does the job: @example C-x ( ' [0, 1; 1, 1] ^ ($-1) * [1, 1] RET v u DEL C-x ) @end example @noindent This program is quite efficient because Calc knows how to raise a matrix (or other value) to the power @cite{n} in only @c{$\log_2 n$} @cite{log(n,2)} steps. For example, this program can compute the 1000th Fibonacci number (a 209-digit integer!) in about 10 steps; even though the @kbd{Z < ... Z >} solution had much simpler steps, it would have required so many steps that it would not have been practical. @node Programming Answer 7, Programming Answer 8, Programming Answer 6, Answers to Exercises @subsection Programming Tutorial Exercise 7 @noindent The trick here is to compute the harmonic numbers differently, so that the loop counter itself accumulates the sum of reciprocals. We use a separate variable to hold the integer counter. @group @smallexample 1: 1 2: 1 1: . . 1: 4 . 1 t 1 1 RET 4 Z ( t 2 r 1 1 + s 1 & Z ) @end smallexample @end group @noindent The body of the loop goes as follows: First save the harmonic sum so far in variable 2. Then delete it from the stack; the for loop itself will take care of remembering it for us. Next, recall the count from variable 1, add one to it, and feed its reciprocal to the for loop to use as the step value. The for loop will increase the ``loop counter'' by that amount and keep going until the loop counter exceeds 4. @group @smallexample 2: 31 3: 31 1: 3.99498713092 2: 3.99498713092 . 1: 4.02724519544 . r 1 r 2 RET 31 & + @end smallexample @end group Thus we find that the 30th harmonic number is 3.99, and the 31st harmonic number is 4.02. @node Programming Answer 8, Programming Answer 9, Programming Answer 7, Answers to Exercises @subsection Programming Tutorial Exercise 8 @noindent The first step is to compute the derivative @cite{f'(x)} and thus the formula @c{$\displaystyle{x - {f(x) \over f'(x)}}$} @cite{x - f(x)/f'(x)}. (Because this definition is long, it will be repeated in concise form below. You can use @w{@kbd{M-# m}} to load it from there. While you are entering a @kbd{Z ` Z '} body in a macro, Calc simply collects keystrokes without executing them. In the following diagrams we'll pretend Calc actually executed the keystrokes as you typed them, just for purposes of illustration.) @group @smallexample 2: sin(cos(x)) - 0.5 3: 4.5 1: 4.5 2: sin(cos(x)) - 0.5 . 1: -(sin(x) cos(cos(x))) . ' sin(cos(x))-0.5 RET 4.5 m r C-x ( Z ` TAB RET a d x RET @end smallexample @end group @noindent @group @smallexample 2: 4.5 1: x + (sin(cos(x)) - 0.5) / sin(x) cos(cos(x)) . / ' x RET TAB - t 1 @end smallexample @end group Now, we enter the loop. We'll use a repeat loop with a 20-repetition limit just in case the method fails to converge for some reason. (Normally, the @w{@kbd{Z /}} command will stop the loop before all 20 repetitions are done.) @group @smallexample 1: 4.5 3: 4.5 2: 4.5 . 2: x + (sin(cos(x)) ... 1: 5.24196456928 1: 4.5 . . 20 Z < RET r 1 TAB s l x RET @end smallexample @end group This is the new guess for @cite{x}. Now we compare it with the old one to see if we've converged. @group @smallexample 3: 5.24196 2: 5.24196 1: 5.24196 1: 5.26345856348 2: 5.24196 1: 0 . . 1: 4.5 . . RET M-TAB a = Z / Z > Z ' C-x ) @end smallexample @end group The loop converges in just a few steps to this value. To check the result, we can simply substitute it back into the equation. @group @smallexample 2: 5.26345856348 1: 0.499999999997 . RET ' sin(cos($)) RET @end smallexample @end group Let's test the new definition again: @group @smallexample 2: x^2 - 9 1: 3. 1: 1 . . ' x^2-9 RET 1 X @end smallexample @end group Once again, here's the full Newton's Method definition: @group @example C-x ( Z ` TAB RET a d x RET / ' x RET TAB - t 1 20 Z < RET r 1 TAB s l x RET RET M-TAB a = Z / Z > Z ' C-x ) @end example @end group @c [fix-ref Nesting and Fixed Points] It turns out that Calc has a built-in command for applying a formula repeatedly until it converges to a number. @xref{Nesting and Fixed Points}, to see how to use it. @c [fix-ref Root Finding] Also, of course, @kbd{a R} is a built-in command that uses Newton's method (among others) to look for numerical solutions to any equation. @xref{Root Finding}. @node Programming Answer 9, Programming Answer 10, Programming Answer 8, Answers to Exercises @subsection Programming Tutorial Exercise 9 @noindent The first step is to adjust @cite{z} to be greater than 5. A simple ``for'' loop will do the job here. If @cite{z} is less than 5, we reduce the problem using @c{$\psi(z) = \psi(z+1) - 1/z$} @cite{psi(z) = psi(z+1) - 1/z}. We go on to compute @c{$\psi(z+1)$} @cite{psi(z+1)}, and remember to add back a factor of @cite{-1/z} when we're done. This step is repeated until @cite{z > 5}. (Because this definition is long, it will be repeated in concise form below. You can use @w{@kbd{M-# m}} to load it from there. While you are entering a @kbd{Z ` Z '} body in a macro, Calc simply collects keystrokes without executing them. In the following diagrams we'll pretend Calc actually executed the keystrokes as you typed them, just for purposes of illustration.) @group @smallexample 1: 1. 1: 1. . . 1.0 RET C-x ( Z ` s 1 0 t 2 @end smallexample @end group Here, variable 1 holds @cite{z} and variable 2 holds the adjustment factor. If @cite{z < 5}, we use a loop to increase it. (By the way, we started with @samp{1.0} instead of the integer 1 because otherwise the calculation below will try to do exact fractional arithmetic, and will never converge because fractions compare equal only if they are exactly equal, not just equal to within the current precision.) @group @smallexample 3: 1. 2: 1. 1: 6. 2: 1. 1: 1 . 1: 5 . . RET 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ] @end smallexample @end group Now we compute the initial part of the sum: @c{$\ln z - {1 \over 2z}$} @cite{ln(z) - 1/2z} minus the adjustment factor. @group @smallexample 2: 1.79175946923 2: 1.7084261359 1: -0.57490719743 1: 0.0833333333333 1: 2.28333333333 . . . L r 1 2 * & - r 2 - @end smallexample @end group Now we evaluate the series. We'll use another ``for'' loop counting up the value of @cite{2 n}. (Calc does have a summation command, @kbd{a +}, but we'll use loops just to get more practice with them.) @group @smallexample 3: -0.5749 3: -0.5749 4: -0.5749 2: -0.5749 2: 2 2: 1:6 3: 1:6 1: 2.3148e-3 1: 40 1: 2 2: 2 . . . 1: 36. . 2 RET 40 Z ( RET k b TAB RET r 1 TAB ^ * / @end smallexample @end group @noindent @group @smallexample 3: -0.5749 3: -0.5772 2: -0.5772 1: -0.577215664892 2: -0.5749 2: -0.5772 1: 0 . 1: 2.3148e-3 1: -0.5749 . . . TAB RET M-TAB - RET M-TAB a = Z / 2 Z ) Z ' C-x ) @end smallexample @end group This is the value of @c{$-\gamma$} @cite{- gamma}, with a slight bit of roundoff error. To get a full 12 digits, let's use a higher precision: @group @smallexample 2: -0.577215664892 2: -0.577215664892 1: 1. 1: -0.577215664901532 1. RET p 16 RET X @end smallexample @end group Here's the complete sequence of keystrokes: @group @example C-x ( Z ` s 1 0 t 2 RET 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ] L r 1 2 * & - r 2 - 2 RET 40 Z ( RET k b TAB RET r 1 TAB ^ * / TAB RET M-TAB - RET M-TAB a = Z / 2 Z ) Z ' C-x ) @end example @end group @node Programming Answer 10, Programming Answer 11, Programming Answer 9, Answers to Exercises @subsection Programming Tutorial Exercise 10 @noindent Taking the derivative of a term of the form @cite{x^n} will produce a term like @c{$n x^{n-1}$} @cite{n x^(n-1)}. Taking the derivative of a constant produces zero. From this it is easy to see that the @cite{n}th derivative of a polynomial, evaluated at @cite{x = 0}, will equal the coefficient on the @cite{x^n} term times @cite{n!}. (Because this definition is long, it will be repeated in concise form below. You can use @w{@kbd{M-# m}} to load it from there. While you are entering a @kbd{Z ` Z '} body in a macro, Calc simply collects keystrokes without executing them. In the following diagrams we'll pretend Calc actually executed the keystrokes as you typed them, just for purposes of illustration.) @group @smallexample 2: 5 x^4 + (x + 1)^2 3: 5 x^4 + (x + 1)^2 1: 6 2: 0 . 1: 6 . ' 5 x^4 + (x+1)^2 RET 6 C-x ( Z ` [ ] t 1 0 TAB @end smallexample @end group @noindent Variable 1 will accumulate the vector of coefficients. @group @smallexample 2: 0 3: 0 2: 5 x^4 + ... 1: 5 x^4 + ... 2: 5 x^4 + ... 1: 1 . 1: 1 . . Z ( TAB RET 0 s l x RET M-TAB ! / s | 1 @end smallexample @end group @noindent Note that @kbd{s | 1} appends the top-of-stack value to the vector in a variable; it is completely analogous to @kbd{s + 1}. We could have written instead, @kbd{r 1 TAB | t 1}. @group @smallexample 1: 20 x^3 + 2 x + 2 1: 0 1: [1, 2, 1, 0, 5, 0, 0] . . . a d x RET 1 Z ) DEL r 1 Z ' C-x ) @end smallexample @end group To convert back, a simple method is just to map the coefficients against a table of powers of @cite{x}. @group @smallexample 2: [1, 2, 1, 0, 5, 0, 0] 2: [1, 2, 1, 0, 5, 0, 0] 1: 6 1: [0, 1, 2, 3, 4, 5, 6] . . 6 RET 1 + 0 RET 1 C-u v x @end smallexample @end group @noindent @group @smallexample 2: [1, 2, 1, 0, 5, 0, 0] 2: 1 + 2 x + x^2 + 5 x^4 1: [1, x, x^2, x^3, ... ] . . ' x RET TAB V M ^ * @end smallexample @end group Once again, here are the whole polynomial to/from vector programs: @group @example C-x ( Z ` [ ] t 1 0 TAB Z ( TAB RET 0 s l x RET M-TAB ! / s | 1 a d x RET 1 Z ) r 1 Z ' C-x ) C-x ( 1 + 0 RET 1 C-u v x ' x RET TAB V M ^ * C-x ) @end example @end group @node Programming Answer 11, Programming Answer 12, Programming Answer 10, Answers to Exercises @subsection Programming Tutorial Exercise 11 @noindent First we define a dummy program to go on the @kbd{z s} key. The true @w{@kbd{z s}} key is supposed to take two numbers from the stack and return one number, so @kbd{DEL} as a dummy definition will make sure the stack comes out right. @group @smallexample 2: 4 1: 4 2: 4 1: 2 . 1: 2 . . 4 RET 2 C-x ( DEL C-x ) Z K s RET 2 @end smallexample @end group The last step replaces the 2 that was eaten during the creation of the dummy @kbd{z s} command. Now we move on to the real definition. The recurrence needs to be rewritten slightly, to the form @cite{s(n,m) = s(n-1,m-1) - (n-1) s(n-1,m)}. (Because this definition is long, it will be repeated in concise form below. You can use @kbd{M-# m} to load it from there.) @group @smallexample 2: 4 4: 4 3: 4 2: 4 1: 2 3: 2 2: 2 1: 2 . 2: 4 1: 0 . 1: 2 . . C-x ( M-2 RET a = Z [ DEL DEL 1 Z : @end smallexample @end group @noindent @group @smallexample 4: 4 2: 4 2: 3 4: 3 4: 3 3: 3 3: 2 1: 2 1: 2 3: 2 3: 2 2: 2 2: 2 . . 2: 3 2: 3 1: 3 1: 0 1: 2 1: 1 . . . . RET 0 a = Z [ DEL DEL 0 Z : TAB 1 - TAB M-2 RET 1 - z s @end smallexample @end group @noindent (Note that the value 3 that our dummy @kbd{z s} produces is not correct; it is merely a placeholder that will do just as well for now.) @group @smallexample 3: 3 4: 3 3: 3 2: 3 1: -6 2: 3 3: 3 2: 3 1: 9 . 1: 2 2: 3 1: 3 . . 1: 2 . . M-TAB M-TAB TAB RET M-TAB z s * - @end smallexample @end group @noindent @group @smallexample 1: -6 2: 4 1: 11 2: 11 . 1: 2 . 1: 11 . . Z ] Z ] C-x ) Z K s RET DEL 4 RET 2 z s M-RET k s @end smallexample @end group Even though the result that we got during the definition was highly bogus, once the definition is complete the @kbd{z s} command gets the right answers. Here's the full program once again: @group @example C-x ( M-2 RET a = Z [ DEL DEL 1 Z : RET 0 a = Z [ DEL DEL 0 Z : TAB 1 - TAB M-2 RET 1 - z s M-TAB M-TAB TAB RET M-TAB z s * - Z ] Z ] C-x ) @end example @end group You can read this definition using @kbd{M-# m} (@code{read-kbd-macro}) followed by @kbd{Z K s}, without having to make a dummy definition first, because @code{read-kbd-macro} doesn't need to execute the definition as it reads it in. For this reason, @code{M-# m} is often the easiest way to create recursive programs in Calc. @node Programming Answer 12, , Programming Answer 11, Answers to Exercises @subsection Programming Tutorial Exercise 12 @noindent This turns out to be a much easier way to solve the problem. Let's denote Stirling numbers as calls of the function @samp{s}. First, we store the rewrite rules corresponding to the definition of Stirling numbers in a convenient variable: @smallexample s e StirlingRules RET [ s(n,n) := 1 :: n >= 0, s(n,0) := 0 :: n > 0, s(n,m) := s(n-1,m-1) - (n-1) s(n-1,m) :: n >= m :: m >= 1 ] C-c C-c @end smallexample Now, it's just a matter of applying the rules: @group @smallexample 2: 4 1: s(4, 2) 1: 11 1: 2 . . . 4 RET 2 C-x ( ' s($$,$) RET a r StirlingRules RET C-x ) @end smallexample @end group As in the case of the @code{fib} rules, it would be useful to put these rules in @code{EvalRules} and to add a @samp{:: remember} condition to the last rule. @c This ends the table-of-contents kludge from above: @tex \global\let\chapternofonts=\oldchapternofonts @end tex @c [reference] @node Introduction, Data Types, Tutorial, Top @chapter Introduction @noindent This chapter is the beginning of the Calc reference manual. It covers basic concepts such as the stack, algebraic and numeric entry, undo, numeric prefix arguments, etc. @c [when-split] @c (Chapter 2, the Tutorial, has been printed in a separate volume.) @menu * Basic Commands:: * Help Commands:: * Stack Basics:: * Numeric Entry:: * Algebraic Entry:: * Quick Calculator:: * Keypad Mode:: * Prefix Arguments:: * Undo:: * Error Messages:: * Multiple Calculators:: * Troubleshooting Commands:: @end menu @node Basic Commands, Help Commands, Introduction, Introduction @section Basic Commands @noindent @pindex calc @pindex calc-mode @cindex Starting the Calculator @cindex Running the Calculator To start the Calculator in its standard interface, type @kbd{M-x calc}. By default this creates a pair of small windows, @samp{*Calculator*} and @samp{*Calc Trail*}. The former displays the contents of the Calculator stack and is manipulated exclusively through Calc commands. It is possible (though not usually necessary) to create several Calc Mode buffers each of which has an independent stack, undo list, and mode settings. There is exactly one Calc Trail buffer; it records a list of the results of all calculations that have been done. The Calc Trail buffer uses a variant of Calc Mode, so Calculator commands still work when the trail buffer's window is selected. It is possible to turn the trail window off, but the @samp{*Calc Trail*} buffer itself still exists and is updated silently. @xref{Trail Commands}.@refill @kindex M-# c @kindex M-# M-# @c @mindex @null @kindex M-# # In most installations, the @kbd{M-# c} key sequence is a more convenient way to start the Calculator. Also, @kbd{M-# M-#} and @kbd{M-# #} are synonyms for @kbd{M-# c} unless you last used Calc in its ``keypad'' mode. @kindex x @kindex M-x @pindex calc-execute-extended-command Most Calc commands use one or two keystrokes. Lower- and upper-case letters are distinct. Commands may also be entered in full @kbd{M-x} form; for some commands this is the only form. As a convenience, the @kbd{x} key (@code{calc-execute-extended-command}) is like @kbd{M-x} except that it enters the initial string @samp{calc-} for you. For example, the following key sequences are equivalent: @kbd{S}, @kbd{M-x calc-sin @key{RET}}, @kbd{x sin @key{RET}}.@refill @cindex Extensions module @cindex @file{calc-ext} module The Calculator exists in many parts. When you type @kbd{M-# c}, the Emacs ``auto-load'' mechanism will bring in only the first part, which contains the basic arithmetic functions. The other parts will be auto-loaded the first time you use the more advanced commands like trig functions or matrix operations. This is done to improve the response time of the Calculator in the common case when all you need to do is a little arithmetic. If for some reason the Calculator fails to load an extension module automatically, you can force it to load all the extensions by using the @kbd{M-# L} (@code{calc-load-everything}) command. @xref{Mode Settings}.@refill If you type @kbd{M-x calc} or @kbd{M-# c} with any numeric prefix argument, the Calculator is loaded if necessary, but it is not actually started. If the argument is positive, the @file{calc-ext} extensions are also loaded if necessary. User-written Lisp code that wishes to make use of Calc's arithmetic routines can use @samp{(calc 0)} or @samp{(calc 1)} to auto-load the Calculator.@refill @kindex M-# b @pindex full-calc If you type @kbd{M-# b}, then next time you use @kbd{M-# c} you will get a Calculator that uses the full height of the Emacs screen. When full-screen mode is on, @kbd{M-# c} runs the @code{full-calc} command instead of @code{calc}. From the Unix shell you can type @samp{emacs -f full-calc} to start a new Emacs specifically for use as a calculator. When Calc is started from the Emacs command line like this, Calc's normal ``quit'' commands actually quit Emacs itself. @kindex M-# o @pindex calc-other-window The @kbd{M-# o} command is like @kbd{M-# c} except that the Calc window is not actually selected. If you are already in the Calc window, @kbd{M-# o} switches you out of it. (The regular Emacs @kbd{C-x o} command would also work for this, but it has a tendency to drop you into the Calc Trail window instead, which @kbd{M-# o} takes care not to do.) @c @mindex M-# q For one quick calculation, you can type @kbd{M-# q} (@code{quick-calc}) which prompts you for a formula (like @samp{2+3/4}). The result is displayed at the bottom of the Emacs screen without ever creating any special Calculator windows. @xref{Quick Calculator}. @c @mindex M-# k Finally, if you are using the X window system you may want to try @kbd{M-# k} (@code{calc-keypad}) which runs Calc with a ``calculator keypad'' picture as well as a stack display. Click on the keys with the mouse to operate the calculator. @xref{Keypad Mode}. @kindex q @pindex calc-quit @cindex Quitting the Calculator @cindex Exiting the Calculator The @kbd{q} key (@code{calc-quit}) exits Calc Mode and closes the Calculator's window(s). It does not delete the Calculator buffers. If you type @kbd{M-x calc} again, the Calculator will reappear with the contents of the stack intact. Typing @kbd{M-# c} or @kbd{M-# M-#} again from inside the Calculator buffer is equivalent to executing @code{calc-quit}; you can think of @kbd{M-# M-#} as toggling the Calculator on and off.@refill @kindex M-# x The @kbd{M-# x} command also turns the Calculator off, no matter which user interface (standard, Keypad, or Embedded) is currently active. It also cancels @code{calc-edit} mode if used from there. @kindex d SPC @pindex calc-refresh @cindex Refreshing a garbled display @cindex Garbled displays, refreshing The @kbd{d SPC} key sequence (@code{calc-refresh}) redraws the contents of the Calculator buffer from memory. Use this if the contents of the buffer have been damaged somehow. @c @mindex o The @kbd{o} key (@code{calc-realign}) moves the cursor back to its ``home'' position at the bottom of the Calculator buffer. @kindex < @kindex > @pindex calc-scroll-left @pindex calc-scroll-right @cindex Horizontal scrolling @cindex Scrolling @cindex Wide text, scrolling The @kbd{<} and @kbd{>} keys are bound to @code{calc-scroll-left} and @code{calc-scroll-right}. These are just like the normal horizontal scrolling commands except that they scroll one half-screen at a time by default. (Calc formats its output to fit within the bounds of the window whenever it can.)@refill @kindex @{ @kindex @} @pindex calc-scroll-down @pindex calc-scroll-up @cindex Vertical scrolling The @kbd{@{} and @kbd{@}} keys are bound to @code{calc-scroll-down} and @code{calc-scroll-up}. They scroll up or down by one-half the height of the Calc window.@refill @kindex M-# 0 @pindex calc-reset The @kbd{M-# 0} command (@code{calc-reset}; that's @kbd{M-#} followed by a zero) resets the Calculator to its default state. This clears the stack, resets all the modes, clears the caches (@pxref{Caches}), and so on. (It does @emph{not} erase the values of any variables.) With a numeric prefix argument, @kbd{M-# 0} preserves the contents of the stack but resets everything else. @pindex calc-version The @kbd{M-x calc-version} command displays the current version number of Calc and the name of the person who installed it on your system. (This information is also present in the @samp{*Calc Trail*} buffer, and in the output of the @kbd{h h} command.) @node Help Commands, Stack Basics, Basic Commands, Introduction @section Help Commands @noindent @cindex Help commands @kindex ? @pindex calc-help The @kbd{?} key (@code{calc-help}) displays a series of brief help messages. Some keys (such as @kbd{b} and @kbd{d}) are prefix keys, like Emacs' @key{ESC} and @kbd{C-x} prefixes. You can type @kbd{?} after a prefix to see a list of commands beginning with that prefix. (If the message includes @samp{[MORE]}, press @kbd{?} again to see additional commands for that prefix.) @kindex h h @pindex calc-full-help The @kbd{h h} (@code{calc-full-help}) command displays all the @kbd{?} responses at once. When printed, this makes a nice, compact (three pages) summary of Calc keystrokes. In general, the @kbd{h} key prefix introduces various commands that provide help within Calc. Many of the @kbd{h} key functions are Calc-specific analogues to the @kbd{C-h} functions for Emacs help. @kindex h i @kindex M-# i @kindex i @pindex calc-info The @kbd{h i} (@code{calc-info}) command runs the Emacs Info system to read this manual on-line. This is basically the same as typing @kbd{C-h i} (the regular way to run the Info system), then, if Info is not already in the Calc manual, selecting the beginning of the manual. The @kbd{M-# i} command is another way to read the Calc manual; it is different from @kbd{h i} in that it works any time, not just inside Calc. The plain @kbd{i} key is also equivalent to @kbd{h i}, though this key is obsolete and may be replaced with a different command in a future version of Calc. @kindex h t @kindex M-# t @pindex calc-tutorial The @kbd{h t} (@code{calc-tutorial}) command runs the Info system on the Tutorial section of the Calc manual. It is like @kbd{h i}, except that it selects the starting node of the tutorial rather than the beginning of the whole manual. (It actually selects the node ``Interactive Tutorial'' which tells a few things about using the Info system before going on to the actual tutorial.) The @kbd{M-# t} key is equivalent to @kbd{h t} (but it works at all times). @kindex h s @kindex M-# s @pindex calc-info-summary The @kbd{h s} (@code{calc-info-summary}) command runs the Info system on the Summary node of the Calc manual. @xref{Summary}. The @kbd{M-# s} key is equivalent to @kbd{h s}. @kindex h k @pindex calc-describe-key The @kbd{h k} (@code{calc-describe-key}) command looks up a key sequence in the Calc manual. For example, @kbd{h k H a S} looks up the documentation on the @kbd{H a S} (@code{calc-solve-for}) command. This works by looking up the textual description of the key(s) in the Key Index of the manual, then jumping to the node indicated by the index. Most Calc commands do not have traditional Emacs documentation strings, since the @kbd{h k} command is both more convenient and more instructive. This means the regular Emacs @kbd{C-h k} (@code{describe-key}) command will not be useful for Calc keystrokes. @kindex h c @pindex calc-describe-key-briefly The @kbd{h c} (@code{calc-describe-key-briefly}) command reads a key sequence and displays a brief one-line description of it at the bottom of the screen. It looks for the key sequence in the Summary node of the Calc manual; if it doesn't find the sequence there, it acts just like its regular Emacs counterpart @kbd{C-h c} (@code{describe-key-briefly}). For example, @kbd{h c H a S} gives the description: @smallexample H a S runs calc-solve-for: a `H a S' v => fsolve(a,v) (?=notes) @end smallexample @noindent which means the command @kbd{H a S} or @kbd{H M-x calc-solve-for} takes a value @cite{a} from the stack, prompts for a value @cite{v}, then applies the algebraic function @code{fsolve} to these values. The @samp{?=notes} message means you can now type @kbd{?} to see additional notes from the summary that apply to this command. @kindex h f @pindex calc-describe-function The @kbd{h f} (@code{calc-describe-function}) command looks up an algebraic function or a command name in the Calc manual. The prompt initially contains @samp{calcFunc-}; follow this with an algebraic function name to look up that function in the Function Index. Or, backspace and enter a command name beginning with @samp{calc-} to look it up in the Command Index. This command will also look up operator symbols that can appear in algebraic formulas, like @samp{%} and @samp{=>}. @kindex h v @pindex calc-describe-variable The @kbd{h v} (@code{calc-describe-variable}) command looks up a variable in the Calc manual. The prompt initially contains the @samp{var-} prefix; just add a variable name like @code{pi} or @code{PlotRejects}. @kindex h b @pindex describe-bindings The @kbd{h b} (@code{calc-describe-bindings}) command is just like @kbd{C-h b}, except that only local (Calc-related) key bindings are listed. @kindex h n The @kbd{h n} or @kbd{h C-n} (@code{calc-view-news}) command displays the ``news'' or change history of Calc. This is kept in the file @file{README}, which Calc looks for in the same directory as the Calc source files. @kindex h C-c @kindex h C-d @kindex h C-w The @kbd{h C-c}, @kbd{h C-d}, and @kbd{h C-w} keys display copying, distribution, and warranty information about Calc. These work by pulling up the appropriate parts of the ``Copying'' or ``Reporting Bugs'' sections of the manual. @node Stack Basics, Numeric Entry, Help Commands, Introduction @section Stack Basics @noindent @cindex Stack basics @c [fix-tut RPN Calculations and the Stack] Calc uses RPN notation. If you are not familar with RPN, @pxref{RPN Tutorial}. To add the numbers 1 and 2 in Calc you would type the keys: @kbd{1 @key{RET} 2 +}. (@key{RET} corresponds to the @key{ENTER} key on most calculators.) The first three keystrokes ``push'' the numbers 1 and 2 onto the stack. The @kbd{+} key always ``pops'' the top two numbers from the stack, adds them, and pushes the result (3) back onto the stack. This number is ready for further calculations: @kbd{5 -} pushes 5 onto the stack, then pops the 3 and 5, subtracts them, and pushes the result (@i{-2}).@refill Note that the ``top'' of the stack actually appears at the @emph{bottom} of the buffer. A line containing a single @samp{.} character signifies the end of the buffer; Calculator commands operate on the number(s) directly above this line. The @kbd{d t} (@code{calc-truncate-stack}) command allows you to move the @samp{.} marker up and down in the stack; @pxref{Truncating the Stack}. @kindex d l @pindex calc-line-numbering Stack elements are numbered consecutively, with number 1 being the top of the stack. These line numbers are ordinarily displayed on the lefthand side of the window. The @kbd{d l} (@code{calc-line-numbering}) command controls whether these numbers appear. (Line numbers may be turned off since they slow the Calculator down a bit and also clutter the display.) @kindex o @pindex calc-realign The unshifted letter @kbd{o} (@code{calc-realign}) command repositions the cursor to its top-of-stack ``home'' position. It also undoes any horizontal scrolling in the window. If you give it a numeric prefix argument, it instead moves the cursor to the specified stack element. The @key{RET} (or equivalent @key{SPC}) key is only required to separate two consecutive numbers. (After all, if you typed @kbd{1 2} by themselves the Calculator would enter the number 12.) If you press @kbd{RET} or @kbd{SPC} @emph{not} right after typing a number, the key duplicates the number on the top of the stack. @kbd{@key{RET} *} is thus a handy way to square a number.@refill The @key{DEL} key pops and throws away the top number on the stack. The @key{TAB} key swaps the top two objects on the stack. @xref{Stack and Trail}, for descriptions of these and other stack-related commands.@refill @node Numeric Entry, Algebraic Entry, Stack Basics, Introduction @section Numeric Entry @noindent @kindex 0-9 @kindex . @kindex e @cindex Numeric entry @cindex Entering numbers Pressing a digit or other numeric key begins numeric entry using the minibuffer. The number is pushed on the stack when you press the @key{RET} or @key{SPC} keys. If you press any other non-numeric key, the number is pushed onto the stack and the appropriate operation is performed. If you press a numeric key which is not valid, the key is ignored. @cindex Minus signs @cindex Negative numbers, entering @kindex _ There are three different concepts corresponding to the word ``minus,'' typified by @cite{a-b} (subtraction), @cite{-x} (change-sign), and @cite{-5} (negative number). Calc uses three different keys for these operations, respectively: @kbd{-}, @kbd{n}, and @kbd{_} (the underscore). The @kbd{-} key subtracts the two numbers on the top of the stack. The @kbd{n} key changes the sign of the number on the top of the stack or the number currently being entered. The @kbd{_} key begins entry of a negative number or changes the sign of the number currently being entered. The following sequences all enter the number @i{-5} onto the stack: @kbd{0 @key{RET} 5 -}, @kbd{5 n @key{RET}}, @kbd{5 @key{RET} n}, @kbd{_ 5 @key{RET}}, @kbd{5 _ @key{RET}}.@refill Some other keys are active during numeric entry, such as @kbd{#} for non-decimal numbers, @kbd{:} for fractions, and @kbd{@@} for HMS forms. These notations are described later in this manual with the corresponding data types. @xref{Data Types}. During numeric entry, the only editing key available is @kbd{DEL}. @node Algebraic Entry, Quick Calculator, Numeric Entry, Introduction @section Algebraic Entry @noindent @kindex ' @pindex calc-algebraic-entry @cindex Algebraic notation @cindex Formulas, entering Calculations can also be entered in algebraic form. This is accomplished by typing the apostrophe key, @kbd{'}, followed by the expression in standard format: @kbd{@key{'} 2+3*4 @key{RET}} computes @c{$2+(3\times4) = 14$} @cite{2+(3*4) = 14} and pushes that on the stack. If you wish you can ignore the RPN aspect of Calc altogether and simply enter algebraic expressions in this way. You may want to use @key{DEL} every so often to clear previous results off the stack.@refill You can press the apostrophe key during normal numeric entry to switch the half-entered number into algebraic entry mode. One reason to do this would be to use the full Emacs cursor motion and editing keys, which are available during algebraic entry but not during numeric entry. In the same vein, during either numeric or algebraic entry you can press @kbd{`} (backquote) to switch to @code{calc-edit} mode, where you complete your half-finished entry in a separate buffer. @xref{Editing Stack Entries}. @kindex m a @pindex calc-algebraic-mode @cindex Algebraic mode If you prefer algebraic entry, you can use the command @kbd{m a} (@code{calc-algebraic-mode}) to set Algebraic mode. In this mode, digits and other keys that would normally start numeric entry instead start full algebraic entry; as long as your formula begins with a digit you can omit the apostrophe. Open parentheses and square brackets also begin algebraic entry. You can still do RPN calculations in this mode, but you will have to press @key{RET} to terminate every number: @kbd{2 @key{RET} 3 @key{RET} * 4 @key{RET} +} would accomplish the same thing as @kbd{2*3+4 @key{RET}}.@refill @cindex Incomplete algebraic mode If you give a numeric prefix argument like @kbd{C-u} to the @kbd{m a} command, it enables Incomplete Algebraic mode; this is like regular Algebraic mode except that it applies to the @kbd{(} and @kbd{[} keys only. Numeric keys still begin a numeric entry in this mode. @kindex m t @pindex calc-total-algebraic-mode @cindex Total algebraic mode The @kbd{m t} (@code{calc-total-algebraic-mode}) gives you an even stronger algebraic-entry mode, in which @emph{all} regular letter and punctuation keys begin algebraic entry. Use this if you prefer typing @w{@kbd{sqrt( )}} instead of @kbd{Q}, @w{@kbd{factor( )}} instead of @kbd{a f}, and so on. To type regular Calc commands when you are in ``total'' algebraic mode, hold down the @key{META} key. Thus @kbd{M-q} is the command to quit Calc, @kbd{M-p} sets the precision, and @kbd{M-m t} (or @kbd{M-m M-t}, if you prefer) turns total algebraic mode back off again. Meta keys also terminate algebraic entry, so that @kbd{2+3 M-S} is equivalent to @kbd{2+3 RET M-S}. The symbol @samp{Alg*} will appear in the mode line whenever you are in this mode. Pressing @kbd{'} (the apostrophe) a second time re-enters the previous algebraic formula. You can then use the normal Emacs editing keys to modify this formula to your liking before pressing @key{RET}. @kindex $ @cindex Formulas, referring to stack Within a formula entered from the keyboard, the symbol @kbd{$} represents the number on the top of the stack. If an entered formula contains any @kbd{$} characters, the Calculator replaces the top of stack with that formula rather than simply pushing the formula onto the stack. Thus, @kbd{' 1+2 @key{RET}} pushes 3 on the stack, and @kbd{$*2 @key{RET}} replaces it with 6. Note that the @kbd{$} key always initiates algebraic entry; the @kbd{'} is unnecessary if @kbd{$} is the first character in the new formula.@refill Higher stack elements can be accessed from an entered formula with the symbols @kbd{$$}, @kbd{$$$}, and so on. The number of stack elements removed (to be replaced by the entered values) equals the number of dollar signs in the longest such symbol in the formula. For example, @samp{$$+$$$} adds the second and third stack elements, replacing the top three elements with the answer. (All information about the top stack element is thus lost since no single @samp{$} appears in this formula.)@refill A slightly different way to refer to stack elements is with a dollar sign followed by a number: @samp{$1}, @samp{$2}, and so on are much like @samp{$}, @samp{$$}, etc., except that stack entries referred to numerically are not replaced by the algebraic entry. That is, while @samp{$+1} replaces 5 on the stack with 6, @samp{$1+1} leaves the 5 on the stack and pushes an additional 6. If a sequence of formulas are entered separated by commas, each formula is pushed onto the stack in turn. For example, @samp{1,2,3} pushes those three numbers onto the stack (leaving the 3 at the top), and @samp{$+1,$-1} replaces a 5 on the stack with 4 followed by 6. Also, @samp{$,$$} exchanges the top two elements of the stack, just like the @key{TAB} key. You can finish an algebraic entry with @kbd{M-=} or @kbd{M-RET} instead of @key{RET}. This uses @kbd{=} to evaluate the variables in each formula that goes onto the stack. (Thus @kbd{' pi @key{RET}} pushes the variable @samp{pi}, but @kbd{' pi M-RET} pushes 3.1415.) If you finish your algebraic entry by pressing @kbd{LFD} (or @kbd{C-j}) instead of @key{RET}, Calc disables the default simplifications (as if by @kbd{m O}; @pxref{Simplification Modes}) while the entry is being pushed on the stack. Thus @kbd{' 1+2 @key{RET}} pushes 3 on the stack, but @kbd{' 1+2 @key{LFD}} pushes the formula @cite{1+2}; you might then press @kbd{=} when it is time to evaluate this formula. @node Quick Calculator, Prefix Arguments, Algebraic Entry, Introduction @section ``Quick Calculator'' Mode @noindent @kindex M-# q @pindex quick-calc @cindex Quick Calculator There is another way to invoke the Calculator if all you need to do is make one or two quick calculations. Type @kbd{M-# q} (or @kbd{M-x quick-calc}), then type any formula as an algebraic entry. The Calculator will compute the result and display it in the echo area, without ever actually putting up a Calc window. You can use the @kbd{$} character in a Quick Calculator formula to refer to the previous Quick Calculator result. Older results are not retained; the Quick Calculator has no effect on the full Calculator's stack or trail. If you compute a result and then forget what it was, just run @code{M-# q} again and enter @samp{$} as the formula. If this is the first time you have used the Calculator in this Emacs session, the @kbd{M-# q} command will create the @code{*Calculator*} buffer and perform all the usual initializations; it simply will refrain from putting that buffer up in a new window. The Quick Calculator refers to the @code{*Calculator*} buffer for all mode settings. Thus, for example, to set the precision that the Quick Calculator uses, simply run the full Calculator momentarily and use the regular @kbd{p} command. If you use @code{M-# q} from inside the Calculator buffer, the effect is the same as pressing the apostrophe key (algebraic entry). The result of a Quick calculation is placed in the Emacs ``kill ring'' as well as being displayed. A subsequent @kbd{C-y} command will yank the result into the editing buffer. You can also use this to yank the result into the next @kbd{M-# q} input line as a more explicit alternative to @kbd{$} notation, or to yank the result into the Calculator stack after typing @kbd{M-# c}. If you finish your formula by typing @key{LFD} (or @kbd{C-j}) instead of @key{RET}, the result is inserted immediately into the current buffer rather than going into the kill ring. Quick Calculator results are actually evaluated as if by the @kbd{=} key (which replaces variable names by their stored values, if any). If the formula you enter is an assignment to a variable using the @samp{:=} operator, say, @samp{foo := 2 + 3} or @samp{foo := foo + 1}, then the result of the evaluation is stored in that Calc variable. @xref{Store and Recall}. If the result is an integer and the current display radix is decimal, the number will also be displayed in hex and octal formats. If the integer is in the range from 1 to 126, it will also be displayed as an ASCII character. For example, the quoted character @samp{"x"} produces the vector result @samp{[120]} (because 120 is the ASCII code of the lower-case `x'; @pxref{Strings}). Since this is a vector, not an integer, it is displayed only according to the current mode settings. But running Quick Calc again and entering @samp{120} will produce the result @samp{120 (16#78, 8#170, x)} which shows the number in its decimal, hexadecimal, octal, and ASCII forms. Please note that the Quick Calculator is not any faster at loading or computing the answer than the full Calculator; the name ``quick'' merely refers to the fact that it's much less hassle to use for small calculations. @node Prefix Arguments, Undo, Quick Calculator, Introduction @section Numeric Prefix Arguments @noindent Many Calculator commands use numeric prefix arguments. Some, such as @kbd{d s} (@code{calc-sci-notation}), set a parameter to the value of the prefix argument or use a default if you don't use a prefix. Others (like @kbd{d f} (@code{calc-fix-notation})) require an argument and prompt for a number if you don't give one as a prefix.@refill As a rule, stack-manipulation commands accept a numeric prefix argument which is interpreted as an index into the stack. A positive argument operates on the top @var{n} stack entries; a negative argument operates on the @var{n}th stack entry in isolation; and a zero argument operates on the entire stack. Most commands that perform computations (such as the arithmetic and scientific functions) accept a numeric prefix argument that allows the operation to be applied across many stack elements. For unary operations (that is, functions of one argument like absolute value or complex conjugate), a positive prefix argument applies that function to the top @var{n} stack entries simultaneously, and a negative argument applies it to the @var{n}th stack entry only. For binary operations (functions of two arguments like addition, GCD, and vector concatenation), a positive prefix argument ``reduces'' the function across the top @var{n} stack elements (for example, @kbd{C-u 5 +} sums the top 5 stack entries; @pxref{Reducing and Mapping}), and a negative argument maps the next-to-top @var{n} stack elements with the top stack element as a second argument (for example, @kbd{7 c-u -5 +} adds 7 to the top 5 stack elements). This feature is not available for operations which use the numeric prefix argument for some other purpose. Numeric prefixes are specified the same way as always in Emacs: Press a sequence of @key{META}-digits, or press @key{ESC} followed by digits, or press @kbd{C-u} followed by digits. Some commands treat plain @kbd{C-u} (without any actual digits) specially.@refill @kindex ~ @pindex calc-num-prefix You can type @kbd{~} (@code{calc-num-prefix}) to pop an integer from the top of the stack and enter it as the numeric prefix for the next command. For example, @kbd{C-u 16 p} sets the precision to 16 digits; an alternate (silly) way to do this would be @kbd{2 @key{RET} 4 ^ ~ p}, i.e., compute 2 to the fourth power and set the precision to that value.@refill Conversely, if you have typed a numeric prefix argument the @kbd{~} key pushes it onto the stack in the form of an integer. @node Undo, Error Messages, Prefix Arguments, Introduction @section Undoing Mistakes @noindent @kindex U @kindex C-_ @pindex calc-undo @cindex Mistakes, undoing @cindex Undoing mistakes @cindex Errors, undoing The shift-@kbd{U} key (@code{calc-undo}) undoes the most recent operation. If that operation added or dropped objects from the stack, those objects are removed or restored. If it was a ``store'' operation, you are queried whether or not to restore the variable to its original value. The @kbd{U} key may be pressed any number of times to undo successively farther back in time; with a numeric prefix argument it undoes a specified number of operations. The undo history is cleared only by the @kbd{q} (@code{calc-quit}) command. (Recall that @kbd{M-# c} is synonymous with @code{calc-quit} while inside the Calculator; this also clears the undo history.) Currently the mode-setting commands (like @code{calc-precision}) are not undoable. You can undo past a point where you changed a mode, but you will need to reset the mode yourself. @kindex D @pindex calc-redo @cindex Redoing after an Undo The shift-@kbd{D} key (@code{calc-redo}) redoes an operation that was mistakenly undone. Pressing @kbd{U} with a negative prefix argument is equivalent to executing @code{calc-redo}. You can redo any number of times, up to the number of recent consecutive undo commands. Redo information is cleared whenever you give any command that adds new undo information, i.e., if you undo, then enter a number on the stack or make any other change, then it will be too late to redo. @kindex M-RET @pindex calc-last-args @cindex Last-arguments feature @cindex Arguments, restoring The @kbd{M-@key{RET}} key (@code{calc-last-args}) is like undo in that it restores the arguments of the most recent command onto the stack; however, it does not remove the result of that command. Given a numeric prefix argument, this command applies to the @cite{n}th most recent command which removed items from the stack; it pushes those items back onto the stack. The @kbd{K} (@code{calc-keep-args}) command provides a related function to @kbd{M-@key{RET}}. @xref{Stack and Trail}. It is also possible to recall previous results or inputs using the trail. @xref{Trail Commands}. The standard Emacs @kbd{C-_} undo key is recognized as a synonym for @kbd{U}. @node Error Messages, Multiple Calculators, Undo, Introduction @section Error Messages @noindent @kindex w @pindex calc-why @cindex Errors, messages @cindex Why did an error occur? Many situations that would produce an error message in other calculators simply create unsimplified formulas in the Emacs Calculator. For example, @kbd{1 @key{RET} 0 /} pushes the formula @cite{1 / 0}; @w{@kbd{0 L}} pushes the formula @samp{ln(0)}. Floating-point overflow and underflow are also reasons for this to happen. When a function call must be left in symbolic form, Calc usually produces a message explaining why. Messages that are probably surprising or indicative of user errors are displayed automatically. Other messages are simply kept in Calc's memory and are displayed only if you type @kbd{w} (@code{calc-why}). You can also press @kbd{w} if the same computation results in several messages. (The first message will end with @samp{[w=more]} in this case.) @kindex d w @pindex calc-auto-why The @kbd{d w} (@code{calc-auto-why}) command controls when error messages are displayed automatically. (Calc effectively presses @kbd{w} for you after your computation finishes.) By default, this occurs only for ``important'' messages. The other possible modes are to report @emph{all} messages automatically, or to report none automatically (so that you must always press @kbd{w} yourself to see the messages). @node Multiple Calculators, Troubleshooting Commands, Error Messages, Introduction @section Multiple Calculators @noindent @pindex another-calc It is possible to have any number of Calc Mode buffers at once. Usually this is done by executing @kbd{M-x another-calc}, which is similar to @kbd{M-# c} except that if a @samp{*Calculator*} buffer already exists, a new, independent one with a name of the form @samp{*Calculator*<@var{n}>} is created. You can also use the command @code{calc-mode} to put any buffer into Calculator mode, but this would ordinarily never be done. The @kbd{q} (@code{calc-quit}) command does not destroy a Calculator buffer; it only closes its window. Use @kbd{M-x kill-buffer} to destroy a Calculator buffer. Each Calculator buffer keeps its own stack, undo list, and mode settings such as precision, angular mode, and display formats. In Emacs terms, variables such as @code{calc-stack} are buffer-local variables. The global default values of these variables are used only when a new Calculator buffer is created. The @code{calc-quit} command saves the stack and mode settings of the buffer being quit as the new defaults. There is only one trail buffer, @samp{*Calc Trail*}, used by all Calculator buffers. @node Troubleshooting Commands, , Multiple Calculators, Introduction @section Troubleshooting Commands @noindent This section describes commands you can use in case a computation incorrectly fails or gives the wrong answer. @xref{Reporting Bugs}, if you find a problem that appears to be due to a bug or deficiency in Calc. @menu * Autoloading Problems:: * Recursion Depth:: * Caches:: * Debugging Calc:: @end menu @node Autoloading Problems, Recursion Depth, Troubleshooting Commands, Troubleshooting Commands @subsection Autoloading Problems @noindent The Calc program is split into many component files; components are loaded automatically as you use various commands that require them. Occasionally Calc may lose track of when a certain component is necessary; typically this means you will type a command and it won't work because some function you've never heard of was undefined. @kindex M-# L @pindex calc-load-everything If this happens, the easiest workaround is to type @kbd{M-# L} (@code{calc-load-everything}) to force all the parts of Calc to be loaded right away. This will cause Emacs to take up a lot more memory than it would otherwise, but it's guaranteed to fix the problem. If you seem to run into this problem no matter what you do, or if even the @kbd{M-# L} command crashes, Calc may have been improperly installed. @xref{Installation}, for details of the installation process. @node Recursion Depth, Caches, Autoloading Problems, Troubleshooting Commands @subsection Recursion Depth @noindent @kindex M @kindex I M @pindex calc-more-recursion-depth @pindex calc-less-recursion-depth @cindex Recursion depth @cindex ``Computation got stuck'' message @cindex @code{max-lisp-eval-depth} @cindex @code{max-specpdl-size} Calc uses recursion in many of its calculations. Emacs Lisp keeps a variable @code{max-lisp-eval-depth} which limits the amount of recursion possible in an attempt to recover from program bugs. If a calculation ever halts incorrectly with the message ``Computation got stuck or ran too long,'' use the @kbd{M} command (@code{calc-more-recursion-depth}) to increase this limit. (Of course, this will not help if the calculation really did get stuck due to some problem inside Calc.)@refill The limit is always increased (multiplied) by a factor of two. There is also an @kbd{I M} (@code{calc-less-recursion-depth}) command which decreases this limit by a factor of two, down to a minimum value of 200. The default value is 1000. These commands also double or halve @code{max-specpdl-size}, another internal Lisp recursion limit. The minimum value for this limit is 600. @node Caches, Debugging Calc, Recursion Depth, Troubleshooting Commands @subsection Caches @noindent @cindex Caches @cindex Flushing caches Calc saves certain values after they have been computed once. For example, the @kbd{P} (@code{calc-pi}) command initially ``knows'' the constant @c{$\pi$} @cite{pi} to about 20 decimal places; if the current precision is greater than this, it will recompute @c{$\pi$} @cite{pi} using a series approximation. This value will not need to be recomputed ever again unless you raise the precision still further. Many operations such as logarithms and sines make use of similarly cached values such as @c{$\pi \over 4$} @cite{pi/4} and @c{$\ln 2$} @cite{ln(2)}. The visible effect of caching is that high-precision computations may seem to do extra work the first time. Other things cached include powers of two (for the binary arithmetic functions), matrix inverses and determinants, symbolic integrals, and data points computed by the graphing commands. @pindex calc-flush-caches If you suspect a Calculator cache has become corrupt, you can use the @code{calc-flush-caches} command to reset all caches to the empty state. (This should only be necessary in the event of bugs in the Calculator.) The @kbd{M-# 0} (with the zero key) command also resets caches along with all other aspects of the Calculator's state. @node Debugging Calc, , Caches, Troubleshooting Commands @subsection Debugging Calc @noindent A few commands exist to help in the debugging of Calc commands. @xref{Programming}, to see the various ways that you can write your own Calc commands. @kindex Z T @pindex calc-timing The @kbd{Z T} (@code{calc-timing}) command turns on and off a mode in which the timing of slow commands is reported in the Trail. Any Calc command that takes two seconds or longer writes a line to the Trail showing how many seconds it took. This value is accurate only to within one second. All steps of executing a command are included; in particular, time taken to format the result for display in the stack and trail is counted. Some prompts also count time taken waiting for them to be answered, while others do not; this depends on the exact implementation of the command. For best results, if you are timing a sequence that includes prompts or multiple commands, define a keyboard macro to run the whole sequence at once. Calc's @kbd{X} command (@pxref{Keyboard Macros}) will then report the time taken to execute the whole macro. Another advantage of the @kbd{X} command is that while it is executing, the stack and trail are not updated from step to step. So if you expect the output of your test sequence to leave a result that may take a long time to format and you don't wish to count this formatting time, end your sequence with a @key{DEL} keystroke to clear the result from the stack. When you run the sequence with @kbd{X}, Calc will never bother to format the large result. Another thing @kbd{Z T} does is to increase the Emacs variable @code{gc-cons-threshold} to a much higher value (two million; the usual default in Calc is 250,000) for the duration of each command. This generally prevents garbage collection during the timing of the command, though it may cause your Emacs process to grow abnormally large. (Garbage collection time is a major unpredictable factor in the timing of Emacs operations.) Another command that is useful when debugging your own Lisp extensions to Calc is @kbd{M-x calc-pass-errors}, which disables the error handler that changes the ``@code{max-lisp-eval-depth} exceeded'' message to the much more friendly ``Computation got stuck or ran too long.'' This handler interferes with the Emacs Lisp debugger's @code{debug-on-error} mode. Errors are reported in the handler itself rather than at the true location of the error. After you have executed @code{calc-pass-errors}, Lisp errors will be reported correctly but the user-friendly message will be lost. @node Data Types, Stack and Trail, Introduction, Top @chapter Data Types @noindent This chapter discusses the various types of objects that can be placed on the Calculator stack, how they are displayed, and how they are entered. (@xref{Data Type Formats}, for information on how these data types are represented as underlying Lisp objects.)@refill Integers, fractions, and floats are various ways of describing real numbers. HMS forms also for many purposes act as real numbers. These types can be combined to form complex numbers, modulo forms, error forms, or interval forms. (But these last four types cannot be combined arbitrarily:@: error forms may not contain modulo forms, for example.) Finally, all these types of numbers may be combined into vectors, matrices, or algebraic formulas. @menu * Integers:: The most basic data type. * Fractions:: This and above are called @dfn{rationals}. * Floats:: This and above are called @dfn{reals}. * Complex Numbers:: This and above are called @dfn{numbers}. * Infinities:: * Vectors and Matrices:: * Strings:: * HMS Forms:: * Date Forms:: * Modulo Forms:: * Error Forms:: * Interval Forms:: * Incomplete Objects:: * Variables:: * Formulas:: @end menu @node Integers, Fractions, Data Types, Data Types @section Integers @noindent @cindex Integers The Calculator stores integers to arbitrary precision. Addition, subtraction, and multiplication of integers always yields an exact integer result. (If the result of a division or exponentiation of integers is not an integer, it is expressed in fractional or floating-point form according to the current Fraction Mode. @xref{Fraction Mode}.) A decimal integer is represented as an optional sign followed by a sequence of digits. Grouping (@pxref{Grouping Digits}) can be used to insert a comma at every third digit for display purposes, but you must not type commas during the entry of numbers.@refill @kindex # A non-decimal integer is represented as an optional sign, a radix between 2 and 36, a @samp{#} symbol, and one or more digits. For radix 11 and above, the letters A through Z (upper- or lower-case) count as digits and do not terminate numeric entry mode. @xref{Radix Modes}, for how to set the default radix for display of integers. Numbers of any radix may be entered at any time. If you press @kbd{#} at the beginning of a number, the current display radix is used.@refill @node Fractions, Floats, Integers, Data Types @section Fractions @noindent @cindex Fractions A @dfn{fraction} is a ratio of two integers. Fractions are traditionally written ``2/3'' but Calc uses the notation @samp{2:3}. (The @kbd{/} key performs RPN division; the following two sequences push the number @samp{2:3} on the stack: @kbd{2 :@: 3 @key{RET}}, or @kbd{2 @key{RET} 3 /} assuming Fraction Mode has been enabled.) When the Calculator produces a fractional result it always reduces it to simplest form, which may in fact be an integer.@refill Fractions may also be entered in a three-part form, where @samp{2:3:4} represents two-and-three-quarters. @xref{Fraction Formats}, for fraction display formats.@refill Non-decimal fractions are entered and displayed as @samp{@var{radix}#@var{num}:@var{denom}} (or in the analogous three-part form). The numerator and denominator always use the same radix.@refill @node Floats, Complex Numbers, Fractions, Data Types @section Floats @noindent @cindex Floating-point numbers A floating-point number or @dfn{float} is a number stored in scientific notation. The number of significant digits in the fractional part is governed by the current floating precision (@pxref{Precision}). The range of acceptable values is from @c{$10^{-3999999}$} @cite{10^-3999999} (inclusive) to @c{$10^{4000000}$} @cite{10^4000000} (exclusive), plus the corresponding negative values and zero. Calculations that would exceed the allowable range of values (such as @samp{exp(exp(20))}) are left in symbolic form by Calc. The messages ``floating-point overflow'' or ``floating-point underflow'' indicate that during the calculation a number would have been produced that was too large or too close to zero, respectively, to be represented by Calc. This does not necessarily mean the final result would have overflowed, just that an overflow occurred while computing the result. (In fact, it could report an underflow even though the final result would have overflowed!) If a rational number and a float are mixed in a calculation, the result will in general be expressed as a float. Commands that require an integer value (such as @kbd{k g} [@code{gcd}]) will also accept integer-valued floats, i.e., floating-point numbers with nothing after the decimal point. Floats are identified by the presence of a decimal point and/or an exponent. In general a float consists of an optional sign, digits including an optional decimal point, and an optional exponent consisting of an @samp{e}, an optional sign, and up to seven exponent digits. For example, @samp{23.5e-2} is 23.5 times ten to the minus-second power, or 0.235. Floating-point numbers are normally displayed in decimal notation with all significant figures shown. Exceedingly large or small numbers are displayed in scientific notation. Various other display options are available. @xref{Float Formats}. @cindex Accuracy of calculations Floating-point numbers are stored in decimal, not binary. The result of each operation is rounded to the nearest value representable in the number of significant digits specified by the current precision, rounding away from zero in the case of a tie. Thus (in the default display mode) what you see is exactly what you get. Some operations such as square roots and transcendental functions are performed with several digits of extra precision and then rounded down, in an effort to make the final result accurate to the full requested precision. However, accuracy is not rigorously guaranteed. If you suspect the validity of a result, try doing the same calculation in a higher precision. The Calculator's arithmetic is not intended to be IEEE-conformant in any way.@refill While floats are always @emph{stored} in decimal, they can be entered and displayed in any radix just like integers and fractions. The notation @samp{@var{radix}#@var{ddd}.@var{ddd}} is a floating-point number whose digits are in the specified radix. Note that the @samp{.} is more aptly referred to as a ``radix point'' than as a decimal point in this case. The number @samp{8#123.4567} is defined as @samp{8#1234567 * 8^-4}. If the radix is 14 or less, you can use @samp{e} notation to write a non-decimal number in scientific notation. The exponent is written in decimal, and is considered to be a power of the radix: @samp{8#1234567e-4}. If the radix is 15 or above, the letter @samp{e} is a digit, so scientific notation must be written out, e.g., @samp{16#123.4567*16^2}. The first two exercises of the Modes Tutorial explore some of the properties of non-decimal floats. @node Complex Numbers, Infinities, Floats, Data Types @section Complex Numbers @noindent @cindex Complex numbers There are two supported formats for complex numbers: rectangular and polar. The default format is rectangular, displayed in the form @samp{(@var{real},@var{imag})} where @var{real} is the real part and @var{imag} is the imaginary part, each of which may be any real number. Rectangular complex numbers can also be displayed in @samp{@var{a}+@var{b}i} notation; @pxref{Complex Formats}.@refill Polar complex numbers are displayed in the form `@t{(}@var{r}@t{;}@c{$\theta$} @var{theta}@t{)}' where @var{r} is the nonnegative magnitude and @c{$\theta$} @var{theta} is the argument or phase angle. The range of @c{$\theta$} @var{theta} depends on the current angular mode (@pxref{Angular Modes}); it is generally between @i{-180} and @i{+180} degrees or the equivalent range in radians.@refill Complex numbers are entered in stages using incomplete objects. @xref{Incomplete Objects}. Operations on rectangular complex numbers yield rectangular complex results, and similarly for polar complex numbers. Where the two types are mixed, or where new complex numbers arise (as for the square root of a negative real), the current @dfn{Polar Mode} is used to determine the type. @xref{Polar Mode}. A complex result in which the imaginary part is zero (or the phase angle is 0 or 180 degrees or @c{$\pi$} @cite{pi} radians) is automatically converted to a real number. @node Infinities, Vectors and Matrices, Complex Numbers, Data Types @section Infinities @noindent @cindex Infinity @cindex @code{inf} variable @cindex @code{uinf} variable @cindex @code{nan} variable @vindex inf @vindex uinf @vindex nan The word @code{inf} represents the mathematical concept of @dfn{infinity}. Calc actually has three slightly different infinity-like values: @code{inf}, @code{uinf}, and @code{nan}. These are just regular variable names (@pxref{Variables}); you should avoid using these names for your own variables because Calc gives them special treatment. Infinities, like all variable names, are normally entered using algebraic entry. Mathematically speaking, it is not rigorously correct to treat ``infinity'' as if it were a number, but mathematicians often do so informally. When they say that @samp{1 / inf = 0}, what they really mean is that @cite{1 / x}, as @cite{x} becomes larger and larger, becomes arbitrarily close to zero. So you can imagine that if @cite{x} got ``all the way to infinity,'' then @cite{1 / x} would go all the way to zero. Similarly, when they say that @samp{exp(inf) = inf}, they mean that @c{$e^x$} @cite{exp(x)} grows without bound as @cite{x} grows. The symbol @samp{-inf} likewise stands for an infinitely negative real value; for example, we say that @samp{exp(-inf) = 0}. You can have an infinity pointing in any direction on the complex plane: @samp{sqrt(-inf) = i inf}. The same concept of limits can be used to define @cite{1 / 0}. We really want the value that @cite{1 / x} approaches as @cite{x} approaches zero. But if all we have is @cite{1 / 0}, we can't tell which direction @cite{x} was coming from. If @cite{x} was positive and decreasing toward zero, then we should say that @samp{1 / 0 = inf}. But if @cite{x} was negative and increasing toward zero, the answer is @samp{1 / 0 = -inf}. In fact, @cite{x} could be an imaginary number, giving the answer @samp{i inf} or @samp{-i inf}. Calc uses the special symbol @samp{uinf} to mean @dfn{undirected infinity}, i.e., a value which is infinitely large but with an unknown sign (or direction on the complex plane). Calc actually has three modes that say how infinities are handled. Normally, infinities never arise from calculations that didn't already have them. Thus, @cite{1 / 0} is treated simply as an error and left unevaluated. The @kbd{m i} (@code{calc-infinite-mode}) command (@pxref{Infinite Mode}) enables a mode in which @cite{1 / 0} evaluates to @code{uinf} instead. There is also an alternative type of infinite mode which says to treat zeros as if they were positive, so that @samp{1 / 0 = inf}. While this is less mathematically correct, it may be the answer you want in some cases. Since all infinities are ``as large'' as all others, Calc simplifies, e.g., @samp{5 inf} to @samp{inf}. Another example is @samp{5 - inf = -inf}, where the @samp{-inf} is so large that adding a finite number like five to it does not affect it. Note that @samp{a - inf} also results in @samp{-inf}; Calc assumes that variables like @code{a} always stand for finite quantities. Just to show that infinities really are all the same size, note that @samp{sqrt(inf) = inf^2 = exp(inf) = inf} in Calc's notation. It's not so easy to define certain formulas like @samp{0 * inf} and @samp{inf / inf}. Depending on where these zeros and infinities came from, the answer could be literally anything. The latter formula could be the limit of @cite{x / x} (giving a result of one), or @cite{2 x / x} (giving two), or @cite{x^2 / x} (giving @code{inf}), or @cite{x / x^2} (giving zero). Calc uses the symbol @code{nan} to represent such an @dfn{indeterminate} value. (The name ``nan'' comes from analogy with the ``NAN'' concept of IEEE standard arithmetic; it stands for ``Not A Number.'' This is somewhat of a misnomer, since @code{nan} @emph{does} stand for some number or infinity, it's just that @emph{which} number it stands for cannot be determined.) In Calc's notation, @samp{0 * inf = nan} and @samp{inf / inf = nan}. A few other common indeterminate expressions are @samp{inf - inf} and @samp{inf ^ 0}. Also, @samp{0 / 0 = nan} if you have turned on ``infinite mode'' (as described above). Infinities are especially useful as parts of @dfn{intervals}. @xref{Interval Forms}. @node Vectors and Matrices, Strings, Infinities, Data Types @section Vectors and Matrices @noindent @cindex Vectors @cindex Plain vectors @cindex Matrices The @dfn{vector} data type is flexible and general. A vector is simply a list of zero or more data objects. When these objects are numbers, the whole is a vector in the mathematical sense. When these objects are themselves vectors of equal (nonzero) length, the whole is a @dfn{matrix}. A vector which is not a matrix is referred to here as a @dfn{plain vector}. A vector is displayed as a list of values separated by commas and enclosed in square brackets: @samp{[1, 2, 3]}. Thus the following is a 2 row by 3 column matrix: @samp{[[1, 2, 3], [4, 5, 6]]}. Vectors, like complex numbers, are entered as incomplete objects. @xref{Incomplete Objects}. During algebraic entry, vectors are entered all at once in the usual brackets-and-commas form. Matrices may be entered algebraically as nested vectors, or using the shortcut notation @w{@samp{[1, 2, 3; 4, 5, 6]}}, with rows separated by semicolons. The commas may usually be omitted when entering vectors: @samp{[1 2 3]}. Curly braces may be used in place of brackets: @samp{@{1, 2, 3@}}, but the commas are required in this case. Traditional vector and matrix arithmetic is also supported; @pxref{Basic Arithmetic} and @pxref{Matrix Functions}. Many other operations are applied to vectors element-wise. For example, the complex conjugate of a vector is a vector of the complex conjugates of its elements.@refill @c @starindex @tindex vec Algebraic functions for building vectors include @samp{vec(a, b, c)} to build @samp{[a, b, c]}, @samp{cvec(a, n, m)} to build an @c{$n\times m$} @asis{@var{n}x@var{m}} matrix of @samp{a}s, and @samp{index(n)} to build a vector of integers from 1 to @samp{n}. @node Strings, HMS Forms, Vectors and Matrices, Data Types @section Strings @noindent @kindex " @cindex Strings @cindex Character strings Character strings are not a special data type in the Calculator. Rather, a string is represented simply as a vector all of whose elements are integers in the range 0 to 255 (ASCII codes). You can enter a string at any time by pressing the @kbd{"} key. Quotation marks and backslashes are written @samp{\"} and @samp{\\}, respectively, inside strings. Other notations introduced by backslashes are: @group @example \a 7 \^@@ 0 \b 8 \^a-z 1-26 \e 27 \^[ 27 \f 12 \^\\ 28 \n 10 \^] 29 \r 13 \^^ 30 \t 9 \^_ 31 \^? 127 @end example @end group @noindent Finally, a backslash followed by three octal digits produces any character from its ASCII code. @kindex d " @pindex calc-display-strings Strings are normally displayed in vector-of-integers form. The @w{@kbd{d "}} (@code{calc-display-strings}) command toggles a mode in which any vectors of small integers are displayed as quoted strings instead. The backslash notations shown above are also used for displaying strings. Characters 128 and above are not translated by Calc; unless you have an Emacs modified for 8-bit fonts, these will show up in backslash-octal-digits notation. For characters below 32, and for character 127, Calc uses the backslash-letter combination if there is one, or otherwise uses a @samp{\^} sequence. The only Calc feature that uses strings is @dfn{compositions}; @pxref{Compositions}. Strings also provide a convenient way to do conversions between ASCII characters and integers. @c @starindex @tindex string There is a @code{string} function which provides a different display format for strings. Basically, @samp{string(@var{s})}, where @var{s} is a vector of integers in the proper range, is displayed as the corresponding string of characters with no surrounding quotation marks or other modifications. Thus @samp{string("ABC")} (or @samp{string([65 66 67])}) will look like @samp{ABC} on the stack. This happens regardless of whether @w{@kbd{d "}} has been used. The only way to turn it off is to use @kbd{d U} (unformatted language mode) which will display @samp{string("ABC")} instead. Control characters are displayed somewhat differently by @code{string}. Characters below 32, and character 127, are shown using @samp{^} notation (same as shown above, but without the backslash). The quote and backslash characters are left alone, as are characters 128 and above. @c @starindex @tindex bstring The @code{bstring} function is just like @code{string} except that the resulting string is breakable across multiple lines if it doesn't fit all on one line. Potential break points occur at every space character in the string. @node HMS Forms, Date Forms, Strings, Data Types @section HMS Forms @noindent @cindex Hours-minutes-seconds forms @cindex Degrees-minutes-seconds forms @dfn{HMS} stands for Hours-Minutes-Seconds; when used as an angular argument, the interpretation is Degrees-Minutes-Seconds. All functions that operate on angles accept HMS forms. These are interpreted as degrees regardless of the current angular mode. It is also possible to use HMS as the angular mode so that calculated angles are expressed in degrees, minutes, and seconds. @kindex @@ @c @mindex @null @kindex ' (HMS forms) @c @mindex @null @kindex " (HMS forms) @c @mindex @null @kindex h (HMS forms) @c @mindex @null @kindex o (HMS forms) @c @mindex @null @kindex m (HMS forms) @c @mindex @null @kindex s (HMS forms) The default format for HMS values is @samp{@var{hours}@@ @var{mins}' @var{secs}"}. During entry, the letters @samp{h} (for ``hours'') or @samp{o} (approximating the ``degrees'' symbol) are accepted as well as @samp{@@}, @samp{m} is accepted in place of @samp{'}, and @samp{s} is accepted in place of @samp{"}. The @var{hours} value is an integer (or integer-valued float). The @var{mins} value is an integer or integer-valued float between 0 and 59. The @var{secs} value is a real number between 0 (inclusive) and 60 (exclusive). A positive HMS form is interpreted as @var{hours} + @var{mins}/60 + @var{secs}/3600. A negative HMS form is interpreted as @i{- @var{hours}} @i{-} @var{mins}/60 @i{-} @var{secs}/3600. Display format for HMS forms is quite flexible. @xref{HMS Formats}.@refill HMS forms can be added and subtracted. When they are added to numbers, the numbers are interpreted according to the current angular mode. HMS forms can also be multiplied and divided by real numbers. Dividing two HMS forms produces a real-valued ratio of the two angles. @pindex calc-time @cindex Time of day Just for kicks, @kbd{M-x calc-time} pushes the current time of day on the stack as an HMS form. @node Date Forms, Modulo Forms, HMS Forms, Data Types @section Date Forms @noindent @cindex Date forms A @dfn{date form} represents a date and possibly an associated time. Simple date arithmetic is supported: Adding a number to a date produces a new date shifted by that many days; adding an HMS form to a date shifts it by that many hours. Subtracting two date forms computes the number of days between them (represented as a simple number). Many other operations, such as multiplying two date forms, are nonsensical and are not allowed by Calc. Date forms are entered and displayed enclosed in @samp{< >} brackets. The default format is, e.g., @samp{} for dates, or @samp{<3:32:20pm Wed Jan 9, 1991>} for dates with times. Input is flexible; date forms can be entered in any of the usual notations for dates and times. @xref{Date Formats}. Date forms are stored internally as numbers, specifically the number of days since midnight on the morning of January 1 of the year 1 AD. If the internal number is an integer, the form represents a date only; if the internal number is a fraction or float, the form represents a date and time. For example, @samp{<6:00am Wed Jan 9, 1991>} is represented by the number 726842.25. The standard precision of 12 decimal digits is enough to ensure that a (reasonable) date and time can be stored without roundoff error. If the current precision is greater than 12, date forms will keep additional digits in the seconds position. For example, if the precision is 15, the seconds will keep three digits after the decimal point. Decreasing the precision below 12 may cause the time part of a date form to become inaccurate. This can also happen if astronomically high years are used, though this will not be an issue in everyday (or even everymillenium) use. Note that date forms without times are stored as exact integers, so roundoff is never an issue for them. You can use the @kbd{v p} (@code{calc-pack}) and @kbd{v u} (@code{calc-unpack}) commands to get at the numerical representation of a date form. @xref{Packing and Unpacking}. Date forms can go arbitrarily far into the future or past. Negative year numbers represent years BC. Calc uses a combination of the Gregorian and Julian calendars, following the history of Great Britain and the British colonies. This is the same calendar that is used by the @code{cal} program in most Unix implementations. @cindex Julian calendar @cindex Gregorian calendar Some historical background: The Julian calendar was created by Julius Caesar in the year 46 BC as an attempt to fix the gradual drift caused by the lack of leap years in the calendar used until that time. The Julian calendar introduced an extra day in all years divisible by four. After some initial confusion, the calendar was adopted around the year we call 8 AD. Some centuries later it became apparent that the Julian year of 365.25 days was itself not quite right. In 1582 Pope Gregory XIII introduced the Gregorian calendar, which added the new rule that years divisible by 100, but not by 400, were not to be considered leap years despite being divisible by four. Many countries delayed adoption of the Gregorian calendar because of religious differences; in Britain it was put off until the year 1752, by which time the Julian calendar had fallen eleven days behind the true seasons. So the switch to the Gregorian calendar in early September 1752 introduced a discontinuity: The day after Sep 2, 1752 is Sep 14, 1752. Calc follows this convention. To take another example, Russia waited until 1918 before adopting the new calendar, and thus needed to remove thirteen days (between Feb 1, 1918 and Feb 14, 1918). This means that Calc's reckoning will be inconsistent with Russian history between 1752 and 1918, and similarly for various other countries. Today's timekeepers introduce an occasional ``leap second'' as well, but Calc does not take these minor effects into account. (If it did, it would have to report a non-integer number of days between, say, @samp{<12:00am Mon Jan 1, 1900>} and @samp{<12:00am Sat Jan 1, 2000>}.) Calc uses the Julian calendar for all dates before the year 1752, including dates BC when the Julian calendar technically had not yet been invented. Thus the claim that day number @i{-10000} is called ``August 16, 28 BC'' should be taken with a grain of salt. Please note that there is no ``year 0''; the day before @samp{} is @samp{}. These are days 0 and @i{-1} respectively in Calc's internal numbering scheme. @cindex Julian day counting Another day counting system in common use is, confusingly, also called ``Julian.'' It was invented in 1583 by Joseph Justus Scaliger, who named it in honor of his father Julius Caesar Scaliger. For obscure reasons he chose to start his day numbering on Jan 1, 4713 BC at noon, which in Calc's scheme is @i{-1721423.5} (recall that Calc starts at midnight instead of noon). Thus to convert a Calc date code obtained by unpacking a date form into a Julian day number, simply add 1721423.5. The Julian code for @samp{6:00am Jan 9, 1991} is 2448265.75. The built-in @kbd{t J} command performs this conversion for you. @cindex Unix time format The Unix operating system measures time as an integer number of seconds since midnight, Jan 1, 1970. To convert a Calc date value into a Unix time stamp, first subtract 719164 (the code for @samp{}), then multiply by 86400 (the number of seconds in a day) and press @kbd{R} to round to the nearest integer. If you have a date form, you can simply subtract the day @samp{} instead of unpacking and subtracting 719164. Likewise, divide by 86400 and add @samp{} to convert from Unix time to a Calc date form. (Note that Unix normally maintains the time in the GMT time zone; you may need to subtract five hours to get New York time, or eight hours for California time. The same is usually true of Julian day counts.) The built-in @kbd{t U} command performs these conversions. @node Modulo Forms, Error Forms, Date Forms, Data Types @section Modulo Forms @noindent @cindex Modulo forms A @dfn{modulo form} is a real number which is taken modulo (i.e., within an integer multiple of) some value @cite{M}. Arithmetic modulo @cite{M} often arises in number theory. Modulo forms are written `@i{a} @t{mod} @i{M}', where @cite{a} and @cite{M} are real numbers or HMS forms, and @c{$0 \le a < M$} @cite{0 <= a < @var{M}}. In many applications @cite{a} and @cite{M} will be integers but this is not required.@refill Modulo forms are not to be confused with the modulo operator @samp{%}. The expression @samp{27 % 10} means to compute 27 modulo 10 to produce the result 7. Further computations treat this 7 as just a regular integer. The expression @samp{27 mod 10} produces the result @samp{7 mod 10}; further computations with this value are again reduced modulo 10 so that the result always lies in the desired range. When two modulo forms with identical @cite{M}'s are added or multiplied, the Calculator simply adds or multiplies the values, then reduces modulo @cite{M}. If one argument is a modulo form and the other a plain number, the plain number is treated like a compatible modulo form. It is also possible to raise modulo forms to powers; the result is the value raised to the power, then reduced modulo @cite{M}. (When all values involved are integers, this calculation is done much more efficiently than actually computing the power and then reducing.) @cindex Modulo division Two modulo forms `@i{a} @t{mod} @i{M}' and `@i{b} @t{mod} @i{M}' can be divided if @cite{a}, @cite{b}, and @cite{M} are all integers. The result is the modulo form which, when multiplied by `@i{b} @t{mod} @i{M}', produces `@i{a} @t{mod} @i{M}'. If there is no solution to this equation (which can happen only when @cite{M} is non-prime), or if any of the arguments are non-integers, the division is left in symbolic form. Other operations, such as square roots, are not yet supported for modulo forms. (Note that, although @w{`@t{(}@i{a} @t{mod} @i{M}@t{)^.5}'} will compute a ``modulo square root'' in the sense of reducing @c{$\sqrt a$} @cite{sqrt(a)} modulo @cite{M}, this is not a useful definition from the number-theoretical point of view.)@refill @c @mindex M @kindex M (modulo forms) @c @mindex mod @tindex mod (operator) To create a modulo form during numeric entry, press the shift-@kbd{M} key to enter the word @samp{mod}. As a special convenience, pressing shift-@kbd{M} a second time automatically enters the value of @cite{M} that was most recently used before. During algebraic entry, either type @samp{mod} by hand or press @kbd{M-m} (that's @kbd{@key{META}-m}). Once again, pressing this a second time enters the current modulo.@refill You can also use @kbd{v p} and @kbd{%} to modify modulo forms. @xref{Building Vectors}. @xref{Basic Arithmetic}. It is possible to mix HMS forms and modulo forms. For example, an HMS form modulo 24 could be used to manipulate clock times; an HMS form modulo 360 would be suitable for angles. Making the modulo @cite{M} also be an HMS form eliminates troubles that would arise if the angular mode were inadvertently set to Radians, in which case @w{@samp{2@@ 0' 0" mod 24}} would be interpreted as two degrees modulo 24 radians! Modulo forms cannot have variables or formulas for components. If you enter the formula @samp{(x + 2) mod 5}, Calc propagates the modulus to each of the coefficients: @samp{(1 mod 5) x + (2 mod 5)}. @c @starindex @tindex makemod The algebraic function @samp{makemod(a, m)} builds the modulo form @w{@samp{a mod m}}. @node Error Forms, Interval Forms, Modulo Forms, Data Types @section Error Forms @noindent @cindex Error forms @cindex Standard deviations An @dfn{error form} is a number with an associated standard deviation, as in @samp{2.3 +/- 0.12}. The notation `@i{x} @t{+/-} @c{$\sigma$} @asis{sigma}' stands for an uncertain value which follows a normal or Gaussian distribution of mean @cite{x} and standard deviation or ``error'' @c{$\sigma$} @cite{sigma}. Both the mean and the error can be either numbers or formulas. Generally these are real numbers but the mean may also be complex. If the error is negative or complex, it is changed to its absolute value. An error form with zero error is converted to a regular number by the Calculator.@refill All arithmetic and transcendental functions accept error forms as input. Operations on the mean-value part work just like operations on regular numbers. The error part for any function @cite{f(x)} (such as @c{$\sin x$} @cite{sin(x)}) is defined by the error of @cite{x} times the derivative of @cite{f} evaluated at the mean value of @cite{x}. For a two-argument function @cite{f(x,y)} (such as addition) the error is the square root of the sum of the squares of the errors due to @cite{x} and @cite{y}. @tex $$ \eqalign{ f(x \hbox{\code{ +/- }} \sigma) &= f(x) \hbox{\code{ +/- }} \sigma \left| {df(x) \over dx} \right| \cr f(x \hbox{\code{ +/- }} \sigma_x, y \hbox{\code{ +/- }} \sigma_y) &= f(x,y) \hbox{\code{ +/- }} \sqrt{\left(\sigma_x \left| {\partial f(x,y) \over \partial x} \right| \right)^2 +\left(\sigma_y \left| {\partial f(x,y) \over \partial y} \right| \right)^2 } \cr } $$ @end tex Note that this definition assumes the errors in @cite{x} and @cite{y} are uncorrelated. A side effect of this definition is that @samp{(2 +/- 1) * (2 +/- 1)} is not the same as @samp{(2 +/- 1)^2}; the former represents the product of two independent values which happen to have the same probability distributions, and the latter is the product of one random value with itself. The former will produce an answer with less error, since on the average the two independent errors can be expected to cancel out.@refill Consult a good text on error analysis for a discussion of the proper use of standard deviations. Actual errors often are neither Gaussian-distributed nor uncorrelated, and the above formulas are valid only when errors are small. As an example, the error arising from `@t{sin(}@i{x} @t{+/-} @c{$\sigma$} @i{sigma}@t{)}' is `@c{$\sigma$\nobreak} @i{sigma} @t{abs(cos(}@i{x}@t{))}'. When @cite{x} is close to zero, @c{$\cos x$} @cite{cos(x)} is close to one so the error in the sine is close to @c{$\sigma$} @cite{sigma}; this makes sense, since @c{$\sin x$} @cite{sin(x)} is approximately @cite{x} near zero, so a given error in @cite{x} will produce about the same error in the sine. Likewise, near 90 degrees @c{$\cos x$} @cite{cos(x)} is nearly zero and so the computed error is small: The sine curve is nearly flat in that region, so an error in @cite{x} has relatively little effect on the value of @c{$\sin x$} @cite{sin(x)}. However, consider @samp{sin(90 +/- 1000)}. The cosine of 90 is zero, so Calc will report zero error! We get an obviously wrong result because we have violated the small-error approximation underlying the error analysis. If the error in @cite{x} had been small, the error in @c{$\sin x$} @cite{sin(x)} would indeed have been negligible.@refill @c @mindex p @kindex p (error forms) @tindex +/- To enter an error form during regular numeric entry, use the @kbd{p} (``plus-or-minus'') key to type the @samp{+/-} symbol. (If you try actually typing @samp{+/-} the @kbd{+} key will be interpreted as the Calculator's @kbd{+} command!) Within an algebraic formula, you can press @kbd{M-p} to type the @samp{+/-} symbol, or type it out by hand. Error forms and complex numbers can be mixed; the formulas shown above are used for complex numbers, too; note that if the error part evaluates to a complex number its absolute value (or the square root of the sum of the squares of the absolute values of the two error contributions) is used. Mathematically, this corresponds to a radially symmetric Gaussian distribution of numbers on the complex plane. However, note that Calc considers an error form with real components to represent a real number, not a complex distribution around a real mean. Error forms may also be composed of HMS forms. For best results, both the mean and the error should be HMS forms if either one is. @c @starindex @tindex sdev The algebraic function @samp{sdev(a, b)} builds the error form @samp{a +/- b}. @node Interval Forms, Incomplete Objects, Error Forms, Data Types @section Interval Forms @noindent @cindex Interval forms An @dfn{interval} is a subset of consecutive real numbers. For example, the interval @samp{[2 ..@: 4]} represents all the numbers from 2 to 4, inclusive. If you multiply it by the interval @samp{[0.5 ..@: 2]} you obtain @samp{[1 ..@: 8]}. This calculation represents the fact that if you multiply some number in the range @samp{[2 ..@: 4]} by some other number in the range @samp{[0.5 ..@: 2]}, your result will lie in the range from 1 to 8. Interval arithmetic is used to get a worst-case estimate of the possible range of values a computation will produce, given the set of possible values of the input. @ifinfo Calc supports several varieties of intervals, including @dfn{closed} intervals of the type shown above, @dfn{open} intervals such as @samp{(2 ..@: 4)}, which represents the range of numbers from 2 to 4 @emph{exclusive}, and @dfn{semi-open} intervals in which one end uses a round parenthesis and the other a square bracket. In mathematical terms, @samp{[2 ..@: 4]} means @cite{2 <= x <= 4}, whereas @samp{[2 ..@: 4)} represents @cite{2 <= x < 4}, @samp{(2 ..@: 4]} represents @cite{2 < x <= 4}, and @samp{(2 ..@: 4)} represents @cite{2 < x < 4}.@refill @end ifinfo @tex Calc supports several varieties of intervals, including \dfn{closed} intervals of the type shown above, \dfn{open} intervals such as \samp{(2 ..\: 4)}, which represents the range of numbers from 2 to 4 \emph{exclusive}, and \dfn{semi-open} intervals in which one end uses a round parenthesis and the other a square bracket. In mathematical terms, $$ \eqalign{ [2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 \le x \le 4 \cr [2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 \le x < 4 \cr (2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 < x \le 4 \cr (2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 < x < 4 \cr } $$ @end tex The lower and upper limits of an interval must be either real numbers (or HMS or date forms), or symbolic expressions which are assumed to be real-valued, or @samp{-inf} and @samp{inf}. In general the lower limit must be less than the upper limit. A closed interval containing only one value, @samp{[3 ..@: 3]}, is converted to a plain number (3) automatically. An interval containing no values at all (such as @samp{[3 ..@: 2]} or @samp{[2 ..@: 2)}) can be represented but is not guaranteed to behave well when used in arithmetic. Note that the interval @samp{[3 .. inf)} represents all real numbers greater than or equal to 3, and @samp{(-inf .. inf)} represents all real numbers. In fact, @samp{[-inf .. inf]} represents all real numbers including the real infinities. Intervals are entered in the notation shown here, either as algebraic formulas, or using incomplete forms. (@xref{Incomplete Objects}.) In algebraic formulas, multiple periods in a row are collected from left to right, so that @samp{1...1e2} is interpreted as @samp{1.0 ..@: 1e2} rather than @samp{1 ..@: 0.1e2}. Add spaces or zeros if you want to get the other interpretation. If you omit the lower or upper limit, a default of @samp{-inf} or @samp{inf} (respectively) is furnished. ``Infinite mode'' also affects operations on intervals (@pxref{Infinities}). Calc will always introduce an open infinity, as in @samp{1 / (0 .. 2] = [0.5 .. inf)}. But closed infinities, @w{@samp{1 / [0 .. 2] = [0.5 .. inf]}}, arise only in infinite mode; otherwise they are left unevaluated. Note that the ``direction'' of a zero is not an issue in this case since the zero is always assumed to be continuous with the rest of the interval. For intervals that contain zero inside them Calc is forced to give the result, @samp{1 / (-2 .. 2) = [-inf .. inf]}. While it may seem that intervals and error forms are similar, they are based on entirely different concepts of inexact quantities. An error form `@i{x} @t{+/-} @c{$\sigma$} @i{sigma}' means a variable is random, and its value could be anything but is ``probably'' within one @c{$\sigma$} @i{sigma} of the mean value @cite{x}. An interval `@t{[}@i{a} @t{..@:} @i{b}@t{]}' means a variable's value is unknown, but guaranteed to lie in the specified range. Error forms are statistical or ``average case'' approximations; interval arithmetic tends to produce ``worst case'' bounds on an answer.@refill Intervals may not contain complex numbers, but they may contain HMS forms or date forms. @xref{Set Operations}, for commands that interpret interval forms as subsets of the set of real numbers. @c @starindex @tindex intv The algebraic function @samp{intv(n, a, b)} builds an interval form from @samp{a} to @samp{b}; @samp{n} is an integer code which must be 0 for @samp{(..)}, 1 for @samp{(..]}, 2 for @samp{[..)}, or 3 for @samp{[..]}. Please note that in fully rigorous interval arithmetic, care would be taken to make sure that the computation of the lower bound rounds toward minus infinity, while upper bound computations round toward plus infinity. Calc's arithmetic always uses a round-to-nearest mode, which means that roundoff errors could creep into an interval calculation to produce intervals slightly smaller than they ought to be. For example, entering @samp{[1..2]} and pressing @kbd{Q 2 ^} should yield the interval @samp{[1..2]} again, but in fact it yields the (slightly too small) interval @samp{[1..1.9999999]} due to roundoff error. @node Incomplete Objects, Variables, Interval Forms, Data Types @section Incomplete Objects @noindent @c @mindex [ ] @kindex [ @c @mindex ( ) @kindex ( @kindex , @c @mindex @null @kindex ] @c @mindex @null @kindex ) @cindex Incomplete vectors @cindex Incomplete complex numbers @cindex Incomplete interval forms When @kbd{(} or @kbd{[} is typed to begin entering a complex number or vector, respectively, the effect is to push an @dfn{incomplete} complex number or vector onto the stack. The @kbd{,} key adds the value(s) at the top of the stack onto the current incomplete object. The @kbd{)} and @kbd{]} keys ``close'' the incomplete object after adding any values on the top of the stack in front of the incomplete object. As a result, the sequence of keystrokes @kbd{[ 2 , 3 @key{RET} 2 * , 9 ]} pushes the vector @samp{[2, 6, 9]} onto the stack. Likewise, @kbd{( 1 , 2 Q )} pushes the complex number @samp{(1, 1.414)} (approximately). If several values lie on the stack in front of the incomplete object, all are collected and appended to the object. Thus the @kbd{,} key is redundant: @kbd{[ 2 @key{RET} 3 @key{RET} 2 * 9 ]}. Some people prefer the equivalent @key{SPC} key to @key{RET}.@refill As a special case, typing @kbd{,} immediately after @kbd{(}, @kbd{[}, or @kbd{,} adds a zero or duplicates the preceding value in the list being formed. Typing @key{DEL} during incomplete entry removes the last item from the list. @kindex ; The @kbd{;} key is used in the same way as @kbd{,} to create polar complex numbers: @kbd{( 1 ; 2 )}. When entering a vector, @kbd{;} is useful for creating a matrix. In particular, @kbd{[ [ 1 , 2 ; 3 , 4 ; 5 , 6 ] ]} is equivalent to @kbd{[ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ]}. @kindex .. @pindex calc-dots Incomplete entry is also used to enter intervals. For example, @kbd{[ 2 ..@: 4 )} enters a semi-open interval. Note that when you type the first period, it will be interpreted as a decimal point, but when you type a second period immediately afterward, it is re-interpreted as part of the interval symbol. Typing @kbd{..} corresponds to executing the @code{calc-dots} command. If you find incomplete entry distracting, you may wish to enter vectors and complex numbers as algebraic formulas by pressing the apostrophe key. @node Variables, Formulas, Incomplete Objects, Data Types @section Variables @noindent @cindex Variables, in formulas A @dfn{variable} is somewhere between a storage register on a conventional calculator, and a variable in a programming language. (In fact, a Calc variable is really just an Emacs Lisp variable that contains a Calc number or formula.) A variable's name is normally composed of letters and digits. Calc also allows apostrophes and @code{#} signs in variable names. The Calc variable @code{foo} corresponds to the Emacs Lisp variable @code{var-foo}. Commands like @kbd{s s} (@code{calc-store}) that operate on variables can be made to use any arbitrary Lisp variable simply by backspacing over the @samp{var-} prefix in the minibuffer.@refill In a command that takes a variable name, you can either type the full name of a variable, or type a single digit to use one of the special convenience variables @code{var-q0} through @code{var-q9}. For example, @kbd{3 s s 2} stores the number 3 in variable @code{var-q2}, and @w{@kbd{3 s s foo @key{RET}}} stores that number in variable @code{var-foo}.@refill To push a variable itself (as opposed to the variable's value) on the stack, enter its name as an algebraic expression using the apostrophe (@key{'}) key. Variable names in algebraic formulas implicitly have @samp{var-} prefixed to their names. The @samp{#} character in variable names used in algebraic formulas corresponds to a dash @samp{-} in the Lisp variable name. If the name contains any dashes, the prefix @samp{var-} is @emph{not} automatically added. Thus the two formulas @samp{foo + 1} and @samp{var#foo + 1} both refer to the same variable. @kindex = @pindex calc-evaluate @cindex Evaluation of variables in a formula @cindex Variables, evaluation @cindex Formulas, evaluation The @kbd{=} (@code{calc-evaluate}) key ``evaluates'' a formula by replacing all variables in the formula which have been given values by a @code{calc-store} or @code{calc-let} command by their stored values. Other variables are left alone. Thus a variable that has not been stored acts like an abstract variable in algebra; a variable that has been stored acts more like a register in a traditional calculator. With a positive numeric prefix argument, @kbd{=} evaluates the top @var{n} stack entries; with a negative argument, @kbd{=} evaluates the @var{n}th stack entry. @cindex @code{e} variable @cindex @code{pi} variable @cindex @code{i} variable @cindex @code{phi} variable @cindex @code{gamma} variable @vindex e @vindex pi @vindex i @vindex phi @vindex gamma A few variables are called @dfn{special constants}. Their names are @samp{e}, @samp{pi}, @samp{i}, @samp{phi}, and @samp{gamma}. (@xref{Scientific Functions}.) When they are evaluated with @kbd{=}, their values are calculated if necessary according to the current precision or complex polar mode. If you wish to use these symbols for other purposes, simply undefine or redefine them using @code{calc-store}.@refill The variables @samp{inf}, @samp{uinf}, and @samp{nan} stand for infinite or indeterminate values. It's best not to use them as regular variables, since Calc uses special algebraic rules when it manipulates them. Calc displays a warning message if you store a value into any of these special variables. @xref{Store and Recall}, for a discussion of commands dealing with variables. @node Formulas, , Variables, Data Types @section Formulas @noindent @cindex Formulas @cindex Expressions @cindex Operators in formulas @cindex Precedence of operators When you press the apostrophe key you may enter any expression or formula in algebraic form. (Calc uses the terms ``expression'' and ``formula'' interchangeably.) An expression is built up of numbers, variable names, and function calls, combined with various arithmetic operators. Parentheses may be used to indicate grouping. Spaces are ignored within formulas, except that spaces are not permitted within variable names or numbers. Arithmetic operators, in order from highest to lowest precedence, and with their equivalent function names, are: @samp{_} [@code{subscr}] (subscripts); postfix @samp{%} [@code{percent}] (as in @samp{25% = 0.25}); prefix @samp{+} and @samp{-} [@code{neg}] (as in @samp{-x}) and prefix @samp{!} [@code{lnot}] (logical ``not,'' as in @samp{!x}); @samp{+/-} [@code{sdev}] (the standard deviation symbol) and @samp{mod} [@code{makemod}] (the symbol for modulo forms); postfix @samp{!} [@code{fact}] (factorial, as in @samp{n!}) and postfix @samp{!!} [@code{dfact}] (double factorial); @samp{^} [@code{pow}] (raised-to-the-power-of); @samp{*} [@code{mul}]; @samp{/} [@code{div}], @samp{%} [@code{mod}] (modulo), and @samp{\} [@code{idiv}] (integer division); infix @samp{+} [@code{add}] and @samp{-} [@code{sub}] (as in @samp{x-y}); @samp{|} [@code{vconcat}] (vector concatenation); relations @samp{=} [@code{eq}], @samp{!=} [@code{neq}], @samp{<} [@code{lt}], @samp{>} [@code{gt}], @samp{<=} [@code{leq}], and @samp{>=} [@code{geq}]; @samp{&&} [@code{land}] (logical ``and''); @samp{||} [@code{lor}] (logical ``or''); the C-style ``if'' operator @samp{a?b:c} [@code{if}]; @samp{!!!} [@code{pnot}] (rewrite pattern ``not''); @samp{&&&} [@code{pand}] (rewrite pattern ``and''); @samp{|||} [@code{por}] (rewrite pattern ``or''); @samp{:=} [@code{assign}] (for assignments and rewrite rules); @samp{::} [@code{condition}] (rewrite pattern condition); @samp{=>} [@code{evalto}]. Note that, unlike in usual computer notation, multiplication binds more strongly than division: @samp{a*b/c*d} is equivalent to @c{$a b \over c d$} @cite{(a*b)/(c*d)}. @cindex Multiplication, implicit @cindex Implicit multiplication The multiplication sign @samp{*} may be omitted in many cases. In particular, if the righthand side is a number, variable name, or parenthesized expression, the @samp{*} may be omitted. Implicit multiplication has the same precedence as the explicit @samp{*} operator. The one exception to the rule is that a variable name followed by a parenthesized expression, as in @samp{f(x)}, is interpreted as a function call, not an implicit @samp{*}. In many cases you must use a space if you omit the @samp{*}: @samp{2a} is the same as @samp{2*a}, and @samp{a b} is the same as @samp{a*b}, but @samp{ab} is a variable called @code{ab}, @emph{not} the product of @samp{a} and @samp{b}! Also note that @samp{f (x)} is still a function call.@refill @cindex Implicit comma in vectors The rules are slightly different for vectors written with square brackets. In vectors, the space character is interpreted (like the comma) as a separator of elements of the vector. Thus @w{@samp{[ 2a b+c d ]}} is equivalent to @samp{[2*a, b+c, d]}, whereas @samp{2a b+c d} is equivalent to @samp{2*a*b + c*d}. Note that spaces around the brackets, and around explicit commas, are ignored. To force spaces to be interpreted as multiplication you can enclose a formula in parentheses as in @samp{[(a b) 2(c d)]}, which is interpreted as @samp{[a*b, 2*c*d]}. An implicit comma is also inserted between @samp{][}, as in the matrix @samp{[[1 2][3 4]]}.@refill Vectors that contain commas (not embedded within nested parentheses or brackets) do not treat spaces specially: @samp{[a b, 2 c d]} is a vector of two elements. Also, if it would be an error to treat spaces as separators, but not otherwise, then Calc will ignore spaces: @w{@samp{[a - b]}} is a vector of one element, but @w{@samp{[a -b]}} is a vector of two elements. Finally, vectors entered with curly braces instead of square brackets do not give spaces any special treatment. When Calc displays a vector that does not contain any commas, it will insert parentheses if necessary to make the meaning clear: @w{@samp{[(a b)]}}. The expression @samp{5%-2} is ambiguous; is this five-percent minus two, or five modulo minus-two? Calc always interprets the leftmost symbol as an infix operator preferentially (modulo, in this case), so you would need to write @samp{(5%)-2} to get the former interpretation. @cindex Function call notation A function call is, e.g., @samp{sin(1+x)}. Function names follow the same rules as variable names except that the default prefix @samp{calcFunc-} is used (instead of @samp{var-}) for the internal Lisp form. Most mathematical Calculator commands like @code{calc-sin} have function equivalents like @code{sin}. If no Lisp function is defined for a function called by a formula, the call is left as it is during algebraic manipulation: @samp{f(x+y)} is left alone. Beware that many innocent-looking short names like @code{in} and @code{re} have predefined meanings which could surprise you; however, single letters or single letters followed by digits are always safe to use for your own function names. @xref{Function Index}.@refill In the documentation for particular commands, the notation @kbd{H S} (@code{calc-sinh}) [@code{sinh}] means that the key sequence @kbd{H S}, the command @kbd{M-x calc-sinh}, and the algebraic function @code{sinh(x)} all represent the same operation.@refill Commands that interpret (``parse'') text as algebraic formulas include algebraic entry (@kbd{'}), editing commands like @kbd{`} which parse the contents of the editing buffer when you finish, the @kbd{M-# g} and @w{@kbd{M-# r}} commands, the @kbd{C-y} command, the X window system ``paste'' mouse operation, and Embedded Mode. All of these operations use the same rules for parsing formulas; in particular, language modes (@pxref{Language Modes}) affect them all in the same way. When you read a large amount of text into the Calculator (say a vector which represents a big set of rewrite rules; @pxref{Rewrite Rules}), you may wish to include comments in the text. Calc's formula parser ignores the symbol @samp{%%} and anything following it on a line: @example [ a + b, %% the sum of "a" and "b" c + d, %% last line is coming up: e + f ] @end example @noindent This is parsed exactly the same as @samp{[ a + b, c + d, e + f ]}. @xref{Syntax Tables}, for a way to create your own operators and other input notations. @xref{Compositions}, for a way to create new display formats. @xref{Algebra}, for commands for manipulating formulas symbolically. @node Stack and Trail, Mode Settings, Data Types, Top @chapter Stack and Trail Commands @noindent This chapter describes the Calc commands for manipulating objects on the stack and in the trail buffer. (These commands operate on objects of any type, such as numbers, vectors, formulas, and incomplete objects.) @menu * Stack Manipulation:: * Editing Stack Entries:: * Trail Commands:: * Keep Arguments:: @end menu @node Stack Manipulation, Editing Stack Entries, Stack and Trail, Stack and Trail @section Stack Manipulation Commands @noindent @kindex RET @kindex SPC @pindex calc-enter @cindex Duplicating stack entries To duplicate the top object on the stack, press @key{RET} or @key{SPC} (two equivalent keys for the @code{calc-enter} command). Given a positive numeric prefix argument, these commands duplicate several elements at the top of the stack. Given a negative argument, these commands duplicate the specified element of the stack. Given an argument of zero, they duplicate the entire stack. For example, with @samp{10 20 30} on the stack, @key{RET} creates @samp{10 20 30 30}, @kbd{C-u 2 @key{RET}} creates @samp{10 20 30 20 30}, @kbd{C-u - 2 @key{RET}} creates @samp{10 20 30 20}, and @kbd{C-u 0 @key{RET}} creates @samp{10 20 30 10 20 30}.@refill @kindex LFD @pindex calc-over The @key{LFD} (@code{calc-over}) command (on a key marked Line-Feed if you have it, else on @kbd{C-j}) is like @code{calc-enter} except that the sign of the numeric prefix argument is interpreted oppositely. Also, with no prefix argument the default argument is 2. Thus with @samp{10 20 30} on the stack, @key{LFD} and @kbd{C-u 2 @key{LFD}} are both equivalent to @kbd{C-u - 2 @key{RET}}, producing @samp{10 20 30 20}.@refill @kindex DEL @kindex C-d @pindex calc-pop @cindex Removing stack entries @cindex Deleting stack entries To remove the top element from the stack, press @key{DEL} (@code{calc-pop}). The @kbd{C-d} key is a synonym for @key{DEL}. (If the top element is an incomplete object with at least one element, the last element is removed from it.) Given a positive numeric prefix argument, several elements are removed. Given a negative argument, the specified element of the stack is deleted. Given an argument of zero, the entire stack is emptied. For example, with @samp{10 20 30} on the stack, @key{DEL} leaves @samp{10 20}, @kbd{C-u 2 @key{DEL}} leaves @samp{10}, @kbd{C-u - 2 @key{DEL}} leaves @samp{10 30}, and @kbd{C-u 0 @key{DEL}} leaves an empty stack.@refill @kindex M-DEL @pindex calc-pop-above The @key{M-DEL} (@code{calc-pop-above}) command is to @key{DEL} what @key{LFD} is to @key{RET}: It interprets the sign of the numeric prefix argument in the opposite way, and the default argument is 2. Thus @key{M-DEL} by itself removes the second-from-top stack element, leaving the first, third, fourth, and so on; @kbd{M-3 M-DEL} deletes the third stack element. @kindex TAB @pindex calc-roll-down To exchange the top two elements of the stack, press @key{TAB} (@code{calc-roll-down}). Given a positive numeric prefix argument, the specified number of elements at the top of the stack are rotated downward. Given a negative argument, the entire stack is rotated downward the specified number of times. Given an argument of zero, the entire stack is reversed top-for-bottom. For example, with @samp{10 20 30 40 50} on the stack, @key{TAB} creates @samp{10 20 30 50 40}, @kbd{C-u 3 @key{TAB}} creates @samp{10 20 50 30 40}, @kbd{C-u - 2 @key{TAB}} creates @samp{40 50 10 20 30}, and @kbd{C-u 0 @key{TAB}} creates @samp{50 40 30 20 10}.@refill @kindex M-TAB @pindex calc-roll-up The command @key{M-TAB} (@code{calc-roll-up}) is analogous to @key{TAB} except that it rotates upward instead of downward. Also, the default with no prefix argument is to rotate the top 3 elements. For example, with @samp{10 20 30 40 50} on the stack, @key{M-TAB} creates @samp{10 20 40 50 30}, @kbd{C-u 4 @key{M-TAB}} creates @samp{10 30 40 50 20}, @kbd{C-u - 2 @key{M-TAB}} creates @samp{30 40 50 10 20}, and @kbd{C-u 0 @key{M-TAB}} creates @samp{50 40 30 20 10}.@refill A good way to view the operation of @key{TAB} and @key{M-TAB} is in terms of moving a particular element to a new position in the stack. With a positive argument @i{n}, @key{TAB} moves the top stack element down to level @i{n}, making room for it by pulling all the intervening stack elements toward the top. @key{M-TAB} moves the element at level @i{n} up to the top. (Compare with @key{LFD}, which copies instead of moving the element in level @i{n}.) With a negative argument @i{-n}, @key{TAB} rotates the stack to move the object in level @i{n} to the deepest place in the stack, and the object in level @i{n+1} to the top. @key{M-TAB} rotates the deepest stack element to be in level @i{n}, also putting the top stack element in level @i{n+1}. @xref{Selecting Subformulas}, for a way to apply these commands to any portion of a vector or formula on the stack. @node Editing Stack Entries, Trail Commands, Stack Manipulation, Stack and Trail @section Editing Stack Entries @noindent @kindex ` @pindex calc-edit @pindex calc-edit-finish @cindex Editing the stack with Emacs The backquote, @kbd{`} (@code{calc-edit}) command creates a temporary buffer (@samp{*Calc Edit*}) for editing the top-of-stack value using regular Emacs commands. With a numeric prefix argument, it edits the specified number of stack entries at once. (An argument of zero edits the entire stack; a negative argument edits one specific stack entry.) When you are done editing, press @kbd{M-# M-#} to finish and return to Calc. The @key{RET} and @key{LFD} keys also work to finish most sorts of editing, though in some cases Calc leaves @key{RET} with its usual meaning (``insert a newline'') if it's a situation where you might want to insert new lines into the editing buffer. The traditional Emacs ``finish'' key sequence, @kbd{C-c C-c}, also works to finish editing and may be easier to type, depending on your keyboard. When you finish editing, the Calculator parses the lines of text in the @samp{*Calc Edit*} buffer as numbers or formulas, replaces the original stack elements in the original buffer with these new values, then kills the @samp{*Calc Edit*} buffer. The original Calculator buffer continues to exist during editing, but for best results you should be careful not to change it until you have finished the edit. You can also cancel the edit by pressing @kbd{M-# x}. The formula is normally reevaluated as it is put onto the stack. For example, editing @samp{a + 2} to @samp{3 + 2} and pressing @kbd{M-# M-#} will push 5 on the stack. If you use @key{LFD} to finish, Calc will put the result on the stack without evaluating it. If you give a prefix argument to @kbd{M-# M-#} (or @kbd{C-c C-c}), Calc will not kill the @samp{*Calc Edit*} buffer. You can switch back to that buffer and continue editing if you wish. However, you should understand that if you initiated the edit with @kbd{`}, the @kbd{M-# M-#} operation will be programmed to replace the top of the stack with the new edited value, and it will do this even if you have rearranged the stack in the meanwhile. This is not so much of a problem with other editing commands, though, such as @kbd{s e} (@code{calc-edit-variable}; @pxref{Operations on Variables}). If the @code{calc-edit} command involves more than one stack entry, each line of the @samp{*Calc Edit*} buffer is interpreted as a separate formula. Otherwise, the entire buffer is interpreted as one formula, with line breaks ignored. (You can use @kbd{C-o} or @kbd{C-q C-j} to insert a newline in the buffer without pressing @key{RET}.) The @kbd{`} key also works during numeric or algebraic entry. The text entered so far is moved to the @code{*Calc Edit*} buffer for more extensive editing than is convenient in the minibuffer. @node Trail Commands, Keep Arguments, Editing Stack Entries, Stack and Trail @section Trail Commands @noindent @cindex Trail buffer The commands for manipulating the Calc Trail buffer are two-key sequences beginning with the @kbd{t} prefix. @kindex t d @pindex calc-trail-display The @kbd{t d} (@code{calc-trail-display}) command turns display of the trail on and off. Normally the trail display is toggled on if it was off, off if it was on. With a numeric prefix of zero, this command always turns the trail off; with a prefix of one, it always turns the trail on. The other trail-manipulation commands described here automatically turn the trail on. Note that when the trail is off values are still recorded there; they are simply not displayed. To set Emacs to turn the trail off by default, type @kbd{t d} and then save the mode settings with @kbd{m m} (@code{calc-save-modes}). @kindex t i @pindex calc-trail-in @kindex t o @pindex calc-trail-out The @kbd{t i} (@code{calc-trail-in}) and @kbd{t o} (@code{calc-trail-out}) commands switch the cursor into and out of the Calc Trail window. In practice they are rarely used, since the commands shown below are a more convenient way to move around in the trail, and they work ``by remote control'' when the cursor is still in the Calculator window.@refill @cindex Trail pointer There is a @dfn{trail pointer} which selects some entry of the trail at any given time. The trail pointer looks like a @samp{>} symbol right before the selected number. The following commands operate on the trail pointer in various ways. @kindex t y @pindex calc-trail-yank @cindex Retrieving previous results The @kbd{t y} (@code{calc-trail-yank}) command reads the selected value in the trail and pushes it onto the Calculator stack. It allows you to re-use any previously computed value without retyping. With a numeric prefix argument @var{n}, it yanks the value @var{n} lines above the current trail pointer. @kindex t < @pindex calc-trail-scroll-left @kindex t > @pindex calc-trail-scroll-right The @kbd{t <} (@code{calc-trail-scroll-left}) and @kbd{t >} (@code{calc-trail-scroll-right}) commands horizontally scroll the trail window left or right by one half of its width.@refill @kindex t n @pindex calc-trail-next @kindex t p @pindex calc-trail-previous @kindex t f @pindex calc-trail-forward @kindex t b @pindex calc-trail-backward The @kbd{t n} (@code{calc-trail-next}) and @kbd{t p} (@code{calc-trail-previous)} commands move the trail pointer down or up one line. The @kbd{t f} (@code{calc-trail-forward}) and @kbd{t b} (@code{calc-trail-backward}) commands move the trail pointer down or up one screenful at a time. All of these commands accept numeric prefix arguments to move several lines or screenfuls at a time.@refill @kindex t [ @pindex calc-trail-first @kindex t ] @pindex calc-trail-last @kindex t h @pindex calc-trail-here The @kbd{t [} (@code{calc-trail-first}) and @kbd{t ]} (@code{calc-trail-last}) commands move the trail pointer to the first or last line of the trail. The @kbd{t h} (@code{calc-trail-here}) command moves the trail pointer to the cursor position; unlike the other trail commands, @kbd{t h} works only when Calc Trail is the selected window.@refill @kindex t s @pindex calc-trail-isearch-forward @kindex t r @pindex calc-trail-isearch-backward @ifinfo The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r} (@code{calc-trail-isearch-backward}) commands perform an incremental search forward or backward through the trail. You can press @key{RET} to terminate the search; the trail pointer moves to the current line. If you cancel the search with @kbd{C-g}, the trail pointer stays where it was when the search began.@refill @end ifinfo @tex The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r} (@code{calc-trail-isearch-backward}) com\-mands perform an incremental search forward or backward through the trail. You can press @key{RET} to terminate the search; the trail pointer moves to the current line. If you cancel the search with @kbd{C-g}, the trail pointer stays where it was when the search began. @end tex @kindex t m @pindex calc-trail-marker The @kbd{t m} (@code{calc-trail-marker}) command allows you to enter a line of text of your own choosing into the trail. The text is inserted after the line containing the trail pointer; this usually means it is added to the end of the trail. Trail markers are useful mainly as the targets for later incremental searches in the trail. @kindex t k @pindex calc-trail-kill The @kbd{t k} (@code{calc-trail-kill}) command removes the selected line from the trail. The line is saved in the Emacs kill ring suitable for yanking into another buffer, but it is not easy to yank the text back into the trail buffer. With a numeric prefix argument, this command kills the @var{n} lines below or above the selected one. The @kbd{t .} (@code{calc-full-trail-vectors}) command is described elsewhere; @pxref{Vector and Matrix Formats}. @node Keep Arguments, , Trail Commands, Stack and Trail @section Keep Arguments @noindent @kindex K @pindex calc-keep-args The @kbd{K} (@code{calc-keep-args}) command acts like a prefix for the following command. It prevents that command from removing its arguments from the stack. For example, after @kbd{2 @key{RET} 3 +}, the stack contains the sole number 5, but after @kbd{2 @key{RET} 3 K +}, the stack contains the arguments and the result: @samp{2 3 5}. This works for all commands that take arguments off the stack. As another example, @kbd{K a s} simplifies a formula, pushing the simplified version of the formula onto the stack after the original formula (rather than replacing the original formula). Note that you could get the same effect by typing @kbd{RET a s}, copying the formula and then simplifying the copy. One difference is that for a very large formula the time taken to format the intermediate copy in @kbd{RET a s} could be noticeable; @kbd{K a s} would avoid this extra work. Even stack manipulation commands are affected. @key{TAB} works by popping two values and pushing them back in the opposite order, so @kbd{2 @key{RET} 3 K @key{TAB}} produces @samp{2 3 3 2}. A few Calc commands provide other ways of doing the same thing. For example, @kbd{' sin($)} replaces the number on the stack with its sine using algebraic entry; to push the sine and keep the original argument you could use either @kbd{' sin($1)} or @kbd{K ' sin($)}. @xref{Algebraic Entry}. Also, the @kbd{s s} command is effectively the same as @kbd{K s t}. @xref{Storing Variables}. Keyboard macros may interact surprisingly with the @kbd{K} prefix. If you have defined a keyboard macro to be, say, @samp{Q +} to add one number to the square root of another, then typing @kbd{K X} will execute @kbd{K Q +}, probably not what you expected. The @kbd{K} prefix will apply to just the first command in the macro rather than the whole macro. If you execute a command and then decide you really wanted to keep the argument, you can press @kbd{M-@key{RET}} (@code{calc-last-args}). This command pushes the last arguments that were popped by any command onto the stack. Note that the order of things on the stack will be different than with @kbd{K}: @kbd{2 @key{RET} 3 + M-@key{RET}} leaves @samp{5 2 3} on the stack instead of @samp{2 3 5}. @xref{Undo}. @node Mode Settings, Arithmetic, Stack and Trail, Top @chapter Mode Settings @noindent This chapter describes commands that set modes in the Calculator. They do not affect the contents of the stack, although they may change the @emph{appearance} or @emph{interpretation} of the stack's contents. @menu * General Mode Commands:: * Precision:: * Inverse and Hyperbolic:: * Calculation Modes:: * Simplification Modes:: * Declarations:: * Display Modes:: * Language Modes:: * Modes Variable:: * Calc Mode Line:: @end menu @node General Mode Commands, Precision, Mode Settings, Mode Settings @section General Mode Commands @noindent @kindex m m @pindex calc-save-modes @cindex Continuous memory @cindex Saving mode settings @cindex Permanent mode settings @cindex @file{.emacs} file, mode settings You can save all of the current mode settings in your @file{.emacs} file with the @kbd{m m} (@code{calc-save-modes}) command. This will cause Emacs to reestablish these modes each time it starts up. The modes saved in the file include everything controlled by the @kbd{m} and @kbd{d} prefix keys, the current precision and binary word size, whether or not the trail is displayed, the current height of the Calc window, and more. The current interface (used when you type @kbd{M-# M-#}) is also saved. If there were already saved mode settings in the file, they are replaced. Otherwise, the new mode information is appended to the end of the file. @kindex m R @pindex calc-mode-record-mode The @kbd{m R} (@code{calc-mode-record-mode}) command tells Calc to record the new mode settings (as if by pressing @kbd{m m}) every time a mode setting changes. If Embedded Mode is enabled, other options are available; @pxref{Mode Settings in Embedded Mode}. @kindex m F @pindex calc-settings-file-name The @kbd{m F} (@code{calc-settings-file-name}) command allows you to choose a different place than your @file{.emacs} file for @kbd{m m}, @kbd{Z P}, and similar commands to save permanent information. You are prompted for a file name. All Calc modes are then reset to their default values, then settings from the file you named are loaded if this file exists, and this file becomes the one that Calc will use in the future for commands like @kbd{m m}. The default settings file name is @file{~/.emacs}. You can see the current file name by giving a blank response to the @kbd{m F} prompt. See also the discussion of the @code{calc-settings-file} variable; @pxref{Installation}. If the file name you give contains the string @samp{.emacs} anywhere inside it, @kbd{m F} will not automatically load the new file. This is because you are presumably switching to your @file{~/.emacs} file, which may contain other things you don't want to reread. You can give a numeric prefix argument of 1 to @kbd{m F} to force it to read the file no matter what its name. Conversely, an argument of @i{-1} tells @kbd{m F} @emph{not} to read the new file. An argument of 2 or @i{-2} tells @kbd{m F} not to reset the modes to their defaults beforehand, which is useful if you intend your new file to have a variant of the modes present in the file you were using before. @kindex m x @pindex calc-always-load-extensions The @kbd{m x} (@code{calc-always-load-extensions}) command enables a mode in which the first use of Calc loads the entire program, including all extensions modules. Otherwise, the extensions modules will not be loaded until the various advanced Calc features are used. Since this mode only has effect when Calc is first loaded, @kbd{m x} is usually followed by @kbd{m m} to make the mode-setting permanent. To load all of Calc just once, rather than always in the future, you can press @kbd{M-# L}. @kindex m S @pindex calc-shift-prefix The @kbd{m S} (@code{calc-shift-prefix}) command enables a mode in which all of Calc's letter prefix keys may be typed shifted as well as unshifted. If you are typing, say, @kbd{a S} (@code{calc-solve-for}) quite often you might find it easier to turn this mode on so that you can type @kbd{A S} instead. When this mode is enabled, the commands that used to be on those single shifted letters (e.g., @kbd{A} (@code{calc-abs})) can now be invoked by pressing the shifted letter twice: @kbd{A A}. Note that the @kbd{v} prefix key always works both shifted and unshifted, and the @kbd{z} and @kbd{Z} prefix keys are always distinct. Also, the @kbd{h} prefix is not affected by this mode. Press @kbd{m S} again to disable shifted-prefix mode. @node Precision, Inverse and Hyperbolic, General Mode Commands, Mode Settings @section Precision @noindent @kindex p @pindex calc-precision @cindex Precision of calculations The @kbd{p} (@code{calc-precision}) command controls the precision to which floating-point calculations are carried. The precision must be at least 3 digits and may be arbitrarily high, within the limits of memory and time. This affects only floats: Integer and rational calculations are always carried out with as many digits as necessary. The @kbd{p} key prompts for the current precision. If you wish you can instead give the precision as a numeric prefix argument. Many internal calculations are carried to one or two digits higher precision than normal. Results are rounded down afterward to the current precision. Unless a special display mode has been selected, floats are always displayed with their full stored precision, i.e., what you see is what you get. Reducing the current precision does not round values already on the stack, but those values will be rounded down before being used in any calculation. The @kbd{c 0} through @kbd{c 9} commands (@pxref{Conversions}) can be used to round an existing value to a new precision.@refill @cindex Accuracy of calculations It is important to distinguish the concepts of @dfn{precision} and @dfn{accuracy}. In the normal usage of these words, the number 123.4567 has a precision of 7 digits but an accuracy of 4 digits. The precision is the total number of digits not counting leading or trailing zeros (regardless of the position of the decimal point). The accuracy is simply the number of digits after the decimal point (again not counting trailing zeros). In Calc you control the precision, not the accuracy of computations. If you were to set the accuracy instead, then calculations like @samp{exp(100)} would generate many more digits than you would typically need, while @samp{exp(-100)} would probably round to zero! In Calc, both these computations give you exactly 12 (or the requested number of) significant digits. The only Calc features that deal with accuracy instead of precision are fixed-point display mode for floats (@kbd{d f}; @pxref{Float Formats}), and the rounding functions like @code{floor} and @code{round} (@pxref{Integer Truncation}). Also, @kbd{c 0} through @kbd{c 9} deal with both precision and accuracy depending on the magnitudes of the numbers involved. If you need to work with a particular fixed accuracy (say, dollars and cents with two digits after the decimal point), one solution is to work with integers and an ``implied'' decimal point. For example, $8.99 divided by 6 would be entered @kbd{899 RET 6 /}, yielding 149.833 (actually $1.49833 with our implied decimal point); pressing @kbd{R} would round this to 150 cents, i.e., $1.50. @xref{Floats}, for still more on floating-point precision and related issues. @node Inverse and Hyperbolic, Calculation Modes, Precision, Mode Settings @section Inverse and Hyperbolic Flags @noindent @kindex I @pindex calc-inverse There is no single-key equivalent to the @code{calc-arcsin} function. Instead, you must first press @kbd{I} (@code{calc-inverse}) to set the @dfn{Inverse Flag}, then press @kbd{S} (@code{calc-sin}). The @kbd{I} key actually toggles the Inverse Flag. When this flag is set, the word @samp{Inv} appears in the mode line.@refill @kindex H @pindex calc-hyperbolic Likewise, the @kbd{H} key (@code{calc-hyperbolic}) sets or clears the Hyperbolic Flag, which transforms @code{calc-sin} into @code{calc-sinh}. If both of these flags are set at once, the effect will be @code{calc-arcsinh}. (The Hyperbolic flag is also used by some non-trigonometric commands; for example @kbd{H L} computes a base-10, instead of base-@i{e}, logarithm.)@refill Command names like @code{calc-arcsin} are provided for completeness, and may be executed with @kbd{x} or @kbd{M-x}. Their effect is simply to toggle the Inverse and/or Hyperbolic flags and then execute the corresponding base command (@code{calc-sin} in this case). The Inverse and Hyperbolic flags apply only to the next Calculator command, after which they are automatically cleared. (They are also cleared if the next keystroke is not a Calc command.) Digits you type after @kbd{I} or @kbd{H} (or @kbd{K}) are treated as prefix arguments for the next command, not as numeric entries. The same is true of @kbd{C-u}, but not of the minus sign (@kbd{K -} means to subtract and keep arguments). The third Calc prefix flag, @kbd{K} (keep-arguments), is discussed elsewhere. @xref{Keep Arguments}. @node Calculation Modes, Simplification Modes, Inverse and Hyperbolic, Mode Settings @section Calculation Modes @noindent The commands in this section are two-key sequences beginning with the @kbd{m} prefix. (That's the letter @kbd{m}, not the @key{META} key.) The @samp{m a} (@code{calc-algebraic-mode}) command is described elsewhere (@pxref{Algebraic Entry}). @menu * Angular Modes:: * Polar Mode:: * Fraction Mode:: * Infinite Mode:: * Symbolic Mode:: * Matrix Mode:: * Automatic Recomputation:: * Working Message:: @end menu @node Angular Modes, Polar Mode, Calculation Modes, Calculation Modes @subsection Angular Modes @noindent @cindex Angular mode The Calculator supports three notations for angles: radians, degrees, and degrees-minutes-seconds. When a number is presented to a function like @code{sin} that requires an angle, the current angular mode is used to interpret the number as either radians or degrees. If an HMS form is presented to @code{sin}, it is always interpreted as degrees-minutes-seconds. Functions that compute angles produce a number in radians, a number in degrees, or an HMS form depending on the current angular mode. If the result is a complex number and the current mode is HMS, the number is instead expressed in degrees. (Complex-number calculations would normally be done in radians mode, though. Complex numbers are converted to degrees by calculating the complex result in radians and then multiplying by 180 over @c{$\pi$} @cite{pi}.) @kindex m r @pindex calc-radians-mode @kindex m d @pindex calc-degrees-mode @kindex m h @pindex calc-hms-mode The @kbd{m r} (@code{calc-radians-mode}), @kbd{m d} (@code{calc-degrees-mode}), and @kbd{m h} (@code{calc-hms-mode}) commands control the angular mode. The current angular mode is displayed on the Emacs mode line. The default angular mode is degrees.@refill @node Polar Mode, Fraction Mode, Angular Modes, Calculation Modes @subsection Polar Mode @noindent @cindex Polar mode The Calculator normally ``prefers'' rectangular complex numbers in the sense that rectangular form is used when the proper form can not be decided from the input. This might happen by multiplying a rectangular number by a polar one, by taking the square root of a negative real number, or by entering @kbd{( 2 @key{SPC} 3 )}. @kindex m p @pindex calc-polar-mode The @kbd{m p} (@code{calc-polar-mode}) command toggles complex-number preference between rectangular and polar forms. In polar mode, all of the above example situations would produce polar complex numbers. @node Fraction Mode, Infinite Mode, Polar Mode, Calculation Modes @subsection Fraction Mode @noindent @cindex Fraction mode @cindex Division of integers Division of two integers normally yields a floating-point number if the result cannot be expressed as an integer. In some cases you would rather get an exact fractional answer. One way to accomplish this is to multiply fractions instead: @kbd{6 @key{RET} 1:4 *} produces @cite{3:2} even though @kbd{6 @key{RET} 4 /} produces @cite{1.5}. @kindex m f @pindex calc-frac-mode To set the Calculator to produce fractional results for normal integer divisions, use the @kbd{m f} (@code{calc-frac-mode}) command. For example, @cite{8/4} produces @cite{2} in either mode, but @cite{6/4} produces @cite{3:2} in Fraction Mode, @cite{1.5} in Float Mode.@refill At any time you can use @kbd{c f} (@code{calc-float}) to convert a fraction to a float, or @kbd{c F} (@code{calc-fraction}) to convert a float to a fraction. @xref{Conversions}. @node Infinite Mode, Symbolic Mode, Fraction Mode, Calculation Modes @subsection Infinite Mode @noindent @cindex Infinite mode The Calculator normally treats results like @cite{1 / 0} as errors; formulas like this are left in unsimplified form. But Calc can be put into a mode where such calculations instead produce ``infinite'' results. @kindex m i @pindex calc-infinite-mode The @kbd{m i} (@code{calc-infinite-mode}) command turns this mode on and off. When the mode is off, infinities do not arise except in calculations that already had infinities as inputs. (One exception is that infinite open intervals like @samp{[0 .. inf)} can be generated; however, intervals closed at infinity (@samp{[0 .. inf]}) will not be generated when infinite mode is off.) With infinite mode turned on, @samp{1 / 0} will generate @code{uinf}, an undirected infinity. @xref{Infinities}, for a discussion of the difference between @code{inf} and @code{uinf}. Also, @cite{0 / 0} evaluates to @code{nan}, the ``indeterminate'' symbol. Various other functions can also return infinities in this mode; for example, @samp{ln(0) = -inf}, and @samp{gamma(-7) = uinf}. Once again, note that @samp{exp(inf) = inf} regardless of infinite mode because this calculation has infinity as an input. @cindex Positive infinite mode The @kbd{m i} command with a numeric prefix argument of zero, i.e., @kbd{C-u 0 m i}, turns on a ``positive infinite mode'' in which zero is treated as positive instead of being directionless. Thus, @samp{1 / 0 = inf} and @samp{-1 / 0 = -inf} in this mode. Note that zero never actually has a sign in Calc; there are no separate representations for @i{+0} and @i{-0}. Positive infinite mode merely changes the interpretation given to the single symbol, @samp{0}. One consequence of this is that, while you might expect @samp{1 / -0 = -inf}, actually @samp{1 / -0} is equivalent to @samp{1 / 0}, which is equal to positive @code{inf}. @node Symbolic Mode, Matrix Mode, Infinite Mode, Calculation Modes @subsection Symbolic Mode @noindent @cindex Symbolic mode @cindex Inexact results Calculations are normally performed numerically wherever possible. For example, the @code{calc-sqrt} command, or @code{sqrt} function in an algebraic expression, produces a numeric answer if the argument is a number or a symbolic expression if the argument is an expression: @kbd{2 Q} pushes 1.4142 but @kbd{@key{'} x+1 @key{RET} Q} pushes @samp{sqrt(x+1)}. @kindex m s @pindex calc-symbolic-mode In @dfn{symbolic mode}, controlled by the @kbd{m s} (@code{calc-symbolic-mode}) command, functions which would produce inexact, irrational results are left in symbolic form. Thus @kbd{16 Q} pushes 4, but @kbd{2 Q} pushes @samp{sqrt(2)}. @kindex N @pindex calc-eval-num The shift-@kbd{N} (@code{calc-eval-num}) command evaluates numerically the expression at the top of the stack, by temporarily disabling @code{calc-symbolic-mode} and executing @kbd{=} (@code{calc-evaluate}). Given a numeric prefix argument, it also sets the floating-point precision to the specified value for the duration of the command.@refill To evaluate a formula numerically without expanding the variables it contains, you can use the key sequence @kbd{m s a v m s} (this uses @code{calc-alg-evaluate}, which resimplifies but doesn't evaluate variables.) @node Matrix Mode, Automatic Recomputation, Symbolic Mode, Calculation Modes @subsection Matrix and Scalar Modes @noindent @cindex Matrix mode @cindex Scalar mode Calc sometimes makes assumptions during algebraic manipulation that are awkward or incorrect when vectors and matrices are involved. Calc has two modes, @dfn{matrix mode} and @dfn{scalar mode}, which modify its behavior around vectors in useful ways. @kindex m v @pindex calc-matrix-mode Press @kbd{m v} (@code{calc-matrix-mode}) once to enter matrix mode. In this mode, all objects are assumed to be matrices unless provably otherwise. One major effect is that Calc will no longer consider multiplication to be commutative. (Recall that in matrix arithmetic, @samp{A*B} is not the same as @samp{B*A}.) This assumption affects rewrite rules and algebraic simplification. Another effect of this mode is that calculations that would normally produce constants like 0 and 1 (e.g., @cite{a - a} and @cite{a / a}, respectively) will now produce function calls that represent ``generic'' zero or identity matrices: @samp{idn(0)}, @samp{idn(1)}. The @code{idn} function @samp{idn(@var{a},@var{n})} returns @var{a} times an @var{n}x@var{n} identity matrix; if @var{n} is omitted, it doesn't know what dimension to use and so the @code{idn} call remains in symbolic form. However, if this generic identity matrix is later combined with a matrix whose size is known, it will be converted into a true identity matrix of the appropriate size. On the other hand, if it is combined with a scalar (as in @samp{idn(1) + 2}), Calc will assume it really was a scalar after all and produce, e.g., 3. Press @kbd{m v} a second time to get scalar mode. Here, objects are assumed @emph{not} to be vectors or matrices unless provably so. For example, normally adding a variable to a vector, as in @samp{[x, y, z] + a}, will leave the sum in symbolic form because as far as Calc knows, @samp{a} could represent either a number or another 3-vector. In scalar mode, @samp{a} is assumed to be a non-vector, and the addition is evaluated to @samp{[x+a, y+a, z+a]}. Press @kbd{m v} a third time to return to the normal mode of operation. If you press @kbd{m v} with a numeric prefix argument @var{n}, you get a special ``dimensioned matrix mode'' in which matrices of unknown size are assumed to be @var{n}x@var{n} square matrices. Then, the function call @samp{idn(1)} will expand into an actual matrix rather than representing a ``generic'' matrix. @cindex Declaring scalar variables Of course these modes are approximations to the true state of affairs, which is probably that some quantities will be matrices and others will be scalars. One solution is to ``declare'' certain variables or functions to be scalar-valued. @xref{Declarations}, to see how to make declarations in Calc. There is nothing stopping you from declaring a variable to be scalar and then storing a matrix in it; however, if you do, the results you get from Calc may not be valid. Suppose you let Calc get the result @samp{[x+a, y+a, z+a]} shown above, and then stored @samp{[1, 2, 3]} in @samp{a}. The result would not be the same as for @samp{[x, y, z] + [1, 2, 3]}, but that's because you have broken your earlier promise to Calc that @samp{a} would be scalar. Another way to mix scalars and matrices is to use selections (@pxref{Selecting Subformulas}). Use matrix mode when operating on your formula normally; then, to apply scalar mode to a certain part of the formula without affecting the rest just select that part, change into scalar mode and press @kbd{=} to resimplify the part under this mode, then change back to matrix mode before deselecting. @node Automatic Recomputation, Working Message, Matrix Mode, Calculation Modes @subsection Automatic Recomputation @noindent The @dfn{evaluates-to} operator, @samp{=>}, has the special property that any @samp{=>} formulas on the stack are recomputed whenever variable values or mode settings that might affect them are changed. @xref{Evaluates-To Operator}. @kindex m C @pindex calc-auto-recompute The @kbd{m C} (@code{calc-auto-recompute}) command turns this automatic recomputation on and off. If you turn it off, Calc will not update @samp{=>} operators on the stack (nor those in the attached Embedded Mode buffer, if there is one). They will not be updated unless you explicitly do so by pressing @kbd{=} or until you press @kbd{m C} to turn recomputation back on. (While automatic recomputation is off, you can think of @kbd{m C m C} as a command to update all @samp{=>} operators while leaving recomputation off.) To update @samp{=>} operators in an Embedded buffer while automatic recomputation is off, use @w{@kbd{M-# u}}. @xref{Embedded Mode}. @node Working Message, , Automatic Recomputation, Calculation Modes @subsection Working Messages @noindent @cindex Performance @cindex Working messages Since the Calculator is written entirely in Emacs Lisp, which is not designed for heavy numerical work, many operations are quite slow. The Calculator normally displays the message @samp{Working...} in the echo area during any command that may be slow. In addition, iterative operations such as square roots and trigonometric functions display the intermediate result at each step. Both of these types of messages can be disabled if you find them distracting. @kindex m w @pindex calc-working Type @kbd{m w} (@code{calc-working}) with a numeric prefix of 0 to disable all ``working'' messages. Use a numeric prefix of 1 to enable only the plain @samp{Working...} message. Use a numeric prefix of 2 to see intermediate results as well. With no numeric prefix this displays the current mode.@refill While it may seem that the ``working'' messages will slow Calc down considerably, experiments have shown that their impact is actually quite small. But if your terminal is slow you may find that it helps to turn the messages off. @node Simplification Modes, Declarations, Calculation Modes, Mode Settings @section Simplification Modes @noindent The current @dfn{simplification mode} controls how numbers and formulas are ``normalized'' when being taken from or pushed onto the stack. Some normalizations are unavoidable, such as rounding floating-point results to the current precision, and reducing fractions to simplest form. Others, such as simplifying a formula like @cite{a+a} (or @cite{2+3}), are done by default but can be turned off when necessary. When you press a key like @kbd{+} when @cite{2} and @cite{3} are on the stack, Calc pops these numbers, normalizes them, creates the formula @cite{2+3}, normalizes it, and pushes the result. Of course the standard rules for normalizing @cite{2+3} will produce the result @cite{5}. Simplification mode commands consist of the lower-case @kbd{m} prefix key followed by a shifted letter. @kindex m O @pindex calc-no-simplify-mode The @kbd{m O} (@code{calc-no-simplify-mode}) command turns off all optional simplifications. These would leave a formula like @cite{2+3} alone. In fact, nothing except simple numbers are ever affected by normalization in this mode. @kindex m N @pindex calc-num-simplify-mode The @kbd{m N} (@code{calc-num-simplify-mode}) command turns off simplification of any formulas except those for which all arguments are constants. For example, @cite{1+2} is simplified to @cite{3}, and @cite{a+(2-2)} is simplified to @cite{a+0} but no further, since one argument of the sum is not a constant. Unfortunately, @cite{(a+2)-2} is @emph{not} simplified because the top-level @samp{-} operator's arguments are not both constant numbers (one of them is the formula @cite{a+2}). A constant is a number or other numeric object (such as a constant error form or modulo form), or a vector all of whose elements are constant.@refill @kindex m D @pindex calc-default-simplify-mode The @kbd{m D} (@code{calc-default-simplify-mode}) command restores the default simplifications for all formulas. This includes many easy and fast algebraic simplifications such as @cite{a+0} to @cite{a}, and @cite{a + 2 a} to @cite{3 a}, as well as evaluating functions like @cite{@t{deriv}(x^2, x)} to @cite{2 x}. @kindex m B @pindex calc-bin-simplify-mode The @kbd{m B} (@code{calc-bin-simplify-mode}) mode applies the default simplifications to a result and then, if the result is an integer, uses the @kbd{b c} (@code{calc-clip}) command to clip the integer according to the current binary word size. @xref{Binary Functions}. Real numbers are rounded to the nearest integer and then clipped; other kinds of results (after the default simplifications) are left alone. @kindex m A @pindex calc-alg-simplify-mode The @kbd{m A} (@code{calc-alg-simplify-mode}) mode does algebraic simplification; it applies all the default simplifications, and also the more powerful (and slower) simplifications made by @kbd{a s} (@code{calc-simplify}). @xref{Algebraic Simplifications}. @kindex m E @pindex calc-ext-simplify-mode The @kbd{m E} (@code{calc-ext-simplify-mode}) mode does ``extended'' algebraic simplification, as by the @kbd{a e} (@code{calc-simplify-extended}) command. @xref{Unsafe Simplifications}. @kindex m U @pindex calc-units-simplify-mode The @kbd{m U} (@code{calc-units-simplify-mode}) mode does units simplification; it applies the command @kbd{u s} (@code{calc-simplify-units}), which in turn is a superset of @kbd{a s}. In this mode, variable names which are identifiable as unit names (like @samp{mm} for ``millimeters'') are simplified with their unit definitions in mind.@refill A common technique is to set the simplification mode down to the lowest amount of simplification you will allow to be applied automatically, then use manual commands like @kbd{a s} and @kbd{c c} (@code{calc-clean}) to perform higher types of simplifications on demand. @xref{Algebraic Definitions}, for another sample use of no-simplification mode.@refill @node Declarations, Display Modes, Simplification Modes, Mode Settings @section Declarations @noindent A @dfn{declaration} is a statement you make that promises you will use a certain variable or function in a restricted way. This may give Calc the freedom to do things that it couldn't do if it had to take the fully general situation into account. @menu * Declaration Basics:: * Kinds of Declarations:: * Functions for Declarations:: @end menu @node Declaration Basics, Kinds of Declarations, Declarations, Declarations @subsection Declaration Basics @noindent @kindex s d @pindex calc-declare-variable The @kbd{s d} (@code{calc-declare-variable}) command is the easiest way to make a declaration for a variable. This command prompts for the variable name, then prompts for the declaration. The default at the declaration prompt is the previous declaration, if any. You can edit this declaration, or press @kbd{C-k} to erase it and type a new declaration. (Or, erase it and press @key{RET} to clear the declaration, effectively ``undeclaring'' the variable.) A declaration is in general a vector of @dfn{type symbols} and @dfn{range} values. If there is only one type symbol or range value, you can write it directly rather than enclosing it in a vector. For example, @kbd{s d foo RET real RET} declares @code{foo} to be a real number, and @kbd{s d bar RET [int, const, [1..6]] RET} declares @code{bar} to be a constant integer between 1 and 6. (Actually, you can omit the outermost brackets and Calc will provide them for you: @kbd{s d bar RET int, const, [1..6] RET}.) @cindex @code{Decls} variable @vindex Decls Declarations in Calc are kept in a special variable called @code{Decls}. This variable encodes the set of all outstanding declarations in the form of a matrix. Each row has two elements: A variable or vector of variables declared by that row, and the declaration specifier as described above. You can use the @kbd{s D} command to edit this variable if you wish to see all the declarations at once. @xref{Operations on Variables}, for a description of this command and the @kbd{s p} command that allows you to save your declarations permanently if you wish. Items being declared can also be function calls. The arguments in the call are ignored; the effect is to say that this function returns values of the declared type for any valid arguments. The @kbd{s d} command declares only variables, so if you wish to make a function declaration you will have to edit the @code{Decls} matrix yourself. For example, the declaration matrix @group @smallexample [ [ foo, real ] [ [j, k, n], int ] [ f(1,2,3), [0 .. inf) ] ] @end smallexample @end group @noindent declares that @code{foo} represents a real number, @code{j}, @code{k} and @code{n} represent integers, and the function @code{f} always returns a real number in the interval shown. @vindex All If there is a declaration for the variable @code{All}, then that declaration applies to all variables that are not otherwise declared. It does not apply to function names. For example, using the row @samp{[All, real]} says that all your variables are real unless they are explicitly declared without @code{real} in some other row. The @kbd{s d} command declares @code{All} if you give a blank response to the variable-name prompt. @node Kinds of Declarations, Functions for Declarations, Declaration Basics, Declarations @subsection Kinds of Declarations @noindent The type-specifier part of a declaration (that is, the second prompt in the @kbd{s d} command) can be a type symbol, an interval, or a vector consisting of zero or more type symbols followed by zero or more intervals or numbers that represent the set of possible values for the variable. @group @smallexample [ [ a, [1, 2, 3, 4, 5] ] [ b, [1 .. 5] ] [ c, [int, 1 .. 5] ] ] @end smallexample @end group Here @code{a} is declared to contain one of the five integers shown; @code{b} is any number in the interval from 1 to 5 (any real number since we haven't specified), and @code{c} is any integer in that interval. Thus the declarations for @code{a} and @code{c} are nearly equivalent (see below). The type-specifier can be the empty vector @samp{[]} to say that nothing is known about a given variable's value. This is the same as not declaring the variable at all except that it overrides any @code{All} declaration which would otherwise apply. The initial value of @code{Decls} is the empty vector @samp{[]}. If @code{Decls} has no stored value or if the value stored in it is not valid, it is ignored and there are no declarations as far as Calc is concerned. (The @kbd{s d} command will replace such a malformed value with a fresh empty matrix, @samp{[]}, before recording the new declaration.) Unrecognized type symbols are ignored. The following type symbols describe what sorts of numbers will be stored in a variable: @table @code @item int Integers. @item numint Numerical integers. (Integers or integer-valued floats.) @item frac Fractions. (Rational numbers which are not integers.) @item rat Rational numbers. (Either integers or fractions.) @item float Floating-point numbers. @item real Real numbers. (Integers, fractions, or floats. Actually, intervals and error forms with real components also count as reals here.) @item pos Positive real numbers. (Strictly greater than zero.) @item nonneg Nonnegative real numbers. (Greater than or equal to zero.) @item number Numbers. (Real or complex.) @end table Calc uses this information to determine when certain simplifications of formulas are safe. For example, @samp{(x^y)^z} cannot be simplified to @samp{x^(y z)} in general; for example, @samp{((-3)^2)^1:2} is 3, but @samp{(-3)^(2*1:2) = (-3)^1} is @i{-3}. However, this simplification @emph{is} safe if @code{z} is known to be an integer, or if @code{x} is known to be a nonnegative real number. If you have given declarations that allow Calc to deduce either of these facts, Calc will perform this simplification of the formula. Calc can apply a certain amount of logic when using declarations. For example, @samp{(x^y)^(2n+1)} will be simplified if @code{n} has been declared @code{int}; Calc knows that an integer times an integer, plus an integer, must always be an integer. (In fact, Calc would simplify @samp{(-x)^(2n+1)} to @samp{-(x^(2n+1))} since it is able to determine that @samp{2n+1} must be an odd integer.) Similarly, @samp{(abs(x)^y)^z} will be simplified to @samp{abs(x)^(y z)} because Calc knows that the @code{abs} function always returns a nonnegative real. If you had a @code{myabs} function that also had this property, you could get Calc to recognize it by adding the row @samp{[myabs(), nonneg]} to the @code{Decls} matrix. One instance of this simplification is @samp{sqrt(x^2)} (since the @code{sqrt} function is effectively a one-half power). Normally Calc leaves this formula alone. After the command @kbd{s d x RET real RET}, however, it can simplify the formula to @samp{abs(x)}. And after @kbd{s d x RET nonneg RET}, Calc can simplify this formula all the way to @samp{x}. If there are any intervals or real numbers in the type specifier, they comprise the set of possible values that the variable or function being declared can have. In particular, the type symbol @code{real} is effectively the same as the range @samp{[-inf .. inf]} (note that infinity is included in the range of possible values); @code{pos} is the same as @samp{(0 .. inf]}, and @code{nonneg} is the same as @samp{[0 .. inf]}. Saying @samp{[real, [-5 .. 5]]} is redundant because the fact that the variable is real can be deduced just from the interval, but @samp{[int, [-5 .. 5]]} and @samp{[rat, [-5 .. 5]]} are useful combinations. Note that the vector of intervals or numbers is in the same format used by Calc's set-manipulation commands. @xref{Set Operations}. The type specifier @samp{[1, 2, 3]} is equivalent to @samp{[numint, 1, 2, 3]}, @emph{not} to @samp{[int, 1, 2, 3]}. In other words, the range of possible values means only that the variable's value must be numerically equal to a number in that range, but not that it must be equal in type as well. Calc's set operations act the same way; @samp{in(2, [1., 2., 3.])} and @samp{in(1.5, [1:2, 3:2, 5:2])} both report ``true.'' If you use a conflicting combination of type specifiers, the results are unpredictable. An example is @samp{[pos, [0 .. 5]]}, where the interval does not lie in the range described by the type symbol. ``Real'' declarations mostly affect simplifications involving powers like the one described above. Another case where they are used is in the @kbd{a P} command which returns a list of all roots of a polynomial; if the variable has been declared real, only the real roots (if any) will be included in the list. ``Integer'' declarations are used for simplifications which are valid only when certain values are integers (such as @samp{(x^y)^z} shown above). Another command that makes use of declarations is @kbd{a s}, when simplifying equations and inequalities. It will cancel @code{x} from both sides of @samp{a x = b x} only if it is sure @code{x} is non-zero, say, because it has a @code{pos} declaration. To declare specifically that @code{x} is real and non-zero, use @samp{[[-inf .. 0), (0 .. inf]]}. (There is no way in the current notation to say that @code{x} is nonzero but not necessarily real.) The @kbd{a e} command does ``unsafe'' simplifications, including cancelling @samp{x} from the equation when @samp{x} is not known to be nonzero. Another set of type symbols distinguish between scalars and vectors. @table @code @item scalar The value is not a vector. @item vector The value is a vector. @item matrix The value is a matrix (a rectangular vector of vectors). @end table These type symbols can be combined with the other type symbols described above; @samp{[int, matrix]} describes an object which is a matrix of integers. Scalar/vector declarations are used to determine whether certain algebraic operations are safe. For example, @samp{[a, b, c] + x} is normally not simplified to @samp{[a + x, b + x, c + x]}, but it will be if @code{x} has been declared @code{scalar}. On the other hand, multiplication is usually assumed to be commutative, but the terms in @samp{x y} will never be exchanged if both @code{x} and @code{y} are known to be vectors or matrices. (Calc currently never distinguishes between @code{vector} and @code{matrix} declarations.) @xref{Matrix Mode}, for a discussion of ``matrix mode'' and ``scalar mode,'' which are similar to declaring @samp{[All, matrix]} or @samp{[All, scalar]} but much more convenient. One more type symbol that is recognized is used with the @kbd{H a d} command for taking total derivatives of a formula. @xref{Calculus}. @table @code @item const The value is a constant with respect to other variables. @end table Calc does not check the declarations for a variable when you store a value in it. However, storing @i{-3.5} in a variable that has been declared @code{pos}, @code{int}, or @code{matrix} may have unexpected effects; Calc may evaluate @samp{sqrt(x^2)} to @cite{3.5} if it substitutes the value first, or to @cite{-3.5} if @code{x} was declared @code{pos} and the formula @samp{sqrt(x^2)} is simplified to @samp{x} before the value is substituted. Before using a variable for a new purpose, it is best to use @kbd{s d} or @kbd{s D} to check to make sure you don't still have an old declaration for the variable that will conflict with its new meaning. @node Functions for Declarations, , Kinds of Declarations, Declarations @subsection Functions for Declarations @noindent Calc has a set of functions for accessing the current declarations in a convenient manner. These functions return 1 if the argument can be shown to have the specified property, or 0 if the argument can be shown @emph{not} to have that property; otherwise they are left unevaluated. These functions are suitable for use with rewrite rules (@pxref{Conditional Rewrite Rules}) or programming constructs (@pxref{Conditionals in Macros}). They can be entered only using algebraic notation. @xref{Logical Operations}, for functions that perform other tests not related to declarations. For example, @samp{dint(17)} returns 1 because 17 is an integer, as do @samp{dint(n)} and @samp{dint(2 n - 3)} if @code{n} has been declared @code{int}, but @samp{dint(2.5)} and @samp{dint(n + 0.5)} return 0. Calc consults knowledge of its own built-in functions as well as your own declarations: @samp{dint(floor(x))} returns 1. @c @starindex @tindex dint @c @starindex @tindex dnumint @c @starindex @tindex dnatnum The @code{dint} function checks if its argument is an integer. The @code{dnatnum} function checks if its argument is a natural number, i.e., a nonnegative integer. The @code{dnumint} function checks if its argument is numerically an integer, i.e., either an integer or an integer-valued float. Note that these and the other data type functions also accept vectors or matrices composed of suitable elements, and that real infinities @samp{inf} and @samp{-inf} are considered to be integers for the purposes of these functions. @c @starindex @tindex drat The @code{drat} function checks if its argument is rational, i.e., an integer or fraction. Infinities count as rational, but intervals and error forms do not. @c @starindex @tindex dreal The @code{dreal} function checks if its argument is real. This includes integers, fractions, floats, real error forms, and intervals. @c @starindex @tindex dimag The @code{dimag} function checks if its argument is imaginary, i.e., is mathematically equal to a real number times @cite{i}. @c @starindex @tindex dpos @c @starindex @tindex dneg @c @starindex @tindex dnonneg The @code{dpos} function checks for positive (but nonzero) reals. The @code{dneg} function checks for negative reals. The @code{dnonneg} function checks for nonnegative reals, i.e., reals greater than or equal to zero. Note that the @kbd{a s} command can simplify an expression like @cite{x > 0} to 1 or 0 using @code{dpos}, and that @kbd{a s} is effectively applied to all conditions in rewrite rules, so the actual functions @code{dpos}, @code{dneg}, and @code{dnonneg} are rarely necessary. @c @starindex @tindex dnonzero The @code{dnonzero} function checks that its argument is nonzero. This includes all nonzero real or complex numbers, all intervals that do not include zero, all nonzero modulo forms, vectors all of whose elements are nonzero, and variables or formulas whose values can be deduced to be nonzero. It does not include error forms, since they represent values which could be anything including zero. (This is also the set of objects considered ``true'' in conditional contexts.) @c @starindex @tindex deven @c @starindex @tindex dodd The @code{deven} function returns 1 if its argument is known to be an even integer (or integer-valued float); it returns 0 if its argument is known not to be even (because it is known to be odd or a non-integer). The @kbd{a s} command uses this to simplify a test of the form @samp{x % 2 = 0}. There is also an analogous @code{dodd} function. @c @starindex @tindex drange The @code{drange} function returns a set (an interval or a vector of intervals and/or numbers; @pxref{Set Operations}) that describes the set of possible values of its argument. If the argument is a variable or a function with a declaration, the range is copied from the declaration. Otherwise, the possible signs of the expression are determined using a method similar to @code{dpos}, etc., and a suitable set like @samp{[0 .. inf]} is returned. If the expression is not provably real, the @code{drange} function remains unevaluated. @c @starindex @tindex dscalar The @code{dscalar} function returns 1 if its argument is provably scalar, or 0 if its argument is provably non-scalar. It is left unevaluated if this cannot be determined. (If matrix mode or scalar mode are in effect, this function returns 1 or 0, respectively, if it has no other information.) When Calc interprets a condition (say, in a rewrite rule) it considers an unevaluated formula to be ``false.'' Thus, @samp{dscalar(a)} is ``true'' only if @code{a} is provably scalar, and @samp{!dscalar(a)} is ``true'' only if @code{a} is provably non-scalar; both are ``false'' if there is insufficient information to tell. @node Display Modes, Language Modes, Declarations, Mode Settings @section Display Modes @noindent The commands in this section are two-key sequences beginning with the @kbd{d} prefix. The @kbd{d l} (@code{calc-line-numbering}) and @kbd{d b} (@code{calc-line-breaking}) commands are described elsewhere; @pxref{Stack Basics} and @pxref{Normal Language Modes}, respectively. Display formats for vectors and matrices are also covered elsewhere; @pxref{Vector and Matrix Formats}.@refill One thing all display modes have in common is their treatment of the @kbd{H} prefix. This prefix causes any mode command that would normally refresh the stack to leave the stack display alone. The word ``Dirty'' will appear in the mode line when Calc thinks the stack display may not reflect the latest mode settings. @kindex d RET @pindex calc-refresh-top The @kbd{d RET} (@code{calc-refresh-top}) command reformats the top stack entry according to all the current modes. Positive prefix arguments reformat the top @var{n} entries; negative prefix arguments reformat the specified entry, and a prefix of zero is equivalent to @kbd{d SPC} (@code{calc-refresh}), which reformats the entire stack. For example, @kbd{H d s M-2 d RET} changes to scientific notation but reformats only the top two stack entries in the new mode. The @kbd{I} prefix has another effect on the display modes. The mode is set only temporarily; the top stack entry is reformatted according to that mode, then the original mode setting is restored. In other words, @kbd{I d s} is equivalent to @kbd{H d s d RET H d @var{(old mode)}}. @menu * Radix Modes:: * Grouping Digits:: * Float Formats:: * Complex Formats:: * Fraction Formats:: * HMS Formats:: * Date Formats:: * Truncating the Stack:: * Justification:: * Labels:: @end menu @node Radix Modes, Grouping Digits, Display Modes, Display Modes @subsection Radix Modes @noindent @cindex Radix display @cindex Non-decimal numbers @cindex Decimal and non-decimal numbers Calc normally displays numbers in decimal (@dfn{base-10} or @dfn{radix-10}) notation. Calc can actually display in any radix from two (binary) to 36. When the radix is above 10, the letters @code{A} to @code{Z} are used as digits. When entering such a number, letter keys are interpreted as potential digits rather than terminating numeric entry mode. @kindex d 2 @kindex d 8 @kindex d 6 @kindex d 0 @cindex Hexadecimal integers @cindex Octal integers The key sequences @kbd{d 2}, @kbd{d 8}, @kbd{d 6}, and @kbd{d 0} select binary, octal, hexadecimal, and decimal as the current display radix, respectively. Numbers can always be entered in any radix, though the current radix is used as a default if you press @kbd{#} without any initial digits. A number entered without a @kbd{#} is @emph{always} interpreted as decimal.@refill @kindex d r @pindex calc-radix To set the radix generally, use @kbd{d r} (@code{calc-radix}) and enter an integer from 2 to 36. You can specify the radix as a numeric prefix argument; otherwise you will be prompted for it. @kindex d z @pindex calc-leading-zeros @cindex Leading zeros Integers normally are displayed with however many digits are necessary to represent the integer and no more. The @kbd{d z} (@code{calc-leading-zeros}) command causes integers to be padded out with leading zeros according to the current binary word size. (@xref{Binary Functions}, for a discussion of word size.) If the absolute value of the word size is @cite{w}, all integers are displayed with at least enough digits to represent @c{$2^w-1$} @cite{(2^w)-1} in the current radix. (Larger integers will still be displayed in their entirety.) @node Grouping Digits, Float Formats, Radix Modes, Display Modes @subsection Grouping Digits @noindent @kindex d g @pindex calc-group-digits @cindex Grouping digits @cindex Digit grouping Long numbers can be hard to read if they have too many digits. For example, the factorial of 30 is 33 digits long! Press @kbd{d g} (@code{calc-group-digits}) to enable @dfn{grouping} mode, in which digits are displayed in clumps of 3 or 4 (depending on the current radix) separated by commas. The @kbd{d g} command toggles grouping on and off. With a numerix prefix of 0, this command displays the current state of the grouping flag; with an argument of minus one it disables grouping; with a positive argument @cite{N} it enables grouping on every @cite{N} digits. For floating-point numbers, grouping normally occurs only before the decimal point. A negative prefix argument @cite{-N} enables grouping every @cite{N} digits both before and after the decimal point.@refill @kindex d , @pindex calc-group-char The @kbd{d ,} (@code{calc-group-char}) command allows you to choose any character as the grouping separator. The default is the comma character. If you find it difficult to read vectors of large integers grouped with commas, you may wish to use spaces or some other character instead. This command takes the next character you type, whatever it is, and uses it as the digit separator. As a special case, @kbd{d , \} selects @samp{\,} (@TeX{}'s thin-space symbol) as the digit separator. Please note that grouped numbers will not generally be parsed correctly if re-read in textual form, say by the use of @kbd{M-# y} and @kbd{M-# g}. (@xref{Kill and Yank}, for details on these commands.) One exception is the @samp{\,} separator, which doesn't interfere with parsing because it is ignored by @TeX{} language mode. @node Float Formats, Complex Formats, Grouping Digits, Display Modes @subsection Float Formats @noindent Floating-point quantities are normally displayed in standard decimal form, with scientific notation used if the exponent is especially high or low. All significant digits are normally displayed. The commands in this section allow you to choose among several alternative display formats for floats. @kindex d n @pindex calc-normal-notation The @kbd{d n} (@code{calc-normal-notation}) command selects the normal display format. All significant figures in a number are displayed. With a positive numeric prefix, numbers are rounded if necessary to that number of significant digits. With a negative numerix prefix, the specified number of significant digits less than the current precision is used. (Thus @kbd{C-u -2 d n} displays 10 digits if the current precision is 12.) @kindex d f @pindex calc-fix-notation The @kbd{d f} (@code{calc-fix-notation}) command selects fixed-point notation. The numeric argument is the number of digits after the decimal point, zero or more. This format will relax into scientific notation if a nonzero number would otherwise have been rounded all the way to zero. Specifying a negative number of digits is the same as for a positive number, except that small nonzero numbers will be rounded to zero rather than switching to scientific notation. @kindex d s @pindex calc-sci-notation @cindex Scientific notation, display of The @kbd{d s} (@code{calc-sci-notation}) command selects scientific notation. A positive argument sets the number of significant figures displayed, of which one will be before and the rest after the decimal point. A negative argument works the same as for @kbd{d n} format. The default is to display all significant digits. @kindex d e @pindex calc-eng-notation @cindex Engineering notation, display of The @kbd{d e} (@code{calc-eng-notation}) command selects engineering notation. This is similar to scientific notation except that the exponent is rounded down to a multiple of three, with from one to three digits before the decimal point. An optional numeric prefix sets the number of significant digits to display, as for @kbd{d s}. It is important to distinguish between the current @emph{precision} and the current @emph{display format}. After the commands @kbd{C-u 10 p} and @kbd{C-u 6 d n} the Calculator computes all results to ten significant figures but displays only six. (In fact, intermediate calculations are often carried to one or two more significant figures, but values placed on the stack will be rounded down to ten figures.) Numbers are never actually rounded to the display precision for storage, except by commands like @kbd{C-k} and @kbd{M-# y} which operate on the actual displayed text in the Calculator buffer. @kindex d . @pindex calc-point-char The @kbd{d .} (@code{calc-point-char}) command selects the character used as a decimal point. Normally this is a period; users in some countries may wish to change this to a comma. Note that this is only a display style; on entry, periods must always be used to denote floating-point numbers, and commas to separate elements in a list. @node Complex Formats, Fraction Formats, Float Formats, Display Modes @subsection Complex Formats @noindent @kindex d c @pindex calc-complex-notation There are three supported notations for complex numbers in rectangular form. The default is as a pair of real numbers enclosed in parentheses and separated by a comma: @samp{(a,b)}. The @kbd{d c} (@code{calc-complex-notation}) command selects this style.@refill @kindex d i @pindex calc-i-notation @kindex d j @pindex calc-j-notation The other notations are @kbd{d i} (@code{calc-i-notation}), in which numbers are displayed in @samp{a+bi} form, and @kbd{d j} (@code{calc-j-notation}) which displays the form @samp{a+bj} preferred in some disciplines.@refill @cindex @code{i} variable @vindex i Complex numbers are normally entered in @samp{(a,b)} format. If you enter @samp{2+3i} as an algebraic formula, it will be stored as the formula @samp{2 + 3 * i}. However, if you use @kbd{=} to evaluate this formula and you have not changed the variable @samp{i}, the @samp{i} will be interpreted as @samp{(0,1)} and the formula will be simplified to @samp{(2,3)}. Other commands (like @code{calc-sin}) will @emph{not} interpret the formula @samp{2 + 3 * i} as a complex number. @xref{Variables}, under ``special constants.''@refill @node Fraction Formats, HMS Formats, Complex Formats, Display Modes @subsection Fraction Formats @noindent @kindex d o @pindex calc-over-notation Display of fractional numbers is controlled by the @kbd{d o} (@code{calc-over-notation}) command. By default, a number like eight thirds is displayed in the form @samp{8:3}. The @kbd{d o} command prompts for a one- or two-character format. If you give one character, that character is used as the fraction separator. Common separators are @samp{:} and @samp{/}. (During input of numbers, the @kbd{:} key must be used regardless of the display format; in particular, the @kbd{/} is used for RPN-style division, @emph{not} for entering fractions.) If you give two characters, fractions use ``integer-plus-fractional-part'' notation. For example, the format @samp{+/} would display eight thirds as @samp{2+2/3}. If two colons are present in a number being entered, the number is interpreted in this form (so that the entries @kbd{2:2:3} and @kbd{8:3} are equivalent). It is also possible to follow the one- or two-character format with a number. For example: @samp{:10} or @samp{+/3}. In this case, Calc adjusts all fractions that are displayed to have the specified denominator, if possible. Otherwise it adjusts the denominator to be a multiple of the specified value. For example, in @samp{:6} mode the fraction @cite{1:6} will be unaffected, but @cite{2:3} will be displayed as @cite{4:6}, @cite{1:2} will be displayed as @cite{3:6}, and @cite{1:8} will be displayed as @cite{3:24}. Integers are also affected by this mode: 3 is displayed as @cite{18:6}. Note that the format @samp{:1} writes fractions the same as @samp{:}, but it writes integers as @cite{n:1}. The fraction format does not affect the way fractions or integers are stored, only the way they appear on the screen. The fraction format never affects floats. @node HMS Formats, Date Formats, Fraction Formats, Display Modes @subsection HMS Formats @noindent @kindex d h @pindex calc-hms-notation The @kbd{d h} (@code{calc-hms-notation}) command controls the display of HMS (hours-minutes-seconds) forms. It prompts for a string which consists basically of an ``hours'' marker, optional punctuation, a ``minutes'' marker, more optional punctuation, and a ``seconds'' marker. Punctuation is zero or more spaces, commas, or semicolons. The hours marker is one or more non-punctuation characters. The minutes and seconds markers must be single non-punctuation characters. The default HMS format is @samp{@@ ' "}, producing HMS values of the form @samp{23@@ 30' 15.75"}. The format @samp{deg, ms} would display this same value as @samp{23deg, 30m15.75s}. During numeric entry, the @kbd{h} or @kbd{o} keys are recognized as synonyms for @kbd{@@} regardless of display format. The @kbd{m} and @kbd{s} keys are recognized as synonyms for @kbd{'} and @kbd{"}, respectively, but only if an @kbd{@@} (or @kbd{h} or @kbd{o}) has already been typed; otherwise, they have their usual meanings (@kbd{m-} prefix and @kbd{s-} prefix). Thus, @kbd{5 "}, @kbd{0 @@ 5 "}, and @kbd{0 h 5 s} are some of the ways to enter the quantity ``five seconds.'' The @kbd{'} key is recognized as ``minutes'' only if @kbd{@@} (or @kbd{h} or @kbd{o}) has already been pressed; otherwise it means to switch to algebraic entry. @node Date Formats, Truncating the Stack, HMS Formats, Display Modes @subsection Date Formats @noindent @kindex d d @pindex calc-date-notation The @kbd{d d} (@code{calc-date-notation}) command controls the display of date forms (@pxref{Date Forms}). It prompts for a string which contains letters that represent the various parts of a date and time. To show which parts should be omitted when the form represents a pure date with no time, parts of the string can be enclosed in @samp{< >} marks. If you don't include @samp{< >} markers in the format, Calc guesses at which parts, if any, should be omitted when formatting pure dates. The default format is: @samp{Www Mmm D, YYYY}. An example string in this format is @samp{3:32pm Wed Jan 9, 1991}. If you enter a blank format string, this default format is reestablished. Calc uses @samp{< >} notation for nameless functions as well as for dates. @xref{Specifying Operators}. To avoid confusion with nameless functions, your date formats should avoid using the @samp{#} character. @menu * Date Formatting Codes:: * Free-Form Dates:: * Standard Date Formats:: @end menu @node Date Formatting Codes, Free-Form Dates, Date Formats, Date Formats @subsubsection Date Formatting Codes @noindent When displaying a date, the current date format is used. All characters except for letters and @samp{<} and @samp{>} are copied literally when dates are formatted. The portion between @samp{< >} markers is omitted for pure dates, or included for date/time forms. Letters are interpreted according to the table below. When dates are read in during algebraic entry, Calc first tries to match the input string to the current format either with or without the time part. The punctuation characters (including spaces) must match exactly; letter fields must correspond to suitable text in the input. If this doesn't work, Calc checks if the input is a simple number; if so, the number is interpreted as a number of days since Jan 1, 1 AD. Otherwise, Calc tries a much more relaxed and flexible algorithm which is described in the next section. Weekday names are ignored during reading. Two-digit year numbers are interpreted as lying in the range from 1941 to 2039. Years outside that range are always entered and displayed in full. Year numbers with a leading @samp{+} sign are always interpreted exactly, allowing the entry and display of the years 1 through 99 AD. Here is a complete list of the formatting codes for dates: @table @asis @item Y Year: ``91'' for 1991, ``7'' for 2007, ``+23'' for 23 AD. @item YY Year: ``91'' for 1991, ``07'' for 2007, ``+23'' for 23 AD. @item BY Year: ``91'' for 1991, `` 7'' for 2007, ``+23'' for 23 AD. @item YYY Year: ``1991'' for 1991, ``23'' for 23 AD. @item YYYY Year: ``1991'' for 1991, ``+23'' for 23 AD. @item aa Year: ``ad'' or blank. @item AA Year: ``AD'' or blank. @item aaa Year: ``ad '' or blank. (Note trailing space.) @item AAA Year: ``AD '' or blank. @item aaaa Year: ``a.d.'' or blank. @item AAAA Year: ``A.D.'' or blank. @item bb Year: ``bc'' or blank. @item BB Year: ``BC'' or blank. @item bbb Year: `` bc'' or blank. (Note leading space.) @item BBB Year: `` BC'' or blank. @item bbbb Year: ``b.c.'' or blank. @item BBBB Year: ``B.C.'' or blank. @item M Month: ``8'' for August. @item MM Month: ``08'' for August. @item BM Month: `` 8'' for August. @item MMM Month: ``AUG'' for August. @item Mmm Month: ``Aug'' for August. @item mmm Month: ``aug'' for August. @item MMMM Month: ``AUGUST'' for August. @item Mmmm Month: ``August'' for August. @item D Day: ``7'' for 7th day of month. @item DD Day: ``07'' for 7th day of month. @item BD Day: `` 7'' for 7th day of month. @item W Weekday: ``0'' for Sunday, ``6'' for Saturday. @item WWW Weekday: ``SUN'' for Sunday. @item Www Weekday: ``Sun'' for Sunday. @item www Weekday: ``sun'' for Sunday. @item WWWW Weekday: ``SUNDAY'' for Sunday. @item Wwww Weekday: ``Sunday'' for Sunday. @item d Day of year: ``34'' for Feb. 3. @item ddd Day of year: ``034'' for Feb. 3. @item bdd Day of year: `` 34'' for Feb. 3. @item h Hour: ``5'' for 5 AM; ``17'' for 5 PM. @item hh Hour: ``05'' for 5 AM; ``17'' for 5 PM. @item bh Hour: `` 5'' for 5 AM; ``17'' for 5 PM. @item H Hour: ``5'' for 5 AM and 5 PM. @item HH Hour: ``05'' for 5 AM and 5 PM. @item BH Hour: `` 5'' for 5 AM and 5 PM. @item p AM/PM: ``a'' or ``p''. @item P AM/PM: ``A'' or ``P''. @item pp AM/PM: ``am'' or ``pm''. @item PP AM/PM: ``AM'' or ``PM''. @item pppp AM/PM: ``a.m.'' or ``p.m.''. @item PPPP AM/PM: ``A.M.'' or ``P.M.''. @item m Minutes: ``7'' for 7. @item mm Minutes: ``07'' for 7. @item bm Minutes: `` 7'' for 7. @item s Seconds: ``7'' for 7; ``7.23'' for 7.23. @item ss Seconds: ``07'' for 7; ``07.23'' for 7.23. @item bs Seconds: `` 7'' for 7; `` 7.23'' for 7.23. @item SS Optional seconds: ``07'' for 7; blank for 0. @item BS Optional seconds: `` 7'' for 7; blank for 0. @item N Numeric date/time: ``726842.25'' for 6:00am Wed Jan 9, 1991. @item n Numeric date: ``726842'' for any time on Wed Jan 9, 1991. @item J Julian date/time: ``2448265.75'' for 6:00am Wed Jan 9, 1991. @item j Julian date: ``2448266'' for any time on Wed Jan 9, 1991. @item U Unix time: ``663400800'' for 6:00am Wed Jan 9, 1991. @item X Brackets suppression. An ``X'' at the front of the format causes the surrounding @w{@samp{< >}} delimiters to be omitted when formatting dates. Note that the brackets are still required for algebraic entry. @end table If ``SS'' or ``BS'' (optional seconds) is preceded by a colon, the colon is also omitted if the seconds part is zero. If ``bb,'' ``bbb'' or ``bbbb'' or their upper-case equivalents appear in the format, then negative year numbers are displayed without a minus sign. Note that ``aa'' and ``bb'' are mutually exclusive. Some typical usages would be @samp{YYYY AABB}; @samp{AAAYYYYBBB}; @samp{YYYYBBB}. The formats ``YY,'' ``YYYY,'' ``MM,'' ``DD,'' ``ddd,'' ``hh,'' ``HH,'' ``mm,'' ``ss,'' and ``SS'' actually match any number of digits during reading unless several of these codes are strung together with no punctuation in between, in which case the input must have exactly as many digits as there are letters in the format. The ``j,'' ``J,'' and ``U'' formats do not make any time zone adjustment. They effectively use @samp{julian(x,0)} and @samp{unixtime(x,0)} to make the conversion; @pxref{Date Arithmetic}. @node Free-Form Dates, Standard Date Formats, Date Formatting Codes, Date Formats @subsubsection Free-Form Dates @noindent When reading a date form during algebraic entry, Calc falls back on the algorithm described here if the input does not exactly match the current date format. This algorithm generally ``does the right thing'' and you don't have to worry about it, but it is described here in full detail for the curious. Calc does not distinguish between upper- and lower-case letters while interpreting dates. First, the time portion, if present, is located somewhere in the text and then removed. The remaining text is then interpreted as the date. A time is of the form @samp{hh:mm:ss}, possibly with the seconds part omitted and possibly with an AM/PM indicator added to indicate 12-hour time. If the AM/PM is present, the minutes may also be omitted. The AM/PM part may be any of the words @samp{am}, @samp{pm}, @samp{noon}, or @samp{midnight}; each of these may be abbreviated to one letter, and the alternate forms @samp{a.m.}, @samp{p.m.}, and @samp{mid} are also understood. Obviously @samp{noon} and @samp{midnight} are allowed only on 12:00:00. The words @samp{noon}, @samp{mid}, and @samp{midnight} are also recognized with no number attached. If there is no AM/PM indicator, the time is interpreted in 24-hour format. To read the date portion, all words and numbers are isolated from the string; other characters are ignored. All words must be either month names or day-of-week names (the latter of which are ignored). Names can be written in full or as three-letter abbreviations. Large numbers, or numbers with @samp{+} or @samp{-} signs, are interpreted as years. If one of the other numbers is greater than 12, then that must be the day and the remaining number in the input is therefore the month. Otherwise, Calc assumes the month, day and year are in the same order that they appear in the current date format. If the year is omitted, the current year is taken from the system clock. If there are too many or too few numbers, or any unrecognizable words, then the input is rejected. If there are any large numbers (of five digits or more) other than the year, they are ignored on the assumption that they are something like Julian dates that were included along with the traditional date components when the date was formatted. One of the words @samp{ad}, @samp{a.d.}, @samp{bc}, or @samp{b.c.} may optionally be used; the latter two are equivalent to a minus sign on the year value. If you always enter a four-digit year, and use a name instead of a number for the month, there is no danger of ambiguity. @node Standard Date Formats, , Free-Form Dates, Date Formats @subsubsection Standard Date Formats @noindent There are actually ten standard date formats, numbered 0 through 9. Entering a blank line at the @kbd{d d} command's prompt gives you format number 1, Calc's usual format. You can enter any digit to select the other formats. To create your own standard date formats, give a numeric prefix argument from 0 to 9 to the @w{@kbd{d d}} command. The format you enter will be recorded as the new standard format of that number, as well as becoming the new current date format. You can save your formats permanently with the @w{@kbd{m m}} command (@pxref{Mode Settings}). @table @asis @item 0 @samp{N} (Numerical format) @item 1 @samp{Www Mmm D, YYYY} (American format) @item 2 @samp{D Mmm YYYY<, h:mm:SS>} (European format) @item 3 @samp{Www Mmm BD< hh:mm:ss> YYYY} (Unix written date format) @item 4 @samp{M/D/Y< H:mm:SSpp>} (American slashed format) @item 5 @samp{D.M.Y< h:mm:SS>} (European dotted format) @item 6 @samp{M-D-Y< H:mm:SSpp>} (American dashed format) @item 7 @samp{D-M-Y< h:mm:SS>} (European dashed format) @item 8 @samp{j<, h:mm:ss>} (Julian day plus time) @item 9 @samp{YYddd< hh:mm:ss>} (Year-day format) @end table @node Truncating the Stack, Justification, Date Formats, Display Modes @subsection Truncating the Stack @noindent @kindex d t @pindex calc-truncate-stack @cindex Truncating the stack @cindex Narrowing the stack The @kbd{d t} (@code{calc-truncate-stack}) command moves the @samp{.}@: line that marks the top-of-stack up or down in the Calculator buffer. The number right above that line is considered to the be at the top of the stack. Any numbers below that line are ``hidden'' from all stack operations. This is similar to the Emacs ``narrowing'' feature, except that the values below the @samp{.} are @emph{visible}, just temporarily frozen. This feature allows you to keep several independent calculations running at once in different parts of the stack, or to apply a certain command to an element buried deep in the stack.@refill Pressing @kbd{d t} by itself moves the @samp{.} to the line the cursor is on. Thus, this line and all those below it become hidden. To un-hide these lines, move down to the end of the buffer and press @w{@kbd{d t}}. With a positive numeric prefix argument @cite{n}, @kbd{d t} hides the bottom @cite{n} values in the buffer. With a negative argument, it hides all but the top @cite{n} values. With an argument of zero, it hides zero values, i.e., moves the @samp{.} all the way down to the bottom.@refill @kindex d [ @pindex calc-truncate-up @kindex d ] @pindex calc-truncate-down The @kbd{d [} (@code{calc-truncate-up}) and @kbd{d ]} (@code{calc-truncate-down}) commands move the @samp{.} up or down one line at a time (or several lines with a prefix argument).@refill @node Justification, Labels, Truncating the Stack, Display Modes @subsection Justification @noindent @kindex d < @pindex calc-left-justify @kindex d = @pindex calc-center-justify @kindex d > @pindex calc-right-justify Values on the stack are normally left-justified in the window. You can control this arrangement by typing @kbd{d <} (@code{calc-left-justify}), @kbd{d >} (@code{calc-right-justify}), or @kbd{d =} (@code{calc-center-justify}). For example, in right-justification mode, stack entries are displayed flush-right against the right edge of the window.@refill If you change the width of the Calculator window you may have to type @kbd{d SPC} (@code{calc-refresh}) to re-align right-justified or centered text. Right-justification is especially useful together with fixed-point notation (see @code{d f}; @code{calc-fix-notation}). With these modes together, the decimal points on numbers will always line up. With a numeric prefix argument, the justification commands give you a little extra control over the display. The argument specifies the horizontal ``origin'' of a display line. It is also possible to specify a maximum line width using the @kbd{d b} command (@pxref{Normal Language Modes}). For reference, the precise rules for formatting and breaking lines are given below. Notice that the interaction between origin and line width is slightly different in each justification mode. In left-justified mode, the line is indented by a number of spaces given by the origin (default zero). If the result is longer than the maximum line width, if given, or too wide to fit in the Calc window otherwise, then it is broken into lines which will fit; each broken line is indented to the origin. In right-justified mode, lines are shifted right so that the rightmost character is just before the origin, or just before the current window width if no origin was specified. If the line is too long for this, then it is broken; the current line width is used, if specified, or else the origin is used as a width if that is specified, or else the line is broken to fit in the window. In centering mode, the origin is the column number of the center of each stack entry. If a line width is specified, lines will not be allowed to go past that width; Calc will either indent less or break the lines if necessary. If no origin is specified, half the line width or Calc window width is used. Note that, in each case, if line numbering is enabled the display is indented an additional four spaces to make room for the line number. The width of the line number is taken into account when positioning according to the current Calc window width, but not when positioning by explicit origins and widths. In the latter case, the display is formatted as specified, and then uniformly shifted over four spaces to fit the line numbers. @node Labels, , Justification, Display Modes @subsection Labels @noindent @kindex d @{ @pindex calc-left-label The @kbd{d @{} (@code{calc-left-label}) command prompts for a string, then displays that string to the left of every stack entry. If the entries are left-justified (@pxref{Justification}), then they will appear immediately after the label (unless you specified an origin greater than the length of the label). If the entries are centered or right-justified, the label appears on the far left and does not affect the horizontal position of the stack entry. Give a blank string (with @kbd{d @{ @key{RET}}) to turn the label off. @kindex d @} @pindex calc-right-label The @kbd{d @}} (@code{calc-right-label}) command similarly adds a label on the righthand side. It does not affect positioning of the stack entries unless they are right-justified. Also, if both a line width and an origin are given in right-justified mode, the stack entry is justified to the origin and the righthand label is justified to the line width. One application of labels would be to add equation numbers to formulas you are manipulating in Calc and then copying into a document (possibly using Embedded Mode). The equations would typically be centered, and the equation numbers would be on the left or right as you prefer. @node Language Modes, Modes Variable, Display Modes, Mode Settings @section Language Modes @noindent The commands in this section change Calc to use a different notation for entry and display of formulas, corresponding to the conventions of some other common language such as Pascal or @TeX{}. Objects displayed on the stack or yanked from the Calculator to an editing buffer will be formatted in the current language; objects entered in algebraic entry or yanked from another buffer will be interpreted according to the current language. The current language has no effect on things written to or read from the trail buffer, nor does it affect numeric entry. Only algebraic entry is affected. You can make even algebraic entry ignore the current language and use the standard notation by giving a numeric prefix, e.g., @kbd{C-u '}. For example, suppose the formula @samp{2*a[1] + atan(a[2])} occurs in a C program; elsewhere in the program you need the derivatives of this formula with respect to @samp{a[1]} and @samp{a[2]}. First, type @kbd{d C} to switch to C notation. Now use @code{C-u M-# g} to grab the formula into the Calculator, @kbd{a d a[1] @key{RET}} to differentiate with respect to the first variable, and @kbd{M-# y} to yank the formula for the derivative back into your C program. Press @kbd{U} to undo the differentiation and repeat with @kbd{a d a[2] @key{RET}} for the other derivative. Without being switched into C mode first, Calc would have misinterpreted the brackets in @samp{a[1]} and @samp{a[2]}, would not have known that @code{atan} was equivalent to Calc's built-in @code{arctan} function, and would have written the formula back with notations (like implicit multiplication) which would not have been legal for a C program. As another example, suppose you are maintaining a C program and a @TeX{} document, each of which needs a copy of the same formula. You can grab the formula from the program in C mode, switch to @TeX{} mode, and yank the formula into the document in @TeX{} math-mode format. Language modes are selected by typing the letter @kbd{d} followed by a shifted letter key. @menu * Normal Language Modes:: * C FORTRAN Pascal:: * TeX Language Mode:: * Eqn Language Mode:: * Mathematica Language Mode:: * Maple Language Mode:: * Compositions:: * Syntax Tables:: @end menu @node Normal Language Modes, C FORTRAN Pascal, Language Modes, Language Modes @subsection Normal Language Modes @noindent @kindex d N @pindex calc-normal-language The @kbd{d N} (@code{calc-normal-language}) command selects the usual notation for Calc formulas, as described in the rest of this manual. Matrices are displayed in a multi-line tabular format, but all other objects are written in linear form, as they would be typed from the keyboard. @kindex d O @pindex calc-flat-language @cindex Matrix display The @kbd{d O} (@code{calc-flat-language}) command selects a language identical with the normal one, except that matrices are written in one-line form along with everything else. In some applications this form may be more suitable for yanking data into other buffers. @kindex d b @pindex calc-line-breaking @cindex Line breaking @cindex Breaking up long lines Even in one-line mode, long formulas or vectors will still be split across multiple lines if they exceed the width of the Calculator window. The @kbd{d b} (@code{calc-line-breaking}) command turns this line-breaking feature on and off. (It works independently of the current language.) If you give a numeric prefix argument of five or greater to the @kbd{d b} command, that argument will specify the line width used when breaking long lines. @kindex d B @pindex calc-big-language The @kbd{d B} (@code{calc-big-language}) command selects a language which uses textual approximations to various mathematical notations, such as powers, quotients, and square roots: @example ____________ | a + 1 2 | ----- + c \| b @end example @noindent in place of @samp{sqrt((a+1)/b + c^2)}. Subscripts like @samp{a_i} are displayed as actual subscripts in ``big'' mode. Double subscripts, @samp{a_i_j} (@samp{subscr(subscr(a, i), j)}) are displayed as @samp{a} with subscripts separated by commas: @samp{i, j}. They must still be entered in the usual underscore notation. One slight ambiguity of Big notation is that @example 3 - - 4 @end example @noindent can represent either the negative rational number @cite{-3:4}, or the actual expression @samp{-(3/4)}; but the latter formula would normally never be displayed because it would immediately be evaluated to @cite{-3:4} or @cite{-0.75}, so this ambiguity is not a problem in typical use. Non-decimal numbers are displayed with subscripts. Thus there is no way to tell the difference between @samp{16#C2} and @samp{C2_16}, though generally you will know which interpretation is correct. Logarithms @samp{log(x,b)} and @samp{log10(x)} also use subscripts in Big mode. In Big mode, stack entries often take up several lines. To aid readability, stack entries are separated by a blank line in this mode. You may find it useful to expand the Calc window's height using @kbd{C-x ^} (@code{enlarge-window}) or to make the Calc window the only one on the screen with @kbd{C-x 1} (@code{delete-other-windows}). Long lines are currently not rearranged to fit the window width in Big mode, so you may need to use the @kbd{<} and @kbd{>} keys to scroll across a wide formula. For really big formulas, you may even need to use @kbd{@{} and @kbd{@}} to scroll up and down. @kindex d U @pindex calc-unformatted-language The @kbd{d U} (@code{calc-unformatted-language}) command altogether disables the use of operator notation in formulas. In this mode, the formula shown above would be displayed: @example sqrt(add(div(add(a, 1), b), pow(c, 2))) @end example These four modes differ only in display format, not in the format expected for algebraic entry. The standard Calc operators work in all four modes, and unformatted notation works in any language mode (except that Mathematica mode expects square brackets instead of parentheses). @node C FORTRAN Pascal, TeX Language Mode, Normal Language Modes, Language Modes @subsection C, FORTRAN, and Pascal Modes @noindent @kindex d C @pindex calc-c-language @cindex C language The @kbd{d C} (@code{calc-c-language}) command selects the conventions of the C language for display and entry of formulas. This differs from the normal language mode in a variety of (mostly minor) ways. In particular, C language operators and operator precedences are used in place of Calc's usual ones. For example, @samp{a^b} means @samp{xor(a,b)} in C mode; a value raised to a power is written as a function call, @samp{pow(a,b)}. In C mode, vectors and matrices use curly braces instead of brackets. Octal and hexadecimal values are written with leading @samp{0} or @samp{0x} rather than using the @samp{#} symbol. Array subscripting is translated into @code{subscr} calls, so that @samp{a[i]} in C mode is the same as @samp{a_i} in normal mode. Assignments turn into the @code{assign} function, which Calc normally displays using the @samp{:=} symbol. The variables @code{var-pi} and @code{var-e} would be displayed @samp{pi} and @samp{e} in normal mode, but in C mode they are displayed as @samp{M_PI} and @samp{M_E}, corresponding to the names of constants typically provided in the @file{} header. Functions whose names are different in C are translated automatically for entry and display purposes. For example, entering @samp{asin(x)} will push the formula @samp{arcsin(x)} onto the stack; this formula will be displayed as @samp{asin(x)} as long as C mode is in effect. @kindex d P @pindex calc-pascal-language @cindex Pascal language The @kbd{d P} (@code{calc-pascal-language}) command selects Pascal conventions. Like C mode, Pascal mode interprets array brackets and uses a different table of operators. Hexadecimal numbers are entered and displayed with a preceding dollar sign. (Thus the regular meaning of @kbd{$2} during algebraic entry does not work in Pascal mode, though @kbd{$} (and @kbd{$$}, etc.) not followed by digits works the same as always.) No special provisions are made for other non-decimal numbers, vectors, and so on, since there is no universally accepted standard way of handling these in Pascal. @kindex d F @pindex calc-fortran-language @cindex FORTRAN language The @kbd{d F} (@code{calc-fortran-language}) command selects FORTRAN conventions. Various function names are transformed into FORTRAN equivalents. Vectors are written as @samp{/1, 2, 3/}, and may be entered this way or using square brackets. Since FORTRAN uses round parentheses for both function calls and array subscripts, Calc displays both in the same way; @samp{a(i)} is interpreted as a function call upon reading, and subscripts must be entered as @samp{subscr(a, i)}. Also, if the variable @code{a} has been declared to have type @code{vector} or @code{matrix} then @samp{a(i)} will be parsed as a subscript. (@xref{Declarations}.) Usually it doesn't matter, though; if you enter the subscript expression @samp{a(i)} and Calc interprets it as a function call, you'll never know the difference unless you switch to another language mode or replace @code{a} with an actual vector (or unless @code{a} happens to be the name of a built-in function!). Underscores are allowed in variable and function names in all of these language modes. The underscore here is equivalent to the @samp{#} in normal mode, or to hyphens in the underlying Emacs Lisp variable names. FORTRAN and Pascal modes normally do not adjust the case of letters in formulas. Most built-in Calc names use lower-case letters. If you use a positive numeric prefix argument with @kbd{d P} or @kbd{d F}, these modes will use upper-case letters exclusively for display, and will convert to lower-case on input. With a negative prefix, these modes convert to lower-case for display and input. @node TeX Language Mode, Eqn Language Mode, C FORTRAN Pascal, Language Modes @subsection @TeX{} Language Mode @noindent @kindex d T @pindex calc-tex-language @cindex TeX language The @kbd{d T} (@code{calc-tex-language}) command selects the conventions of ``math mode'' in the @TeX{} typesetting language, by Donald Knuth. Formulas are entered and displayed in @TeX{} notation, as in @samp{\sin\left( a \over b \right)}. Math formulas are usually enclosed by @samp{$ $} signs in @TeX{}; these should be omitted when interfacing with Calc. To Calc, the @samp{$} sign has the same meaning it always does in algebraic formulas (a reference to an existing entry on the stack).@refill Complex numbers are displayed as in @samp{3 + 4i}. Fractions and quotients are written using @code{\over}; binomial coefficients are written with @code{\choose}. Interval forms are written with @code{\ldots}, and error forms are written with @code{\pm}. Absolute values are written as in @samp{|x + 1|}, and the floor and ceiling functions are written with @code{\lfloor}, @code{\rfloor}, etc. The words @code{\left} and @code{\right} are ignored when reading formulas in @TeX{} mode. Both @code{inf} and @code{uinf} are written as @code{\infty}; when read, @code{\infty} always translates to @code{inf}.@refill Function calls are written the usual way, with the function name followed by the arguments in parentheses. However, functions for which @TeX{} has special names (like @code{\sin}) will use curly braces instead of parentheses for very simple arguments. During input, curly braces and parentheses work equally well for grouping, but when the document is formatted the curly braces will be invisible. Thus the printed result is @c{$\sin{2 x}$} @cite{sin 2x} but @c{$\sin(2 + x)$} @cite{sin(2 + x)}. Function and variable names not treated specially by @TeX{} are simply written out as-is, which will cause them to come out in italic letters in the printed document. If you invoke @kbd{d T} with a positive numeric prefix argument, names of more than one character will instead be written @samp{\hbox@{@var{name}@}}. The @samp{\hbox@{ @}} notation is ignored during reading. If you use a negative prefix argument, such function names are written @samp{\@var{name}}, and function names that begin with @code{\} during reading have the @code{\} removed. (Note that in this mode, long variable names are still written with @code{\hbox}. However, you can always make an actual variable name like @code{\bar} in any @TeX{} mode.) During reading, text of the form @samp{\matrix@{ ...@: @}} is replaced by @samp{[ ...@: ]}. The same also applies to @code{\pmatrix} and @code{\bmatrix}. The symbol @samp{&} is interpreted as a comma, and the symbols @samp{\cr} and @samp{\\} are interpreted as semicolons. During output, matrices are displayed in @samp{\matrix@{ a & b \\ c & d@}} format; you may need to edit this afterwards to change @code{\matrix} to @code{\pmatrix} or @code{\\} to @code{\cr}. Accents like @code{\tilde} and @code{\bar} translate into function calls internally (@samp{tilde(x)}, @samp{bar(x)}). The @code{\underline} sequence is treated as an accent. The @code{\vec} accent corresponds to the function name @code{Vec}, because @code{vec} is the name of a built-in Calc function. The following table shows the accents in Calc, @TeX{}, and @dfn{eqn} (described in the next section): @iftex @begingroup @let@calcindexershow=@calcindexernoshow @c Suppress marginal notes @let@calcindexersh=@calcindexernoshow @end iftex @c @starindex @tindex acute @c @starindex @tindex bar @c @starindex @tindex breve @c @starindex @tindex check @c @starindex @tindex dot @c @starindex @tindex dotdot @c @starindex @tindex dyad @c @starindex @tindex grave @c @starindex @tindex hat @c @starindex @tindex Prime @c @starindex @tindex tilde @c @starindex @tindex under @c @starindex @tindex Vec @iftex @endgroup @end iftex @example Calc TeX eqn ---- --- --- acute \acute bar \bar bar breve \breve check \check dot \dot dot dotdot \ddot dotdot dyad dyad grave \grave hat \hat hat Prime prime tilde \tilde tilde under \underline under Vec \vec vec @end example The @samp{=>} (evaluates-to) operator appears as a @code{\to} symbol: @samp{@{@var{a} \to @var{b}@}}. @TeX{} defines @code{\to} as an alias for @code{\rightarrow}. However, if the @samp{=>} is the top-level expression being formatted, a slightly different notation is used: @samp{\evalto @var{a} \to @var{b}}. The @code{\evalto} word is ignored by Calc's input routines, and is undefined in @TeX{}. You will typically want to include one of the following definitions at the top of a @TeX{} file that uses @code{\evalto}: @example \def\evalto@{@} \def\evalto#1\to@{@} @end example The first definition formats evaluates-to operators in the usual way. The second causes only the @var{b} part to appear in the printed document; the @var{a} part and the arrow are hidden. Another definition you may wish to use is @samp{\let\to=\Rightarrow} which causes @code{\to} to appear more like Calc's @samp{=>} symbol. @xref{Evaluates-To Operator}, for a discussion of @code{evalto}. The complete set of @TeX{} control sequences that are ignored during reading is: @example \hbox \mbox \text \left \right \, \> \: \; \! \quad \qquad \hfil \hfill \displaystyle \textstyle \dsize \tsize \scriptstyle \scriptscriptstyle \ssize \ssize \rm \bf \it \sl \roman \bold \italic \slanted \cal \mit \Cal \Bbb \frak \goth \evalto @end example Note that, because these symbols are ignored, reading a @TeX{} formula into Calc and writing it back out may lose spacing and font information. Also, the ``discretionary multiplication sign'' @samp{\*} is read the same as @samp{*}. @ifinfo The @TeX{} version of this manual includes some printed examples at the end of this section. @end ifinfo @iftex Here are some examples of how various Calc formulas are formatted in @TeX{}: @group @example sin(a^2 / b_i) \sin\left( {a^2 \over b_i} \right) @end example @tex \let\rm\goodrm $$ \sin\left( a^2 \over b_i \right) $$ @end tex @sp 1 @end group @group @example [(3, 4), 3:4, 3 +/- 4, [3 .. inf)] [3 + 4i, @{3 \over 4@}, 3 \pm 4, [3 \ldots \infty)] @end example @tex \turnoffactive $$ [3 + 4i, {3 \over 4}, 3 \pm 4, [ 3 \ldots \infty)] $$ @end tex @sp 1 @end group @group @example [abs(a), abs(a / b), floor(a), ceil(a / b)] [|a|, \left| a \over b \right|, \lfloor a \rfloor, \left\lceil a \over b \right\rceil] @end example @tex $$ [|a|, \left| a \over b \right|, \lfloor a \rfloor, \left\lceil a \over b \right\rceil] $$ @end tex @sp 1 @end group @group @example [sin(a), sin(2 a), sin(2 + a), sin(a / b)] [\sin@{a@}, \sin@{2 a@}, \sin(2 + a), \sin\left( @{a \over b@} \right)] @end example @tex \turnoffactive\let\rm\goodrm $$ [\sin{a}, \sin{2 a}, \sin(2 + a), \sin\left( {a \over b} \right)] $$ @end tex @sp 2 @end group @group First with plain @kbd{d T}, then with @kbd{C-u d T}, then finally with @kbd{C-u - d T} (using the example definition @samp{\def\foo#1@{\tilde F(#1)@}}: @example [f(a), foo(bar), sin(pi)] [f(a), foo(bar), \sin{\pi}] [f(a), \hbox@{foo@}(\hbox@{bar@}), \sin@{\pi@}] [f(a), \foo@{\hbox@{bar@}@}, \sin@{\pi@}] @end example @tex \let\rm\goodrm $$ [f(a), foo(bar), \sin{\pi}] $$ $$ [f(a), \hbox{foo}(\hbox{bar}), \sin{\pi}] $$ $$ [f(a), \tilde F(\hbox{bar}), \sin{\pi}] $$ @end tex @sp 2 @end group @group First with @samp{\def\evalto@{@}}, then with @samp{\def\evalto#1\to@{@}}: @example 2 + 3 => 5 \evalto 2 + 3 \to 5 @end example @tex \turnoffactive $$ 2 + 3 \to 5 $$ $$ 5 $$ @end tex @sp 2 @end group @group First with standard @code{\to}, then with @samp{\let\to\Rightarrow}: @example [2 + 3 => 5, a / 2 => (b + c) / 2] [@{2 + 3 \to 5@}, @{@{a \over 2@} \to @{b + c \over 2@}@}] @end example @tex \turnoffactive $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$ {\let\to\Rightarrow $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$} @end tex @sp 2 @end group @group Matrices normally, then changing @code{\matrix} to @code{\pmatrix}: @example [ [ a / b, 0 ], [ 0, 2^(x + 1) ] ] \matrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @} \pmatrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @} @end example @tex \turnoffactive $$ \matrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$ $$ \pmatrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$ @end tex @sp 2 @end group @end iftex @node Eqn Language Mode, Mathematica Language Mode, TeX Language Mode, Language Modes @subsection Eqn Language Mode @noindent @kindex d E @pindex calc-eqn-language @dfn{Eqn} is another popular formatter for math formulas. It is designed for use with the TROFF text formatter, and comes standard with many versions of Unix. The @kbd{d E} (@code{calc-eqn-language}) command selects @dfn{eqn} notation. The @dfn{eqn} language's main idiosyncrasy is that whitespace plays a significant part in the parsing of the language. For example, @samp{sqrt x+1 + y} treats @samp{x+1} as the argument of the @code{sqrt} operator. @dfn{Eqn} also understands more conventional grouping using curly braces: @samp{sqrt@{x+1@} + y}. Braces are required only when the argument contains spaces. In Calc's @dfn{eqn} mode, however, curly braces are required to delimit arguments of operators like @code{sqrt}. The first of the above examples would treat only the @samp{x} as the argument of @code{sqrt}, and in fact @samp{sin x+1} would be interpreted as @samp{sin * x + 1}, because @code{sin} is not a special operator in the @dfn{eqn} language. If you always surround the argument with curly braces, Calc will never misunderstand. Calc also understands parentheses as grouping characters. Another peculiarity of @dfn{eqn}'s syntax makes it advisable to separate words with spaces from any surrounding characters that aren't curly braces, so Calc writes @samp{sin ( x + y )} in @dfn{eqn} mode. (The spaces around @code{sin} are important to make @dfn{eqn} recognize that @code{sin} should be typeset in a roman font, and the spaces around @code{x} and @code{y} are a good idea just in case the @dfn{eqn} document has defined special meanings for these names, too.) Powers and subscripts are written with the @code{sub} and @code{sup} operators, respectively. Note that the caret symbol @samp{^} is treated the same as a space in @dfn{eqn} mode, as is the @samp{~} symbol (these are used to introduce spaces of various widths into the typeset output of @dfn{eqn}). As in @TeX{} mode, Calc's formatter omits parentheses around the arguments of functions like @code{ln} and @code{sin} if they are ``simple-looking''; in this case Calc surrounds the argument with braces, separated by a @samp{~} from the function name: @samp{sin~@{x@}}. Font change codes (like @samp{roman @var{x}}) and positioning codes (like @samp{~} and @samp{down @var{n} @var{x}}) are ignored by the @dfn{eqn} reader. Also ignored are the words @code{left}, @code{right}, @code{mark}, and @code{lineup}. Quotation marks in @dfn{eqn} mode input are treated the same as curly braces: @samp{sqrt "1+x"} is equivalent to @samp{sqrt @{1+x@}}; this is only an approximation to the true meaning of quotes in @dfn{eqn}, but it is good enough for most uses. Accent codes (@samp{@var{x} dot}) are handled by treating them as function calls (@samp{dot(@var{x})}) internally. @xref{TeX Language Mode} for a table of these accent functions. The @code{prime} accent is treated specially if it occurs on a variable or function name: @samp{f prime prime @w{( x prime )}} is stored internally as @samp{f'@w{'}(x')}. For example, taking the derivative of @samp{f(2 x)} with @kbd{a d x} will produce @samp{2 f'(2 x)}, which @dfn{eqn} mode will display as @samp{2 f prime ( 2 x )}. Assignments are written with the @samp{<-} (left-arrow) symbol, and @code{evalto} operators are written with @samp{->} or @samp{evalto ... ->} (@pxref{TeX Language Mode}, for a discussion of this). The regular Calc symbols @samp{:=} and @samp{=>} are also recognized for these operators during reading. Vectors in @dfn{eqn} mode use regular Calc square brackets, but matrices are formatted as @samp{matrix @{ ccol @{ a above b @} ... @}}. The words @code{lcol} and @code{rcol} are recognized as synonyms for @code{ccol} during input, and are generated instead of @code{ccol} if the matrix justification mode so specifies. @node Mathematica Language Mode, Maple Language Mode, Eqn Language Mode, Language Modes @subsection Mathematica Language Mode @noindent @kindex d M @pindex calc-mathematica-language @cindex Mathematica language The @kbd{d M} (@code{calc-mathematica-language}) command selects the conventions of Mathematica, a powerful and popular mathematical tool from Wolfram Research, Inc. Notable differences in Mathematica mode are that the names of built-in functions are capitalized, and function calls use square brackets instead of parentheses. Thus the Calc formula @samp{sin(2 x)} is entered and displayed @w{@samp{Sin[2 x]}} in Mathematica mode. Vectors and matrices use curly braces in Mathematica. Complex numbers are written @samp{3 + 4 I}. The standard special constants in Calc are written @code{Pi}, @code{E}, @code{I}, @code{GoldenRatio}, @code{EulerGamma}, @code{Infinity}, @code{ComplexInfinity}, and @code{Indeterminate} in Mathematica mode. Non-decimal numbers are written, e.g., @samp{16^^7fff}. Floating-point numbers in scientific notation are written @samp{1.23*10.^3}. Subscripts use double square brackets: @samp{a[[i]]}.@refill @node Maple Language Mode, Compositions, Mathematica Language Mode, Language Modes @subsection Maple Language Mode @noindent @kindex d W @pindex calc-maple-language @cindex Maple language The @kbd{d W} (@code{calc-maple-language}) command selects the conventions of Maple, another mathematical tool from the University of Waterloo. Maple's language is much like C. Underscores are allowed in symbol names; square brackets are used for subscripts; explicit @samp{*}s for multiplications are required. Use either @samp{^} or @samp{**} to denote powers. Maple uses square brackets for lists and curly braces for sets. Calc interprets both notations as vectors, and displays vectors with square brackets. This means Maple sets will be converted to lists when they pass through Calc. As a special case, matrices are written as calls to the function @code{matrix}, given a list of lists as the argument, and can be read in this form or with all-capitals @code{MATRIX}. The Maple interval notation @samp{2 .. 3} has no surrounding brackets; Calc reads @samp{2 .. 3} as the closed interval @samp{[2 .. 3]}, and writes any kind of interval as @samp{2 .. 3}. This means you cannot see the difference between an open and a closed interval while in Maple display mode. Maple writes complex numbers as @samp{3 + 4*I}. Its special constants are @code{Pi}, @code{E}, @code{I}, and @code{infinity} (all three of @code{inf}, @code{uinf}, and @code{nan} display as @code{infinity}). Floating-point numbers are written @samp{1.23*10.^3}. Among things not currently handled by Calc's Maple mode are the various quote symbols, procedures and functional operators, and inert (@samp{&}) operators. @node Compositions, Syntax Tables, Maple Language Mode, Language Modes @subsection Compositions @noindent @cindex Compositions There are several @dfn{composition functions} which allow you to get displays in a variety of formats similar to those in Big language mode. Most of these functions do not evaluate to anything; they are placeholders which are left in symbolic form by Calc's evaluator but are recognized by Calc's display formatting routines. Two of these, @code{string} and @code{bstring}, are described elsewhere. @xref{Strings}. For example, @samp{string("ABC")} is displayed as @samp{ABC}. When viewed on the stack it will be indistinguishable from the variable @code{ABC}, but internally it will be stored as @samp{string([65, 66, 67])} and can still be manipulated this way; for example, the selection and vector commands @kbd{j 1 v v j u} would select the vector portion of this object and reverse the elements, then deselect to reveal a string whose characters had been reversed. The composition functions do the same thing in all language modes (although their components will of course be formatted in the current language mode). The one exception is Unformatted mode (@kbd{d U}), which does not give the composition functions any special treatment. The functions are discussed here because of their relationship to the language modes. @menu * Composition Basics:: * Horizontal Compositions:: * Vertical Compositions:: * Other Compositions:: * Information about Compositions:: * User-Defined Compositions:: @end menu @node Composition Basics, Horizontal Compositions, Compositions, Compositions @subsubsection Composition Basics @noindent Compositions are generally formed by stacking formulas together horizontally or vertically in various ways. Those formulas are themselves compositions. @TeX{} users will find this analogous to @TeX{}'s ``boxes.'' Each multi-line composition has a @dfn{baseline}; horizontal compositions use the baselines to decide how formulas should be positioned relative to one another. For example, in the Big mode formula @group @example 2 a + b 17 + ------ c @end example @end group @noindent the second term of the sum is four lines tall and has line three as its baseline. Thus when the term is combined with 17, line three is placed on the same level as the baseline of 17. @tex \bigskip @end tex Another important composition concept is @dfn{precedence}. This is an integer that represents the binding strength of various operators. For example, @samp{*} has higher precedence (195) than @samp{+} (180), which means that @samp{(a * b) + c} will be formatted without the parentheses, but @samp{a * (b + c)} will keep the parentheses. The operator table used by normal and Big language modes has the following precedences: @example _ 1200 @r{(subscripts)} % 1100 @r{(as in n}%@r{)} - 1000 @r{(as in }-@r{n)} ! 1000 @r{(as in }!@r{n)} mod 400 +/- 300 !! 210 @r{(as in n}!!@r{)} ! 210 @r{(as in n}!@r{)} ^ 200 * 195 @r{(or implicit multiplication)} / % \ 190 + - 180 @r{(as in a}+@r{b)} | 170 < = 160 @r{(and other relations)} && 110 || 100 ? : 90 !!! 85 &&& 80 ||| 75 := 50 :: 45 => 40 @end example The general rule is that if an operator with precedence @cite{n} occurs as an argument to an operator with precedence @cite{m}, then the argument is enclosed in parentheses if @cite{n < m}. Top-level expressions and expressions which are function arguments, vector components, etc., are formatted with precedence zero (so that they normally never get additional parentheses). For binary left-associative operators like @samp{+}, the righthand argument is actually formatted with one-higher precedence than shown in the table. This makes sure @samp{(a + b) + c} omits the parentheses, but the unnatural form @samp{a + (b + c)} keeps its parentheses. Right-associative operators like @samp{^} format the lefthand argument with one-higher precedence. @c @starindex @tindex cprec The @code{cprec} function formats an expression with an arbitrary precedence. For example, @samp{cprec(abc, 185)} will combine into sums and products as follows: @samp{7 + abc}, @samp{7 (abc)} (because this @code{cprec} form has higher precedence than addition, but lower precedence than multiplication). @tex \bigskip @end tex A final composition issue is @dfn{line breaking}. Calc uses two different strategies for ``flat'' and ``non-flat'' compositions. A non-flat composition is anything that appears on multiple lines (not counting line breaking). Examples would be matrices and Big mode powers and quotients. Non-flat compositions are displayed exactly as specified. If they come out wider than the current window, you must use horizontal scrolling (@kbd{<} and @kbd{>}) to view them. Flat compositions, on the other hand, will be broken across several lines if they are too wide to fit the window. Certain points in a composition are noted internally as @dfn{break points}. Calc's general strategy is to fill each line as much as possible, then to move down to the next line starting at the first break point that didn't fit. However, the line breaker understands the hierarchical structure of formulas. It will not break an ``inner'' formula if it can use an earlier break point from an ``outer'' formula instead. For example, a vector of sums might be formatted as: @group @example [ a + b + c, d + e + f, g + h + i, j + k + l, m ] @end example @end group @noindent If the @samp{m} can fit, then so, it seems, could the @samp{g}. But Calc prefers to break at the comma since the comma is part of a ``more outer'' formula. Calc would break at a plus sign only if it had to, say, if the very first sum in the vector had itself been too large to fit. Of the composition functions described below, only @code{choriz} generates break points. The @code{bstring} function (@pxref{Strings}) also generates breakable items: A break point is added after every space (or group of spaces) except for spaces at the very beginning or end of the string. Composition functions themselves count as levels in the formula hierarchy, so a @code{choriz} that is a component of a larger @code{choriz} will be less likely to be broken. As a special case, if a @code{bstring} occurs as a component of a @code{choriz} or @code{choriz}-like object (such as a vector or a list of arguments in a function call), then the break points in that @code{bstring} will be on the same level as the break points of the surrounding object. @node Horizontal Compositions, Vertical Compositions, Composition Basics, Compositions @subsubsection Horizontal Compositions @noindent @c @starindex @tindex choriz The @code{choriz} function takes a vector of objects and composes them horizontally. For example, @samp{choriz([17, a b/c, d])} formats as @w{@samp{17a b / cd}} in normal language mode, or as @group @example a b 17---d c @end example @end group @noindent in Big language mode. This is actually one case of the general function @samp{choriz(@var{vec}, @var{sep}, @var{prec})}, where either or both of @var{sep} and @var{prec} may be omitted. @var{Prec} gives the @dfn{precedence} to use when formatting each of the components of @var{vec}. The default precedence is the precedence from the surrounding environment. @var{Sep} is a string (i.e., a vector of character codes as might be entered with @code{" "} notation) which should separate components of the composition. Also, if @var{sep} is given, the line breaker will allow lines to be broken after each occurrence of @var{sep}. If @var{sep} is omitted, the composition will not be breakable (unless any of its component compositions are breakable). For example, @samp{2 choriz([a, b c, d = e], " + ", 180)} is formatted as @samp{2 a + b c + (d = e)}. To get the @code{choriz} to have precedence 180 ``outwards'' as well as ``inwards,'' enclose it in a @code{cprec} form: @samp{2 cprec(choriz(...), 180)} formats as @samp{2 (a + b c + (d = e))}. The baseline of a horizontal composition is the same as the baselines of the component compositions, which are all aligned. @node Vertical Compositions, Other Compositions, Horizontal Compositions, Compositions @subsubsection Vertical Compositions @noindent @c @starindex @tindex cvert The @code{cvert} function makes a vertical composition. Each component of the vector is centered in a column. The baseline of the result is by default the top line of the resulting composition. For example, @samp{f(cvert([a, bb, ccc]), cvert([a^2 + 1, b^2]))} formats in Big mode as @group @example f( a , 2 ) bb a + 1 ccc 2 b @end example @end group @c @starindex @tindex cbase There are several special composition functions that work only as components of a vertical composition. The @code{cbase} function controls the baseline of the vertical composition; the baseline will be the same as the baseline of whatever component is enclosed in @code{cbase}. Thus @samp{f(cvert([a, cbase(bb), ccc]), cvert([a^2 + 1, cbase(b^2)]))} displays as @group @example 2 a + 1 a 2 f(bb , b ) ccc @end example @end group @c @starindex @tindex ctbase @c @starindex @tindex cbbase There are also @code{ctbase} and @code{cbbase} functions which make the baseline of the vertical composition equal to the top or bottom line (rather than the baseline) of that component. Thus @samp{cvert([cbase(a / b)]) + cvert([ctbase(a / b)]) + cvert([cbbase(a / b)])} gives @group @example a a - - + a + b b - b @end example @end group There should be only one @code{cbase}, @code{ctbase}, or @code{cbbase} function in a given vertical composition. These functions can also be written with no arguments: @samp{ctbase()} is a zero-height object which means the baseline is the top line of the following item, and @samp{cbbase()} means the baseline is the bottom line of the preceding item. @c @starindex @tindex crule The @code{crule} function builds a ``rule,'' or horizontal line, across a vertical composition. By itself @samp{crule()} uses @samp{-} characters to build the rule. You can specify any other character, e.g., @samp{crule("=")}. The argument must be a character code or vector of exactly one character code. It is repeated to match the width of the widest item in the stack. For example, a quotient with a thick line is @samp{cvert([a + 1, cbase(crule("=")), b^2])}: @group @example a + 1 ===== 2 b @end example @end group @c @starindex @tindex clvert @c @starindex @tindex crvert Finally, the functions @code{clvert} and @code{crvert} act exactly like @code{cvert} except that the items are left- or right-justified in the stack. Thus @samp{clvert([a, bb, ccc]) + crvert([a, bb, ccc])} gives: @group @example a + a bb bb ccc ccc @end example @end group Like @code{choriz}, the vertical compositions accept a second argument which gives the precedence to use when formatting the components. Vertical compositions do not support separator strings. @node Other Compositions, Information about Compositions, Vertical Compositions, Compositions @subsubsection Other Compositions @noindent @c @starindex @tindex csup The @code{csup} function builds a superscripted expression. For example, @samp{csup(a, b)} looks the same as @samp{a^b} does in Big language mode. This is essentially a horizontal composition of @samp{a} and @samp{b}, where @samp{b} is shifted up so that its bottom line is one above the baseline. @c @starindex @tindex csub Likewise, the @code{csub} function builds a subscripted expression. This shifts @samp{b} down so that its top line is one below the bottom line of @samp{a} (note that this is not quite analogous to @code{csup}). Other arrangements can be obtained by using @code{choriz} and @code{cvert} directly. @c @starindex @tindex cflat The @code{cflat} function formats its argument in ``flat'' mode, as obtained by @samp{d O}, if the current language mode is normal or Big. It has no effect in other language modes. For example, @samp{a^(b/c)} is formatted by Big mode like @samp{csup(a, cflat(b/c))} to improve its readability. @c @starindex @tindex cspace The @code{cspace} function creates horizontal space. For example, @samp{cspace(4)} is effectively the same as @samp{string(" ")}. A second string (i.e., vector of characters) argument is repeated instead of the space character. For example, @samp{cspace(4, "ab")} looks like @samp{abababab}. If the second argument is not a string, it is formatted in the normal way and then several copies of that are composed together: @samp{cspace(4, a^2)} yields @group @example 2 2 2 2 a a a a @end example @end group @noindent If the number argument is zero, this is a zero-width object. @c @starindex @tindex cvspace The @code{cvspace} function creates vertical space, or a vertical stack of copies of a certain string or formatted object. The baseline is the center line of the resulting stack. A numerical argument of zero will produce an object which contributes zero height if used in a vertical composition. @c @starindex @tindex ctspace @c @starindex @tindex cbspace There are also @code{ctspace} and @code{cbspace} functions which create vertical space with the baseline the same as the baseline of the top or bottom copy, respectively, of the second argument. Thus @samp{cvspace(2, a/b) + ctspace(2, a/b) + cbspace(2, a/b)} displays as: @group @example a - a b - a a b + - + - a b b - a b - b @end example @end group @node Information about Compositions, User-Defined Compositions, Other Compositions, Compositions @subsubsection Information about Compositions @noindent The functions in this section are actual functions; they compose their arguments according to the current language and other display modes, then return a certain measurement of the composition as an integer. @c @starindex @tindex cwidth The @code{cwidth} function measures the width, in characters, of a composition. For example, @samp{cwidth(a + b)} is 5, and @samp{cwidth(a / b)} is 5 in normal mode, 1 in Big mode, and 11 in @TeX{} mode (for @samp{@{a \over b@}}). The argument may involve the composition functions described in this section. @c @starindex @tindex cheight The @code{cheight} function measures the height of a composition. This is the total number of lines in the argument's printed form. @c @starindex @tindex cascent @c @starindex @tindex cdescent The functions @code{cascent} and @code{cdescent} measure the amount of the height that is above (and including) the baseline, or below the baseline, respectively. Thus @samp{cascent(@var{x}) + cdescent(@var{x})} always equals @samp{cheight(@var{x})}. For a one-line formula like @samp{a + b}, @code{cascent} returns 1 and @code{cdescent} returns 0. For @samp{a / b} in Big mode, @code{cascent} returns 2 and @code{cdescent} returns 1. The only formula for which @code{cascent} will return zero is @samp{cvspace(0)} or equivalents. @node User-Defined Compositions, , Information about Compositions, Compositions @subsubsection User-Defined Compositions @noindent @kindex Z C @pindex calc-user-define-composition The @kbd{Z C} (@code{calc-user-define-composition}) command lets you define the display format for any algebraic function. You provide a formula containing a certain number of argument variables on the stack. Any time Calc formats a call to the specified function in the current language mode and with that number of arguments, Calc effectively replaces the function call with that formula with the arguments replaced. Calc builds the default argument list by sorting all the variable names that appear in the formula into alphabetical order. You can edit this argument list before pressing @key{RET} if you wish. Any variables in the formula that do not appear in the argument list will be displayed literally; any arguments that do not appear in the formula will not affect the display at all. You can define formats for built-in functions, for functions you have defined with @kbd{Z F} (@pxref{Algebraic Definitions}), or for functions which have no definitions but are being used as purely syntactic objects. You can define different formats for each language mode, and for each number of arguments, using a succession of @kbd{Z C} commands. When Calc formats a function call, it first searches for a format defined for the current language mode (and number of arguments); if there is none, it uses the format defined for the Normal language mode. If neither format exists, Calc uses its built-in standard format for that function (usually just @samp{@var{func}(@var{args})}). If you execute @kbd{Z C} with the number 0 on the stack instead of a formula, any defined formats for the function in the current language mode will be removed. The function will revert to its standard format. For example, the default format for the binomial coefficient function @samp{choose(n, m)} in the Big language mode is @group @example n ( ) m @end example @end group @noindent You might prefer the notation, @group @example C n m @end example @end group @noindent To define this notation, first make sure you are in Big mode, then put the formula @smallexample choriz([cvert([cvspace(1), n]), C, cvert([cvspace(1), m])]) @end smallexample @noindent on the stack and type @kbd{Z C}. Answer the first prompt with @code{choose}. The second prompt will be the default argument list of @samp{(C m n)}. Edit this list to be @samp{(n m)} and press @key{RET}. Now, try it out: For example, turn simplification off with @kbd{m O} and enter @samp{choose(a,b) + choose(7,3)} as an algebraic entry. @group @example C + C a b 7 3 @end example @end group As another example, let's define the usual notation for Stirling numbers of the first kind, @samp{stir1(n, m)}. This is just like the regular format for binomial coefficients but with square brackets instead of parentheses. @smallexample choriz([string("["), cvert([n, cbase(cvspace(1)), m]), string("]")]) @end smallexample Now type @kbd{Z C stir1 @key{RET}}, edit the argument list to @samp{(n m)}, and type @key{RET}. The formula provided to @kbd{Z C} usually will involve composition functions, but it doesn't have to. Putting the formula @samp{a + b + c} onto the stack and typing @kbd{Z C foo @key{RET} @key{RET}} would define the function @samp{foo(x,y,z)} to display like @samp{x + y + z}. This ``sum'' will act exactly like a real sum for all formatting purposes (it will be parenthesized the same, and so on). However it will be computationally unrelated to a sum. For example, the formula @samp{2 * foo(1, 2, 3)} will display as @samp{2 (1 + 2 + 3)}. Operator precedences have caused the ``sum'' to be written in parentheses, but the arguments have not actually been summed. (Generally a display format like this would be undesirable, since it can easily be confused with a real sum.) The special function @code{eval} can be used inside a @kbd{Z C} composition formula to cause all or part of the formula to be evaluated at display time. For example, if the formula is @samp{a + eval(b + c)}, then @samp{foo(1, 2, 3)} will be displayed as @samp{1 + 5}. Evaluation will use the default simplifications, regardless of the current simplification mode. There are also @code{evalsimp} and @code{evalextsimp} which simplify as if by @kbd{a s} and @kbd{a e} (respectively). Note that these ``functions'' operate only in the context of composition formulas (and also in rewrite rules, where they serve a similar purpose; @pxref{Rewrite Rules}). On the stack, a call to @code{eval} will be left in symbolic form. It is not a good idea to use @code{eval} except as a last resort. It can cause the display of formulas to be extremely slow. For example, while @samp{eval(a + b)} might seem quite fast and simple, there are several situations where it could be slow. For example, @samp{a} and/or @samp{b} could be polar complex numbers, in which case doing the sum requires trigonometry. Or, @samp{a} could be the factorial @samp{fact(100)} which is unevaluated because you have typed @kbd{m O}; @code{eval} will evaluate it anyway to produce a large, unwieldy integer. You can save your display formats permanently using the @kbd{Z P} command (@pxref{Creating User Keys}). @node Syntax Tables, , Compositions, Language Modes @subsection Syntax Tables @noindent @cindex Syntax tables @cindex Parsing formulas, customized Syntax tables do for input what compositions do for output: They allow you to teach custom notations to Calc's formula parser. Calc keeps a separate syntax table for each language mode. (Note that the Calc ``syntax tables'' discussed here are completely unrelated to the syntax tables described in the Emacs manual.) @kindex Z S @pindex calc-edit-user-syntax The @kbd{Z S} (@code{calc-edit-user-syntax}) command edits the syntax table for the current language mode. If you want your syntax to work in any language, define it in the normal language mode. Type @kbd{M-# M-#} to finish editing the syntax table, or @kbd{M-# x} to cancel the edit. The @kbd{m m} command saves all the syntax tables along with the other mode settings; @pxref{General Mode Commands}. @menu * Syntax Table Basics:: * Precedence in Syntax Tables:: * Advanced Syntax Patterns:: * Conditional Syntax Rules:: @end menu @node Syntax Table Basics, Precedence in Syntax Tables, Syntax Tables, Syntax Tables @subsubsection Syntax Table Basics @noindent @dfn{Parsing} is the process of converting a raw string of characters, such as you would type in during algebraic entry, into a Calc formula. Calc's parser works in two stages. First, the input is broken down into @dfn{tokens}, such as words, numbers, and punctuation symbols like @samp{+}, @samp{:=}, and @samp{+/-}. Space between tokens is ignored (except when it serves to separate adjacent words). Next, the parser matches this string of tokens against various built-in syntactic patterns, such as ``an expression followed by @samp{+} followed by another expression'' or ``a name followed by @samp{(}, zero or more expressions separated by commas, and @samp{)}.'' A @dfn{syntax table} is a list of user-defined @dfn{syntax rules}, which allow you to specify new patterns to define your own favorite input notations. Calc's parser always checks the syntax table for the current language mode, then the table for the normal language mode, before it uses its built-in rules to parse an algebraic formula you have entered. Each syntax rule should go on its own line; it consists of a @dfn{pattern}, a @samp{:=} symbol, and a Calc formula with an optional @dfn{condition}. (Syntax rules resemble algebraic rewrite rules, but the notation for patterns is completely different.) A syntax pattern is a list of tokens, separated by spaces. Except for a few special symbols, tokens in syntax patterns are matched literally, from left to right. For example, the rule, @example foo ( ) := 2+3 @end example @noindent would cause Calc to parse the formula @samp{4+foo()*5} as if it were @samp{4+(2+3)*5}. Notice that the parentheses were written as two separate tokens in the rule. As a result, the rule works for both @samp{foo()} and @w{@samp{foo ( )}}. If we had written the rule as @samp{foo () := 2+3}, then Calc would treat @samp{()} as a single, indivisible token, so that @w{@samp{foo( )}} would not be recognized by the rule. (It would be parsed as a regular zero-argument function call instead.) In fact, this rule would also make trouble for the rest of Calc's parser: An unrelated formula like @samp{bar()} would now be tokenized into @samp{bar ()} instead of @samp{bar ( )}, so that the standard parser for function calls would no longer recognize it! While it is possible to make a token with a mixture of letters and punctuation symbols, this is not recommended. It is better to break it into several tokens, as we did with @samp{foo()} above. The symbol @samp{#} in a syntax pattern matches any Calc expression. On the righthand side, the things that matched the @samp{#}s can be referred to as @samp{#1}, @samp{#2}, and so on (where @samp{#1} matches the leftmost @samp{#} in the pattern). For example, these rules match a user-defined function, prefix operator, infix operator, and postfix operator, respectively: @example foo ( # ) := myfunc(#1) foo # := myprefix(#1) # foo # := myinfix(#1,#2) # foo := mypostfix(#1) @end example Thus @samp{foo(3)} will parse as @samp{myfunc(3)}, and @samp{2+3 foo} will parse as @samp{mypostfix(2+3)}. It is important to write the first two rules in the order shown, because Calc tries rules in order from first to last. If the pattern @samp{foo #} came first, it would match anything that could match the @samp{foo ( # )} rule, since an expression in parentheses is itself a valid expression. Thus the @w{@samp{foo ( # )}} rule would never get to match anything. Likewise, the last two rules must be written in the order shown or else @samp{3 foo 4} will be parsed as @samp{mypostfix(3) * 4}. (Of course, the best way to avoid these ambiguities is not to use the same symbol in more than one way at the same time! In case you're not convinced, try the following exercise: How will the above rules parse the input @samp{foo(3,4)}, if at all? Work it out for yourself, then try it in Calc and see.) Calc is quite flexible about what sorts of patterns are allowed. The only rule is that every pattern must begin with a literal token (like @samp{foo} in the first two patterns above), or with a @samp{#} followed by a literal token (as in the last two patterns). After that, any mixture is allowed, although putting two @samp{#}s in a row will not be very useful since two expressions with nothing between them will be parsed as one expression that uses implicit multiplication. As a more practical example, Maple uses the notation @samp{sum(a(i), i=1..10)} for sums, which Calc's Maple mode doesn't recognize at present. To handle this syntax, we simply add the rule, @example sum ( # , # = # .. # ) := sum(#1,#2,#3,#4) @end example @noindent to the Maple mode syntax table. As another example, C mode can't read assignment operators like @samp{++} and @samp{*=}. We can define these operators quite easily: @example # *= # := muleq(#1,#2) # ++ := postinc(#1) ++ # := preinc(#1) @end example @noindent To complete the job, we would use corresponding composition functions and @kbd{Z C} to cause these functions to display in their respective Maple and C notations. (Note that the C example ignores issues of operator precedence, which are discussed in the next section.) You can enclose any token in quotes to prevent its usual interpretation in syntax patterns: @example # ":=" # := becomes(#1,#2) @end example Quotes also allow you to include spaces in a token, although once again it is generally better to use two tokens than one token with an embedded space. To include an actual quotation mark in a quoted token, precede it with a backslash. (This also works to include backslashes in tokens.) @example # "bad token" # "/\"\\" # := silly(#1,#2,#3) @end example @noindent This will parse @samp{3 bad token 4 /"\ 5} to @samp{silly(3,4,5)}. The token @kbd{#} has a predefined meaning in Calc's formula parser; it is not legal to use @samp{"#"} in a syntax rule. However, longer tokens that include the @samp{#} character are allowed. Also, while @samp{"$"} and @samp{"\""} are allowed as tokens, their presence in the syntax table will prevent those characters from working in their usual ways (referring to stack entries and quoting strings, respectively). Finally, the notation @samp{%%} anywhere in a syntax table causes the rest of the line to be ignored as a comment. @node Precedence in Syntax Tables, Advanced Syntax Patterns, Syntax Table Basics, Syntax Tables @subsubsection Precedence @noindent Different operators are generally assigned different @dfn{precedences}. By default, an operator defined by a rule like @example # foo # := foo(#1,#2) @end example @noindent will have an extremely low precedence, so that @samp{2*3+4 foo 5 == 6} will be parsed as @samp{(2*3+4) foo (5 == 6)}. To change the precedence of an operator, use the notation @samp{#/@var{p}} in place of @samp{#}, where @var{p} is an integer precedence level. For example, 185 lies between the precedences for @samp{+} and @samp{*}, so if we change this rule to @example #/185 foo #/186 := foo(#1,#2) @end example @noindent then @samp{2+3 foo 4*5} will be parsed as @samp{2+(3 foo (4*5))}. Also, because we've given the righthand expression slightly higher precedence, our new operator will be left-associative: @samp{1 foo 2 foo 3} will be parsed as @samp{(1 foo 2) foo 3}. By raising the precedence of the lefthand expression instead, we can create a right-associative operator. @xref{Composition Basics}, for a table of precedences of the standard Calc operators. For the precedences of operators in other language modes, look in the Calc source file @file{calc-lang.el}. @node Advanced Syntax Patterns, Conditional Syntax Rules, Precedence in Syntax Tables, Syntax Tables @subsubsection Advanced Syntax Patterns @noindent To match a function with a variable number of arguments, you could write @example foo ( # ) := myfunc(#1) foo ( # , # ) := myfunc(#1,#2) foo ( # , # , # ) := myfunc(#1,#2,#3) @end example @noindent but this isn't very elegant. To match variable numbers of items, Calc uses some notations inspired regular expressions and the ``extended BNF'' style used by some language designers. @example foo ( @{ # @}*, ) := apply(myfunc,#1) @end example The token @samp{@{} introduces a repeated or optional portion. One of the three tokens @samp{@}*}, @samp{@}+}, or @samp{@}?} ends the portion. These will match zero or more, one or more, or zero or one copies of the enclosed pattern, respectively. In addition, @samp{@}*} and @samp{@}+} can be followed by a separator token (with no space in between, as shown above). Thus @samp{@{ # @}*,} matches nothing, or one expression, or several expressions separated by commas. A complete @samp{@{ ... @}} item matches as a vector of the items that matched inside it. For example, the above rule will match @samp{foo(1,2,3)} to get @samp{apply(myfunc,[1,2,3])}. The Calc @code{apply} function takes a function name and a vector of arguments and builds a call to the function with those arguments, so the net result is the formula @samp{myfunc(1,2,3)}. If the body of a @samp{@{ ... @}} contains several @samp{#}s (or nested @samp{@{ ... @}} constructs), then the items will be strung together into the resulting vector. If the body does not contain anything but literal tokens, the result will always be an empty vector. @example foo ( @{ # , # @}+, ) := bar(#1) foo ( @{ @{ # @}*, @}*; ) := matrix(#1) @end example @noindent will parse @samp{foo(1,2,3,4)} as @samp{bar([1,2,3,4])}, and @samp{foo(1,2;3,4)} as @samp{matrix([[1,2],[3,4]])}. Also, after some thought it's easy to see how this pair of rules will parse @samp{foo(1,2,3)} as @samp{matrix([[1,2,3]])}, since the first rule will only match an even number of arguments. The rule @example foo ( # @{ , # , # @}? ) := bar(#1,#2) @end example @noindent will parse @samp{foo(2,3,4)} as @samp{bar(2,[3,4])}, and @samp{foo(2)} as @samp{bar(2,[])}. The notation @samp{@{ ... @}?.} (note the trailing period) works just the same as regular @samp{@{ ... @}?}, except that it does not count as an argument; the following two rules are equivalent: @example foo ( # , @{ also @}? # ) := bar(#1,#3) foo ( # , @{ also @}?. # ) := bar(#1,#2) @end example @noindent Note that in the first case the optional text counts as @samp{#2}, which will always be an empty vector, but in the second case no empty vector is produced. Another variant is @samp{@{ ... @}?$}, which means the body is optional only at the end of the input formula. All built-in syntax rules in Calc use this for closing delimiters, so that during algebraic entry you can type @kbd{[sqrt(2), sqrt(3 RET}, omitting the closing parenthesis and bracket. Calc does this automatically for trailing @samp{)}, @samp{]}, and @samp{>} tokens in syntax rules, but you can use @samp{@{ ... @}?$} explicitly to get this effect with any token (such as @samp{"@}"} or @samp{end}). Like @samp{@{ ... @}?.}, this notation does not count as an argument. Conversely, you can use quotes, as in @samp{")"}, to prevent a closing-delimiter token from being automatically treated as optional. Calc's parser does not have full backtracking, which means some patterns will not work as you might expect: @example foo ( @{ # , @}? # , # ) := bar(#1,#2,#3) @end example @noindent Here we are trying to make the first argument optional, so that @samp{foo(2,3)} parses as @samp{bar([],2,3)}. Unfortunately, Calc first tries to match @samp{2,} against the optional part of the pattern, finds a match, and so goes ahead to match the rest of the pattern. Later on it will fail to match the second comma, but it doesn't know how to go back and try the other alternative at that point. One way to get around this would be to use two rules: @example foo ( # , # , # ) := bar([#1],#2,#3) foo ( # , # ) := bar([],#1,#2) @end example More precisely, when Calc wants to match an optional or repeated part of a pattern, it scans forward attempting to match that part. If it reaches the end of the optional part without failing, it ``finalizes'' its choice and proceeds. If it fails, though, it backs up and tries the other alternative. Thus Calc has ``partial'' backtracking. A fully backtracking parser would go on to make sure the rest of the pattern matched before finalizing the choice. @node Conditional Syntax Rules, , Advanced Syntax Patterns, Syntax Tables @subsubsection Conditional Syntax Rules @noindent It is possible to attach a @dfn{condition} to a syntax rule. For example, the rules @example foo ( # ) := ifoo(#1) :: integer(#1) foo ( # ) := gfoo(#1) @end example @noindent will parse @samp{foo(3)} as @samp{ifoo(3)}, but will parse @samp{foo(3.5)} and @samp{foo(x)} as calls to @code{gfoo}. Any number of conditions may be attached; all must be true for the rule to succeed. A condition is ``true'' if it evaluates to a nonzero number. @xref{Logical Operations}, for a list of Calc functions like @code{integer} that perform logical tests. The exact sequence of events is as follows: When Calc tries a rule, it first matches the pattern as usual. It then substitutes @samp{#1}, @samp{#2}, etc., in the conditions, if any. Next, the conditions are simplified and evaluated in order from left to right, as if by the @w{@kbd{a s}} algebra command (@pxref{Simplifying Formulas}). Each result is true if it is a nonzero number, or an expression that can be proven to be nonzero (@pxref{Declarations}). If the results of all conditions are true, the expression (such as @samp{ifoo(#1)}) has its @samp{#}s substituted, and that is the result of the parse. If the result of any condition is false, Calc goes on to try the next rule in the syntax table. Syntax rules also support @code{let} conditions, which operate in exactly the same way as they do in algebraic rewrite rules. @xref{Other Features of Rewrite Rules}, for details. A @code{let} condition is always true, but as a side effect it defines a variable which can be used in later conditions, and also in the expression after the @samp{:=} sign: @example foo ( # ) := hifoo(x) :: let(x := #1 + 0.5) :: dnumint(x) @end example @noindent The @code{dnumint} function tests if a value is numerically an integer, i.e., either a true integer or an integer-valued float. This rule will parse @code{foo} with a half-integer argument, like @samp{foo(3.5)}, to a call like @samp{hifoo(4.)}. The lefthand side of a syntax rule @code{let} must be a simple variable, not the arbitrary pattern that is allowed in rewrite rules. The @code{matches} function is also treated specially in syntax rule conditions (again, in the same way as in rewrite rules). @xref{Matching Commands}. If the matching pattern contains meta-variables, then those meta-variables may be used in later conditions and in the result expression. The arguments to @code{matches} are not evaluated in this situation. @example sum ( # , # ) := sum(#1,a,b,c) :: matches(#2, a=[b..c]) @end example @noindent This is another way to implement the Maple mode @code{sum} notation. In this approach, we allow @samp{#2} to equal the whole expression @samp{i=1..10}. Then, we use @code{matches} to break it apart into its components. If the expression turns out not to match the pattern, the syntax rule will fail. Note that @kbd{Z S} always uses Calc's normal language mode for editing expressions in syntax rules, so we must use regular Calc notation for the interval @samp{[b..c]} that will correspond to the Maple mode interval @samp{1..10}. @node Modes Variable, Calc Mode Line, Language Modes, Mode Settings @section The @code{Modes} Variable @noindent @kindex m g @pindex calc-get-modes The @kbd{m g} (@code{calc-get-modes}) command pushes onto the stack a vector of numbers that describes the various mode settings that are in effect. With a numeric prefix argument, it pushes only the @var{n}th mode, i.e., the @var{n}th element of this vector. Keyboard macros can use the @kbd{m g} command to modify their behavior based on the current mode settings. @cindex @code{Modes} variable @vindex Modes The modes vector is also available in the special variable @code{Modes}. In other words, @kbd{m g} is like @kbd{s r Modes RET}. It will not work to store into this variable; in fact, if you do, @code{Modes} will cease to track the current modes. (The @kbd{m g} command will continue to work, however.) In general, each number in this vector is suitable as a numeric prefix argument to the associated mode-setting command. (Recall that the @kbd{~} key takes a number from the stack and gives it as a numeric prefix to the next command.) The elements of the modes vector are as follows: @enumerate @item Current precision. Default is 12; associated command is @kbd{p}. @item Binary word size. Default is 32; associated command is @kbd{b w}. @item Stack size (not counting the value about to be pushed by @kbd{m g}). This is zero if @kbd{m g} is executed with an empty stack. @item Number radix. Default is 10; command is @kbd{d r}. @item Floating-point format. This is the number of digits, plus the constant 0 for normal notation, 10000 for scientific notation, 20000 for engineering notation, or 30000 for fixed-point notation. These codes are acceptable as prefix arguments to the @kbd{d n} command, but note that this may lose information: For example, @kbd{d s} and @kbd{C-u 12 d s} have similar (but not quite identical) effects if the current precision is 12, but they both produce a code of 10012, which will be treated by @kbd{d n} as @kbd{C-u 12 d s}. If the precision then changes, the float format will still be frozen at 12 significant figures. @item Angular mode. Default is 1 (degrees). Other values are 2 (radians) and 3 (HMS). The @kbd{m d} command accepts these prefixes. @item Symbolic mode. Value is 0 or 1; default is 0. Command is @kbd{m s}. @item Fraction mode. Value is 0 or 1; default is 0. Command is @kbd{m f}. @item Polar mode. Value is 0 (rectangular) or 1 (polar); default is 0. Command is @kbd{m p}. @item Matrix/scalar mode. Default value is @i{-1}. Value is 0 for scalar mode, @i{-2} for matrix mode, or @i{N} for @c{$N\times N$} @i{NxN} matrix mode. Command is @kbd{m v}. @item Simplification mode. Default is 1. Value is @i{-1} for off (@kbd{m O}), 0 for @kbd{m N}, 2 for @kbd{m B}, 3 for @kbd{m A}, 4 for @kbd{m E}, or 5 for @w{@kbd{m U}}. The @kbd{m D} command accepts these prefixes. @item Infinite mode. Default is @i{-1} (off). Value is 1 if the mode is on, or 0 if the mode is on with positive zeros. Command is @kbd{m i}. @end enumerate For example, the sequence @kbd{M-1 m g RET 2 + ~ p} increases the precision by two, leaving a copy of the old precision on the stack. Later, @kbd{~ p} will restore the original precision using that stack value. (This sequence might be especially useful inside a keyboard macro.) As another example, @kbd{M-3 m g 1 - ~ DEL} deletes all but the oldest (bottommost) stack entry. Yet another example: The HP-48 ``round'' command rounds a number to the current displayed precision. You could roughly emulate this in Calc with the sequence @kbd{M-5 m g 10000 % ~ c c}. (This would not work for fixed-point mode, but it wouldn't be hard to do a full emulation with the help of the @kbd{Z [} and @kbd{Z ]} programming commands. @xref{Conditionals in Macros}.) @node Calc Mode Line, , Modes Variable, Mode Settings @section The Calc Mode Line @noindent @cindex Mode line indicators This section is a summary of all symbols that can appear on the Calc mode line, the highlighted bar that appears under the Calc stack window (or under an editing window in Embedded Mode). The basic mode line format is: @example --%%-Calc: 12 Deg @var{other modes} (Calculator) @end example The @samp{%%} is the Emacs symbol for ``read-only''; it shows that regular Emacs commands are not allowed to edit the stack buffer as if it were text. The word @samp{Calc:} changes to @samp{CalcEmbed:} if Embedded Mode is enabled. The words after this describe the various Calc modes that are in effect. The first mode is always the current precision, an integer. The second mode is always the angular mode, either @code{Deg}, @code{Rad}, or @code{Hms}. Here is a complete list of the remaining symbols that can appear on the mode line: @table @code @item Alg Algebraic mode (@kbd{m a}; @pxref{Algebraic Entry}). @item Alg[( Incomplete algebraic mode (@kbd{C-u m a}). @item Alg* Total algebraic mode (@kbd{m t}). @item Symb Symbolic mode (@kbd{m s}; @pxref{Symbolic Mode}). @item Matrix Matrix mode (@kbd{m v}; @pxref{Matrix Mode}). @item Matrix@var{n} Dimensioned matrix mode (@kbd{C-u @var{n} m v}). @item Scalar Scalar mode (@kbd{m v}; @pxref{Matrix Mode}). @item Polar Polar complex mode (@kbd{m p}; @pxref{Polar Mode}). @item Frac Fraction mode (@kbd{m f}; @pxref{Fraction Mode}). @item Inf Infinite mode (@kbd{m i}; @pxref{Infinite Mode}). @item +Inf Positive infinite mode (@kbd{C-u 0 m i}). @item NoSimp Default simplifications off (@kbd{m O}; @pxref{Simplification Modes}). @item NumSimp Default simplifications for numeric arguments only (@kbd{m N}). @item BinSimp@var{w} Binary-integer simplification mode; word size @var{w} (@kbd{m B}, @kbd{b w}). @item AlgSimp Algebraic simplification mode (@kbd{m A}). @item ExtSimp Extended algebraic simplification mode (@kbd{m E}). @item UnitSimp Units simplification mode (@kbd{m U}). @item Bin Current radix is 2 (@kbd{d 2}; @pxref{Radix Modes}). @item Oct Current radix is 8 (@kbd{d 8}). @item Hex Current radix is 16 (@kbd{d 6}). @item Radix@var{n} Current radix is @var{n} (@kbd{d r}). @item Zero Leading zeros (@kbd{d z}; @pxref{Radix Modes}). @item Big Big language mode (@kbd{d B}; @pxref{Normal Language Modes}). @item Flat One-line normal language mode (@kbd{d O}). @item Unform Unformatted language mode (@kbd{d U}). @item C C language mode (@kbd{d C}; @pxref{C FORTRAN Pascal}). @item Pascal Pascal language mode (@kbd{d P}). @item Fortran FORTRAN language mode (@kbd{d F}). @item TeX @TeX{} language mode (@kbd{d T}; @pxref{TeX Language Mode}). @item Eqn @dfn{Eqn} language mode (@kbd{d E}; @pxref{Eqn Language Mode}). @item Math Mathematica language mode (@kbd{d M}; @pxref{Mathematica Language Mode}). @item Maple Maple language mode (@kbd{d W}; @pxref{Maple Language Mode}). @item Norm@var{n} Normal float mode with @var{n} digits (@kbd{d n}; @pxref{Float Formats}). @item Fix@var{n} Fixed point mode with @var{n} digits after the point (@kbd{d f}). @item Sci Scientific notation mode (@kbd{d s}). @item Sci@var{n} Scientific notation with @var{n} digits (@kbd{d s}). @item Eng Engineering notation mode (@kbd{d e}). @item Eng@var{n} Engineering notation with @var{n} digits (@kbd{d e}). @item Left@var{n} Left-justified display indented by @var{n} (@kbd{d <}; @pxref{Justification}). @item Right Right-justified display (@kbd{d >}). @item Right@var{n} Right-justified display with width @var{n} (@kbd{d >}). @item Center Centered display (@kbd{d =}). @item Center@var{n} Centered display with center column @var{n} (@kbd{d =}). @item Wid@var{n} Line breaking with width @var{n} (@kbd{d b}; @pxref{Normal Language Modes}). @item Wide No line breaking (@kbd{d b}). @item Break Selections show deep structure (@kbd{j b}; @pxref{Making Selections}). @item Save Record modes in @file{~/.emacs} (@kbd{m R}; @pxref{General Mode Commands}). @item Local Record modes in Embedded buffer (@kbd{m R}). @item LocEdit Record modes as editing-only in Embedded buffer (@kbd{m R}). @item LocPerm Record modes as permanent-only in Embedded buffer (@kbd{m R}). @item Global Record modes as global in Embedded buffer (@kbd{m R}). @item Manual Automatic recomputation turned off (@kbd{m C}; @pxref{Automatic Recomputation}). @item Graph GNUPLOT process is alive in background (@pxref{Graphics}). @item Sel Top-of-stack has a selection (Embedded only; @pxref{Making Selections}). @item Dirty The stack display may not be up-to-date (@pxref{Display Modes}). @item Inv ``Inverse'' prefix was pressed (@kbd{I}; @pxref{Inverse and Hyperbolic}). @item Hyp ``Hyperbolic'' prefix was pressed (@kbd{H}). @item Keep ``Keep-arguments'' prefix was pressed (@kbd{K}). @item Narrow Stack is truncated (@kbd{d t}; @pxref{Truncating the Stack}). @end table In addition, the symbols @code{Active} and @code{~Active} can appear as minor modes on an Embedded buffer's mode line. @xref{Embedded Mode}. @node Arithmetic, Scientific Functions, Mode Settings, Top @chapter Arithmetic Functions @noindent This chapter describes the Calc commands for doing simple calculations on numbers, such as addition, absolute value, and square roots. These commands work by removing the top one or two values from the stack, performing the desired operation, and pushing the result back onto the stack. If the operation cannot be performed, the result pushed is a formula instead of a number, such as @samp{2/0} (because division by zero is illegal) or @samp{sqrt(x)} (because the argument @samp{x} is a formula). Most of the commands described here can be invoked by a single keystroke. Some of the more obscure ones are two-letter sequences beginning with the @kbd{f} (``functions'') prefix key. @xref{Prefix Arguments}, for a discussion of the effect of numeric prefix arguments on commands in this chapter which do not otherwise interpret a prefix argument. @menu * Basic Arithmetic:: * Integer Truncation:: * Complex Number Functions:: * Conversions:: * Date Arithmetic:: * Financial Functions:: * Binary Functions:: @end menu @node Basic Arithmetic, Integer Truncation, Arithmetic, Arithmetic @section Basic Arithmetic @noindent @kindex + @pindex calc-plus @c @mindex @null @tindex + The @kbd{+} (@code{calc-plus}) command adds two numbers. The numbers may be any of the standard Calc data types. The resulting sum is pushed back onto the stack. If both arguments of @kbd{+} are vectors or matrices (of matching dimensions), the result is a vector or matrix sum. If one argument is a vector and the other a scalar (i.e., a non-vector), the scalar is added to each of the elements of the vector to form a new vector. If the scalar is not a number, the operation is left in symbolic form: Suppose you added @samp{x} to the vector @samp{[1,2]}. You may want the result @samp{[1+x,2+x]}, or you may plan to substitute a 2-vector for @samp{x} in the future. Since the Calculator can't tell which interpretation you want, it makes the safest assumption. @xref{Reducing and Mapping}, for a way to add @samp{x} to every element of a vector. If either argument of @kbd{+} is a complex number, the result will in general be complex. If one argument is in rectangular form and the other polar, the current Polar Mode determines the form of the result. If Symbolic Mode is enabled, the sum may be left as a formula if the necessary conversions for polar addition are non-trivial. If both arguments of @kbd{+} are HMS forms, the forms are added according to the usual conventions of hours-minutes-seconds notation. If one argument is an HMS form and the other is a number, that number is converted from degrees or radians (depending on the current Angular Mode) to HMS format and then the two HMS forms are added. If one argument of @kbd{+} is a date form, the other can be either a real number, which advances the date by a certain number of days, or an HMS form, which advances the date by a certain amount of time. Subtracting two date forms yields the number of days between them. Adding two date forms is meaningless, but Calc interprets it as the subtraction of one date form and the negative of the other. (The negative of a date form can be understood by remembering that dates are stored as the number of days before or after Jan 1, 1 AD.) If both arguments of @kbd{+} are error forms, the result is an error form with an appropriately computed standard deviation. If one argument is an error form and the other is a number, the number is taken to have zero error. Error forms may have symbolic formulas as their mean and/or error parts; adding these will produce a symbolic error form result. However, adding an error form to a plain symbolic formula (as in @samp{(a +/- b) + c}) will not work, for the same reasons just mentioned for vectors. Instead you must write @samp{(a +/- b) + (c +/- 0)}. If both arguments of @kbd{+} are modulo forms with equal values of @cite{M}, or if one argument is a modulo form and the other a plain number, the result is a modulo form which represents the sum, modulo @cite{M}, of the two values. If both arguments of @kbd{+} are intervals, the result is an interval which describes all possible sums of the possible input values. If one argument is a plain number, it is treated as the interval @w{@samp{[x ..@: x]}}. If one argument of @kbd{+} is an infinity and the other is not, the result is that same infinity. If both arguments are infinite and in the same direction, the result is the same infinity, but if they are infinite in different directions the result is @code{nan}. @kindex - @pindex calc-minus @c @mindex @null @tindex - The @kbd{-} (@code{calc-minus}) command subtracts two values. The top number on the stack is subtracted from the one behind it, so that the computation @kbd{5 @key{RET} 2 -} produces 3, not @i{-3}. All options available for @kbd{+} are available for @kbd{-} as well. @kindex * @pindex calc-times @c @mindex @null @tindex * The @kbd{*} (@code{calc-times}) command multiplies two numbers. If one argument is a vector and the other a scalar, the scalar is multiplied by the elements of the vector to produce a new vector. If both arguments are vectors, the interpretation depends on the dimensions of the vectors: If both arguments are matrices, a matrix multiplication is done. If one argument is a matrix and the other a plain vector, the vector is interpreted as a row vector or column vector, whichever is dimensionally correct. If both arguments are plain vectors, the result is a single scalar number which is the dot product of the two vectors. If one argument of @kbd{*} is an HMS form and the other a number, the HMS form is multiplied by that amount. It is an error to multiply two HMS forms together, or to attempt any multiplication involving date forms. Error forms, modulo forms, and intervals can be multiplied; see the comments for addition of those forms. When two error forms or intervals are multiplied they are considered to be statistically independent; thus, @samp{[-2 ..@: 3] * [-2 ..@: 3]} is @samp{[-6 ..@: 9]}, whereas @w{@samp{[-2 ..@: 3] ^ 2}} is @samp{[0 ..@: 9]}. @kindex / @pindex calc-divide @c @mindex @null @tindex / The @kbd{/} (@code{calc-divide}) command divides two numbers. When dividing a scalar @cite{B} by a square matrix @cite{A}, the computation performed is @cite{B} times the inverse of @cite{A}. This also occurs if @cite{B} is itself a vector or matrix, in which case the effect is to solve the set of linear equations represented by @cite{B}. If @cite{B} is a matrix with the same number of rows as @cite{A}, or a plain vector (which is interpreted here as a column vector), then the equation @cite{A X = B} is solved for the vector or matrix @cite{X}. Otherwise, if @cite{B} is a non-square matrix with the same number of @emph{columns} as @cite{A}, the equation @cite{X A = B} is solved. If you wish a vector @cite{B} to be interpreted as a row vector to be solved as @cite{X A = B}, make it into a one-row matrix with @kbd{C-u 1 v p} first. To force a left-handed solution with a square matrix @cite{B}, transpose @cite{A} and @cite{B} before dividing, then transpose the result. HMS forms can be divided by real numbers or by other HMS forms. Error forms can be divided in any combination of ways. Modulo forms where both values and the modulo are integers can be divided to get an integer modulo form result. Intervals can be divided; dividing by an interval that encompasses zero or has zero as a limit will result in an infinite interval. @kindex ^ @pindex calc-power @c @mindex @null @tindex ^ The @kbd{^} (@code{calc-power}) command raises a number to a power. If the power is an integer, an exact result is computed using repeated multiplications. For non-integer powers, Calc uses Newton's method or logarithms and exponentials. Square matrices can be raised to integer powers. If either argument is an error (or interval or modulo) form, the result is also an error (or interval or modulo) form. @kindex I ^ @tindex nroot If you press the @kbd{I} (inverse) key first, the @kbd{I ^} command computes an Nth root: @kbd{125 RET 3 I ^} computes the number 5. (This is entirely equivalent to @kbd{125 RET 1:3 ^}.) @kindex \ @pindex calc-idiv @tindex idiv @c @mindex @null @tindex \ The @kbd{\} (@code{calc-idiv}) command divides two numbers on the stack to produce an integer result. It is equivalent to dividing with @key{/}, then rounding down with @kbd{F} (@code{calc-floor}), only a bit more convenient and efficient. Also, since it is an all-integer operation when the arguments are integers, it avoids problems that @kbd{/ F} would have with floating-point roundoff. @kindex % @pindex calc-mod @c @mindex @null @tindex % The @kbd{%} (@code{calc-mod}) command performs a ``modulo'' (or ``remainder'') operation. Mathematically, @samp{a%b = a - (a\b)*b}, and is defined for all real numbers @cite{a} and @cite{b} (except @cite{b=0}). For positive @cite{b}, the result will always be between 0 (inclusive) and @cite{b} (exclusive). Modulo does not work for HMS forms and error forms. If @cite{a} is a modulo form, its modulo is changed to @cite{b}, which must be positive real number. @kindex : @pindex calc-fdiv @tindex fdiv The @kbd{:} (@code{calc-fdiv}) command [@code{fdiv} function in a formula] divides the two integers on the top of the stack to produce a fractional result. This is a convenient shorthand for enabling Fraction Mode (with @kbd{m f}) temporarily and using @samp{/}. Note that during numeric entry the @kbd{:} key is interpreted as a fraction separator, so to divide 8 by 6 you would have to type @kbd{8 @key{RET} 6 @key{RET} :}. (Of course, in this case, it would be much easier simply to enter the fraction directly as @kbd{8:6 @key{RET}}!) @kindex n @pindex calc-change-sign The @kbd{n} (@code{calc-change-sign}) command negates the number on the top of the stack. It works on numbers, vectors and matrices, HMS forms, date forms, error forms, intervals, and modulo forms. @kindex A @pindex calc-abs @tindex abs The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the absolute value of a number. The result of @code{abs} is always a nonnegative real number: With a complex argument, it computes the complex magnitude. With a vector or matrix argument, it computes the Frobenius norm, i.e., the square root of the sum of the squares of the absolute values of the elements. The absolute value of an error form is defined by replacing the mean part with its absolute value and leaving the error part the same. The absolute value of a modulo form is undefined. The absolute value of an interval is defined in the obvious way. @kindex f A @pindex calc-abssqr @tindex abssqr The @kbd{f A} (@code{calc-abssqr}) [@code{abssqr}] command computes the absolute value squared of a number, vector or matrix, or error form. @kindex f s @pindex calc-sign @tindex sign The @kbd{f s} (@code{calc-sign}) [@code{sign}] command returns 1 if its argument is positive, @i{-1} if its argument is negative, or 0 if its argument is zero. In algebraic form, you can also write @samp{sign(a,x)} which evaluates to @samp{x * sign(a)}, i.e., either @samp{x}, @samp{-x}, or zero depending on the sign of @samp{a}. @kindex & @pindex calc-inv @tindex inv @cindex Reciprocal The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the reciprocal of a number, i.e., @cite{1 / x}. Operating on a square matrix, it computes the inverse of that matrix. @kindex Q @pindex calc-sqrt @tindex sqrt The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] command computes the square root of a number. For a negative real argument, the result will be a complex number whose form is determined by the current Polar Mode. @kindex f h @pindex calc-hypot @tindex hypot The @kbd{f h} (@code{calc-hypot}) [@code{hypot}] command computes the square root of the sum of the squares of two numbers. That is, @samp{hypot(a,b)} is the length of the hypotenuse of a right triangle with sides @cite{a} and @cite{b}. If the arguments are complex numbers, their squared magnitudes are used. @kindex f Q @pindex calc-isqrt @tindex isqrt The @kbd{f Q} (@code{calc-isqrt}) [@code{isqrt}] command computes the integer square root of an integer. This is the true square root of the number, rounded down to an integer. For example, @samp{isqrt(10)} produces 3. Note that, like @kbd{\} [@code{idiv}], this uses exact integer arithmetic throughout to avoid roundoff problems. If the input is a floating-point number or other non-integer value, this is exactly the same as @samp{floor(sqrt(x))}. @kindex f n @kindex f x @pindex calc-min @tindex min @pindex calc-max @tindex max The @kbd{f n} (@code{calc-min}) [@code{min}] and @kbd{f x} (@code{calc-max}) [@code{max}] commands take the minimum or maximum of two real numbers, respectively. These commands also work on HMS forms, date forms, intervals, and infinities. (In algebraic expressions, these functions take any number of arguments and return the maximum or minimum among all the arguments.)@refill @kindex f M @kindex f X @pindex calc-mant-part @tindex mant @pindex calc-xpon-part @tindex xpon The @kbd{f M} (@code{calc-mant-part}) [@code{mant}] function extracts the ``mantissa'' part @cite{m} of its floating-point argument; @kbd{f X} (@code{calc-xpon-part}) [@code{xpon}] extracts the ``exponent'' part @cite{e}. The original number is equal to @c{$m \times 10^e$} @cite{m * 10^e}, where @cite{m} is in the interval @samp{[1.0 ..@: 10.0)} except that @cite{m=e=0} if the original number is zero. For integers and fractions, @code{mant} returns the number unchanged and @code{xpon} returns zero. The @kbd{v u} (@code{calc-unpack}) command can also be used to ``unpack'' a floating-point number; this produces an integer mantissa and exponent, with the constraint that the mantissa is not a multiple of ten (again except for the @cite{m=e=0} case).@refill @kindex f S @pindex calc-scale-float @tindex scf The @kbd{f S} (@code{calc-scale-float}) [@code{scf}] function scales a number by a given power of ten. Thus, @samp{scf(mant(x), xpon(x)) = x} for any real @samp{x}. The second argument must be an integer, but the first may actually be any numeric value. For example, @samp{scf(5,-2) = 0.05} or @samp{1:20} depending on the current Fraction Mode.@refill @kindex f [ @kindex f ] @pindex calc-decrement @pindex calc-increment @tindex decr @tindex incr The @kbd{f [} (@code{calc-decrement}) [@code{decr}] and @kbd{f ]} (@code{calc-increment}) [@code{incr}] functions decrease or increase a number by one unit. For integers, the effect is obvious. For floating-point numbers, the change is by one unit in the last place. For example, incrementing @samp{12.3456} when the current precision is 6 digits yields @samp{12.3457}. If the current precision had been 8 digits, the result would have been @samp{12.345601}. Incrementing @samp{0.0} produces @c{$10^{-p}$} @cite{10^-p}, where @cite{p} is the current precision. These operations are defined only on integers and floats. With numeric prefix arguments, they change the number by @cite{n} units. Note that incrementing followed by decrementing, or vice-versa, will almost but not quite always cancel out. Suppose the precision is 6 digits and the number @samp{9.99999} is on the stack. Incrementing will produce @samp{10.0000}; decrementing will produce @samp{9.9999}. One digit has been dropped. This is an unavoidable consequence of the way floating-point numbers work. Incrementing a date/time form adjusts it by a certain number of seconds. Incrementing a pure date form adjusts it by a certain number of days. @node Integer Truncation, Complex Number Functions, Basic Arithmetic, Arithmetic @section Integer Truncation @noindent There are four commands for truncating a real number to an integer, differing mainly in their treatment of negative numbers. All of these commands have the property that if the argument is an integer, the result is the same integer. An integer-valued floating-point argument is converted to integer form. If you press @kbd{H} (@code{calc-hyperbolic}) first, the result will be expressed as an integer-valued floating-point number. @cindex Integer part of a number @kindex F @pindex calc-floor @tindex floor @tindex ffloor @c @mindex @null @kindex H F The @kbd{F} (@code{calc-floor}) [@code{floor} or @code{ffloor}] command truncates a real number to the next lower integer, i.e., toward minus infinity. Thus @kbd{3.6 F} produces 3, but @kbd{_3.6 F} produces @i{-4}.@refill @kindex I F @pindex calc-ceiling @tindex ceil @tindex fceil @c @mindex @null @kindex H I F The @kbd{I F} (@code{calc-ceiling}) [@code{ceil} or @code{fceil}] command truncates toward positive infinity. Thus @kbd{3.6 I F} produces 4, and @kbd{_3.6 I F} produces @i{-3}.@refill @kindex R @pindex calc-round @tindex round @tindex fround @c @mindex @null @kindex H R The @kbd{R} (@code{calc-round}) [@code{round} or @code{fround}] command rounds to the nearest integer. When the fractional part is .5 exactly, this command rounds away from zero. (All other rounding in the Calculator uses this convention as well.) Thus @kbd{3.5 R} produces 4 but @kbd{3.4 R} produces 3; @kbd{_3.5 R} produces @i{-4}.@refill @kindex I R @pindex calc-trunc @tindex trunc @tindex ftrunc @c @mindex @null @kindex H I R The @kbd{I R} (@code{calc-trunc}) [@code{trunc} or @code{ftrunc}] command truncates toward zero. In other words, it ``chops off'' everything after the decimal point. Thus @kbd{3.6 I R} produces 3 and @kbd{_3.6 I R} produces @i{-3}.@refill These functions may not be applied meaningfully to error forms, but they do work for intervals. As a convenience, applying @code{floor} to a modulo form floors the value part of the form. Applied to a vector, these functions operate on all elements of the vector one by one. Applied to a date form, they operate on the internal numerical representation of dates, converting a date/time form into a pure date. @c @starindex @tindex rounde @c @starindex @tindex roundu @c @starindex @tindex frounde @c @starindex @tindex froundu There are two more rounding functions which can only be entered in algebraic notation. The @code{roundu} function is like @code{round} except that it rounds up, toward plus infinity, when the fractional part is .5. This distinction matters only for negative arguments. Also, @code{rounde} rounds to an even number in the case of a tie, rounding up or down as necessary. For example, @samp{rounde(3.5)} and @samp{rounde(4.5)} both return 4, but @samp{rounde(5.5)} returns 6. The advantage of round-to-even is that the net error due to rounding after a long calculation tends to cancel out to zero. An important subtle point here is that the number being fed to @code{rounde} will already have been rounded to the current precision before @code{rounde} begins. For example, @samp{rounde(2.500001)} with a current precision of 6 will incorrectly, or at least surprisingly, yield 2 because the argument will first have been rounded down to @cite{2.5} (which @code{rounde} sees as an exact tie between 2 and 3). Each of these functions, when written in algebraic formulas, allows a second argument which specifies the number of digits after the decimal point to keep. For example, @samp{round(123.4567, 2)} will produce the answer 123.46, and @samp{round(123.4567, -1)} will produce 120 (i.e., the cutoff is one digit to the @emph{left} of the decimal point). A second argument of zero is equivalent to no second argument at all. @cindex Fractional part of a number To compute the fractional part of a number (i.e., the amount which, when added to `@t{floor(}@i{N}@t{)}', will produce @cite{N}) just take @cite{N} modulo 1 using the @code{%} command.@refill Note also the @kbd{\} (integer quotient), @kbd{f I} (integer logarithm), and @kbd{f Q} (integer square root) commands, which are analogous to @kbd{/}, @kbd{B}, and @kbd{Q}, respectively, except that they take integer arguments and return the result rounded down to an integer. @node Complex Number Functions, Conversions, Integer Truncation, Arithmetic @section Complex Number Functions @noindent @kindex J @pindex calc-conj @tindex conj The @kbd{J} (@code{calc-conj}) [@code{conj}] command computes the complex conjugate of a number. For complex number @cite{a+bi}, the complex conjugate is @cite{a-bi}. If the argument is a real number, this command leaves it the same. If the argument is a vector or matrix, this command replaces each element by its complex conjugate. @kindex G @pindex calc-argument @tindex arg The @kbd{G} (@code{calc-argument}) [@code{arg}] command computes the ``argument'' or polar angle of a complex number. For a number in polar notation, this is simply the second component of the pair `@t{(}@i{r}@t{;}@c{$\theta$} @i{theta}@t{)}'. The result is expressed according to the current angular mode and will be in the range @i{-180} degrees (exclusive) to @i{+180} degrees (inclusive), or the equivalent range in radians.@refill @pindex calc-imaginary The @code{calc-imaginary} command multiplies the number on the top of the stack by the imaginary number @cite{i = (0,1)}. This command is not normally bound to a key in Calc, but it is available on the @key{IMAG} button in Keypad Mode. @kindex f r @pindex calc-re @tindex re The @kbd{f r} (@code{calc-re}) [@code{re}] command replaces a complex number by its real part. This command has no effect on real numbers. (As an added convenience, @code{re} applied to a modulo form extracts the value part.)@refill @kindex f i @pindex calc-im @tindex im The @kbd{f i} (@code{calc-im}) [@code{im}] command replaces a complex number by its imaginary part; real numbers are converted to zero. With a vector or matrix argument, these functions operate element-wise.@refill @c @mindex v p @kindex v p (complex) @pindex calc-pack The @kbd{v p} (@code{calc-pack}) command can pack the top two numbers on the the stack into a composite object such as a complex number. With a prefix argument of @i{-1}, it produces a rectangular complex number; with an argument of @i{-2}, it produces a polar complex number. (Also, @pxref{Building Vectors}.) @c @mindex v u @kindex v u (complex) @pindex calc-unpack The @kbd{v u} (@code{calc-unpack}) command takes the complex number (or other composite object) on the top of the stack and unpacks it into its separate components. @node Conversions, Date Arithmetic, Complex Number Functions, Arithmetic @section Conversions @noindent The commands described in this section convert numbers from one form to another; they are two-key sequences beginning with the letter @kbd{c}. @kindex c f @pindex calc-float @tindex pfloat The @kbd{c f} (@code{calc-float}) [@code{pfloat}] command converts the number on the top of the stack to floating-point form. For example, @cite{23} is converted to @cite{23.0}, @cite{3:2} is converted to @cite{1.5}, and @cite{2.3} is left the same. If the value is a composite object such as a complex number or vector, each of the components is converted to floating-point. If the value is a formula, all numbers in the formula are converted to floating-point. Note that depending on the current floating-point precision, conversion to floating-point format may lose information.@refill As a special exception, integers which appear as powers or subscripts are not floated by @kbd{c f}. If you really want to float a power, you can use a @kbd{j s} command to select the power followed by @kbd{c f}. Because @kbd{c f} cannot examine the formula outside of the selection, it does not notice that the thing being floated is a power. @xref{Selecting Subformulas}. The normal @kbd{c f} command is ``pervasive'' in the sense that it applies to all numbers throughout the formula. The @code{pfloat} algebraic function never stays around in a formula; @samp{pfloat(a + 1)} changes to @samp{a + 1.0} as soon as it is evaluated. @kindex H c f @tindex float With the Hyperbolic flag, @kbd{H c f} [@code{float}] operates only on the number or vector of numbers at the top level of its argument. Thus, @samp{float(1)} is 1.0, but @samp{float(a + 1)} is left unevaluated because its argument is not a number. You should use @kbd{H c f} if you wish to guarantee that the final value, once all the variables have been assigned, is a float; you would use @kbd{c f} if you wish to do the conversion on the numbers that appear right now. @kindex c F @pindex calc-fraction @tindex pfrac The @kbd{c F} (@code{calc-fraction}) [@code{pfrac}] command converts a floating-point number into a fractional approximation. By default, it produces a fraction whose decimal representation is the same as the input number, to within the current precision. You can also give a numeric prefix argument to specify a tolerance, either directly, or, if the prefix argument is zero, by using the number on top of the stack as the tolerance. If the tolerance is a positive integer, the fraction is correct to within that many significant figures. If the tolerance is a non-positive integer, it specifies how many digits fewer than the current precision to use. If the tolerance is a floating-point number, the fraction is correct to within that absolute amount. @kindex H c F @tindex frac The @code{pfrac} function is pervasive, like @code{pfloat}. There is also a non-pervasive version, @kbd{H c F} [@code{frac}], which is analogous to @kbd{H c f} discussed above. @kindex c d @pindex calc-to-degrees @tindex deg The @kbd{c d} (@code{calc-to-degrees}) [@code{deg}] command converts a number into degrees form. The value on the top of the stack may be an HMS form (interpreted as degrees-minutes-seconds), or a real number which will be interpreted in radians regardless of the current angular mode.@refill @kindex c r @pindex calc-to-radians @tindex rad The @kbd{c r} (@code{calc-to-radians}) [@code{rad}] command converts an HMS form or angle in degrees into an angle in radians. @kindex c h @pindex calc-to-hms @tindex hms The @kbd{c h} (@code{calc-to-hms}) [@code{hms}] command converts a real number, interpreted according to the current angular mode, to an HMS form describing the same angle. In algebraic notation, the @code{hms} function also accepts three arguments: @samp{hms(@var{h}, @var{m}, @var{s})}. (The three-argument version is independent of the current angular mode.) @pindex calc-from-hms The @code{calc-from-hms} command converts the HMS form on the top of the stack into a real number according to the current angular mode. @kindex c p @kindex I c p @pindex calc-polar @tindex polar @tindex rect The @kbd{c p} (@code{calc-polar}) command converts the complex number on the top of the stack from polar to rectangular form, or from rectangular to polar form, whichever is appropriate. Real numbers are left the same. This command is equivalent to the @code{rect} or @code{polar} functions in algebraic formulas, depending on the direction of conversion. (It uses @code{polar}, except that if the argument is already a polar complex number, it uses @code{rect} instead. The @kbd{I c p} command always uses @code{rect}.)@refill @kindex c c @pindex calc-clean @tindex pclean The @kbd{c c} (@code{calc-clean}) [@code{pclean}] command ``cleans'' the number on the top of the stack. Floating point numbers are re-rounded according to the current precision. Polar numbers whose angular components have strayed from the @i{-180} to @i{+180} degree range are normalized. (Note that results will be undesirable if the current angular mode is different from the one under which the number was produced!) Integers and fractions are generally unaffected by this operation. Vectors and formulas are cleaned by cleaning each component number (i.e., pervasively).@refill If the simplification mode is set below the default level, it is raised to the default level for the purposes of this command. Thus, @kbd{c c} applies the default simplifications even if their automatic application is disabled. @xref{Simplification Modes}. @cindex Roundoff errors, correcting A numeric prefix argument to @kbd{c c} sets the floating-point precision to that value for the duration of the command. A positive prefix (of at least 3) sets the precision to the specified value; a negative or zero prefix decreases the precision by the specified amount. @kindex c 0-9 @pindex calc-clean-num The keystroke sequences @kbd{c 0} through @kbd{c 9} are equivalent to @kbd{c c} with the corresponding negative prefix argument. If roundoff errors have changed 2.0 into 1.999999, typing @kbd{c 1} to clip off one decimal place often conveniently does the trick. The @kbd{c c} command with a numeric prefix argument, and the @kbd{c 0} through @kbd{c 9} commands, also ``clip'' very small floating-point numbers to zero. If the exponent is less than or equal to the negative of the specified precision, the number is changed to 0.0. For example, if the current precision is 12, then @kbd{c 2} changes the vector @samp{[1e-8, 1e-9, 1e-10, 1e-11]} to @samp{[1e-8, 1e-9, 0, 0]}. Numbers this small generally arise from roundoff noise. If the numbers you are using really are legitimately this small, you should avoid using the @kbd{c 0} through @kbd{c 9} commands. (The plain @kbd{c c} command rounds to the current precision but does not clip small numbers.) One more property of @kbd{c 0} through @kbd{c 9}, and of @kbd{c c} with a prefix argument, is that integer-valued floats are converted to plain integers, so that @kbd{c 1} on @samp{[1., 1.5, 2., 2.5, 3.]} produces @samp{[1, 1.5, 2, 2.5, 3]}. This is not done for huge numbers (@samp{1e100} is technically an integer-valued float, but you wouldn't want it automatically converted to a 100-digit integer). @kindex H c 0-9 @kindex H c c @tindex clean With the Hyperbolic flag, @kbd{H c c} and @kbd{H c 0} through @kbd{H c 9} operate non-pervasively [@code{clean}]. @node Date Arithmetic, Financial Functions, Conversions, Arithmetic @section Date Arithmetic @noindent @cindex Date arithmetic, additional functions The commands described in this section perform various conversions and calculations involving date forms (@pxref{Date Forms}). They use the @kbd{t} (for time/date) prefix key followed by shifted letters. The simplest date arithmetic is done using the regular @kbd{+} and @kbd{-} commands. In particular, adding a number to a date form advances the date form by a certain number of days; adding an HMS form to a date form advances the date by a certain amount of time; and subtracting two date forms produces a difference measured in days. The commands described here provide additional, more specialized operations on dates. Many of these commands accept a numeric prefix argument; if you give plain @kbd{C-u} as the prefix, these commands will instead take the additional argument from the top of the stack. @menu * Date Conversions:: * Date Functions:: * Time Zones:: * Business Days:: @end menu @node Date Conversions, Date Functions, Date Arithmetic, Date Arithmetic @subsection Date Conversions @noindent @kindex t D @pindex calc-date @tindex date The @kbd{t D} (@code{calc-date}) [@code{date}] command converts a date form into a number, measured in days since Jan 1, 1 AD. The result will be an integer if @var{date} is a pure date form, or a fraction or float if @var{date} is a date/time form. Or, if its argument is a number, it converts this number into a date form. With a numeric prefix argument, @kbd{t D} takes that many objects (up to six) from the top of the stack and interprets them in one of the following ways: The @samp{date(@var{year}, @var{month}, @var{day})} function builds a pure date form out of the specified year, month, and day, which must all be integers. @var{Year} is a year number, such as 1991 (@emph{not} the same as 91!). @var{Month} must be an integer in the range 1 to 12; @var{day} must be in the range 1 to 31. If the specified month has fewer than 31 days and @var{day} is too large, the equivalent day in the following month will be used. The @samp{date(@var{month}, @var{day})} function builds a pure date form using the current year, as determined by the real-time clock. The @samp{date(@var{year}, @var{month}, @var{day}, @var{hms})} function builds a date/time form using an @var{hms} form. The @samp{date(@var{year}, @var{month}, @var{day}, @var{hour}, @var{minute}, @var{second})} function builds a date/time form. @var{hour} should be an integer in the range 0 to 23; @var{minute} should be an integer in the range 0 to 59; @var{second} should be any real number in the range @samp{[0 .. 60)}. The last two arguments default to zero if omitted. @kindex t J @pindex calc-julian @tindex julian @cindex Julian day counts, conversions The @kbd{t J} (@code{calc-julian}) [@code{julian}] command converts a date form into a Julian day count, which is the number of days since noon on Jan 1, 4713 BC. A pure date is converted to an integer Julian count representing noon of that day. A date/time form is converted to an exact floating-point Julian count, adjusted to interpret the date form in the current time zone but the Julian day count in Greenwich Mean Time. A numeric prefix argument allows you to specify the time zone; @pxref{Time Zones}. Use a prefix of zero to suppress the time zone adjustment. Note that pure date forms are never time-zone adjusted. This command can also do the opposite conversion, from a Julian day count (either an integer day, or a floating-point day and time in the GMT zone), into a pure date form or a date/time form in the current or specified time zone. @kindex t U @pindex calc-unix-time @tindex unixtime @cindex Unix time format, conversions The @kbd{t U} (@code{calc-unix-time}) [@code{unixtime}] command converts a date form into a Unix time value, which is the number of seconds since midnight on Jan 1, 1970, or vice-versa. The numeric result will be an integer if the current precision is 12 or less; for higher precisions, the result may be a float with (@var{precision}@i{-}12) digits after the decimal. Just as for @kbd{t J}, the numeric time is interpreted in the GMT time zone and the date form is interpreted in the current or specified zone. Some systems use Unix-like numbering but with the local time zone; give a prefix of zero to suppress the adjustment if so. @kindex t C @pindex calc-convert-time-zones @tindex tzconv @cindex Time Zones, converting between The @kbd{t C} (@code{calc-convert-time-zones}) [@code{tzconv}] command converts a date form from one time zone to another. You are prompted for each time zone name in turn; you can answer with any suitable Calc time zone expression (@pxref{Time Zones}). If you answer either prompt with a blank line, the local time zone is used for that prompt. You can also answer the first prompt with @kbd{$} to take the two time zone names from the stack (and the date to be converted from the third stack level). @node Date Functions, Business Days, Date Conversions, Date Arithmetic @subsection Date Functions @noindent @kindex t N @pindex calc-now @tindex now The @kbd{t N} (@code{calc-now}) [@code{now}] command pushes the current date and time on the stack as a date form. The time is reported in terms of the specified time zone; with no numeric prefix argument, @kbd{t N} reports for the current time zone. @kindex t P @pindex calc-date-part The @kbd{t P} (@code{calc-date-part}) command extracts one part of a date form. The prefix argument specifies the part; with no argument, this command prompts for a part code from 1 to 9. The various part codes are described in the following paragraphs. @tindex year The @kbd{M-1 t P} [@code{year}] function extracts the year number from a date form as an integer, e.g., 1991. This and the following functions will also accept a real number for an argument, which is interpreted as a standard Calc day number. Note that this function will never return zero, since the year 1 BC immediately precedes the year 1 AD. @tindex month The @kbd{M-2 t P} [@code{month}] function extracts the month number from a date form as an integer in the range 1 to 12. @tindex day The @kbd{M-3 t P} [@code{day}] function extracts the day number from a date form as an integer in the range 1 to 31. @tindex hour The @kbd{M-4 t P} [@code{hour}] function extracts the hour from a date form as an integer in the range 0 (midnight) to 23. Note that 24-hour time is always used. This returns zero for a pure date form. This function (and the following two) also accept HMS forms as input. @tindex minute The @kbd{M-5 t P} [@code{minute}] function extracts the minute from a date form as an integer in the range 0 to 59. @tindex second The @kbd{M-6 t P} [@code{second}] function extracts the second from a date form. If the current precision is 12 or less, the result is an integer in the range 0 to 59. For higher precisions, the result may instead be a floating-point number. @tindex weekday The @kbd{M-7 t P} [@code{weekday}] function extracts the weekday number from a date form as an integer in the range 0 (Sunday) to 6 (Saturday). @tindex yearday The @kbd{M-8 t P} [@code{yearday}] function extracts the day-of-year number from a date form as an integer in the range 1 (January 1) to 366 (December 31 of a leap year). @tindex time The @kbd{M-9 t P} [@code{time}] function extracts the time portion of a date form as an HMS form. This returns @samp{0@@ 0' 0"} for a pure date form. @kindex t M @pindex calc-new-month @tindex newmonth The @kbd{t M} (@code{calc-new-month}) [@code{newmonth}] command computes a new date form that represents the first day of the month specified by the input date. The result is always a pure date form; only the year and month numbers of the input are retained. With a numeric prefix argument @var{n} in the range from 1 to 31, @kbd{t M} computes the @var{n}th day of the month. (If @var{n} is greater than the actual number of days in the month, or if @var{n} is zero, the last day of the month is used.) @kindex t Y @pindex calc-new-year @tindex newyear The @kbd{t Y} (@code{calc-new-year}) [@code{newyear}] command computes a new pure date form that represents the first day of the year specified by the input. The month, day, and time of the input date form are lost. With a numeric prefix argument @var{n} in the range from 1 to 366, @kbd{t Y} computes the @var{n}th day of the year (366 is treated as 365 in non-leap years). A prefix argument of 0 computes the last day of the year (December 31). A negative prefix argument from @i{-1} to @i{-12} computes the first day of the @var{n}th month of the year. @kindex t W @pindex calc-new-week @tindex newweek The @kbd{t W} (@code{calc-new-week}) [@code{newweek}] command computes a new pure date form that represents the Sunday on or before the input date. With a numeric prefix argument, it can be made to use any day of the week as the starting day; the argument must be in the range from 0 (Sunday) to 6 (Saturday). This function always subtracts between 0 and 6 days from the input date. Here's an example use of @code{newweek}: Find the date of the next Wednesday after a given date. Using @kbd{M-3 t W} or @samp{newweek(d, 3)} will give you the @emph{preceding} Wednesday, so @samp{newweek(d+7, 3)} will give you the following Wednesday. A further look at the definition of @code{newweek} shows that if the input date is itself a Wednesday, this formula will return the Wednesday one week in the future. An exercise for the reader is to modify this formula to yield the same day if the input is already a Wednesday. Another interesting exercise is to preserve the time-of-day portion of the input (@code{newweek} resets the time to midnight; hint:@: how can @code{newweek} be defined in terms of the @code{weekday} function?). @c @starindex @tindex pwday The @samp{pwday(@var{date})} function (not on any key) computes the day-of-month number of the Sunday on or before @var{date}. With two arguments, @samp{pwday(@var{date}, @var{day})} computes the day number of the Sunday on or before day number @var{day} of the month specified by @var{date}. The @var{day} must be in the range from 7 to 31; if the day number is greater than the actual number of days in the month, the true number of days is used instead. Thus @samp{pwday(@var{date}, 7)} finds the first Sunday of the month, and @samp{pwday(@var{date}, 31)} finds the last Sunday of the month. With a third @var{weekday} argument, @code{pwday} can be made to look for any day of the week instead of Sunday. @kindex t I @pindex calc-inc-month @tindex incmonth The @kbd{t I} (@code{calc-inc-month}) [@code{incmonth}] command increases a date form by one month, or by an arbitrary number of months specified by a numeric prefix argument. The time portion, if any, of the date form stays the same. The day also stays the same, except that if the new month has fewer days the day number may be reduced to lie in the valid range. For example, @samp{incmonth()} produces @samp{}. Because of this, @kbd{t I t I} and @kbd{M-2 t I} do not always give the same results (@samp{} versus @samp{} in this case). @c @starindex @tindex incyear The @samp{incyear(@var{date}, @var{step})} function increases a date form by the specified number of years, which may be any positive or negative integer. Note that @samp{incyear(d, n)} is equivalent to @w{@samp{incmonth(d, 12*n)}}, but these do not have simple equivalents in terms of day arithmetic because months and years have varying lengths. If the @var{step} argument is omitted, 1 year is assumed. There is no keyboard command for this function; use @kbd{C-u 12 t I} instead. There is no @code{newday} function at all because @kbd{F} [@code{floor}] serves this purpose. Similarly, instead of @code{incday} and @code{incweek} simply use @cite{d + n} or @cite{d + 7 n}. @xref{Basic Arithmetic}, for the @kbd{f ]} [@code{incr}] command which can adjust a date/time form by a certain number of seconds. @node Business Days, Time Zones, Date Functions, Date Arithmetic @subsection Business Days @noindent Often time is measured in ``business days'' or ``working days,'' where weekends and holidays are skipped. Calc's normal date arithmetic functions use calendar days, so that subtracting two consecutive Mondays will yield a difference of 7 days. By contrast, subtracting two consecutive Mondays would yield 5 business days (assuming two-day weekends and the absence of holidays). @kindex t + @kindex t - @tindex badd @tindex bsub @pindex calc-business-days-plus @pindex calc-business-days-minus The @kbd{t +} (@code{calc-business-days-plus}) [@code{badd}] and @kbd{t -} (@code{calc-business-days-minus}) [@code{bsub}] commands perform arithmetic using business days. For @kbd{t +}, one argument must be a date form and the other must be a real number (positive or negative). If the number is not an integer, then a certain amount of time is added as well as a number of days; for example, adding 0.5 business days to a time in Friday evening will produce a time in Monday morning. It is also possible to add an HMS form; adding @samp{12@@ 0' 0"} also adds half a business day. For @kbd{t -}, the arguments are either a date form and a number or HMS form, or two date forms, in which case the result is the number of business days between the two dates. @cindex @code{Holidays} variable @vindex Holidays By default, Calc considers any day that is not a Saturday or Sunday to be a business day. You can define any number of additional holidays by editing the variable @code{Holidays}. (There is an @w{@kbd{s H}} convenience command for editing this variable.) Initially, @code{Holidays} contains the vector @samp{[sat, sun]}. Entries in the @code{Holidays} vector may be any of the following kinds of objects: @itemize @bullet @item Date forms (pure dates, not date/time forms). These specify particular days which are to be treated as holidays. @item Intervals of date forms. These specify a range of days, all of which are holidays (e.g., Christmas week). @xref{Interval Forms}. @item Nested vectors of date forms. Each date form in the vector is considered to be a holiday. @item Any Calc formula which evaluates to one of the above three things. If the formula involves the variable @cite{y}, it stands for a yearly repeating holiday; @cite{y} will take on various year numbers like 1992. For example, @samp{date(y, 12, 25)} specifies Christmas day, and @samp{newweek(date(y, 11, 7), 4) + 21} specifies Thanksgiving (which is held on the fourth Thursday of November). If the formula involves the variable @cite{m}, that variable takes on month numbers from 1 to 12: @samp{date(y, m, 15)} is a holiday that takes place on the 15th of every month. @item A weekday name, such as @code{sat} or @code{sun}. This is really a variable whose name is a three-letter, lower-case day name. @item An interval of year numbers (integers). This specifies the span of years over which this holiday list is to be considered valid. Any business-day arithmetic that goes outside this range will result in an error message. Use this if you are including an explicit list of holidays, rather than a formula to generate them, and you want to make sure you don't accidentally go beyond the last point where the holidays you entered are complete. If there is no limiting interval in the @code{Holidays} vector, the default @samp{[1 .. 2737]} is used. (This is the absolute range of years for which Calc's business-day algorithms will operate.) @item An interval of HMS forms. This specifies the span of hours that are to be considered one business day. For example, if this range is @samp{[9@@ 0' 0" .. 17@@ 0' 0"]} (i.e., 9am to 5pm), then the business day is only eight hours long, so that @kbd{1.5 t +} on @samp{<4:00pm Fri Dec 13, 1991>} will add one business day and four business hours to produce @samp{<12:00pm Tue Dec 17, 1991>}. Likewise, @kbd{t -} will now express differences in time as fractions of an eight-hour day. Times before 9am will be treated as 9am by business date arithmetic, and times at or after 5pm will be treated as 4:59:59pm. If there is no HMS interval in @code{Holidays}, the full 24-hour day @samp{[0@ 0' 0" .. 24@ 0' 0"]} is assumed. (Regardless of the type of bounds you specify, the interval is treated as inclusive on the low end and exclusive on the high end, so that the work day goes from 9am up to, but not including, 5pm.) @end itemize If the @code{Holidays} vector is empty, then @kbd{t +} and @kbd{t -} will act just like @kbd{+} and @kbd{-} because there will then be no difference between business days and calendar days. Calc expands the intervals and formulas you give into a complete list of holidays for internal use. This is done mainly to make sure it can detect multiple holidays. (For example, @samp{} is both New Year's Day and a Sunday, but Calc's algorithms take care to count it only once when figuring the number of holidays between two dates.) Since the complete list of holidays for all the years from 1 to 2737 would be huge, Calc actually computes only the part of the list between the smallest and largest years that have been involved in business-day calculations so far. Normally, you won't have to worry about this. Keep in mind, however, that if you do one calculation for 1992, and another for 1792, even if both involve only a small range of years, Calc will still work out all the holidays that fall in that 200-year span. If you add a (positive) number of days to a date form that falls on a weekend or holiday, the date form is treated as if it were the most recent business day. (Thus adding one business day to a Friday, Saturday, or Sunday will all yield the following Monday.) If you subtract a number of days from a weekend or holiday, the date is effectively on the following business day. (So subtracting one business day from Saturday, Sunday, or Monday yields the preceding Friday.) The difference between two dates one or both of which fall on holidays equals the number of actual business days between them. These conventions are consistent in the sense that, if you add @var{n} business days to any date, the difference between the result and the original date will come out to @var{n} business days. (It can't be completely consistent though; a subtraction followed by an addition might come out a bit differently, since @kbd{t +} is incapable of producing a date that falls on a weekend or holiday.) @c @starindex @tindex holiday There is a @code{holiday} function, not on any keys, that takes any date form and returns 1 if that date falls on a weekend or holiday, as defined in @code{Holidays}, or 0 if the date is a business day. @node Time Zones, , Business Days, Date Arithmetic @subsection Time Zones @noindent @cindex Time zones @cindex Daylight savings time Time zones and daylight savings time are a complicated business. The conversions to and from Julian and Unix-style dates automatically compute the correct time zone and daylight savings adjustment to use, provided they can figure out this information. This section describes Calc's time zone adjustment algorithm in detail, in case you want to do conversions in different time zones or in case Calc's algorithms can't determine the right correction to use. Adjustments for time zones and daylight savings time are done by @kbd{t U}, @kbd{t J}, @kbd{t N}, and @kbd{t C}, but not by any other commands. In particular, @samp{ - } evaluates to exactly 30 days even though there is a daylight-savings transition in between. This is also true for Julian pure dates: @samp{julian() - julian()}. But Julian and Unix date/times will adjust for daylight savings time: @samp{julian(<12am may 1 1991>) - julian(<12am apr 1 1991>)} evaluates to @samp{29.95834} (that's 29 days and 23 hours) because one hour was lost when daylight savings commenced on April 7, 1991. In brief, the idiom @samp{julian(@var{date1}) - julian(@var{date2})} computes the actual number of 24-hour periods between two dates, whereas @samp{@var{date1} - @var{date2}} computes the number of calendar days between two dates without taking daylight savings into account. @pindex calc-time-zone @c @starindex @tindex tzone The @code{calc-time-zone} [@code{tzone}] command converts the time zone specified by its numeric prefix argument into a number of seconds difference from Greenwich mean time (GMT). If the argument is a number, the result is simply that value multiplied by 3600. Typical arguments for North America are 5 (Eastern) or 8 (Pacific). If Daylight Savings time is in effect, one hour should be subtracted from the normal difference. If you give a prefix of plain @kbd{C-u}, @code{calc-time-zone} (like other date arithmetic commands that include a time zone argument) takes the zone argument from the top of the stack. (In the case of @kbd{t J} and @kbd{t U}, the normal argument is then taken from the second-to-top stack position.) This allows you to give a non-integer time zone adjustment. The time-zone argument can also be an HMS form, or it can be a variable which is a time zone name in upper- or lower-case. For example @samp{tzone(PST) = tzone(8)} and @samp{tzone(pdt) = tzone(7)} (for Pacific standard and daylight savings times, respectively). North American and European time zone names are defined as follows; note that for each time zone there is one name for standard time, another for daylight savings time, and a third for ``generalized'' time in which the daylight savings adjustment is computed from context. @group @smallexample YST PST MST CST EST AST NST GMT WET MET MEZ 9 8 7 6 5 4 3.5 0 -1 -2 -2 YDT PDT MDT CDT EDT ADT NDT BST WETDST METDST MESZ 8 7 6 5 4 3 2.5 -1 -2 -3 -3 YGT PGT MGT CGT EGT AGT NGT BGT WEGT MEGT MEGZ 9/8 8/7 7/6 6/5 5/4 4/3 3.5/2.5 0/-1 -1/-2 -2/-3 -2/-3 @end smallexample @end group @vindex math-tzone-names To define time zone names that do not appear in the above table, you must modify the Lisp variable @code{math-tzone-names}. This is a list of lists describing the different time zone names; its structure is best explained by an example. The three entries for Pacific Time look like this: @group @smallexample ( ( "PST" 8 0 ) ; Name as an upper-case string, then standard ( "PDT" 8 -1 ) ; adjustment, then daylight savings adjustment. ( "PGT" 8 "PST" "PDT" ) ) ; Generalized time zone. @end smallexample @end group @cindex @code{TimeZone} variable @vindex TimeZone With no arguments, @code{calc-time-zone} or @samp{tzone()} obtains an argument from the Calc variable @code{TimeZone} if a value has been stored for that variable. If not, Calc runs the Unix @samp{date} command and looks for one of the above time zone names in the output; if this does not succeed, @samp{tzone()} leaves itself unevaluated. The time zone name in the @samp{date} output may be followed by a signed adjustment, e.g., @samp{GMT+5} or @samp{GMT+0500} which specifies a number of hours and minutes to be added to the base time zone. Calc stores the time zone it finds into @code{TimeZone} to speed later calls to @samp{tzone()}. The special time zone name @code{local} is equivalent to no argument, i.e., it uses the local time zone as obtained from the @code{date} command. If the time zone name found is one of the standard or daylight savings zone names from the above table, and Calc's internal daylight savings algorithm says that time and zone are consistent (e.g., @code{PDT} accompanies a date that Calc's algorithm would also consider to be daylight savings, or @code{PST} accompanies a date that Calc would consider to be standard time), then Calc substitutes the corresponding generalized time zone (like @code{PGT}). If your system does not have a suitable @samp{date} command, you may wish to put a @samp{(setq var-TimeZone ...)} in your Emacs initialization file to set the time zone. The easiest way to do this is to edit the @code{TimeZone} variable using Calc's @kbd{s T} command, then use the @kbd{s p} (@code{calc-permanent-variable}) command to save the value of @code{TimeZone} permanently. The @kbd{t J} and @code{t U} commands with no numeric prefix arguments do the same thing as @samp{tzone()}. If the current time zone is a generalized time zone, e.g., @code{EGT}, Calc examines the date being converted to tell whether to use standard or daylight savings time. But if the current time zone is explicit, e.g., @code{EST} or @code{EDT}, then that adjustment is used exactly and Calc's daylight savings algorithm is not consulted. Some places don't follow the usual rules for daylight savings time. The state of Arizona, for example, does not observe daylight savings time. If you run Calc during the winter season in Arizona, the Unix @code{date} command will report @code{MST} time zone, which Calc will change to @code{MGT}. If you then convert a time that lies in the summer months, Calc will apply an incorrect daylight savings time adjustment. To avoid this, set your @code{TimeZone} variable explicitly to @code{MST} to force the use of standard, non-daylight-savings time. @vindex math-daylight-savings-hook @findex math-std-daylight-savings By default Calc always considers daylight savings time to begin at 2 a.m.@: on the first Sunday of April, and to end at 2 a.m.@: on the last Sunday of October. This is the rule that has been in effect in North America since 1987. If you are in a country that uses different rules for computing daylight savings time, you have two choices: Write your own daylight savings hook, or control time zones explicitly by setting the @code{TimeZone} variable and/or always giving a time-zone argument for the conversion functions. The Lisp variable @code{math-daylight-savings-hook} holds the name of a function that is used to compute the daylight savings adjustment for a given date. The default is @code{math-std-daylight-savings}, which computes an adjustment (either 0 or @i{-1}) using the North American rules given above. The daylight savings hook function is called with four arguments: The date, as a floating-point number in standard Calc format; a six-element list of the date decomposed into year, month, day, hour, minute, and second, respectively; a string which contains the generalized time zone name in upper-case, e.g., @code{"WEGT"}; and a special adjustment to be applied to the hour value when converting into a generalized time zone (see below). @findex math-prev-weekday-in-month The Lisp function @code{math-prev-weekday-in-month} is useful for daylight savings computations. This is an internal version of the user-level @code{pwday} function described in the previous section. It takes four arguments: The floating-point date value, the corresponding six-element date list, the day-of-month number, and the weekday number (0-6). The default daylight savings hook ignores the time zone name, but a more sophisticated hook could use different algorithms for different time zones. It would also be possible to use different algorithms depending on the year number, but the default hook always uses the algorithm for 1987 and later. Here is a listing of the default daylight savings hook: @smallexample (defun math-std-daylight-savings (date dt zone bump) (cond ((< (nth 1 dt) 4) 0) ((= (nth 1 dt) 4) (let ((sunday (math-prev-weekday-in-month date dt 7 0))) (cond ((< (nth 2 dt) sunday) 0) ((= (nth 2 dt) sunday) (if (>= (nth 3 dt) (+ 3 bump)) -1 0)) (t -1)))) ((< (nth 1 dt) 10) -1) ((= (nth 1 dt) 10) (let ((sunday (math-prev-weekday-in-month date dt 31 0))) (cond ((< (nth 2 dt) sunday) -1) ((= (nth 2 dt) sunday) (if (>= (nth 3 dt) (+ 2 bump)) 0 -1)) (t 0)))) (t 0)) ) @end smallexample @noindent The @code{bump} parameter is equal to zero when Calc is converting from a date form in a generalized time zone into a GMT date value. It is @i{-1} when Calc is converting in the other direction. The adjustments shown above ensure that the conversion behaves correctly and reasonably around the 2 a.m.@: transition in each direction. There is a ``missing'' hour between 2 a.m.@: and 3 a.m.@: at the beginning of daylight savings time; converting a date/time form that falls in this hour results in a time value for the following hour, from 3 a.m.@: to 4 a.m. At the end of daylight savings time, the hour from 1 a.m.@: to 2 a.m.@: repeats itself; converting a date/time form that falls in in this hour results in a time value for the first manifestion of that time (@emph{not} the one that occurs one hour later). If @code{math-daylight-savings-hook} is @code{nil}, then the daylight savings adjustment is always taken to be zero. In algebraic formulas, @samp{tzone(@var{zone}, @var{date})} computes the time zone adjustment for a given zone name at a given date. The @var{date} is ignored unless @var{zone} is a generalized time zone. If @var{date} is a date form, the daylight savings computation is applied to it as it appears. If @var{date} is a numeric date value, it is adjusted for the daylight-savings version of @var{zone} before being given to the daylight savings hook. This odd-sounding rule ensures that the daylight-savings computation is always done in local time, not in the GMT time that a numeric @var{date} is typically represented in. @c @starindex @tindex dsadj The @samp{dsadj(@var{date}, @var{zone})} function computes the daylight savings adjustment that is appropriate for @var{date} in time zone @var{zone}. If @var{zone} is explicitly in or not in daylight savings time (e.g., @code{PDT} or @code{PST}) the @var{date} is ignored. If @var{zone} is a generalized time zone, the algorithms described above are used. If @var{zone} is omitted, the computation is done for the current time zone. @xref{Reporting Bugs}, for the address of Calc's author, if you should wish to contribute your improved versions of @code{math-tzone-names} and @code{math-daylight-savings-hook} to the Calc distribution. @node Financial Functions, Binary Functions, Date Arithmetic, Arithmetic @section Financial Functions @noindent Calc's financial or business functions use the @kbd{b} prefix key followed by a shifted letter. (The @kbd{b} prefix followed by a lower-case letter is used for operations on binary numbers.) Note that the rate and the number of intervals given to these functions must be on the same time scale, e.g., both months or both years. Mixing an annual interest rate with a time expressed in months will give you very wrong answers! It is wise to compute these functions to a higher precision than you really need, just to make sure your answer is correct to the last penny; also, you may wish to check the definitions at the end of this section to make sure the functions have the meaning you expect. @menu * Percentages:: * Future Value:: * Present Value:: * Related Financial Functions:: * Depreciation Functions:: * Definitions of Financial Functions:: @end menu @node Percentages, Future Value, Financial Functions, Financial Functions @subsection Percentages @kindex M-% @pindex calc-percent @tindex % @tindex percent The @kbd{M-%} (@code{calc-percent}) command takes a percentage value, say 5.4, and converts it to an equivalent actual number. For example, @kbd{5.4 M-%} enters 0.054 on the stack. (That's the @key{META} or @key{ESC} key combined with @kbd{%}.) Actually, @kbd{M-%} creates a formula of the form @samp{5.4%}. You can enter @samp{5.4%} yourself during algebraic entry. The @samp{%} operator simply means, ``the preceding value divided by 100.'' The @samp{%} operator has very high precedence, so that @samp{1+8%} is interpreted as @samp{1+(8%)}, not as @samp{(1+8)%}. (The @samp{%} operator is just a postfix notation for the @code{percent} function, just like @samp{20!} is the notation for @samp{fact(20)}, or twenty-factorial.) The formula @samp{5.4%} would normally evaluate immediately to 0.054, but the @kbd{M-%} command suppresses evaluation as it puts the formula onto the stack. However, the next Calc command that uses the formula @samp{5.4%} will evaluate it as its first step. The net effect is that you get to look at @samp{5.4%} on the stack, but Calc commands see it as @samp{0.054}, which is what they expect. In particular, @samp{5.4%} and @samp{0.054} are suitable values for the @var{rate} arguments of the various financial functions, but the number @samp{5.4} is probably @emph{not} suitable---it represents a rate of 540 percent! The key sequence @kbd{M-% *} effectively means ``percent-of.'' For example, @kbd{68 RET 25 M-% *} computes 17, which is 25% of 68 (and also 68% of 25, which comes out to the same thing). @kindex c % @pindex calc-convert-percent The @kbd{c %} (@code{calc-convert-percent}) command converts the value on the top of the stack from numeric to percentage form. For example, if 0.08 is on the stack, @kbd{c %} converts it to @samp{8%}. The quantity is the same, it's just represented differently. (Contrast this with @kbd{M-%}, which would convert this number to @samp{0.08%}.) The @kbd{=} key is a convenient way to convert a formula like @samp{8%} back to numeric form, 0.08. To compute what percentage one quantity is of another quantity, use @kbd{/ c %}. For example, @w{@kbd{17 RET 68 / c %}} displays @samp{25%}. @kindex b % @pindex calc-percent-change @tindex relch The @kbd{b %} (@code{calc-percent-change}) [@code{relch}] command calculates the percentage change from one number to another. For example, @kbd{40 RET 50 b %} produces the answer @samp{25%}, since 50 is 25% larger than 40. A negative result represents a decrease: @kbd{50 RET 40 b %} produces @samp{-20%}, since 40 is 20% smaller than 50. (The answers are different in magnitude because, in the first case, we're increasing by 25% of 40, but in the second case, we're decreasing by 20% of 50.) The effect of @kbd{40 RET 50 b %} is to compute @cite{(50-40)/40}, converting the answer to percentage form as if by @kbd{c %}. @node Future Value, Present Value, Percentages, Financial Functions @subsection Future Value @noindent @kindex b F @pindex calc-fin-fv @tindex fv The @kbd{b F} (@code{calc-fin-fv}) [@code{fv}] command computes the future value of an investment. It takes three arguments from the stack: @samp{fv(@var{rate}, @var{n}, @var{payment})}. If you give payments of @var{payment} every year for @var{n} years, and the money you have paid earns interest at @var{rate} per year, then this function tells you what your investment would be worth at the end of the period. (The actual interval doesn't have to be years, as long as @var{n} and @var{rate} are expressed in terms of the same intervals.) This function assumes payments occur at the @emph{end} of each interval. @kindex I b F @tindex fvb The @kbd{I b F} [@code{fvb}] command does the same computation, but assuming your payments are at the beginning of each interval. Suppose you plan to deposit $1000 per year in a savings account earning 5.4% interest, starting right now. How much will be in the account after five years? @code{fvb(5.4%, 5, 1000) = 5870.73}. Thus you will have earned $870 worth of interest over the years. Using the stack, this calculation would have been @kbd{5.4 M-% 5 RET 1000 I b F}. Note that the rate is expressed as a number between 0 and 1, @emph{not} as a percentage. @kindex H b F @tindex fvl The @kbd{H b F} [@code{fvl}] command computes the future value of an initial lump sum investment. Suppose you could deposit those five thousand dollars in the bank right now; how much would they be worth in five years? @code{fvl(5.4%, 5, 5000) = 6503.89}. The algebraic functions @code{fv} and @code{fvb} accept an optional fourth argument, which is used as an initial lump sum in the sense of @code{fvl}. In other words, @code{fv(@var{rate}, @var{n}, @var{payment}, @var{initial}) = fv(@var{rate}, @var{n}, @var{payment}) + fvl(@var{rate}, @var{n}, @var{initial})}.@refill To illustrate the relationships between these functions, we could do the @code{fvb} calculation ``by hand'' using @code{fvl}. The final balance will be the sum of the contributions of our five deposits at various times. The first deposit earns interest for five years: @code{fvl(5.4%, 5, 1000) = 1300.78}. The second deposit only earns interest for four years: @code{fvl(5.4%, 4, 1000) = 1234.13}. And so on down to the last deposit, which earns one year's interest: @code{fvl(5.4%, 1, 1000) = 1054.00}. The sum of these five values is, sure enough, $5870.73, just as was computed by @code{fvb} directly. What does @code{fv(5.4%, 5, 1000) = 5569.96} mean? The payments are now at the ends of the periods. The end of one year is the same as the beginning of the next, so what this really means is that we've lost the payment at year zero (which contributed $1300.78), but we're now counting the payment at year five (which, since it didn't have a chance to earn interest, counts as $1000). Indeed, @cite{5569.96 = 5870.73 - 1300.78 + 1000} (give or take a bit of roundoff error). @node Present Value, Related Financial Functions, Future Value, Financial Functions @subsection Present Value @noindent @kindex b P @pindex calc-fin-pv @tindex pv The @kbd{b P} (@code{calc-fin-pv}) [@code{pv}] command computes the present value of an investment. Like @code{fv}, it takes three arguments: @code{pv(@var{rate}, @var{n}, @var{payment})}. It computes the present value of a series of regular payments. Suppose you have the chance to make an investment that will pay $2000 per year over the next four years; as you receive these payments you can put them in the bank at 9% interest. You want to know whether it is better to make the investment, or to keep the money in the bank where it earns 9% interest right from the start. The calculation @code{pv(9%, 4, 2000)} gives the result 6479.44. If your initial investment must be less than this, say, $6000, then the investment is worthwhile. But if you had to put up $7000, then it would be better just to leave it in the bank. Here is the interpretation of the result of @code{pv}: You are trying to compare the return from the investment you are considering, which is @code{fv(9%, 4, 2000) = 9146.26}, with the return from leaving the money in the bank, which is @code{fvl(9%, 4, @var{x})} where @var{x} is the amount of money you would have to put up in advance. The @code{pv} function finds the break-even point, @cite{x = 6479.44}, at which @code{fvl(9%, 4, 6479.44)} is also equal to 9146.26. This is the largest amount you should be willing to invest. @kindex I b P @tindex pvb The @kbd{I b P} [@code{pvb}] command solves the same problem, but with payments occurring at the beginning of each interval. It has the same relationship to @code{fvb} as @code{pv} has to @code{fv}. For example @code{pvb(9%, 4, 2000) = 7062.59}, a larger number than @code{pv} produced because we get to start earning interest on the return from our investment sooner. @kindex H b P @tindex pvl The @kbd{H b P} [@code{pvl}] command computes the present value of an investment that will pay off in one lump sum at the end of the period. For example, if we get our $8000 all at the end of the four years, @code{pvl(9%, 4, 8000) = 5667.40}. This is much less than @code{pv} reported, because we don't earn any interest on the return from this investment. Note that @code{pvl} and @code{fvl} are simple inverses: @code{fvl(9%, 4, 5667.40) = 8000}. You can give an optional fourth lump-sum argument to @code{pv} and @code{pvb}; this is handled in exactly the same way as the fourth argument for @code{fv} and @code{fvb}. @kindex b N @pindex calc-fin-npv @tindex npv The @kbd{b N} (@code{calc-fin-npv}) [@code{npv}] command computes the net present value of a series of irregular investments. The first argument is the interest rate. The second argument is a vector which represents the expected return from the investment at the end of each interval. For example, if the rate represents a yearly interest rate, then the vector elements are the return from the first year, second year, and so on. Thus, @code{npv(9%, [2000,2000,2000,2000]) = pv(9%, 4, 2000) = 6479.44}. Obviously this function is more interesting when the payments are not all the same! The @code{npv} function can actually have two or more arguments. Multiple arguments are interpreted in the same way as for the vector statistical functions like @code{vsum}. @xref{Single-Variable Statistics}. Basically, if there are several payment arguments, each either a vector or a plain number, all these values are collected left-to-right into the complete list of payments. A numeric prefix argument on the @kbd{b N} command says how many payment values or vectors to take from the stack.@refill @kindex I b N @tindex npvb The @kbd{I b N} [@code{npvb}] command computes the net present value where payments occur at the beginning of each interval rather than at the end. @node Related Financial Functions, Depreciation Functions, Present Value, Financial Functions @subsection Related Financial Functions @noindent The functions in this section are basically inverses of the present value functions with respect to the various arguments. @kindex b M @pindex calc-fin-pmt @tindex pmt The @kbd{b M} (@code{calc-fin-pmt}) [@code{pmt}] command computes the amount of periodic payment necessary to amortize a loan. Thus @code{pmt(@var{rate}, @var{n}, @var{amount})} equals the value of @var{payment} such that @code{pv(@var{rate}, @var{n}, @var{payment}) = @var{amount}}.@refill @kindex I b M @tindex pmtb The @kbd{I b M} [@code{pmtb}] command does the same computation but using @code{pvb} instead of @code{pv}. Like @code{pv} and @code{pvb}, these functions can also take a fourth argument which represents an initial lump-sum investment. @kindex H b M The @kbd{H b M} key just invokes the @code{fvl} function, which is the inverse of @code{pvl}. There is no explicit @code{pmtl} function. @kindex b # @pindex calc-fin-nper @tindex nper The @kbd{b #} (@code{calc-fin-nper}) [@code{nper}] command computes the number of regular payments necessary to amortize a loan. Thus @code{nper(@var{rate}, @var{payment}, @var{amount})} equals the value of @var{n} such that @code{pv(@var{rate}, @var{n}, @var{payment}) = @var{amount}}. If @var{payment} is too small ever to amortize a loan for @var{amount} at interest rate @var{rate}, the @code{nper} function is left in symbolic form.@refill @kindex I b # @tindex nperb The @kbd{I b #} [@code{nperb}] command does the same computation but using @code{pvb} instead of @code{pv}. You can give a fourth lump-sum argument to these functions, but the computation will be rather slow in the four-argument case.@refill @kindex H b # @tindex nperl The @kbd{H b #} [@code{nperl}] command does the same computation using @code{pvl}. By exchanging @var{payment} and @var{amount} you can also get the solution for @code{fvl}. For example, @code{nperl(8%, 2000, 1000) = 9.006}, so if you place $1000 in a bank account earning 8%, it will take nine years to grow to $2000.@refill @kindex b T @pindex calc-fin-rate @tindex rate The @kbd{b T} (@code{calc-fin-rate}) [@code{rate}] command computes the rate of return on an investment. This is also an inverse of @code{pv}: @code{rate(@var{n}, @var{payment}, @var{amount})} computes the value of @var{rate} such that @code{pv(@var{rate}, @var{n}, @var{payment}) = @var{amount}}. The result is expressed as a formula like @samp{6.3%}.@refill @kindex I b T @kindex H b T @tindex rateb @tindex ratel The @kbd{I b T} [@code{rateb}] and @kbd{H b T} [@code{ratel}] commands solve the analogous equations with @code{pvb} or @code{pvl} in place of @code{pv}. Also, @code{rate} and @code{rateb} can accept an optional fourth argument just like @code{pv} and @code{pvb}. To redo the above example from a different perspective, @code{ratel(9, 2000, 1000) = 8.00597%}, which says you will need an interest rate of 8% in order to double your account in nine years.@refill @kindex b I @pindex calc-fin-irr @tindex irr The @kbd{b I} (@code{calc-fin-irr}) [@code{irr}] command is the analogous function to @code{rate} but for net present value. Its argument is a vector of payments. Thus @code{irr(@var{payments})} computes the @var{rate} such that @code{npv(@var{rate}, @var{payments}) = 0}; this rate is known as the @dfn{internal rate of return}. @kindex I b I @tindex irrb The @kbd{I b I} [@code{irrb}] command computes the internal rate of return assuming payments occur at the beginning of each period. @node Depreciation Functions, Definitions of Financial Functions, Related Financial Functions, Financial Functions @subsection Depreciation Functions @noindent The functions in this section calculate @dfn{depreciation}, which is the amount of value that a possession loses over time. These functions are characterized by three parameters: @var{cost}, the original cost of the asset; @var{salvage}, the value the asset will have at the end of its expected ``useful life''; and @var{life}, the number of years (or other periods) of the expected useful life. There are several methods for calculating depreciation that differ in the way they spread the depreciation over the lifetime of the asset. @kindex b S @pindex calc-fin-sln @tindex sln The @kbd{b S} (@code{calc-fin-sln}) [@code{sln}] command computes the ``straight-line'' depreciation. In this method, the asset depreciates by the same amount every year (or period). For example, @samp{sln(12000, 2000, 5)} returns 2000. The asset costs $12000 initially and will be worth $2000 after five years; it loses $2000 per year. @kindex b Y @pindex calc-fin-syd @tindex syd The @kbd{b Y} (@code{calc-fin-syd}) [@code{syd}] command computes the accelerated ``sum-of-years'-digits'' depreciation. Here the depreciation is higher during the early years of the asset's life. Since the depreciation is different each year, @kbd{b Y} takes a fourth @var{period} parameter which specifies which year is requested, from 1 to @var{life}. If @var{period} is outside this range, the @code{syd} function will return zero. @kindex b D @pindex calc-fin-ddb @tindex ddb The @kbd{b D} (@code{calc-fin-ddb}) [@code{ddb}] command computes an accelerated depreciation using the double-declining balance method. It also takes a fourth @var{period} parameter. For symmetry, the @code{sln} function will accept a @var{period} parameter as well, although it will ignore its value except that the return value will as usual be zero if @var{period} is out of range. For example, pushing the vector @cite{[1,2,3,4,5]} (perhaps with @kbd{v x 5}) and then mapping @kbd{V M ' [sln(12000,2000,5,$), syd(12000,2000,5,$), ddb(12000,2000,5,$)] RET} produces a matrix that allows us to compare the three depreciation methods: @group @example [ [ 2000, 3333, 4800 ] [ 2000, 2667, 2880 ] [ 2000, 2000, 1728 ] [ 2000, 1333, 592 ] [ 2000, 667, 0 ] ] @end example @end group @noindent (Values have been rounded to nearest integers in this figure.) We see that @code{sln} depreciates by the same amount each year, @kbd{syd} depreciates more at the beginning and less at the end, and @kbd{ddb} weights the depreciation even more toward the beginning. Summing columns with @kbd{V R : +} yields @cite{[10000, 10000, 10000]}; the total depreciation in any method is (by definition) the difference between the cost and the salvage value. @node Definitions of Financial Functions, , Depreciation Functions, Financial Functions @subsection Definitions @noindent For your reference, here are the actual formulas used to compute Calc's financial functions. Calc will not evaluate a financial function unless the @var{rate} or @var{n} argument is known. However, @var{payment} or @var{amount} can be a variable. Calc expands these functions according to the formulas below for symbolic arguments only when you use the @kbd{a "} (@code{calc-expand-formula}) command, or when taking derivatives or integrals or solving equations involving the functions. @ifinfo These formulas are shown using the conventions of ``Big'' display mode (@kbd{d B}); for example, the formula for @code{fv} written linearly is @samp{pmt * ((1 + rate)^n) - 1) / rate}. @example n (1 + rate) - 1 fv(rate, n, pmt) = pmt * --------------- rate n ((1 + rate) - 1) (1 + rate) fvb(rate, n, pmt) = pmt * ---------------------------- rate n fvl(rate, n, pmt) = pmt * (1 + rate) -n 1 - (1 + rate) pv(rate, n, pmt) = pmt * ---------------- rate -n (1 - (1 + rate) ) (1 + rate) pvb(rate, n, pmt) = pmt * ----------------------------- rate -n pvl(rate, n, pmt) = pmt * (1 + rate) -1 -2 -3 npv(rate, [a, b, c]) = a*(1 + rate) + b*(1 + rate) + c*(1 + rate) -1 -2 npvb(rate, [a, b, c]) = a + b*(1 + rate) + c*(1 + rate) -n (amt - x * (1 + rate) ) * rate pmt(rate, n, amt, x) = ------------------------------- -n 1 - (1 + rate) -n (amt - x * (1 + rate) ) * rate pmtb(rate, n, amt, x) = ------------------------------- -n (1 - (1 + rate) ) (1 + rate) amt * rate nper(rate, pmt, amt) = - log(1 - ------------, 1 + rate) pmt amt * rate nperb(rate, pmt, amt) = - log(1 - ---------------, 1 + rate) pmt * (1 + rate) amt nperl(rate, pmt, amt) = - log(---, 1 + rate) pmt 1/n pmt ratel(n, pmt, amt) = ------ - 1 1/n amt cost - salv sln(cost, salv, life) = ----------- life (cost - salv) * (life - per + 1) syd(cost, salv, life, per) = -------------------------------- life * (life + 1) / 2 book * 2 ddb(cost, salv, life, per) = --------, book = cost - depreciation so far life @end example @end ifinfo @tex \turnoffactive $$ \code{fv}(r, n, p) = p { (1 + r)^n - 1 \over r } $$ $$ \code{fvb}(r, n, p) = p { ((1 + r)^n - 1) (1 + r) \over r } $$ $$ \code{fvl}(r, n, p) = p (1 + r)^n $$ $$ \code{pv}(r, n, p) = p { 1 - (1 + r)^{-n} \over r } $$ $$ \code{pvb}(r, n, p) = p { (1 - (1 + r)^{-n}) (1 + r) \over r } $$ $$ \code{pvl}(r, n, p) = p (1 + r)^{-n} $$ $$ \code{npv}(r, [a,b,c]) = a (1 + r)^{-1} + b (1 + r)^{-2} + c (1 + r)^{-3} $$ $$ \code{npvb}(r, [a,b,c]) = a + b (1 + r)^{-1} + c (1 + r)^{-2} $$ $$ \code{pmt}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over 1 - (1 + r)^{-n} }$$ $$ \code{pmtb}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over (1 - (1 + r)^{-n}) (1 + r) } $$ $$ \code{nper}(r, p, a) = -\code{log}(1 - { a r \over p }, 1 + r) $$ $$ \code{nperb}(r, p, a) = -\code{log}(1 - { a r \over p (1 + r) }, 1 + r) $$ $$ \code{nperl}(r, p, a) = -\code{log}({a \over p}, 1 + r) $$ $$ \code{ratel}(n, p, a) = { p^{1/n} \over a^{1/n} } - 1 $$ $$ \code{sln}(c, s, l) = { c - s \over l } $$ $$ \code{syd}(c, s, l, p) = { (c - s) (l - p + 1) \over l (l+1) / 2 } $$ $$ \code{ddb}(c, s, l, p) = { 2 (c - \hbox{depreciation so far}) \over l } $$ @end tex @noindent In @code{pmt} and @code{pmtb}, @cite{x=0} if omitted. These functions accept any numeric objects, including error forms, intervals, and even (though not very usefully) complex numbers. The above formulas specify exactly the behavior of these functions with all sorts of inputs. Note that if the first argument to the @code{log} in @code{nper} is negative, @code{nper} leaves itself in symbolic form rather than returning a (financially meaningless) complex number. @samp{rate(num, pmt, amt)} solves the equation @samp{pv(rate, num, pmt) = amt} for @samp{rate} using @kbd{H a R} (@code{calc-find-root}), with the interval @samp{[.01% .. 100%]} for an initial guess. The @code{rateb} function is the same except that it uses @code{pvb}. Note that @code{ratel} can be solved directly; its formula is shown in the above list. Similarly, @samp{irr(pmts)} solves the equation @samp{npv(rate, pmts) = 0} for @samp{rate}. If you give a fourth argument to @code{nper} or @code{nperb}, Calc will also use @kbd{H a R} to solve the equation using an initial guess interval of @samp{[0 .. 100]}. A fourth argument to @code{fv} simply sums the two components calculated from the above formulas for @code{fv} and @code{fvl}. The same is true of @code{fvb}, @code{pv}, and @code{pvb}. The @kbd{ddb} function is computed iteratively; the ``book'' value starts out equal to @var{cost}, and decreases according to the above formula for the specified number of periods. If the book value would decrease below @var{salvage}, it only decreases to @var{salvage} and the depreciation is zero for all subsequent periods. The @code{ddb} function returns the amount the book value decreased in the specified period. The Calc financial function names were borrowed mostly from Microsoft Excel and Borland's Quattro. The @code{ratel} function corresponds to @samp{@@CGR} in Borland's Reflex. The @code{nper} and @code{nperl} functions correspond to @samp{@@TERM} and @samp{@@CTERM} in Quattro, respectively. Beware that the Calc functions may take their arguments in a different order than the corresponding functions in your favorite spreadsheet. @node Binary Functions, , Financial Functions, Arithmetic @section Binary Number Functions @noindent The commands in this chapter all use two-letter sequences beginning with the @kbd{b} prefix. @cindex Binary numbers The ``binary'' operations actually work regardless of the currently displayed radix, although their results make the most sense in a radix like 2, 8, or 16 (as obtained by the @kbd{d 2}, @kbd{d 8}, or @w{@kbd{d 6}} commands, respectively). You may also wish to enable display of leading zeros with @kbd{d z}. @xref{Radix Modes}. @cindex Word size for binary operations The Calculator maintains a current @dfn{word size} @cite{w}, an arbitrary positive or negative integer. For a positive word size, all of the binary operations described here operate modulo @cite{2^w}. In particular, negative arguments are converted to positive integers modulo @cite{2^w} by all binary functions.@refill If the word size is negative, binary operations produce 2's complement integers from @c{$-2^{-w-1}$} @cite{-(2^(-w-1))} to @c{$2^{-w-1}-1$} @cite{2^(-w-1)-1} inclusive. Either mode accepts inputs in any range; the sign of @cite{w} affects only the results produced. @kindex b c @pindex calc-clip @tindex clip The @kbd{b c} (@code{calc-clip}) [@code{clip}] command can be used to clip a number by reducing it modulo @cite{2^w}. The commands described in this chapter automatically clip their results to the current word size. Note that other operations like addition do not use the current word size, since integer addition generally is not ``binary.'' (However, @pxref{Simplification Modes}, @code{calc-bin-simplify-mode}.) For example, with a word size of 8 bits @kbd{b c} converts a number to the range 0 to 255; with a word size of @i{-8} @kbd{b c} converts to the range @i{-128} to 127.@refill @kindex b w @pindex calc-word-size The default word size is 32 bits. All operations except the shifts and rotates allow you to specify a different word size for that one operation by giving a numeric prefix argument: @kbd{C-u 8 b c} clips the top of stack to the range 0 to 255 regardless of the current word size. To set the word size permanently, use @kbd{b w} (@code{calc-word-size}). This command displays a prompt with the current word size; press @key{RET} immediately to keep this word size, or type a new word size at the prompt. When the binary operations are written in symbolic form, they take an optional second (or third) word-size parameter. When a formula like @samp{and(a,b)} is finally evaluated, the word size current at that time will be used, but when @samp{and(a,b,-8)} is evaluated, a word size of @i{-8} will always be used. A symbolic binary function will be left in symbolic form unless the all of its argument(s) are integers or integer-valued floats. If either or both arguments are modulo forms for which @cite{M} is a power of two, that power of two is taken as the word size unless a numeric prefix argument overrides it. The current word size is never consulted when modulo-power-of-two forms are involved. @kindex b a @pindex calc-and @tindex and The @kbd{b a} (@code{calc-and}) [@code{and}] command computes the bitwise AND of the two numbers on the top of the stack. In other words, for each of the @cite{w} binary digits of the two numbers (pairwise), the corresponding bit of the result is 1 if and only if both input bits are 1: @samp{and(2#1100, 2#1010) = 2#1000}. @kindex b o @pindex calc-or @tindex or The @kbd{b o} (@code{calc-or}) [@code{or}] command computes the bitwise inclusive OR of two numbers. A bit is 1 if either of the input bits, or both, are 1: @samp{or(2#1100, 2#1010) = 2#1110}. @kindex b x @pindex calc-xor @tindex xor The @kbd{b x} (@code{calc-xor}) [@code{xor}] command computes the bitwise exclusive OR of two numbers. A bit is 1 if exactly one of the input bits is 1: @samp{xor(2#1100, 2#1010) = 2#0110}. @kindex b d @pindex calc-diff @tindex diff The @kbd{b d} (@code{calc-diff}) [@code{diff}] command computes the bitwise difference of two numbers; this is defined by @samp{diff(a,b) = and(a,not(b))}, so that @samp{diff(2#1100, 2#1010) = 2#0100}. @kindex b n @pindex calc-not @tindex not The @kbd{b n} (@code{calc-not}) [@code{not}] command computes the bitwise NOT of a number. A bit is 1 if the input bit is 0 and vice-versa. @kindex b l @pindex calc-lshift-binary @tindex lsh The @kbd{b l} (@code{calc-lshift-binary}) [@code{lsh}] command shifts a number left by one bit, or by the number of bits specified in the numeric prefix argument. A negative prefix argument performs a logical right shift, in which zeros are shifted in on the left. In symbolic form, @samp{lsh(a)} is short for @samp{lsh(a,1)}, which in turn is short for @samp{lsh(a,n,w)}. Bits shifted ``off the end,'' according to the current word size, are lost. @kindex H b l @kindex H b r @c @mindex @idots @kindex H b L @c @mindex @null @kindex H b R @c @mindex @null @kindex H b t The @kbd{H b l} command also does a left shift, but it takes two arguments from the stack (the value to shift, and, at top-of-stack, the number of bits to shift). This version interprets the prefix argument just like the regular binary operations, i.e., as a word size. The Hyperbolic flag has a similar effect on the rest of the binary shift and rotate commands. @kindex b r @pindex calc-rshift-binary @tindex rsh The @kbd{b r} (@code{calc-rshift-binary}) [@code{rsh}] command shifts a number right by one bit, or by the number of bits specified in the numeric prefix argument: @samp{rsh(a,n) = lsh(a,-n)}. @kindex b L @pindex calc-lshift-arith @tindex ash The @kbd{b L} (@code{calc-lshift-arith}) [@code{ash}] command shifts a number left. It is analogous to @code{lsh}, except that if the shift is rightward (the prefix argument is negative), an arithmetic shift is performed as described below. @kindex b R @pindex calc-rshift-arith @tindex rash The @kbd{b R} (@code{calc-rshift-arith}) [@code{rash}] command performs an ``arithmetic'' shift to the right, in which the leftmost bit (according to the current word size) is duplicated rather than shifting in zeros. This corresponds to dividing by a power of two where the input is interpreted as a signed, twos-complement number. (The distinction between the @samp{rsh} and @samp{rash} operations is totally independent from whether the word size is positive or negative.) With a negative prefix argument, this performs a standard left shift. @kindex b t @pindex calc-rotate-binary @tindex rot The @kbd{b t} (@code{calc-rotate-binary}) [@code{rot}] command rotates a number one bit to the left. The leftmost bit (according to the current word size) is dropped off the left and shifted in on the right. With a numeric prefix argument, the number is rotated that many bits to the left or right. @xref{Set Operations}, for the @kbd{b p} and @kbd{b u} commands that pack and unpack binary integers into sets. (For example, @kbd{b u} unpacks the number @samp{2#11001} to the set of bit-numbers @samp{[0, 3, 4]}.) Type @kbd{b u V #} to count the number of ``1'' bits in a binary integer. Another interesting use of the set representation of binary integers is to reverse the bits in, say, a 32-bit integer. Type @kbd{b u} to unpack; type @kbd{31 TAB -} to replace each bit-number in the set with 31 minus that bit-number; type @kbd{b p} to pack the set back into a binary integer. @node Scientific Functions, Matrix Functions, Arithmetic, Top @chapter Scientific Functions @noindent The functions described here perform trigonometric and other transcendental calculations. They generally produce floating-point answers correct to the full current precision. The @kbd{H} (Hyperbolic) and @kbd{I} (Inverse) flag keys must be used to get some of these functions from the keyboard. @kindex P @pindex calc-pi @cindex @code{pi} variable @vindex pi @kindex H P @cindex @code{e} variable @vindex e @kindex I P @cindex @code{gamma} variable @vindex gamma @cindex Gamma constant, Euler's @cindex Euler's gamma constant @kindex H I P @cindex @code{phi} variable @cindex Phi, golden ratio @cindex Golden ratio One miscellanous command is shift-@kbd{P} (@code{calc-pi}), which pushes the value of @c{$\pi$} @cite{pi} (at the current precision) onto the stack. With the Hyperbolic flag, it pushes the value @cite{e}, the base of natural logarithms. With the Inverse flag, it pushes Euler's constant @c{$\gamma$} @cite{gamma} (about 0.5772). With both Inverse and Hyperbolic, it pushes the ``golden ratio'' @c{$\phi$} @cite{phi} (about 1.618). (At present, Euler's constant is not available to unlimited precision; Calc knows only the first 100 digits.) In Symbolic mode, these commands push the actual variables @samp{pi}, @samp{e}, @samp{gamma}, and @samp{phi}, respectively, instead of their values; @pxref{Symbolic Mode}.@refill @c @mindex Q @c @mindex I Q @kindex I Q @tindex sqr The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] function is described elsewhere; @pxref{Basic Arithmetic}. With the Inverse flag [@code{sqr}], this command computes the square of the argument. @xref{Prefix Arguments}, for a discussion of the effect of numeric prefix arguments on commands in this chapter which do not otherwise interpret a prefix argument. @menu * Logarithmic Functions:: * Trigonometric and Hyperbolic Functions:: * Advanced Math Functions:: * Branch Cuts:: * Random Numbers:: * Combinatorial Functions:: * Probability Distribution Functions:: @end menu @node Logarithmic Functions, Trigonometric and Hyperbolic Functions, Scientific Functions, Scientific Functions @section Logarithmic Functions @noindent @kindex L @pindex calc-ln @tindex ln @c @mindex @null @kindex I E The shift-@kbd{L} (@code{calc-ln}) [@code{ln}] command computes the natural logarithm of the real or complex number on the top of the stack. With the Inverse flag it computes the exponential function instead, although this is redundant with the @kbd{E} command. @kindex E @pindex calc-exp @tindex exp @c @mindex @null @kindex I L The shift-@kbd{E} (@code{calc-exp}) [@code{exp}] command computes the exponential, i.e., @cite{e} raised to the power of the number on the stack. The meanings of the Inverse and Hyperbolic flags follow from those for the @code{calc-ln} command. @kindex H L @kindex H E @pindex calc-log10 @tindex log10 @tindex exp10 @c @mindex @null @kindex H I L @c @mindex @null @kindex H I E The @kbd{H L} (@code{calc-log10}) [@code{log10}] command computes the common (base-10) logarithm of a number. (With the Inverse flag [@code{exp10}], it raises ten to a given power.) Note that the common logarithm of a complex number is computed by taking the natural logarithm and dividing by @c{$\ln10$} @cite{ln(10)}. @kindex B @kindex I B @pindex calc-log @tindex log @tindex alog The @kbd{B} (@code{calc-log}) [@code{log}] command computes a logarithm to any base. For example, @kbd{1024 @key{RET} 2 B} produces 10, since @c{$2^{10} = 1024$} @cite{2^10 = 1024}. In certain cases like @samp{log(3,9)}, the result will be either @cite{1:2} or @cite{0.5} depending on the current Fraction Mode setting. With the Inverse flag [@code{alog}], this command is similar to @kbd{^} except that the order of the arguments is reversed. @kindex f I @pindex calc-ilog @tindex ilog The @kbd{f I} (@code{calc-ilog}) [@code{ilog}] command computes the integer logarithm of a number to any base. The number and the base must themselves be positive integers. This is the true logarithm, rounded down to an integer. Thus @kbd{ilog(x,10)} is 3 for all @cite{x} in the range from 1000 to 9999. If both arguments are positive integers, exact integer arithmetic is used; otherwise, this is equivalent to @samp{floor(log(x,b))}. @kindex f E @pindex calc-expm1 @tindex expm1 The @kbd{f E} (@code{calc-expm1}) [@code{expm1}] command computes @c{$e^x - 1$} @cite{exp(x)-1}, but using an algorithm that produces a more accurate answer when the result is close to zero, i.e., when @c{$e^x$} @cite{exp(x)} is close to one. @kindex f L @pindex calc-lnp1 @tindex lnp1 The @kbd{f L} (@code{calc-lnp1}) [@code{lnp1}] command computes @c{$\ln(x+1)$} @cite{ln(x+1)}, producing a more accurate answer when @cite{x} is close to zero. @node Trigonometric and Hyperbolic Functions, Advanced Math Functions, Logarithmic Functions, Scientific Functions @section Trigonometric/Hyperbolic Functions @noindent @kindex S @pindex calc-sin @tindex sin The shift-@kbd{S} (@code{calc-sin}) [@code{sin}] command computes the sine of an angle or complex number. If the input is an HMS form, it is interpreted as degrees-minutes-seconds; otherwise, the input is interpreted according to the current angular mode. It is best to use Radians mode when operating on complex numbers.@refill Calc's ``units'' mechanism includes angular units like @code{deg}, @code{rad}, and @code{grad}. While @samp{sin(45 deg)} is not evaluated all the time, the @kbd{u s} (@code{calc-simplify-units}) command will simplify @samp{sin(45 deg)} by taking the sine of 45 degrees, regardless of the current angular mode. @xref{Basic Operations on Units}. Also, the symbolic variable @code{pi} is not ordinarily recognized in arguments to trigonometric functions, as in @samp{sin(3 pi / 4)}, but the @kbd{a s} (@code{calc-simplify}) command recognizes many such formulas when the current angular mode is radians @emph{and} symbolic mode is enabled; this example would be replaced by @samp{sqrt(2) / 2}. @xref{Symbolic Mode}. Beware, this simplification occurs even if you have stored a different value in the variable @samp{pi}; this is one reason why changing built-in variables is a bad idea. Arguments of the form @cite{x} plus a multiple of @c{$\pi/2$} @cite{pi/2} are also simplified. Calc includes similar formulas for @code{cos} and @code{tan}.@refill The @kbd{a s} command knows all angles which are integer multiples of @c{$\pi/12$} @cite{pi/12}, @c{$\pi/10$} @cite{pi/10}, or @c{$\pi/8$} @cite{pi/8} radians. In degrees mode, analogous simplifications occur for integer multiples of 15 or 18 degrees, and for arguments plus multiples of 90 degrees. @kindex I S @pindex calc-arcsin @tindex arcsin With the Inverse flag, @code{calc-sin} computes an arcsine. This is also available as the @code{calc-arcsin} command or @code{arcsin} algebraic function. The returned argument is converted to degrees, radians, or HMS notation depending on the current angular mode. @kindex H S @pindex calc-sinh @tindex sinh @kindex H I S @pindex calc-arcsinh @tindex arcsinh With the Hyperbolic flag, @code{calc-sin} computes the hyperbolic sine, also available as @code{calc-sinh} [@code{sinh}]. With the Hyperbolic and Inverse flags, it computes the hyperbolic arcsine (@code{calc-arcsinh}) [@code{arcsinh}]. @kindex C @pindex calc-cos @tindex cos @c @mindex @idots @kindex I C @pindex calc-arccos @c @mindex @null @tindex arccos @c @mindex @null @kindex H C @pindex calc-cosh @c @mindex @null @tindex cosh @c @mindex @null @kindex H I C @pindex calc-arccosh @c @mindex @null @tindex arccosh @c @mindex @null @kindex T @pindex calc-tan @c @mindex @null @tindex tan @c @mindex @null @kindex I T @pindex calc-arctan @c @mindex @null @tindex arctan @c @mindex @null @kindex H T @pindex calc-tanh @c @mindex @null @tindex tanh @c @mindex @null @kindex H I T @pindex calc-arctanh @c @mindex @null @tindex arctanh The shift-@kbd{C} (@code{calc-cos}) [@code{cos}] command computes the cosine of an angle or complex number, and shift-@kbd{T} (@code{calc-tan}) [@code{tan}] computes the tangent, along with all the various inverse and hyperbolic variants of these functions. @kindex f T @pindex calc-arctan2 @tindex arctan2 The @kbd{f T} (@code{calc-arctan2}) [@code{arctan2}] command takes two numbers from the stack and computes the arc tangent of their ratio. The result is in the full range from @i{-180} (exclusive) to @i{+180} (inclusive) degrees, or the analogous range in radians. A similar result would be obtained with @kbd{/} followed by @kbd{I T}, but the value would only be in the range from @i{-90} to @i{+90} degrees since the division loses information about the signs of the two components, and an error might result from an explicit division by zero which @code{arctan2} would avoid. By (arbitrary) definition, @samp{arctan2(0,0)=0}. @pindex calc-sincos @c @starindex @tindex sincos @c @starindex @c @mindex arc@idots @tindex arcsincos The @code{calc-sincos} [@code{sincos}] command computes the sine and cosine of a number, returning them as a vector of the form @samp{[@var{cos}, @var{sin}]}. With the Inverse flag [@code{arcsincos}], this command takes a two-element vector as an argument and computes @code{arctan2} of the elements. (This command does not accept the Hyperbolic flag.)@refill @node Advanced Math Functions, Branch Cuts, Trigonometric and Hyperbolic Functions, Scientific Functions @section Advanced Mathematical Functions @noindent Calc can compute a variety of less common functions that arise in various branches of mathematics. All of the functions described in this section allow arbitrary complex arguments and, except as noted, will work to arbitrarily large precisions. They can not at present handle error forms or intervals as arguments. NOTE: These functions are still experimental. In particular, their accuracy is not guaranteed in all domains. It is advisable to set the current precision comfortably higher than you actually need when using these functions. Also, these functions may be impractically slow for some values of the arguments. @kindex f g @pindex calc-gamma @tindex gamma The @kbd{f g} (@code{calc-gamma}) [@code{gamma}] command computes the Euler gamma function. For positive integer arguments, this is related to the factorial function: @samp{gamma(n+1) = fact(n)}. For general complex arguments the gamma function can be defined by the following definite integral: @c{$\Gamma(a) = \int_0^\infty t^{a-1} e^t dt$} @cite{gamma(a) = integ(t^(a-1) exp(t), t, 0, inf)}. (The actual implementation uses far more efficient computational methods.) @kindex f G @tindex gammaP @c @mindex @idots @kindex I f G @c @mindex @null @kindex H f G @c @mindex @null @kindex H I f G @pindex calc-inc-gamma @c @mindex @null @tindex gammaQ @c @mindex @null @tindex gammag @c @mindex @null @tindex gammaG The @kbd{f G} (@code{calc-inc-gamma}) [@code{gammaP}] command computes the incomplete gamma function, denoted @samp{P(a,x)}. This is defined by the integral, @c{$P(a,x) = \left( \int_0^x t^{a-1} e^t dt \right) / \Gamma(a)$} @cite{gammaP(a,x) = integ(t^(a-1) exp(t), t, 0, x) / gamma(a)}. This implies that @samp{gammaP(a,inf) = 1} for any @cite{a} (see the definition of the normal gamma function). Several other varieties of incomplete gamma function are defined. The complement of @cite{P(a,x)}, called @cite{Q(a,x) = 1-P(a,x)} by some authors, is computed by the @kbd{I f G} [@code{gammaQ}] command. You can think of this as taking the other half of the integral, from @cite{x} to infinity. @ifinfo The functions corresponding to the integrals that define @cite{P(a,x)} and @cite{Q(a,x)} but without the normalizing @cite{1/gamma(a)} factor are called @cite{g(a,x)} and @cite{G(a,x)}, respectively (where @cite{g} and @cite{G} represent the lower- and upper-case Greek letter gamma). You can obtain these using the @kbd{H f G} [@code{gammag}] and @kbd{H I f G} [@code{gammaG}] commands. @end ifinfo @tex \turnoffactive The functions corresponding to the integrals that define $P(a,x)$ and $Q(a,x)$ but without the normalizing $1/\Gamma(a)$ factor are called $\gamma(a,x)$ and $\Gamma(a,x)$, respectively. You can obtain these using the \kbd{H f G} [\code{gammag}] and \kbd{I H f G} [\code{gammaG}] commands. @end tex @kindex f b @pindex calc-beta @tindex beta The @kbd{f b} (@code{calc-beta}) [@code{beta}] command computes the Euler beta function, which is defined in terms of the gamma function as @c{$B(a,b) = \Gamma(a) \Gamma(b) / \Gamma(a+b)$} @cite{beta(a,b) = gamma(a) gamma(b) / gamma(a+b)}, or by @c{$B(a,b) = \int_0^1 t^{a-1} (1-t)^{b-1} dt$} @cite{beta(a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, 1)}. @kindex f B @kindex H f B @pindex calc-inc-beta @tindex betaI @tindex betaB The @kbd{f B} (@code{calc-inc-beta}) [@code{betaI}] command computes the incomplete beta function @cite{I(x,a,b)}. It is defined by @c{$I(x,a,b) = \left( \int_0^x t^{a-1} (1-t)^{b-1} dt \right) / B(a,b)$} @cite{betaI(x,a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, x) / beta(a,b)}. Once again, the @kbd{H} (hyperbolic) prefix gives the corresponding un-normalized version [@code{betaB}]. @kindex f e @kindex I f e @pindex calc-erf @tindex erf @tindex erfc The @kbd{f e} (@code{calc-erf}) [@code{erf}] command computes the error function @c{$\hbox{erf}(x) = {2 \over \sqrt{\pi}} \int_0^x e^{-t^2} dt$} @cite{erf(x) = 2 integ(exp(-(t^2)), t, 0, x) / sqrt(pi)}. The complementary error function @kbd{I f e} (@code{calc-erfc}) [@code{erfc}] is the corresponding integral from @samp{x} to infinity; the sum @c{$\hbox{erf}(x) + \hbox{erfc}(x) = 1$} @cite{erf(x) + erfc(x) = 1}. @kindex f j @kindex f y @pindex calc-bessel-J @pindex calc-bessel-Y @tindex besJ @tindex besY The @kbd{f j} (@code{calc-bessel-J}) [@code{besJ}] and @kbd{f y} (@code{calc-bessel-Y}) [@code{besY}] commands compute the Bessel functions of the first and second kinds, respectively. In @samp{besJ(n,x)} and @samp{besY(n,x)} the ``order'' parameter @cite{n} is often an integer, but is not required to be one. Calc's implementation of the Bessel functions currently limits the precision to 8 digits, and may not be exact even to that precision. Use with care!@refill @node Branch Cuts, Random Numbers, Advanced Math Functions, Scientific Functions @section Branch Cuts and Principal Values @noindent @cindex Branch cuts @cindex Principal values All of the logarithmic, trigonometric, and other scientific functions are defined for complex numbers as well as for reals. This section describes the values returned in cases where the general result is a family of possible values. Calc follows section 12.5.3 of Steele's @dfn{Common Lisp, the Language}, second edition, in these matters. This section will describe each function briefly; for a more detailed discussion (including some nifty diagrams), consult Steele's book. Note that the branch cuts for @code{arctan} and @code{arctanh} were changed between the first and second editions of Steele. Versions of Calc starting with 2.00 follow the second edition. The new branch cuts exactly match those of the HP-28/48 calculators. They also match those of Mathematica 1.2, except that Mathematica's @code{arctan} cut is always in the right half of the complex plane, and its @code{arctanh} cut is always in the top half of the plane. Calc's cuts are continuous with quadrants I and III for @code{arctan}, or II and IV for @code{arctanh}. Note: The current implementations of these functions with complex arguments are designed with proper behavior around the branch cuts in mind, @emph{not} efficiency or accuracy. You may need to increase the floating precision and wait a while to get suitable answers from them. For @samp{sqrt(a+bi)}: When @cite{a<0} and @cite{b} is small but positive or zero, the result is close to the @cite{+i} axis. For @cite{b} small and negative, the result is close to the @cite{-i} axis. The result always lies in the right half of the complex plane. For @samp{ln(a+bi)}: The real part is defined as @samp{ln(abs(a+bi))}. The imaginary part is defined as @samp{arg(a+bi) = arctan2(b,a)}. Thus the branch cuts for @code{sqrt} and @code{ln} both lie on the negative real axis. The following table describes these branch cuts in another way. If the real and imaginary parts of @cite{z} are as shown, then the real and imaginary parts of @cite{f(z)} will be as shown. Here @code{eps} stands for a small positive value; each occurrence of @code{eps} may stand for a different small value. @smallexample z sqrt(z) ln(z) ---------------------------------------- +, 0 +, 0 any, 0 -, 0 0, + any, pi -, +eps +eps, + +eps, + -, -eps +eps, - +eps, - @end smallexample For @samp{z1^z2}: This is defined by @samp{exp(ln(z1)*z2)}. One interesting consequence of this is that @samp{(-8)^1:3} does not evaluate to @i{-2} as you might expect, but to the complex number @cite{(1., 1.732)}. Both of these are valid cube roots of @i{-8} (as is @cite{(1., -1.732)}); Calc chooses a perhaps less-obvious root for the sake of mathematical consistency. For @samp{arcsin(z)}: This is defined by @samp{-i*ln(i*z + sqrt(1-z^2))}. The branch cuts are on the real axis, less than @i{-1} and greater than 1. For @samp{arccos(z)}: This is defined by @samp{-i*ln(z + i*sqrt(1-z^2))}, or equivalently by @samp{pi/2 - arcsin(z)}. The branch cuts are on the real axis, less than @i{-1} and greater than 1. For @samp{arctan(z)}: This is defined by @samp{(ln(1+i*z) - ln(1-i*z)) / (2*i)}. The branch cuts are on the imaginary axis, below @cite{-i} and above @cite{i}. For @samp{arcsinh(z)}: This is defined by @samp{ln(z + sqrt(1+z^2))}. The branch cuts are on the imaginary axis, below @cite{-i} and above @cite{i}. For @samp{arccosh(z)}: This is defined by @samp{ln(z + (z+1)*sqrt((z-1)/(z+1)))}. The branch cut is on the real axis less than 1. For @samp{arctanh(z)}: This is defined by @samp{(ln(1+z) - ln(1-z)) / 2}. The branch cuts are on the real axis, less than @i{-1} and greater than 1. The following tables for @code{arcsin}, @code{arccos}, and @code{arctan} assume the current angular mode is radians. The hyperbolic functions operate independently of the angular mode. @smallexample z arcsin(z) arccos(z) ------------------------------------------------------- (-1..1), 0 (-pi/2..pi/2), 0 (0..pi), 0 (-1..1), +eps (-pi/2..pi/2), +eps (0..pi), -eps (-1..1), -eps (-pi/2..pi/2), -eps (0..pi), +eps <-1, 0 -pi/2, + pi, - <-1, +eps -pi/2 + eps, + pi - eps, - <-1, -eps -pi/2 + eps, - pi - eps, + >1, 0 pi/2, - 0, + >1, +eps pi/2 - eps, + +eps, - >1, -eps pi/2 - eps, - +eps, + @end smallexample @smallexample z arccosh(z) arctanh(z) ----------------------------------------------------- (-1..1), 0 0, (0..pi) any, 0 (-1..1), +eps +eps, (0..pi) any, +eps (-1..1), -eps +eps, (-pi..0) any, -eps <-1, 0 +, pi -, pi/2 <-1, +eps +, pi - eps -, pi/2 - eps <-1, -eps +, -pi + eps -, -pi/2 + eps >1, 0 +, 0 +, -pi/2 >1, +eps +, +eps +, pi/2 - eps >1, -eps +, -eps +, -pi/2 + eps @end smallexample @smallexample z arcsinh(z) arctan(z) ----------------------------------------------------- 0, (-1..1) 0, (-pi/2..pi/2) 0, any 0, <-1 -, -pi/2 -pi/2, - +eps, <-1 +, -pi/2 + eps pi/2 - eps, - -eps, <-1 -, -pi/2 + eps -pi/2 + eps, - 0, >1 +, pi/2 pi/2, + +eps, >1 +, pi/2 - eps pi/2 - eps, + -eps, >1 -, pi/2 - eps -pi/2 + eps, + @end smallexample Finally, the following identities help to illustrate the relationship between the complex trigonometric and hyperbolic functions. They are valid everywhere, including on the branch cuts. @smallexample sin(i*z) = i*sinh(z) arcsin(i*z) = i*arcsinh(z) cos(i*z) = cosh(z) arcsinh(i*z) = i*arcsin(z) tan(i*z) = i*tanh(z) arctan(i*z) = i*arctanh(z) sinh(i*z) = i*sin(z) cosh(i*z) = cos(z) @end smallexample The ``advanced math'' functions (gamma, Bessel, etc.@:) are also defined for general complex arguments, but their branch cuts and principal values are not rigorously specified at present. @node Random Numbers, Combinatorial Functions, Branch Cuts, Scientific Functions @section Random Numbers @noindent @kindex k r @pindex calc-random @tindex random The @kbd{k r} (@code{calc-random}) [@code{random}] command produces random numbers of various sorts. Given a positive numeric prefix argument @cite{M}, it produces a random integer @cite{N} in the range @c{$0 \le N < M$} @cite{0 <= N < M}. Each of the @cite{M} values appears with equal probability.@refill With no numeric prefix argument, the @kbd{k r} command takes its argument from the stack instead. Once again, if this is a positive integer @cite{M} the result is a random integer less than @cite{M}. However, note that while numeric prefix arguments are limited to six digits or so, an @cite{M} taken from the stack can be arbitrarily large. If @cite{M} is negative, the result is a random integer in the range @c{$M < N \le 0$} @cite{M < N <= 0}. If the value on the stack is a floating-point number @cite{M}, the result is a random floating-point number @cite{N} in the range @c{$0 \le N < M$} @cite{0 <= N < M} or @c{$M < N \le 0$} @cite{M < N <= 0}, according to the sign of @cite{M}. If @cite{M} is zero, the result is a Gaussian-distributed random real number; the distribution has a mean of zero and a standard deviation of one. The algorithm used generates random numbers in pairs; thus, every other call to this function will be especially fast. If @cite{M} is an error form @c{$m$ @code{+/-} $\sigma$} @samp{m +/- s} where @i{m} and @c{$\sigma$} @i{s} are both real numbers, the result uses a Gaussian distribution with mean @i{m} and standard deviation @c{$\sigma$} @i{s}. If @cite{M} is an interval form, the lower and upper bounds specify the acceptable limits of the random numbers. If both bounds are integers, the result is a random integer in the specified range. If either bound is floating-point, the result is a random real number in the specified range. If the interval is open at either end, the result will be sure not to equal that end value. (This makes a big difference for integer intervals, but for floating-point intervals it's relatively minor: with a precision of 6, @samp{random([1.0..2.0))} will return any of one million numbers from 1.00000 to 1.99999; @samp{random([1.0..2.0])} may additionally return 2.00000, but the probability of this happening is extremely small.) If @cite{M} is a vector, the result is one element taken at random from the vector. All elements of the vector are given equal probabilities. @vindex RandSeed The sequence of numbers produced by @kbd{k r} is completely random by default, i.e., the sequence is seeded each time you start Calc using the current time and other information. You can get a reproducible sequence by storing a particular ``seed value'' in the Calc variable @code{RandSeed}. Any integer will do for a seed; integers of from 1 to 12 digits are good. If you later store a different integer into @code{RandSeed}, Calc will switch to a different pseudo-random sequence. If you ``unstore'' @code{RandSeed}, Calc will re-seed itself from the current time. If you store the same integer that you used before back into @code{RandSeed}, you will get the exact same sequence of random numbers as before. @pindex calc-rrandom The @code{calc-rrandom} command (not on any key) produces a random real number between zero and one. It is equivalent to @samp{random(1.0)}. @kindex k a @pindex calc-random-again The @kbd{k a} (@code{calc-random-again}) command produces another random number, re-using the most recent value of @cite{M}. With a numeric prefix argument @var{n}, it produces @var{n} more random numbers using that value of @cite{M}. @kindex k h @pindex calc-shuffle @tindex shuffle The @kbd{k h} (@code{calc-shuffle}) command produces a vector of several random values with no duplicates. The value on the top of the stack specifies the set from which the random values are drawn, and may be any of the @cite{M} formats described above. The numeric prefix argument gives the length of the desired list. (If you do not provide a numeric prefix argument, the length of the list is taken from the top of the stack, and @cite{M} from second-to-top.) If @cite{M} is a floating-point number, zero, or an error form (so that the random values are being drawn from the set of real numbers) there is little practical difference between using @kbd{k h} and using @kbd{k r} several times. But if the set of possible values consists of just a few integers, or the elements of a vector, then there is a very real chance that multiple @kbd{k r}'s will produce the same number more than once. The @kbd{k h} command produces a vector whose elements are always distinct. (Actually, there is a slight exception: If @cite{M} is a vector, no given vector element will be drawn more than once, but if several elements of @cite{M} are equal, they may each make it into the result vector.) One use of @kbd{k h} is to rearrange a list at random. This happens if the prefix argument is equal to the number of values in the list: @kbd{[1, 1.5, 2, 2.5, 3] 5 k h} might produce the permuted list @samp{[2.5, 1, 1.5, 3, 2]}. As a convenient feature, if the argument @var{n} is negative it is replaced by the size of the set represented by @cite{M}. Naturally, this is allowed only when @cite{M} specifies a small discrete set of possibilities. To do the equivalent of @kbd{k h} but with duplications allowed, given @cite{M} on the stack and with @var{n} just entered as a numeric prefix, use @kbd{v b} to build a vector of copies of @cite{M}, then use @kbd{V M k r} to ``map'' the normal @kbd{k r} function over the elements of this vector. @xref{Matrix Functions}. @menu * Random Number Generator:: (Complete description of Calc's algorithm) @end menu @node Random Number Generator, , Random Numbers, Random Numbers @subsection Random Number Generator Calc's random number generator uses several methods to ensure that the numbers it produces are highly random. Knuth's @emph{Art of Computer Programming}, Volume II, contains a thorough description of the theory of random number generators and their measurement and characterization. If @code{RandSeed} has no stored value, Calc calls Emacs' built-in @code{random} function to get a stream of random numbers, which it then treats in various ways to avoid problems inherent in the simple random number generators that many systems use to implement @code{random}. When Calc's random number generator is first invoked, it ``seeds'' the low-level random sequence using the time of day, so that the random number sequence will be different every time you use Calc. Since Emacs Lisp doesn't specify the range of values that will be returned by its @code{random} function, Calc exercises the function several times to estimate the range. When Calc subsequently uses the @code{random} function, it takes only 10 bits of the result near the most-significant end. (It avoids at least the bottom four bits, preferably more, and also tries to avoid the top two bits.) This strategy works well with the linear congruential generators that are typically used to implement @code{random}. If @code{RandSeed} contains an integer, Calc uses this integer to seed an ``additive congruential'' method (Knuth's algorithm 3.2.2A, computing @c{$X_{n-55} - X_{n-24}$} @cite{X_n-55 - X_n-24}). This method expands the seed value into a large table which is maintained internally; the variable @code{RandSeed} is changed from, e.g., 42 to the vector @cite{[42]} to indicate that the seed has been absorbed into this table. When @code{RandSeed} contains a vector, @kbd{k r} and related commands continue to use the same internal table as last time. There is no way to extract the complete state of the random number generator so that you can restart it from any point; you can only restart it from the same initial seed value. A simple way to restart from the same seed is to type @kbd{s r RandSeed} to get the seed vector, @kbd{v u} to unpack it back into a number, then @kbd{s t RandSeed} to reseed the generator with that number. Calc uses a ``shuffling'' method as described in algorithm 3.2.2B of Knuth. It fills a table with 13 random 10-bit numbers. Then, to generate a new random number, it uses the previous number to index into the table, picks the value it finds there as the new random number, then replaces that table entry with a new value obtained from a call to the base random number generator (either the additive congruential generator or the @code{random} function supplied by the system). If there are any flaws in the base generator, shuffling will tend to even them out. But if the system provides an excellent @code{random} function, shuffling will not damage its randomness. To create a random integer of a certain number of digits, Calc builds the integer three decimal digits at a time. For each group of three digits, Calc calls its 10-bit shuffling random number generator (which returns a value from 0 to 1023); if the random value is 1000 or more, Calc throws it out and tries again until it gets a suitable value. To create a random floating-point number with precision @var{p}, Calc simply creates a random @var{p}-digit integer and multiplies by @c{$10^{-p}$} @cite{10^-p}. The resulting random numbers should be very clean, but note that relatively small numbers will have few significant random digits. In other words, with a precision of 12, you will occasionally get numbers on the order of @c{$10^{-9}$} @cite{10^-9} or @c{$10^{-10}$} @cite{10^-10}, but those numbers will only have two or three random digits since they correspond to small integers times @c{$10^{-12}$} @cite{10^-12}. To create a random integer in the interval @samp{[0 .. @var{m})}, Calc counts the digits in @var{m}, creates a random integer with three additional digits, then reduces modulo @var{m}. Unless @var{m} is a power of ten the resulting values will be very slightly biased toward the lower numbers, but this bias will be less than 0.1%. (For example, if @var{m} is 42, Calc will reduce a random integer less than 100000 modulo 42 to get a result less than 42. It is easy to show that the numbers 40 and 41 will be only 2380/2381 as likely to result from this modulo operation as numbers 39 and below.) If @var{m} is a power of ten, however, the numbers should be completely unbiased. The Gaussian random numbers generated by @samp{random(0.0)} use the ``polar'' method described in Knuth section 3.4.1C. This method generates a pair of Gaussian random numbers at a time, so only every other call to @samp{random(0.0)} will require significant calculations. @node Combinatorial Functions, Probability Distribution Functions, Random Numbers, Scientific Functions @section Combinatorial Functions @noindent Commands relating to combinatorics and number theory begin with the @kbd{k} key prefix. @kindex k g @pindex calc-gcd @tindex gcd The @kbd{k g} (@code{calc-gcd}) [@code{gcd}] command computes the Greatest Common Divisor of two integers. It also accepts fractions; the GCD of two fractions is defined by taking the GCD of the numerators, and the LCM of the denominators. This definition is consistent with the idea that @samp{a / gcd(a,x)} should yield an integer for any @samp{a} and @samp{x}. For other types of arguments, the operation is left in symbolic form.@refill @kindex k l @pindex calc-lcm @tindex lcm The @kbd{k l} (@code{calc-lcm}) [@code{lcm}] command computes the Least Common Multiple of two integers or fractions. The product of the LCM and GCD of two numbers is equal to the product of the numbers.@refill @kindex k E @pindex calc-extended-gcd @tindex egcd The @kbd{k E} (@code{calc-extended-gcd}) [@code{egcd}] command computes the GCD of two integers @cite{x} and @cite{y} and returns a vector @cite{[g, a, b]} where @c{$g = \gcd(x,y) = a x + b y$} @cite{g = gcd(x,y) = a x + b y}. @kindex ! @pindex calc-factorial @tindex fact @c @mindex @null @tindex ! The @kbd{!} (@code{calc-factorial}) [@code{fact}] command computes the factorial of the number at the top of the stack. If the number is an integer, the result is an exact integer. If the number is an integer-valued float, the result is a floating-point approximation. If the number is a non-integral real number, the generalized factorial is used, as defined by the Euler Gamma function. Please note that computation of large factorials can be slow; using floating-point format will help since fewer digits must be maintained. The same is true of many of the commands in this section.@refill @kindex k d @pindex calc-double-factorial @tindex dfact @c @mindex @null @tindex !! The @kbd{k d} (@code{calc-double-factorial}) [@code{dfact}] command computes the ``double factorial'' of an integer. For an even integer, this is the product of even integers from 2 to @cite{N}. For an odd integer, this is the product of odd integers from 3 to @cite{N}. If the argument is an integer-valued float, the result is a floating-point approximation. This function is undefined for negative even integers. The notation @cite{N!!} is also recognized for double factorials.@refill @kindex k c @pindex calc-choose @tindex choose The @kbd{k c} (@code{calc-choose}) [@code{choose}] command computes the binomial coefficient @cite{N}-choose-@cite{M}, where @cite{M} is the number on the top of the stack and @cite{N} is second-to-top. If both arguments are integers, the result is an exact integer. Otherwise, the result is a floating-point approximation. The binomial coefficient is defined for all real numbers by @c{$N! \over M! (N-M)!\,$} @cite{N! / M! (N-M)!}. @kindex H k c @pindex calc-perm @tindex perm @ifinfo The @kbd{H k c} (@code{calc-perm}) [@code{perm}] command computes the number-of-permutations function @cite{N! / (N-M)!}. @end ifinfo @tex The \kbd{H k c} (\code{calc-perm}) [\code{perm}] command computes the number-of-perm\-utations function $N! \over (N-M)!\,$. @end tex @kindex k b @kindex H k b @pindex calc-bernoulli-number @tindex bern The @kbd{k b} (@code{calc-bernoulli-number}) [@code{bern}] command computes a given Bernoulli number. The value at the top of the stack is a nonnegative integer @cite{n} that specifies which Bernoulli number is desired. The @kbd{H k b} command computes a Bernoulli polynomial, taking @cite{n} from the second-to-top position and @cite{x} from the top of the stack. If @cite{x} is a variable or formula the result is a polynomial in @cite{x}; if @cite{x} is a number the result is a number. @kindex k e @kindex H k e @pindex calc-euler-number @tindex euler The @kbd{k e} (@code{calc-euler-number}) [@code{euler}] command similarly computes an Euler number, and @w{@kbd{H k e}} computes an Euler polynomial. Bernoulli and Euler numbers occur in the Taylor expansions of several functions. @kindex k s @kindex H k s @pindex calc-stirling-number @tindex stir1 @tindex stir2 The @kbd{k s} (@code{calc-stirling-number}) [@code{stir1}] command computes a Stirling number of the first kind@c{ $n \brack m$} @asis{}, given two integers @cite{n} and @cite{m} on the stack. The @kbd{H k s} [@code{stir2}] command computes a Stirling number of the second kind@c{ $n \brace m$} @asis{}. These are the number of @cite{m}-cycle permutations of @cite{n} objects, and the number of ways to partition @cite{n} objects into @cite{m} non-empty sets, respectively. @kindex k p @pindex calc-prime-test @cindex Primes The @kbd{k p} (@code{calc-prime-test}) command checks if the integer on the top of the stack is prime. For integers less than eight million, the answer is always exact and reasonably fast. For larger integers, a probabilistic method is used (see Knuth vol. II, section 4.5.4, algorithm P). The number is first checked against small prime factors (up to 13). Then, any number of iterations of the algorithm are performed. Each step either discovers that the number is non-prime, or substantially increases the certainty that the number is prime. After a few steps, the chance that a number was mistakenly described as prime will be less than one percent. (Indeed, this is a worst-case estimate of the probability; in practice even a single iteration is quite reliable.) After the @kbd{k p} command, the number will be reported as definitely prime or non-prime if possible, or otherwise ``probably'' prime with a certain probability of error. @c @starindex @tindex prime The normal @kbd{k p} command performs one iteration of the primality test. Pressing @kbd{k p} repeatedly for the same integer will perform additional iterations. Also, @kbd{k p} with a numeric prefix performs the specified number of iterations. There is also an algebraic function @samp{prime(n)} or @samp{prime(n,iters)} which returns 1 if @cite{n} is (probably) prime and 0 if not. @kindex k f @pindex calc-prime-factors @tindex prfac The @kbd{k f} (@code{calc-prime-factors}) [@code{prfac}] command attempts to decompose an integer into its prime factors. For numbers up to 25 million, the answer is exact although it may take some time. The result is a vector of the prime factors in increasing order. For larger inputs, prime factors above 5000 may not be found, in which case the last number in the vector will be an unfactored integer greater than 25 million (with a warning message). For negative integers, the first element of the list will be @i{-1}. For inputs @i{-1}, @i{0}, and @i{1}, the result is a list of the same number. @kindex k n @pindex calc-next-prime @c @mindex nextpr@idots @tindex nextprime The @kbd{k n} (@code{calc-next-prime}) [@code{nextprime}] command finds the next prime above a given number. Essentially, it searches by calling @code{calc-prime-test} on successive integers until it finds one that passes the test. This is quite fast for integers less than eight million, but once the probabilistic test comes into play the search may be rather slow. Ordinarily this command stops for any prime that passes one iteration of the primality test. With a numeric prefix argument, a number must pass the specified number of iterations before the search stops. (This only matters when searching above eight million.) You can always use additional @kbd{k p} commands to increase your certainty that the number is indeed prime. @kindex I k n @pindex calc-prev-prime @c @mindex prevpr@idots @tindex prevprime The @kbd{I k n} (@code{calc-prev-prime}) [@code{prevprime}] command analogously finds the next prime less than a given number. @kindex k t @pindex calc-totient @tindex totient The @kbd{k t} (@code{calc-totient}) [@code{totient}] command computes the Euler ``totient'' function@c{ $\phi(n)$} @asis{}, the number of integers less than @cite{n} which are relatively prime to @cite{n}. @kindex k m @pindex calc-moebius @tindex moebius The @kbd{k m} (@code{calc-moebius}) [@code{moebius}] command computes the @c{M\"obius $\mu$} @asis{Moebius ``mu''} function. If the input number is a product of @cite{k} distinct factors, this is @cite{(-1)^k}. If the input number has any duplicate factors (i.e., can be divided by the same prime more than once), the result is zero. @node Probability Distribution Functions, , Combinatorial Functions, Scientific Functions @section Probability Distribution Functions @noindent The functions in this section compute various probability distributions. For continuous distributions, this is the integral of the probability density function from @cite{x} to infinity. (These are the ``upper tail'' distribution functions; there are also corresponding ``lower tail'' functions which integrate from minus infinity to @cite{x}.) For discrete distributions, the upper tail function gives the sum from @cite{x} to infinity; the lower tail function gives the sum from minus infinity up to, but not including,@w{ }@cite{x}. To integrate from @cite{x} to @cite{y}, just use the distribution function twice and subtract. For example, the probability that a Gaussian random variable with mean 2 and standard deviation 1 will lie in the range from 2.5 to 2.8 is @samp{utpn(2.5,2,1) - utpn(2.8,2,1)} (``the probability that it is greater than 2.5, but not greater than 2.8''), or equivalently @samp{ltpn(2.8,2,1) - ltpn(2.5,2,1)}. @kindex k B @kindex I k B @pindex calc-utpb @tindex utpb @tindex ltpb The @kbd{k B} (@code{calc-utpb}) [@code{utpb}] function uses the binomial distribution. Push the parameters @var{n}, @var{p}, and then @var{x} onto the stack; the result (@samp{utpb(x,n,p)}) is the probability that an event will occur @var{x} or more times out of @var{n} trials, if its probability of occurring in any given trial is @var{p}. The @kbd{I k B} [@code{ltpb}] function is the probability that the event will occur fewer than @var{x} times. The other probability distribution functions similarly take the form @kbd{k @var{X}} (@code{calc-utp@var{x}}) [@code{utp@var{x}}] and @kbd{I k @var{X}} [@code{ltp@var{x}}], for various letters @var{x}. The arguments to the algebraic functions are the value of the random variable first, then whatever other parameters define the distribution. Note these are among the few Calc functions where the order of the arguments in algebraic form differs from the order of arguments as found on the stack. (The random variable comes last on the stack, so that you can type, e.g., @kbd{2 @key{RET} 1 @key{RET} 2.5 k N M-@key{RET} @key{DEL} 2.8 k N -}, using @kbd{M-@key{RET} @key{DEL}} to recover the original arguments but substitute a new value for @cite{x}.) @kindex k C @pindex calc-utpc @tindex utpc @c @mindex @idots @kindex I k C @c @mindex @null @tindex ltpc The @samp{utpc(x,v)} function uses the chi-square distribution with @c{$\nu$} @cite{v} degrees of freedom. It is the probability that a model is correct if its chi-square statistic is @cite{x}. @kindex k F @pindex calc-utpf @tindex utpf @c @mindex @idots @kindex I k F @c @mindex @null @tindex ltpf The @samp{utpf(F,v1,v2)} function uses the F distribution, used in various statistical tests. The parameters @c{$\nu_1$} @cite{v1} and @c{$\nu_2$} @cite{v2} are the degrees of freedom in the numerator and denominator, respectively, used in computing the statistic @cite{F}. @kindex k N @pindex calc-utpn @tindex utpn @c @mindex @idots @kindex I k N @c @mindex @null @tindex ltpn The @samp{utpn(x,m,s)} function uses a normal (Gaussian) distribution with mean @cite{m} and standard deviation @c{$\sigma$} @cite{s}. It is the probability that such a normal-distributed random variable would exceed @cite{x}. @kindex k P @pindex calc-utpp @tindex utpp @c @mindex @idots @kindex I k P @c @mindex @null @tindex ltpp The @samp{utpp(n,x)} function uses a Poisson distribution with mean @cite{x}. It is the probability that @cite{n} or more such Poisson random events will occur. @kindex k T @pindex calc-ltpt @tindex utpt @c @mindex @idots @kindex I k T @c @mindex @null @tindex ltpt The @samp{utpt(t,v)} function uses the Student's ``t'' distribution with @c{$\nu$} @cite{v} degrees of freedom. It is the probability that a t-distributed random variable will be greater than @cite{t}. (Note: This computes the distribution function @c{$A(t|\nu)$} @cite{A(t|v)} where @c{$A(0|\nu) = 1$} @cite{A(0|v) = 1} and @c{$A(\infty|\nu) \to 0$} @cite{A(inf|v) -> 0}. The @code{UTPT} operation on the HP-48 uses a different definition which returns half of Calc's value: @samp{UTPT(t,v) = .5*utpt(t,v)}.) While Calc does not provide inverses of the probability distribution functions, the @kbd{a R} command can be used to solve for the inverse. Since the distribution functions are monotonic, @kbd{a R} is guaranteed to be able to find a solution given any initial guess. @xref{Numerical Solutions}. @node Matrix Functions, Algebra, Scientific Functions, Top @chapter Vector/Matrix Functions @noindent Many of the commands described here begin with the @kbd{v} prefix. (For convenience, the shift-@kbd{V} prefix is equivalent to @kbd{v}.) The commands usually apply to both plain vectors and matrices; some apply only to matrices or only to square matrices. If the argument has the wrong dimensions the operation is left in symbolic form. Vectors are entered and displayed using @samp{[a,b,c]} notation. Matrices are vectors of which all elements are vectors of equal length. (Though none of the standard Calc commands use this concept, a three-dimensional matrix or rank-3 tensor could be defined as a vector of matrices, and so on.) @menu * Packing and Unpacking:: * Building Vectors:: * Extracting Elements:: * Manipulating Vectors:: * Vector and Matrix Arithmetic:: * Set Operations:: * Statistical Operations:: * Reducing and Mapping:: * Vector and Matrix Formats:: @end menu @node Packing and Unpacking, Building Vectors, Matrix Functions, Matrix Functions @section Packing and Unpacking @noindent Calc's ``pack'' and ``unpack'' commands collect stack entries to build composite objects such as vectors and complex numbers. They are described in this chapter because they are most often used to build vectors. @kindex v p @pindex calc-pack The @kbd{v p} (@code{calc-pack}) [@code{pack}] command collects several elements from the stack into a matrix, complex number, HMS form, error form, etc. It uses a numeric prefix argument to specify the kind of object to be built; this argument is referred to as the ``packing mode.'' If the packing mode is a nonnegative integer, a vector of that length is created. For example, @kbd{C-u 5 v p} will pop the top five stack elements and push back a single vector of those five elements. (@kbd{C-u 0 v p} simply creates an empty vector.) The same effect can be had by pressing @kbd{[} to push an incomplete vector on the stack, using @key{TAB} (@code{calc-roll-down}) to sneak the incomplete object up past a certain number of elements, and then pressing @kbd{]} to complete the vector. Negative packing modes create other kinds of composite objects: @table @cite @item -1 Two values are collected to build a complex number. For example, @kbd{5 @key{RET} 7 C-u -1 v p} creates the complex number @cite{(5, 7)}. The result is always a rectangular complex number. The two input values must both be real numbers, i.e., integers, fractions, or floats. If they are not, Calc will instead build a formula like @samp{a + (0, 1) b}. (The other packing modes also create a symbolic answer if the components are not suitable.) @item -2 Two values are collected to build a polar complex number. The first is the magnitude; the second is the phase expressed in either degrees or radians according to the current angular mode. @item -3 Three values are collected into an HMS form. The first two values (hours and minutes) must be integers or integer-valued floats. The third value may be any real number. @item -4 Two values are collected into an error form. The inputs may be real numbers or formulas. @item -5 Two values are collected into a modulo form. The inputs must be real numbers. @item -6 Two values are collected into the interval @samp{[a .. b]}. The inputs may be real numbers, HMS or date forms, or formulas. @item -7 Two values are collected into the interval @samp{[a .. b)}. @item -8 Two values are collected into the interval @samp{(a .. b]}. @item -9 Two values are collected into the interval @samp{(a .. b)}. @item -10 Two integer values are collected into a fraction. @item -11 Two values are collected into a floating-point number. The first is the mantissa; the second, which must be an integer, is the exponent. The result is the mantissa times ten to the power of the exponent. @item -12 This is treated the same as @i{-11} by the @kbd{v p} command. When unpacking, @i{-12} specifies that a floating-point mantissa is desired. @item -13 A real number is converted into a date form. @item -14 Three numbers (year, month, day) are packed into a pure date form. @item -15 Six numbers are packed into a date/time form. @end table With any of the two-input negative packing modes, either or both of the inputs may be vectors. If both are vectors of the same length, the result is another vector made by packing corresponding elements of the input vectors. If one input is a vector and the other is a plain number, the number is packed along with each vector element to produce a new vector. For example, @kbd{C-u -4 v p} could be used to convert a vector of numbers and a vector of errors into a single vector of error forms; @kbd{C-u -5 v p} could convert a vector of numbers and a single number @var{M} into a vector of numbers modulo @var{M}. If you don't give a prefix argument to @kbd{v p}, it takes the packing mode from the top of the stack. The elements to be packed then begin at stack level 2. Thus @kbd{1 @key{RET} 2 @key{RET} 4 n v p} is another way to enter the error form @samp{1 +/- 2}. If the packing mode taken from the stack is a vector, the result is a matrix with the dimensions specified by the elements of the vector, which must each be integers. For example, if the packing mode is @samp{[2, 3]}, then six numbers will be taken from the stack and returned in the form @samp{[@w{[a, b, c]}, [d, e, f]]}. If any elements of the vector are negative, other kinds of packing are done at that level as described above. For example, @samp{[2, 3, -4]} takes 12 objects and creates a @c{$2\times3$} @asis{2x3} matrix of error forms: @samp{[[a +/- b, c +/- d ... ]]}. Also, @samp{[-4, -10]} will convert four integers into an error form consisting of two fractions: @samp{a:b +/- c:d}. @c @starindex @tindex pack There is an equivalent algebraic function, @samp{pack(@var{mode}, @var{items})} where @var{mode} is a packing mode (an integer or a vector of integers) and @var{items} is a vector of objects to be packed (re-packed, really) according to that mode. For example, @samp{pack([3, -4], [a,b,c,d,e,f])} yields @samp{[a +/- b, @w{c +/- d}, e +/- f]}. The function is left in symbolic form if the packing mode is illegal, or if the number of data items does not match the number of items required by the mode. @kindex v u @pindex calc-unpack The @kbd{v u} (@code{calc-unpack}) command takes the vector, complex number, HMS form, or other composite object on the top of the stack and ``unpacks'' it, pushing each of its elements onto the stack as separate objects. Thus, it is the ``inverse'' of @kbd{v p}. If the value at the top of the stack is a formula, @kbd{v u} unpacks it by pushing each of the arguments of the top-level operator onto the stack. You can optionally give a numeric prefix argument to @kbd{v u} to specify an explicit (un)packing mode. If the packing mode is negative and the input is actually a vector or matrix, the result will be two or more similar vectors or matrices of the elements. For example, given the vector @samp{[@w{a +/- b}, c^2, d +/- 7]}, the result of @kbd{C-u -4 v u} will be the two vectors @samp{[a, c^2, d]} and @w{@samp{[b, 0, 7]}}. Note that the prefix argument can have an effect even when the input is not a vector. For example, if the input is the number @i{-5}, then @kbd{c-u -1 v u} yields @i{-5} and 0 (the components of @i{-5} when viewed as a rectangular complex number); @kbd{C-u -2 v u} yields 5 and 180 (assuming degrees mode); and @kbd{C-u -10 v u} yields @i{-5} and 1 (the numerator and denominator of @i{-5}, viewed as a rational number). Plain @kbd{v u} with this input would complain that the input is not a composite object. Unpacking mode @i{-11} converts a float into an integer mantissa and an integer exponent, where the mantissa is not divisible by 10 (except that 0.0 is represented by a mantissa and exponent of 0). Unpacking mode @i{-12} converts a float into a floating-point mantissa and integer exponent, where the mantissa (for non-zero numbers) is guaranteed to lie in the range [1 .. 10). In both cases, the mantissa is shifted left or right (and the exponent adjusted to compensate) in order to satisfy these constraints. Positive unpacking modes are treated differently than for @kbd{v p}. A mode of 1 is much like plain @kbd{v u} with no prefix argument, except that in addition to the components of the input object, a suitable packing mode to re-pack the object is also pushed. Thus, @kbd{C-u 1 v u} followed by @kbd{v p} will re-build the original object. A mode of 2 unpacks two levels of the object; the resulting re-packing mode will be a vector of length 2. This might be used to unpack a matrix, say, or a vector of error forms. Higher unpacking modes unpack the input even more deeply. @c @starindex @tindex unpack There are two algebraic functions analogous to @kbd{v u}. The @samp{unpack(@var{mode}, @var{item})} function unpacks the @var{item} using the given @var{mode}, returning the result as a vector of components. Here the @var{mode} must be an integer, not a vector. For example, @samp{unpack(-4, a +/- b)} returns @samp{[a, b]}, as does @samp{unpack(1, a +/- b)}. @c @starindex @tindex unpackt The @code{unpackt} function is like @code{unpack} but instead of returning a simple vector of items, it returns a vector of two things: The mode, and the vector of items. For example, @samp{unpackt(1, 2:3 +/- 1:4)} returns @samp{[-4, [2:3, 1:4]]}, and @samp{unpackt(2, 2:3 +/- 1:4)} returns @samp{[[-4, -10], [2, 3, 1, 4]]}. The identity for re-building the original object is @samp{apply(pack, unpackt(@var{n}, @var{x})) = @var{x}}. (The @code{apply} function builds a function call given the function name and a vector of arguments.) @cindex Numerator of a fraction, extracting Subscript notation is a useful way to extract a particular part of an object. For example, to get the numerator of a rational number, you can use @samp{unpack(-10, @var{x})_1}. @node Building Vectors, Extracting Elements, Packing and Unpacking, Matrix Functions @section Building Vectors @noindent Vectors and matrices can be added, subtracted, multiplied, and divided; @pxref{Basic Arithmetic}.@refill @kindex | @pindex calc-concat @c @mindex @null @tindex | The @kbd{|} (@code{calc-concat}) command ``concatenates'' two vectors into one. For example, after @kbd{@w{[ 1 , 2 ]} [ 3 , 4 ] |}, the stack will contain the single vector @samp{[1, 2, 3, 4]}. If the arguments are matrices, the rows of the first matrix are concatenated with the rows of the second. (In other words, two matrices are just two vectors of row-vectors as far as @kbd{|} is concerned.) If either argument to @kbd{|} is a scalar (a non-vector), it is treated like a one-element vector for purposes of concatenation: @kbd{1 [ 2 , 3 ] |} produces the vector @samp{[1, 2, 3]}. Likewise, if one argument is a matrix and the other is a plain vector, the vector is treated as a one-row matrix. @kindex H | @tindex append The @kbd{H |} (@code{calc-append}) [@code{append}] command concatenates two vectors without any special cases. Both inputs must be vectors. Whether or not they are matrices is not taken into account. If either argument is a scalar, the @code{append} function is left in symbolic form. See also @code{cons} and @code{rcons} below. @kindex I | @kindex H I | The @kbd{I |} and @kbd{H I |} commands are similar, but they use their two stack arguments in the opposite order. Thus @kbd{I |} is equivalent to @kbd{TAB |}, but possibly more convenient and also a bit faster. @kindex v d @pindex calc-diag @tindex diag The @kbd{v d} (@code{calc-diag}) [@code{diag}] function builds a diagonal square matrix. The optional numeric prefix gives the number of rows and columns in the matrix. If the value at the top of the stack is a vector, the elements of the vector are used as the diagonal elements; the prefix, if specified, must match the size of the vector. If the value on the stack is a scalar, it is used for each element on the diagonal, and the prefix argument is required. To build a constant square matrix, e.g., a @c{$3\times3$} @asis{3x3} matrix filled with ones, use @kbd{0 M-3 v d 1 +}, i.e., build a zero matrix first and then add a constant value to that matrix. (Another alternative would be to use @kbd{v b} and @kbd{v a}; see below.) @kindex v i @pindex calc-ident @tindex idn The @kbd{v i} (@code{calc-ident}) [@code{idn}] function builds an identity matrix of the specified size. It is a convenient form of @kbd{v d} where the diagonal element is always one. If no prefix argument is given, this command prompts for one. In algebraic notation, @samp{idn(a,n)} acts much like @samp{diag(a,n)}, except that @cite{a} is required to be a scalar (non-vector) quantity. If @cite{n} is omitted, @samp{idn(a)} represents @cite{a} times an identity matrix of unknown size. Calc can operate algebraically on such generic identity matrices, and if one is combined with a matrix whose size is known, it is converted automatically to an identity matrix of a suitable matching size. The @kbd{v i} command with an argument of zero creates a generic identity matrix, @samp{idn(1)}. Note that in dimensioned matrix mode (@pxref{Matrix Mode}), generic identity matrices are immediately expanded to the current default dimensions. @kindex v x @pindex calc-index @tindex index The @kbd{v x} (@code{calc-index}) [@code{index}] function builds a vector of consecutive integers from 1 to @var{n}, where @var{n} is the numeric prefix argument. If you do not provide a prefix argument, you will be prompted to enter a suitable number. If @var{n} is negative, the result is a vector of negative integers from @var{n} to @i{-1}. With a prefix argument of just @kbd{C-u}, the @kbd{v x} command takes three values from the stack: @var{n}, @var{start}, and @var{incr} (with @var{incr} at top-of-stack). Counting starts at @var{start} and increases by @var{incr} for successive vector elements. If @var{start} or @var{n} is in floating-point format, the resulting vector elements will also be floats. Note that @var{start} and @var{incr} may in fact be any kind of numbers or formulas. When @var{start} and @var{incr} are specified, a negative @var{n} has a different interpretation: It causes a geometric instead of arithmetic sequence to be generated. For example, @samp{index(-3, a, b)} produces @samp{[a, a b, a b^2]}. If you omit @var{incr} in the algebraic form, @samp{index(@var{n}, @var{start})}, the default value for @var{incr} is one for positive @var{n} or two for negative @var{n}. @kindex v b @pindex calc-build-vector @tindex cvec The @kbd{v b} (@code{calc-build-vector}) [@code{cvec}] function builds a vector of @var{n} copies of the value on the top of the stack, where @var{n} is the numeric prefix argument. In algebraic formulas, @samp{cvec(x,n,m)} can also be used to build an @var{n}-by-@var{m} matrix of copies of @var{x}. (Interactively, just use @kbd{v b} twice: once to build a row, then again to build a matrix of copies of that row.) @kindex v h @kindex I v h @pindex calc-head @pindex calc-tail @tindex head @tindex tail The @kbd{v h} (@code{calc-head}) [@code{head}] function returns the first element of a vector. The @kbd{I v h} (@code{calc-tail}) [@code{tail}] function returns the vector with its first element removed. In both cases, the argument must be a non-empty vector. @kindex v k @pindex calc-cons @tindex cons The @kbd{v k} (@code{calc-cons}) [@code{cons}] function takes a value @var{h} and a vector @var{t} from the stack, and produces the vector whose head is @var{h} and whose tail is @var{t}. This is similar to @kbd{|}, except if @var{h} is itself a vector, @kbd{|} will concatenate the two vectors whereas @code{cons} will insert @var{h} at the front of the vector @var{t}. @kindex H v h @tindex rhead @c @mindex @idots @kindex H I v h @c @mindex @null @kindex H v k @c @mindex @null @tindex rtail @c @mindex @null @tindex rcons Each of these three functions also accepts the Hyperbolic flag [@code{rhead}, @code{rtail}, @code{rcons}] in which case @var{t} instead represents the @emph{last} single element of the vector, with @var{h} representing the remainder of the vector. Thus the vector @samp{[a, b, c, d] = cons(a, [b, c, d]) = rcons([a, b, c], d)}. Also, @samp{head([a, b, c, d]) = a}, @samp{tail([a, b, c, d]) = [b, c, d]}, @samp{rhead([a, b, c, d]) = [a, b, c]}, and @samp{rtail([a, b, c, d]) = d}. @node Extracting Elements, Manipulating Vectors, Building Vectors, Matrix Functions @section Extracting Vector Elements @noindent @kindex v r @pindex calc-mrow @tindex mrow The @kbd{v r} (@code{calc-mrow}) [@code{mrow}] command extracts one row of the matrix on the top of the stack, or one element of the plain vector on the top of the stack. The row or element is specified by the numeric prefix argument; the default is to prompt for the row or element number. The matrix or vector is replaced by the specified row or element in the form of a vector or scalar, respectively. @cindex Permutations, applying With a prefix argument of @kbd{C-u} only, @kbd{v r} takes the index of the element or row from the top of the stack, and the vector or matrix from the second-to-top position. If the index is itself a vector of integers, the result is a vector of the corresponding elements of the input vector, or a matrix of the corresponding rows of the input matrix. This command can be used to obtain any permutation of a vector. With @kbd{C-u}, if the index is an interval form with integer components, it is interpreted as a range of indices and the corresponding subvector or submatrix is returned. @cindex Subscript notation @kindex a _ @pindex calc-subscript @tindex subscr @tindex _ Subscript notation in algebraic formulas (@samp{a_b}) stands for the Calc function @code{subscr}, which is synonymous with @code{mrow}. Thus, @samp{[x, y, z]_k} produces @cite{x}, @cite{y}, or @cite{z} if @cite{k} is one, two, or three, respectively. A double subscript (@samp{M_i_j}, equivalent to @samp{subscr(subscr(M, i), j)}) will access the element at row @cite{i}, column @cite{j} of a matrix. The @kbd{a _} (@code{calc-subscript}) command creates a subscript formula @samp{a_b} out of two stack entries. (It is on the @kbd{a} ``algebra'' prefix because subscripted variables are often used purely as an algebraic notation.) @tindex mrrow Given a negative prefix argument, @kbd{v r} instead deletes one row or element from the matrix or vector on the top of the stack. Thus @kbd{C-u 2 v r} replaces a matrix with its second row, but @kbd{C-u -2 v r} replaces the matrix with the same matrix with its second row removed. In algebraic form this function is called @code{mrrow}. @tindex getdiag Given a prefix argument of zero, @kbd{v r} extracts the diagonal elements of a square matrix in the form of a vector. In algebraic form this function is called @code{getdiag}. @kindex v c @pindex calc-mcol @tindex mcol @tindex mrcol The @kbd{v c} (@code{calc-mcol}) [@code{mcol} or @code{mrcol}] command is the analogous operation on columns of a matrix. Given a plain vector it extracts (or removes) one element, just like @kbd{v r}. If the index in @kbd{C-u v c} is an interval or vector and the argument is a matrix, the result is a submatrix with only the specified columns retained (and possibly permuted in the case of a vector index).@refill To extract a matrix element at a given row and column, use @kbd{v r} to extract the row as a vector, then @kbd{v c} to extract the column element from that vector. In algebraic formulas, it is often more convenient to use subscript notation: @samp{m_i_j} gives row @cite{i}, column @cite{j} of matrix @cite{m}. @kindex v s @pindex calc-subvector @tindex subvec The @kbd{v s} (@code{calc-subvector}) [@code{subvec}] command extracts a subvector of a vector. The arguments are the vector, the starting index, and the ending index, with the ending index in the top-of-stack position. The starting index indicates the first element of the vector to take. The ending index indicates the first element @emph{past} the range to be taken. Thus, @samp{subvec([a, b, c, d, e], 2, 4)} produces the subvector @samp{[b, c]}. You could get the same result using @samp{mrow([a, b, c, d, e], @w{[2 .. 4)})}. If either the start or the end index is zero or negative, it is interpreted as relative to the end of the vector. Thus @samp{subvec([a, b, c, d, e], 2, -2)} also produces @samp{[b, c]}. In the algebraic form, the end index can be omitted in which case it is taken as zero, i.e., elements from the starting element to the end of the vector are used. The infinity symbol, @code{inf}, also has this effect when used as the ending index. @kindex I v s @tindex rsubvec With the Inverse flag, @kbd{I v s} [@code{rsubvec}] removes a subvector from a vector. The arguments are interpreted the same as for the normal @kbd{v s} command. Thus, @samp{rsubvec([a, b, c, d, e], 2, 4)} produces @samp{[a, d, e]}. It is always true that @code{subvec} and @code{rsubvec} return complementary parts of the input vector. @xref{Selecting Subformulas}, for an alternative way to operate on vectors one element at a time. @node Manipulating Vectors, Vector and Matrix Arithmetic, Extracting Elements, Matrix Functions @section Manipulating Vectors @noindent @kindex v l @pindex calc-vlength @tindex vlen The @kbd{v l} (@code{calc-vlength}) [@code{vlen}] command computes the length of a vector. The length of a non-vector is considered to be zero. Note that matrices are just vectors of vectors for the purposes of this command.@refill @kindex H v l @tindex mdims With the Hyperbolic flag, @kbd{H v l} [@code{mdims}] computes a vector of the dimensions of a vector, matrix, or higher-order object. For example, @samp{mdims([[a,b,c],[d,e,f]])} returns @samp{[2, 3]} since its argument is a @c{$2\times3$} @asis{2x3} matrix. @kindex v f @pindex calc-vector-find @tindex find The @kbd{v f} (@code{calc-vector-find}) [@code{find}] command searches along a vector for the first element equal to a given target. The target is on the top of the stack; the vector is in the second-to-top position. If a match is found, the result is the index of the matching element. Otherwise, the result is zero. The numeric prefix argument, if given, allows you to select any starting index for the search. @kindex v a @pindex calc-arrange-vector @tindex arrange @cindex Arranging a matrix @cindex Reshaping a matrix @cindex Flattening a matrix The @kbd{v a} (@code{calc-arrange-vector}) [@code{arrange}] command rearranges a vector to have a certain number of columns and rows. The numeric prefix argument specifies the number of columns; if you do not provide an argument, you will be prompted for the number of columns. The vector or matrix on the top of the stack is @dfn{flattened} into a plain vector. If the number of columns is nonzero, this vector is then formed into a matrix by taking successive groups of @var{n} elements. If the number of columns does not evenly divide the number of elements in the vector, the last row will be short and the result will not be suitable for use as a matrix. For example, with the matrix @samp{[[1, 2], @w{[3, 4]}]} on the stack, @kbd{v a 4} produces @samp{[[1, 2, 3, 4]]} (a @c{$1\times4$} @asis{1x4} matrix), @kbd{v a 1} produces @samp{[[1], [2], [3], [4]]} (a @c{$4\times1$} @asis{4x1} matrix), @kbd{v a 2} produces @samp{[[1, 2], [3, 4]]} (the original @c{$2\times2$} @asis{2x2} matrix), @w{@kbd{v a 3}} produces @samp{[[1, 2, 3], [4]]} (not a matrix), and @kbd{v a 0} produces the flattened list @samp{[1, 2, @w{3, 4}]}. @cindex Sorting data @kindex V S @kindex I V S @pindex calc-sort @tindex sort @tindex rsort The @kbd{V S} (@code{calc-sort}) [@code{sort}] command sorts the elements of a vector into increasing order. Real numbers, real infinities, and constant interval forms come first in this ordering; next come other kinds of numbers, then variables (in alphabetical order), then finally come formulas and other kinds of objects; these are sorted according to a kind of lexicographic ordering with the useful property that one vector is less or greater than another if the first corresponding unequal elements are less or greater, respectively. Since quoted strings are stored by Calc internally as vectors of ASCII character codes (@pxref{Strings}), this means vectors of strings are also sorted into alphabetical order by this command. The @kbd{I V S} [@code{rsort}] command sorts a vector into decreasing order. @cindex Permutation, inverse of @cindex Inverse of permutation @cindex Index tables @cindex Rank tables @kindex V G @kindex I V G @pindex calc-grade @tindex grade @tindex rgrade The @kbd{V G} (@code{calc-grade}) [@code{grade}, @code{rgrade}] command produces an index table or permutation vector which, if applied to the input vector (as the index of @kbd{C-u v r}, say), would sort the vector. A permutation vector is just a vector of integers from 1 to @var{n}, where each integer occurs exactly once. One application of this is to sort a matrix of data rows using one column as the sort key; extract that column, grade it with @kbd{V G}, then use the result to reorder the original matrix with @kbd{C-u v r}. Another interesting property of the @code{V G} command is that, if the input is itself a permutation vector, the result will be the inverse of the permutation. The inverse of an index table is a rank table, whose @var{k}th element says where the @var{k}th original vector element will rest when the vector is sorted. To get a rank table, just use @kbd{V G V G}. With the Inverse flag, @kbd{I V G} produces an index table that would sort the input into decreasing order. Note that @kbd{V S} and @kbd{V G} use a ``stable'' sorting algorithm, i.e., any two elements which are equal will not be moved out of their original order. Generally there is no way to tell with @kbd{V S}, since two elements which are equal look the same, but with @kbd{V G} this can be an important issue. In the matrix-of-rows example, suppose you have names and telephone numbers as two columns and you wish to sort by phone number primarily, and by name when the numbers are equal. You can sort the data matrix by names first, and then again by phone numbers. Because the sort is stable, any two rows with equal phone numbers will remain sorted by name even after the second sort. @cindex Histograms @kindex V H @pindex calc-histogram @c @mindex histo@idots @tindex histogram The @kbd{V H} (@code{calc-histogram}) [@code{histogram}] command builds a histogram of a vector of numbers. Vector elements are assumed to be integers or real numbers in the range [0..@var{n}) for some ``number of bins'' @var{n}, which is the numeric prefix argument given to the command. The result is a vector of @var{n} counts of how many times each value appeared in the original vector. Non-integers in the input are rounded down to integers. Any vector elements outside the specified range are ignored. (You can tell if elements have been ignored by noting that the counts in the result vector don't add up to the length of the input vector.) @kindex H V H With the Hyperbolic flag, @kbd{H V H} pulls two vectors from the stack. The second-to-top vector is the list of numbers as before. The top vector is an equal-sized list of ``weights'' to attach to the elements of the data vector. For example, if the first data element is 4.2 and the first weight is 10, then 10 will be added to bin 4 of the result vector. Without the hyperbolic flag, every element has a weight of one. @kindex v t @pindex calc-transpose @tindex trn The @kbd{v t} (@code{calc-transpose}) [@code{trn}] command computes the transpose of the matrix at the top of the stack. If the argument is a plain vector, it is treated as a row vector and transposed into a one-column matrix. @kindex v v @pindex calc-reverse-vector @tindex rev The @kbd{v v} (@code{calc-reverse-vector}) [@code{vec}] command reverses a vector end-for-end. Given a matrix, it reverses the order of the rows. (To reverse the columns instead, just use @kbd{v t v v v t}. The same principle can be used to apply other vector commands to the columns of a matrix.) @kindex v m @pindex calc-mask-vector @tindex vmask The @kbd{v m} (@code{calc-mask-vector}) [@code{vmask}] command uses one vector as a mask to extract elements of another vector. The mask is in the second-to-top position; the target vector is on the top of the stack. These vectors must have the same length. The result is the same as the target vector, but with all elements which correspond to zeros in the mask vector deleted. Thus, for example, @samp{vmask([1, 0, 1, 0, 1], [a, b, c, d, e])} produces @samp{[a, c, e]}. @xref{Logical Operations}. @kindex v e @pindex calc-expand-vector @tindex vexp The @kbd{v e} (@code{calc-expand-vector}) [@code{vexp}] command expands a vector according to another mask vector. The result is a vector the same length as the mask, but with nonzero elements replaced by successive elements from the target vector. The length of the target vector is normally the number of nonzero elements in the mask. If the target vector is longer, its last few elements are lost. If the target vector is shorter, the last few nonzero mask elements are left unreplaced in the result. Thus @samp{vexp([2, 0, 3, 0, 7], [a, b])} produces @samp{[a, 0, b, 0, 7]}. @kindex H v e With the Hyperbolic flag, @kbd{H v e} takes a filler value from the top of the stack; the mask and target vectors come from the third and second elements of the stack. This filler is used where the mask is zero: @samp{vexp([2, 0, 3, 0, 7], [a, b], z)} produces @samp{[a, z, c, z, 7]}. If the filler value is itself a vector, then successive values are taken from it, so that the effect is to interleave two vectors according to the mask: @samp{vexp([2, 0, 3, 7, 0, 0], [a, b], [x, y])} produces @samp{[a, x, b, 7, y, 0]}. Another variation on the masking idea is to combine @samp{[a, b, c, d, e]} with the mask @samp{[1, 0, 1, 0, 1]} to produce @samp{[a, 0, c, 0, e]}. You can accomplish this with @kbd{V M a &}, mapping the logical ``and'' operation across the two vectors. @xref{Logical Operations}. Note that the @code{? :} operation also discussed there allows other types of masking using vectors. @node Vector and Matrix Arithmetic, Set Operations, Manipulating Vectors, Matrix Functions @section Vector and Matrix Arithmetic @noindent Basic arithmetic operations like addition and multiplication are defined for vectors and matrices as well as for numbers. Division of matrices, in the sense of multiplying by the inverse, is supported. (Division by a matrix actually uses LU-decomposition for greater accuracy and speed.) @xref{Basic Arithmetic}. The following functions are applied element-wise if their arguments are vectors or matrices: @code{change-sign}, @code{conj}, @code{arg}, @code{re}, @code{im}, @code{polar}, @code{rect}, @code{clean}, @code{float}, @code{frac}. @xref{Function Index}.@refill @kindex V J @pindex calc-conj-transpose @tindex ctrn The @kbd{V J} (@code{calc-conj-transpose}) [@code{ctrn}] command computes the conjugate transpose of its argument, i.e., @samp{conj(trn(x))}. @c @mindex A @kindex A (vectors) @pindex calc-abs (vectors) @c @mindex abs @tindex abs (vectors) The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the Frobenius norm of a vector or matrix argument. This is the square root of the sum of the squares of the absolute values of the elements of the vector or matrix. If the vector is interpreted as a point in two- or three-dimensional space, this is the distance from that point to the origin.@refill @kindex v n @pindex calc-rnorm @tindex rnorm The @kbd{v n} (@code{calc-rnorm}) [@code{rnorm}] command computes the row norm, or infinity-norm, of a vector or matrix. For a plain vector, this is the maximum of the absolute values of the elements. For a matrix, this is the maximum of the row-absolute-value-sums, i.e., of the sums of the absolute values of the elements along the various rows. @kindex V N @pindex calc-cnorm @tindex cnorm The @kbd{V N} (@code{calc-cnorm}) [@code{cnorm}] command computes the column norm, or one-norm, of a vector or matrix. For a plain vector, this is the sum of the absolute values of the elements. For a matrix, this is the maximum of the column-absolute-value-sums. General @cite{k}-norms for @cite{k} other than one or infinity are not provided. @kindex V C @pindex calc-cross @tindex cross The @kbd{V C} (@code{calc-cross}) [@code{cross}] command computes the right-handed cross product of two vectors, each of which must have exactly three elements. @c @mindex & @kindex & (matrices) @pindex calc-inv (matrices) @c @mindex inv @tindex inv (matrices) The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the inverse of a square matrix. If the matrix is singular, the inverse operation is left in symbolic form. Matrix inverses are recorded so that once an inverse (or determinant) of a particular matrix has been computed, the inverse and determinant of the matrix can be recomputed quickly in the future. If the argument to @kbd{&} is a plain number @cite{x}, this command simply computes @cite{1/x}. This is okay, because the @samp{/} operator also does a matrix inversion when dividing one by a matrix. @kindex V D @pindex calc-mdet @tindex det The @kbd{V D} (@code{calc-mdet}) [@code{det}] command computes the determinant of a square matrix. @kindex V L @pindex calc-mlud @tindex lud The @kbd{V L} (@code{calc-mlud}) [@code{lud}] command computes the LU decomposition of a matrix. The result is a list of three matrices which, when multiplied together left-to-right, form the original matrix. The first is a permutation matrix that arises from pivoting in the algorithm, the second is lower-triangular with ones on the diagonal, and the third is upper-triangular. @kindex V T @pindex calc-mtrace @tindex tr The @kbd{V T} (@code{calc-mtrace}) [@code{tr}] command computes the trace of a square matrix. This is defined as the sum of the diagonal elements of the matrix. @node Set Operations, Statistical Operations, Vector and Matrix Arithmetic, Matrix Functions @section Set Operations using Vectors @noindent @cindex Sets, as vectors Calc includes several commands which interpret vectors as @dfn{sets} of objects. A set is a collection of objects; any given object can appear only once in the set. Calc stores sets as vectors of objects in sorted order. Objects in a Calc set can be any of the usual things, such as numbers, variables, or formulas. Two set elements are considered equal if they are identical, except that numerically equal numbers like the integer 4 and the float 4.0 are considered equal even though they are not ``identical.'' Variables are treated like plain symbols without attached values by the set operations; subtracting the set @samp{[b]} from @samp{[a, b]} always yields the set @samp{[a]} even though if the variables @samp{a} and @samp{b} both equalled 17, you might expect the answer @samp{[]}. If a set contains interval forms, then it is assumed to be a set of real numbers. In this case, all set operations require the elements of the set to be only things that are allowed in intervals: Real numbers, plus and minus infinity, HMS forms, and date forms. If there are variables or other non-real objects present in a real set, all set operations on it will be left in unevaluated form. If the input to a set operation is a plain number or interval form @var{a}, it is treated like the one-element vector @samp{[@var{a}]}. The result is always a vector, except that if the set consists of a single interval, the interval itself is returned instead. @xref{Logical Operations}, for the @code{in} function which tests if a certain value is a member of a given set. To test if the set @cite{A} is a subset of the set @cite{B}, use @samp{vdiff(A, B) = []}. @kindex V + @pindex calc-remove-duplicates @tindex rdup The @kbd{V +} (@code{calc-remove-duplicates}) [@code{rdup}] command converts an arbitrary vector into set notation. It works by sorting the vector as if by @kbd{V S}, then removing duplicates. (For example, @kbd{[a, 5, 4, a, 4.0]} is sorted to @samp{[4, 4.0, 5, a, a]} and then reduced to @samp{[4, 5, a]}). Overlapping intervals are merged as necessary. You rarely need to use @kbd{V +} explicitly, since all the other set-based commands apply @kbd{V +} to their inputs before using them. @kindex V V @pindex calc-set-union @tindex vunion The @kbd{V V} (@code{calc-set-union}) [@code{vunion}] command computes the union of two sets. An object is in the union of two sets if and only if it is in either (or both) of the input sets. (You could accomplish the same thing by concatenating the sets with @kbd{|}, then using @kbd{V +}.) @kindex V ^ @pindex calc-set-intersect @tindex vint The @kbd{V ^} (@code{calc-set-intersect}) [@code{vint}] command computes the intersection of two sets. An object is in the intersection if and only if it is in both of the input sets. Thus if the input sets are disjoint, i.e., if they share no common elements, the result will be the empty vector @samp{[]}. Note that the characters @kbd{V} and @kbd{^} were chosen to be close to the conventional mathematical notation for set union@c{ ($A \cup B$)} @asis{} and intersection@c{ ($A \cap B$)} @asis{}. @kindex V - @pindex calc-set-difference @tindex vdiff The @kbd{V -} (@code{calc-set-difference}) [@code{vdiff}] command computes the difference between two sets. An object is in the difference @cite{A - B} if and only if it is in @cite{A} but not in @cite{B}. Thus subtracting @samp{[y,z]} from a set will remove the elements @samp{y} and @samp{z} if they are present. You can also think of this as a general @dfn{set complement} operator; if @cite{A} is the set of all possible values, then @cite{A - B} is the ``complement'' of @cite{B}. Obviously this is only practical if the set of all possible values in your problem is small enough to list in a Calc vector (or simple enough to express in a few intervals). @kindex V X @pindex calc-set-xor @tindex vxor The @kbd{V X} (@code{calc-set-xor}) [@code{vxor}] command computes the ``exclusive-or,'' or ``symmetric difference'' of two sets. An object is in the symmetric difference of two sets if and only if it is in one, but @emph{not} both, of the sets. Objects that occur in both sets ``cancel out.'' @kindex V ~ @pindex calc-set-complement @tindex vcompl The @kbd{V ~} (@code{calc-set-complement}) [@code{vcompl}] command computes the complement of a set with respect to the real numbers. Thus @samp{vcompl(x)} is equivalent to @samp{vdiff([-inf .. inf], x)}. For example, @samp{vcompl([2, (3 .. 4]])} evaluates to @samp{[[-inf .. 2), (2 .. 3], (4 .. inf]]}. @kindex V F @pindex calc-set-floor @tindex vfloor The @kbd{V F} (@code{calc-set-floor}) [@code{vfloor}] command reinterprets a set as a set of integers. Any non-integer values, and intervals that do not enclose any integers, are removed. Open intervals are converted to equivalent closed intervals. Successive integers are converted into intervals of integers. For example, the complement of the set @samp{[2, 6, 7, 8]} is messy, but if you wanted the complement with respect to the set of integers you could type @kbd{V ~ V F} to get @samp{[[-inf .. 1], [3 .. 5], [9 .. inf]]}. @kindex V E @pindex calc-set-enumerate @tindex venum The @kbd{V E} (@code{calc-set-enumerate}) [@code{venum}] command converts a set of integers into an explicit vector. Intervals in the set are expanded out to lists of all integers encompassed by the intervals. This only works for finite sets (i.e., sets which do not involve @samp{-inf} or @samp{inf}). @kindex V : @pindex calc-set-span @tindex vspan The @kbd{V :} (@code{calc-set-span}) [@code{vspan}] command converts any set of reals into an interval form that encompasses all its elements. The lower limit will be the smallest element in the set; the upper limit will be the largest element. For an empty set, @samp{vspan([])} returns the empty interval @w{@samp{[0 .. 0)}}. @kindex V # @pindex calc-set-cardinality @tindex vcard The @kbd{V #} (@code{calc-set-cardinality}) [@code{vcard}] command counts the number of integers in a set. The result is the length of the vector that would be produced by @kbd{V E}, although the computation is much more efficient than actually producing that vector. @cindex Sets, as binary numbers Another representation for sets that may be more appropriate in some cases is binary numbers. If you are dealing with sets of integers in the range 0 to 49, you can use a 50-bit binary number where a particular bit is 1 if the corresponding element is in the set. @xref{Binary Functions}, for a list of commands that operate on binary numbers. Note that many of the above set operations have direct equivalents in binary arithmetic: @kbd{b o} (@code{calc-or}), @kbd{b a} (@code{calc-and}), @kbd{b d} (@code{calc-diff}), @kbd{b x} (@code{calc-xor}), and @kbd{b n} (@code{calc-not}), respectively. You can use whatever representation for sets is most convenient to you. @kindex b p @kindex b u @pindex calc-pack-bits @pindex calc-unpack-bits @tindex vpack @tindex vunpack The @kbd{b u} (@code{calc-unpack-bits}) [@code{vunpack}] command converts an integer that represents a set in binary into a set in vector/interval notation. For example, @samp{vunpack(67)} returns @samp{[[0 .. 1], 6]}. If the input is negative, the set it represents is semi-infinite: @samp{vunpack(-4) = [2 .. inf)}. Use @kbd{V E} afterwards to expand intervals to individual values if you wish. Note that this command uses the @kbd{b} (binary) prefix key. The @kbd{b p} (@code{calc-pack-bits}) [@code{vpack}] command converts the other way, from a vector or interval representing a set of nonnegative integers into a binary integer describing the same set. The set may include positive infinity, but must not include any negative numbers. The input is interpreted as a set of integers in the sense of @kbd{V F} (@code{vfloor}). Beware that a simple input like @samp{[100]} can result in a huge integer representation (@c{$2^{100}$} @cite{2^100}, a 31-digit integer, in this case). @node Statistical Operations, Reducing and Mapping, Set Operations, Matrix Functions @section Statistical Operations on Vectors @noindent @cindex Statistical functions The commands in this section take vectors as arguments and compute various statistical measures on the data stored in the vectors. The references used in the definitions of these functions are Bevington's @emph{Data Reduction and Error Analysis for the Physical Sciences}, and @emph{Numerical Recipes} by Press, Flannery, Teukolsky and Vetterling. The statistical commands use the @kbd{u} prefix key followed by a shifted letter or other character. @xref{Manipulating Vectors}, for a description of @kbd{V H} (@code{calc-histogram}). @xref{Curve Fitting}, for the @kbd{a F} command for doing least-squares fits to statistical data. @xref{Probability Distribution Functions}, for several common probability distribution functions. @menu * Single-Variable Statistics:: * Paired-Sample Statistics:: @end menu @node Single-Variable Statistics, Paired-Sample Statistics, Statistical Operations, Statistical Operations @subsection Single-Variable Statistics @noindent These functions do various statistical computations on single vectors. Given a numeric prefix argument, they actually pop @var{n} objects from the stack and combine them into a data vector. Each object may be either a number or a vector; if a vector, any sub-vectors inside it are ``flattened'' as if by @kbd{v a 0}; @pxref{Manipulating Vectors}. By default one object is popped, which (in order to be useful) is usually a vector. If an argument is a variable name, and the value stored in that variable is a vector, then the stored vector is used. This method has the advantage that if your data vector is large, you can avoid the slow process of manipulating it directly on the stack. These functions are left in symbolic form if any of their arguments are not numbers or vectors, e.g., if an argument is a formula, or a non-vector variable. However, formulas embedded within vector arguments are accepted; the result is a symbolic representation of the computation, based on the assumption that the formula does not itself represent a vector. All varieties of numbers such as error forms and interval forms are acceptable. Some of the functions in this section also accept a single error form or interval as an argument. They then describe a property of the normal or uniform (respectively) statistical distribution described by the argument. The arguments are interpreted in the same way as the @var{M} argument of the random number function @kbd{k r}. In particular, an interval with integer limits is considered an integer distribution, so that @samp{[2 .. 6)} is the same as @samp{[2 .. 5]}. An interval with at least one floating-point limit is a continuous distribution: @samp{[2.0 .. 6.0)} is @emph{not} the same as @samp{[2.0 .. 5.0]}! @kindex u # @pindex calc-vector-count @tindex vcount The @kbd{u #} (@code{calc-vector-count}) [@code{vcount}] command computes the number of data values represented by the inputs. For example, @samp{vcount(1, [2, 3], [[4, 5], [], x, y])} returns 7. If the argument is a single vector with no sub-vectors, this simply computes the length of the vector. @kindex u + @kindex u * @pindex calc-vector-sum @pindex calc-vector-prod @tindex vsum @tindex vprod @cindex Summations (statistical) The @kbd{u +} (@code{calc-vector-sum}) [@code{vsum}] command computes the sum of the data values. The @kbd{u *} (@code{calc-vector-prod}) [@code{vprod}] command computes the product of the data values. If the input is a single flat vector, these are the same as @kbd{V R +} and @kbd{V R *} (@pxref{Reducing and Mapping}).@refill @kindex u X @kindex u N @pindex calc-vector-max @pindex calc-vector-min @tindex vmax @tindex vmin The @kbd{u X} (@code{calc-vector-max}) [@code{vmax}] command computes the maximum of the data values, and the @kbd{u N} (@code{calc-vector-min}) [@code{vmin}] command computes the minimum. If the argument is an interval, this finds the minimum or maximum value in the interval. (Note that @samp{vmax([2..6)) = 5} as described above.) If the argument is an error form, this returns plus or minus infinity. @kindex u M @pindex calc-vector-mean @tindex vmean @cindex Mean of data values The @kbd{u M} (@code{calc-vector-mean}) [@code{vmean}] command computes the average (arithmetic mean) of the data values. If the inputs are error forms @c{$x$ @code{+/-} $\sigma$} @samp{x +/- s}, this is the weighted mean of the @cite{x} values with weights @c{$1 / \sigma^2$} @cite{1 / s^2}. @tex \turnoffactive $$ \mu = { \displaystyle \sum { x_i \over \sigma_i^2 } \over \displaystyle \sum { 1 \over \sigma_i^2 } } $$ @end tex If the inputs are not error forms, this is simply the sum of the values divided by the count of the values.@refill Note that a plain number can be considered an error form with error @c{$\sigma = 0$} @cite{s = 0}. If the input to @kbd{u M} is a mixture of plain numbers and error forms, the result is the mean of the plain numbers, ignoring all values with non-zero errors. (By the above definitions it's clear that a plain number effectively has an infinite weight, next to which an error form with a finite weight is completely negligible.) This function also works for distributions (error forms or intervals). The mean of an error form `@i{a} @t{+/-} @i{b}' is simply @cite{a}. The mean of an interval is the mean of the minimum and maximum values of the interval. @kindex I u M @pindex calc-vector-mean-error @tindex vmeane The @kbd{I u M} (@code{calc-vector-mean-error}) [@code{vmeane}] command computes the mean of the data points expressed as an error form. This includes the estimated error associated with the mean. If the inputs are error forms, the error is the square root of the reciprocal of the sum of the reciprocals of the squares of the input errors. (I.e., the variance is the reciprocal of the sum of the reciprocals of the variances.) @tex \turnoffactive $$ \sigma_\mu^2 = {1 \over \displaystyle \sum {1 \over \sigma_i^2}} $$ @end tex If the inputs are plain numbers, the error is equal to the standard deviation of the values divided by the square root of the number of values. (This works out to be equivalent to calculating the standard deviation and then assuming each value's error is equal to this standard deviation.)@refill @tex \turnoffactive $$ \sigma_\mu^2 = {\sigma^2 \over N} $$ @end tex @kindex H u M @pindex calc-vector-median @tindex vmedian @cindex Median of data values The @kbd{H u M} (@code{calc-vector-median}) [@code{vmedian}] command computes the median of the data values. The values are first sorted into numerical order; the median is the middle value after sorting. (If the number of data values is even, the median is taken to be the average of the two middle values.) The median function is different from the other functions in this section in that the arguments must all be real numbers; variables are not accepted even when nested inside vectors. (Otherwise it is not possible to sort the data values.) If any of the input values are error forms, their error parts are ignored. The median function also accepts distributions. For both normal (error form) and uniform (interval) distributions, the median is the same as the mean. @kindex H I u M @pindex calc-vector-harmonic-mean @tindex vhmean @cindex Harmonic mean The @kbd{H I u M} (@code{calc-vector-harmonic-mean}) [@code{vhmean}] command computes the harmonic mean of the data values. This is defined as the reciprocal of the arithmetic mean of the reciprocals of the values. @tex \turnoffactive $$ { N \over \displaystyle \sum {1 \over x_i} } $$ @end tex @kindex u G @pindex calc-vector-geometric-mean @tindex vgmean @cindex Geometric mean The @kbd{u G} (@code{calc-vector-geometric-mean}) [@code{vgmean}] command computes the geometric mean of the data values. This is the @i{N}th root of the product of the values. This is also equal to the @code{exp} of the arithmetic mean of the logarithms of the data values. @tex \turnoffactive $$ \exp \left ( \sum { \ln x_i } \right ) = \left ( \prod { x_i } \right)^{1 / N} $$ @end tex @kindex H u G @tindex agmean The @kbd{H u G} [@code{agmean}] command computes the ``arithmetic-geometric mean'' of two numbers taken from the stack. This is computed by replacing the two numbers with their arithmetic mean and geometric mean, then repeating until the two values converge. @tex \turnoffactive $$ a_{i+1} = { a_i + b_i \over 2 } , \qquad b_{i+1} = \sqrt{a_i b_i} $$ @end tex @cindex Root-mean-square Another commonly used mean, the RMS (root-mean-square), can be computed for a vector of numbers simply by using the @kbd{A} command. @kindex u S @pindex calc-vector-sdev @tindex vsdev @cindex Standard deviation @cindex Sample statistics The @kbd{u S} (@code{calc-vector-sdev}) [@code{vsdev}] command computes the standard deviation@c{ $\sigma$} @asis{} of the data values. If the values are error forms, the errors are used as weights just as for @kbd{u M}. This is the @emph{sample} standard deviation, whose value is the square root of the sum of the squares of the differences between the values and the mean of the @cite{N} values, divided by @cite{N-1}. @tex \turnoffactive $$ \sigma^2 = {1 \over N - 1} \sum (x_i - \mu)^2 $$ @end tex This function also applies to distributions. The standard deviation of a single error form is simply the error part. The standard deviation of a continuous interval happens to equal the difference between the limits, divided by @c{$\sqrt{12}$} @cite{sqrt(12)}. The standard deviation of an integer interval is the same as the standard deviation of a vector of those integers. @kindex I u S @pindex calc-vector-pop-sdev @tindex vpsdev @cindex Population statistics The @kbd{I u S} (@code{calc-vector-pop-sdev}) [@code{vpsdev}] command computes the @emph{population} standard deviation. It is defined by the same formula as above but dividing by @cite{N} instead of by @cite{N-1}. The population standard deviation is used when the input represents the entire set of data values in the distribution; the sample standard deviation is used when the input represents a sample of the set of all data values, so that the mean computed from the input is itself only an estimate of the true mean. @tex \turnoffactive $$ \sigma^2 = {1 \over N} \sum (x_i - \mu)^2 $$ @end tex For error forms and continuous intervals, @code{vpsdev} works exactly like @code{vsdev}. For integer intervals, it computes the population standard deviation of the equivalent vector of integers. @kindex H u S @kindex H I u S @pindex calc-vector-variance @pindex calc-vector-pop-variance @tindex vvar @tindex vpvar @cindex Variance of data values The @kbd{H u S} (@code{calc-vector-variance}) [@code{vvar}] and @kbd{H I u S} (@code{calc-vector-pop-variance}) [@code{vpvar}] commands compute the variance of the data values. The variance is the square@c{ $\sigma^2$} @asis{} of the standard deviation, i.e., the sum of the squares of the deviations of the data values from the mean. (This definition also applies when the argument is a distribution.) @c @starindex @tindex vflat The @code{vflat} algebraic function returns a vector of its arguments, interpreted in the same way as the other functions in this section. For example, @samp{vflat(1, [2, [3, 4]], 5)} returns @samp{[1, 2, 3, 4, 5]}. @node Paired-Sample Statistics, , Single-Variable Statistics, Statistical Operations @subsection Paired-Sample Statistics @noindent The functions in this section take two arguments, which must be vectors of equal size. The vectors are each flattened in the same way as by the single-variable statistical functions. Given a numeric prefix argument of 1, these functions instead take one object from the stack, which must be an @c{$N\times2$} @asis{Nx2} matrix of data values. Once again, variable names can be used in place of actual vectors and matrices. @kindex u C @pindex calc-vector-covariance @tindex vcov @cindex Covariance The @kbd{u C} (@code{calc-vector-covariance}) [@code{vcov}] command computes the sample covariance of two vectors. The covariance of vectors @var{x} and @var{y} is the sum of the products of the differences between the elements of @var{x} and the mean of @var{x} times the differences between the corresponding elements of @var{y} and the mean of @var{y}, all divided by @cite{N-1}. Note that the variance of a vector is just the covariance of the vector with itself. Once again, if the inputs are error forms the errors are used as weight factors. If both @var{x} and @var{y} are composed of error forms, the error for a given data point is taken as the square root of the sum of the squares of the two input errors. @tex \turnoffactive $$ \sigma_{x\!y}^2 = {1 \over N-1} \sum (x_i - \mu_x) (y_i - \mu_y) $$ $$ \sigma_{x\!y}^2 = {\displaystyle {1 \over N-1} \sum {(x_i - \mu_x) (y_i - \mu_y) \over \sigma_i^2} \over \displaystyle {1 \over N} \sum {1 \over \sigma_i^2}} $$ @end tex @kindex I u C @pindex calc-vector-pop-covariance @tindex vpcov The @kbd{I u C} (@code{calc-vector-pop-covariance}) [@code{vpcov}] command computes the population covariance, which is the same as the sample covariance computed by @kbd{u C} except dividing by @cite{N} instead of @cite{N-1}. @kindex H u C @pindex calc-vector-correlation @tindex vcorr @cindex Correlation coefficient @cindex Linear correlation The @kbd{H u C} (@code{calc-vector-correlation}) [@code{vcorr}] command computes the linear correlation coefficient of two vectors. This is defined by the covariance of the vectors divided by the product of their standard deviations. (There is no difference between sample or population statistics here.) @tex \turnoffactive $$ r_{x\!y} = { \sigma_{x\!y}^2 \over \sigma_x^2 \sigma_y^2 } $$ @end tex @node Reducing and Mapping, Vector and Matrix Formats, Statistical Operations, Matrix Functions @section Reducing and Mapping Vectors @noindent The commands in this section allow for more general operations on the elements of vectors. @kindex V A @pindex calc-apply @tindex apply The simplest of these operations is @kbd{V A} (@code{calc-apply}) [@code{apply}], which applies a given operator to the elements of a vector. For example, applying the hypothetical function @code{f} to the vector @w{@samp{[1, 2, 3]}} would produce the function call @samp{f(1, 2, 3)}. Applying the @code{+} function to the vector @samp{[a, b]} gives @samp{a + b}. Applying @code{+} to the vector @samp{[a, b, c]} is an error, since the @code{+} function expects exactly two arguments. While @kbd{V A} is useful in some cases, you will usually find that either @kbd{V R} or @kbd{V M}, described below, is closer to what you want. @menu * Specifying Operators:: * Mapping:: * Reducing:: * Nesting and Fixed Points:: * Generalized Products:: @end menu @node Specifying Operators, Mapping, Reducing and Mapping, Reducing and Mapping @subsection Specifying Operators @noindent Commands in this section (like @kbd{V A}) prompt you to press the key corresponding to the desired operator. Press @kbd{?} for a partial list of the available operators. Generally, an operator is any key or sequence of keys that would normally take one or more arguments from the stack and replace them with a result. For example, @kbd{V A H C} uses the hyperbolic cosine operator, @code{cosh}. (Since @code{cosh} expects one argument, @kbd{V A H C} requires a vector with a single element as its argument.) You can press @kbd{x} at the operator prompt to select any algebraic function by name to use as the operator. This includes functions you have defined yourself using the @kbd{Z F} command. (@xref{Algebraic Definitions}.) If you give a name for which no function has been defined, the result is left in symbolic form, as in @samp{f(1, 2, 3)}. Calc will prompt for the number of arguments the function takes if it can't figure it out on its own (say, because you named a function that is currently undefined). It is also possible to type a digit key before the function name to specify the number of arguments, e.g., @kbd{V M 3 x f RET} calls @code{f} with three arguments even if it looks like it ought to have only two. This technique may be necessary if the function allows a variable number of arguments. For example, the @kbd{v e} [@code{vexp}] function accepts two or three arguments; if you want to map with the three-argument version, you will have to type @kbd{V M 3 v e}. It is also possible to apply any formula to a vector by treating that formula as a function. When prompted for the operator to use, press @kbd{'} (the apostrophe) and type your formula as an algebraic entry. You will then be prompted for the argument list, which defaults to a list of all variables that appear in the formula, sorted into alphabetic order. For example, suppose you enter the formula @w{@samp{x + 2y^x}}. The default argument list would be @samp{(x y)}, which means that if this function is applied to the arguments @samp{[3, 10]} the result will be @samp{3 + 2*10^3}. (If you plan to use a certain formula in this way often, you might consider defining it as a function with @kbd{Z F}.) Another way to specify the arguments to the formula you enter is with @kbd{$}, @kbd{$$}, and so on. For example, @kbd{V A ' $$ + 2$^$$} has the same effect as the previous example. The argument list is automatically taken to be @samp{($$ $)}. (The order of the arguments may seem backwards, but it is analogous to the way normal algebraic entry interacts with the stack.) If you press @kbd{$} at the operator prompt, the effect is similar to the apostrophe except that the relevant formula is taken from top-of-stack instead. The actual vector arguments of the @kbd{V A $} or related command then start at the second-to-top stack position. You will still be prompted for an argument list. @cindex Nameless functions @cindex Generic functions A function can be written without a name using the notation @samp{<#1 - #2>}, which means ``a function of two arguments that computes the first argument minus the second argument.'' The symbols @samp{#1} and @samp{#2} are placeholders for the arguments. You can use any names for these placeholders if you wish, by including an argument list followed by a colon: @samp{}. When you type @kbd{V A ' $$ + 2$^$$ RET}, Calc builds the nameless function @samp{<#1 + 2 #2^#1>} as the function to map across the vectors. When you type @kbd{V A ' x + 2y^x RET RET}, Calc builds the nameless function @w{@samp{}}. In both cases, Calc also writes the nameless function to the Trail so that you can get it back later if you wish. If there is only one argument, you can write @samp{#} in place of @samp{#1}. (Note that @samp{< >} notation is also used for date forms. Calc tells that @samp{<@var{stuff}>} is a nameless function by the presence of @samp{#} signs inside @var{stuff}, or by the fact that @var{stuff} begins with a list of variables followed by a colon.) You can type a nameless function directly to @kbd{V A '}, or put one on the stack and use it with @w{@kbd{V A $}}. Calc will not prompt for an argument list in this case, since the nameless function specifies the argument list as well as the function itself. In @kbd{V A '}, you can omit the @samp{< >} marks if you use @samp{#} notation for the arguments, so that @kbd{V A ' #1+#2 RET} is the same as @kbd{V A ' <#1+#2> RET}, which in turn is the same as @kbd{V A ' $$+$ RET}. @cindex Lambda expressions @c @starindex @tindex lambda The internal format for @samp{} is @samp{lambda(x, y, x + y)}. (The word @code{lambda} derives from Lisp notation and the theory of functions.) The internal format for @samp{<#1 + #2>} is @samp{lambda(ArgA, ArgB, ArgA + ArgB)}. Note that there is no actual Calc function called @code{lambda}; the whole point is that the @code{lambda} expression is used in its symbolic form, not evaluated for an answer until it is applied to specific arguments by a command like @kbd{V A} or @kbd{V M}. (Actually, @code{lambda} does have one special property: Its arguments are never evaluated; for example, putting @samp{<(2/3) #>} on the stack will not simplify the @samp{2/3} until the nameless function is actually called.) @tindex add @tindex sub @c @mindex @idots @tindex mul @c @mindex @null @tindex div @c @mindex @null @tindex pow @c @mindex @null @tindex neg @c @mindex @null @tindex mod @c @mindex @null @tindex vconcat As usual, commands like @kbd{V A} have algebraic function name equivalents. For example, @kbd{V A k g} with an argument of @samp{v} is equivalent to @samp{apply(gcd, v)}. The first argument specifies the operator name, and is either a variable whose name is the same as the function name, or a nameless function like @samp{<#^3+1>}. Operators that are normally written as algebraic symbols have the names @code{add}, @code{sub}, @code{mul}, @code{div}, @code{pow}, @code{neg}, @code{mod}, and @code{vconcat}.@refill @c @starindex @tindex call The @code{call} function builds a function call out of several arguments: @samp{call(gcd, x, y)} is the same as @samp{apply(gcd, [x, y])}, which in turn is the same as @samp{gcd(x, y)}. The first argument of @code{call}, like the other functions described here, may be either a variable naming a function, or a nameless function (@samp{call(<#1+2#2>, x, y)} is the same as @samp{x + 2y}). (Experts will notice that it's not quite proper to use a variable to name a function, since the name @code{gcd} corresponds to the Lisp variable @code{var-gcd} but to the Lisp function @code{calcFunc-gcd}. Calc automatically makes this translation, so you don't have to worry about it.) @node Mapping, Reducing, Specifying Operators, Reducing and Mapping @subsection Mapping @noindent @kindex V M @pindex calc-map @tindex map The @kbd{V M} (@code{calc-map}) [@code{map}] command applies a given operator elementwise to one or more vectors. For example, mapping @code{A} [@code{abs}] produces a vector of the absolute values of the elements in the input vector. Mapping @code{+} pops two vectors from the stack, which must be of equal length, and produces a vector of the pairwise sums of the elements. If either argument is a non-vector, it is duplicated for each element of the other vector. For example, @kbd{[1,2,3] 2 V M ^} squares the elements of the specified vector. With the 2 listed first, it would have computed a vector of powers of two. Mapping a user-defined function pops as many arguments from the stack as the function requires. If you give an undefined name, you will be prompted for the number of arguments to use.@refill If any argument to @kbd{V M} is a matrix, the operator is normally mapped across all elements of the matrix. For example, given the matrix @cite{[[1, -2, 3], [-4, 5, -6]]}, @kbd{V M A} takes six absolute values to produce another @c{$3\times2$} @asis{3x2} matrix, @cite{[[1, 2, 3], [4, 5, 6]]}. @tindex mapr The command @kbd{V M _} [@code{mapr}] (i.e., type an underscore at the operator prompt) maps by rows instead. For example, @kbd{V M _ A} views the above matrix as a vector of two 3-element row vectors. It produces a new vector which contains the absolute values of those row vectors, namely @cite{[3.74, 8.77]}. (Recall, the absolute value of a vector is defined as the square root of the sum of the squares of the elements.) Some operators accept vectors and return new vectors; for example, @kbd{v v} reverses a vector, so @kbd{V M _ v v} would reverse each row of the matrix to get a new matrix, @cite{[[3, -2, 1], [-6, 5, -4]]}. Sometimes a vector of vectors (representing, say, strings, sets, or lists) happens to look like a matrix. If so, remember to use @kbd{V M _} if you want to map a function across the whole strings or sets rather than across their individual elements. @tindex mapc The command @kbd{V M :} [@code{mapc}] maps by columns. Basically, it transposes the input matrix, maps by rows, and then, if the result is a matrix, transposes again. For example, @kbd{V M : A} takes the absolute values of the three columns of the matrix, treating each as a 2-vector, and @kbd{V M : v v} reverses the columns to get the matrix @cite{[[-4, 5, -6], [1, -2, 3]]}. (The symbols @kbd{_} and @kbd{:} were chosen because they had row-like and column-like appearances, and were not already taken by useful operators. Also, they appear shifted on most keyboards so they are easy to type after @kbd{V M}.) The @kbd{_} and @kbd{:} modifiers have no effect on arguments that are not matrices (so if none of the arguments are matrices, they have no effect at all). If some of the arguments are matrices and others are plain numbers, the plain numbers are held constant for all rows of the matrix (so that @kbd{2 V M _ ^} squares every row of a matrix; squaring a vector takes a dot product of the vector with itself). If some of the arguments are vectors with the same lengths as the rows (for @kbd{V M _}) or columns (for @kbd{V M :}) of the matrix arguments, those vectors are also held constant for every row or column. Sometimes it is useful to specify another mapping command as the operator to use with @kbd{V M}. For example, @kbd{V M _ V A +} applies @kbd{V A +} to each row of the input matrix, which in turn adds the two values on that row. If you give another vector-operator command as the operator for @kbd{V M}, it automatically uses map-by-rows mode if you don't specify otherwise; thus @kbd{V M V A +} is equivalent to @kbd{V M _ V A +}. (If you really want to map-by-elements another mapping command, you can use a triple-nested mapping command: @kbd{V M V M V A +} means to map @kbd{V M V A +} over the rows of the matrix; in turn, @kbd{V A +} is mapped over the elements of each row.) @tindex mapa @tindex mapd Previous versions of Calc had ``map across'' and ``map down'' modes that are now considered obsolete; the old ``map across'' is now simply @kbd{V M V A}, and ``map down'' is now @kbd{V M : V A}. The algebraic functions @code{mapa} and @code{mapd} are still supported, though. Note also that, while the old mapping modes were persistent (once you set the mode, it would apply to later mapping commands until you reset it), the new @kbd{:} and @kbd{_} modifiers apply only to the current mapping command. The default @kbd{V M} always means map-by-elements. @xref{Algebraic Manipulation}, for the @kbd{a M} command, which is like @kbd{V M} but for equations and inequalities instead of vectors. @xref{Storing Variables}, for the @kbd{s m} command which modifies a variable's stored value using a @kbd{V M}-like operator. @node Reducing, Nesting and Fixed Points, Mapping, Reducing and Mapping @subsection Reducing @noindent @kindex V R @pindex calc-reduce @tindex reduce The @kbd{V R} (@code{calc-reduce}) [@code{reduce}] command applies a given binary operator across all the elements of a vector. A binary operator is a function such as @code{+} or @code{max} which takes two arguments. For example, reducing @code{+} over a vector computes the sum of the elements of the vector. Reducing @code{-} computes the first element minus each of the remaining elements. Reducing @code{max} computes the maximum element and so on. In general, reducing @code{f} over the vector @samp{[a, b, c, d]} produces @samp{f(f(f(a, b), c), d)}. @kindex I V R @tindex rreduce The @kbd{I V R} [@code{rreduce}] command is similar to @kbd{V R} except that works from right to left through the vector. For example, plain @kbd{V R -} on the vector @samp{[a, b, c, d]} produces @samp{a - b - c - d} but @kbd{I V R -} on the same vector produces @samp{a - (b - (c - d))}, or @samp{a - b + c - d}. This ``alternating sum'' occurs frequently in power series expansions. @kindex V U @tindex accum The @kbd{V U} (@code{calc-accumulate}) [@code{accum}] command does an accumulation operation. Here Calc does the corresponding reduction operation, but instead of producing only the final result, it produces a vector of all the intermediate results. Accumulating @code{+} over the vector @samp{[a, b, c, d]} produces the vector @samp{[a, a + b, a + b + c, a + b + c + d]}. @kindex I V U @tindex raccum The @kbd{I V U} [@code{raccum}] command does a right-to-left accumulation. For example, @kbd{I V U -} on the vector @samp{[a, b, c, d]} produces the vector @samp{[a - b + c - d, b - c + d, c - d, d]}. @tindex reducea @tindex rreducea @tindex reduced @tindex rreduced As for @kbd{V M}, @kbd{V R} normally reduces a matrix elementwise. For example, given the matrix @cite{[[a, b, c], [d, e, f]]}, @kbd{V R +} will compute @cite{a + b + c + d + e + f}. You can type @kbd{V R _} or @kbd{V R :} to modify this behavior. The @kbd{V R _} [@code{reducea}] command reduces ``across'' the matrix; it reduces each row of the matrix as a vector, then collects the results. Thus @kbd{V R _ +} of this matrix would produce @cite{[a + b + c, d + e + f]}. Similarly, @kbd{V R :} [@code{reduced}] reduces down; @kbd{V R : +} would produce @cite{[a + d, b + e, c + f]}. @tindex reducer @tindex rreducer There is a third ``by rows'' mode for reduction that is occasionally useful; @kbd{V R =} [@code{reducer}] simply reduces the operator over the rows of the matrix themselves. Thus @kbd{V R = +} on the above matrix would get the same result as @kbd{V R : +}, since adding two row vectors is equivalent to adding their elements. But @kbd{V R = *} would multiply the two rows (to get a single number, their dot product), while @kbd{V R : *} would produce a vector of the products of the columns. These three matrix reduction modes work with @kbd{V R} and @kbd{I V R}, but they are not currently supported with @kbd{V U} or @kbd{I V U}. @tindex reducec @tindex rreducec The obsolete reduce-by-columns function, @code{reducec}, is still supported but there is no way to get it through the @kbd{V R} command. The commands @kbd{M-# :} and @kbd{M-# _} are equivalent to typing @kbd{M-# r} to grab a rectangle of data into Calc, and then typing @kbd{V R : +} or @kbd{V R _ +}, respectively, to sum the columns or rows of the matrix. @xref{Grabbing From Buffers}. @node Nesting and Fixed Points, Generalized Products, Reducing, Reducing and Mapping @subsection Nesting and Fixed Points @noindent @kindex H V R @tindex nest The @kbd{H V R} [@code{nest}] command applies a function to a given argument repeatedly. It takes two values, @samp{a} and @samp{n}, from the stack, where @samp{n} must be an integer. It then applies the function nested @samp{n} times; if the function is @samp{f} and @samp{n} is 3, the result is @samp{f(f(f(a)))}. The number @samp{n} may be negative if Calc knows an inverse for the function @samp{f}; for example, @samp{nest(sin, a, -2)} returns @samp{arcsin(arcsin(a))}. @kindex H V U @tindex anest The @kbd{H V U} [@code{anest}] command is an accumulating version of @code{nest}: It returns a vector of @samp{n+1} values, e.g., @samp{[a, f(a), f(f(a)), f(f(f(a)))]}. If @samp{n} is negative and @samp{F} is the inverse of @samp{f}, then the result is of the form @samp{[a, F(a), F(F(a)), F(F(F(a)))]}. @kindex H I V R @tindex fixp @cindex Fixed points The @kbd{H I V R} [@code{fixp}] command is like @kbd{H V R}, except that it takes only an @samp{a} value from the stack; the function is applied until it reaches a ``fixed point,'' i.e., until the result no longer changes. @kindex H I V U @tindex afixp The @kbd{H I V U} [@code{afixp}] command is an accumulating @code{fixp}. The first element of the return vector will be the initial value @samp{a}; the last element will be the final result that would have been returned by @code{fixp}. For example, 0.739085 is a fixed point of the cosine function (in radians): @samp{cos(0.739085) = 0.739085}. You can find this value by putting, say, 1.0 on the stack and typing @kbd{H I V U C}. (We use the accumulating version so we can see the intermediate results: @samp{[1, 0.540302, 0.857553, 0.65329, ...]}. With a precision of six, this command will take 36 steps to converge to 0.739085.) Newton's method for finding roots is a classic example of iteration to a fixed point. To find the square root of five starting with an initial guess, Newton's method would look for a fixed point of the function @samp{(x + 5/x) / 2}. Putting a guess of 1 on the stack and typing @kbd{H I V R ' ($ + 5/$)/2 RET} quickly yields the result 2.23607. This is equivalent to using the @kbd{a R} (@code{calc-find-root}) command to find a root of the equation @samp{x^2 = 5}. These examples used numbers for @samp{a} values. Calc keeps applying the function until two successive results are equal to within the current precision. For complex numbers, both the real parts and the imaginary parts must be equal to within the current precision. If @samp{a} is a formula (say, a variable name), then the function is applied until two successive results are exactly the same formula. It is up to you to ensure that the function will eventually converge; if it doesn't, you may have to press @kbd{C-g} to stop the Calculator. The algebraic @code{fixp} function takes two optional arguments, @samp{n} and @samp{tol}. The first is the maximum number of steps to be allowed, and must be either an integer or the symbol @samp{inf} (infinity, the default). The second is a convergence tolerance. If a tolerance is specified, all results during the calculation must be numbers, not formulas, and the iteration stops when the magnitude of the difference between two successive results is less than or equal to the tolerance. (This implies that a tolerance of zero iterates until the results are exactly equal.) Putting it all together, @samp{fixp(<(# + A/#)/2>, B, 20, 1e-10)} computes the square root of @samp{A} given the initial guess @samp{B}, stopping when the result is correct within the specified tolerance, or when 20 steps have been taken, whichever is sooner. @node Generalized Products, , Nesting and Fixed Points, Reducing and Mapping @subsection Generalized Products @kindex V O @pindex calc-outer-product @tindex outer The @kbd{V O} (@code{calc-outer-product}) [@code{outer}] command applies a given binary operator to all possible pairs of elements from two vectors, to produce a matrix. For example, @kbd{V O *} with @samp{[a, b]} and @samp{[x, y, z]} on the stack produces a multiplication table: @samp{[[a x, a y, a z], [b x, b y, b z]]}. Element @var{r},@var{c} of the result matrix is obtained by applying the operator to element @var{r} of the lefthand vector and element @var{c} of the righthand vector. @kindex V I @pindex calc-inner-product @tindex inner The @kbd{V I} (@code{calc-inner-product}) [@code{inner}] command computes the generalized inner product of two vectors or matrices, given a ``multiplicative'' operator and an ``additive'' operator. These can each actually be any binary operators; if they are @samp{*} and @samp{+}, respectively, the result is a standard matrix multiplication. Element @var{r},@var{c} of the result matrix is obtained by mapping the multiplicative operator across row @var{r} of the lefthand matrix and column @var{c} of the righthand matrix, and then reducing with the additive operator. Just as for the standard @kbd{*} command, this can also do a vector-matrix or matrix-vector inner product, or a vector-vector generalized dot product. Since @kbd{V I} requires two operators, it prompts twice. In each case, you can use any of the usual methods for entering the operator. If you use @kbd{$} twice to take both operator formulas from the stack, the first (multiplicative) operator is taken from the top of the stack and the second (additive) operator is taken from second-to-top. @node Vector and Matrix Formats, , Reducing and Mapping, Matrix Functions @section Vector and Matrix Display Formats @noindent Commands for controlling vector and matrix display use the @kbd{v} prefix instead of the usual @kbd{d} prefix. But they are display modes; in particular, they are influenced by the @kbd{I} and @kbd{H} prefix keys in the same way (@pxref{Display Modes}). Matrix display is also influenced by the @kbd{d O} (@code{calc-flat-language}) mode; @pxref{Normal Language Modes}. @kindex V < @pindex calc-matrix-left-justify @kindex V = @pindex calc-matrix-center-justify @kindex V > @pindex calc-matrix-right-justify The commands @kbd{v <} (@code{calc-matrix-left-justify}), @kbd{v >} (@code{calc-matrix-right-justify}), and @w{@kbd{v =}} (@code{calc-matrix-center-justify}) control whether matrix elements are justified to the left, right, or center of their columns.@refill @kindex V [ @pindex calc-vector-brackets @kindex V @{ @pindex calc-vector-braces @kindex V ( @pindex calc-vector-parens The @kbd{v [} (@code{calc-vector-brackets}) command turns the square brackets that surround vectors and matrices displayed in the stack on and off. The @kbd{v @{} (@code{calc-vector-braces}) and @kbd{v (} (@code{calc-vector-parens}) commands use curly braces or parentheses, respectively, instead of square brackets. For example, @kbd{v @{} might be used in preparation for yanking a matrix into a buffer running Mathematica. (In fact, the Mathematica language mode uses this mode; @pxref{Mathematica Language Mode}.) Note that, regardless of the display mode, either brackets or braces may be used to enter vectors, and parentheses may never be used for this purpose.@refill @kindex V ] @pindex calc-matrix-brackets The @kbd{v ]} (@code{calc-matrix-brackets}) command controls the ``big'' style display of matrices. It prompts for a string of code letters; currently implemented letters are @code{R}, which enables brackets on each row of the matrix; @code{O}, which enables outer brackets in opposite corners of the matrix; and @code{C}, which enables commas or semicolons at the ends of all rows but the last. The default format is @samp{RO}. (Before Calc 2.00, the format was fixed at @samp{ROC}.) Here are some example matrices: @group @example [ [ 123, 0, 0 ] [ [ 123, 0, 0 ], [ 0, 123, 0 ] [ 0, 123, 0 ], [ 0, 0, 123 ] ] [ 0, 0, 123 ] ] RO ROC @end example @end group @noindent @group @example [ 123, 0, 0 [ 123, 0, 0 ; 0, 123, 0 0, 123, 0 ; 0, 0, 123 ] 0, 0, 123 ] O OC @end example @end group @noindent @group @example [ 123, 0, 0 ] 123, 0, 0 [ 0, 123, 0 ] 0, 123, 0 [ 0, 0, 123 ] 0, 0, 123 R @r{blank} @end example @end group @noindent Note that of the formats shown here, @samp{RO}, @samp{ROC}, and @samp{OC} are all recognized as matrices during reading, while the others are useful for display only. @kindex V , @pindex calc-vector-commas The @kbd{v ,} (@code{calc-vector-commas}) command turns commas on and off in vector and matrix display.@refill In vectors of length one, and in all vectors when commas have been turned off, Calc adds extra parentheses around formulas that might otherwise be ambiguous. For example, @samp{[a b]} could be a vector of the one formula @samp{a b}, or it could be a vector of two variables with commas turned off. Calc will display the former case as @samp{[(a b)]}. You can disable these extra parentheses (to make the output less cluttered at the expense of allowing some ambiguity) by adding the letter @code{P} to the control string you give to @kbd{v ]} (as described above). @kindex V . @pindex calc-full-vectors The @kbd{v .} (@code{calc-full-vectors}) command turns abbreviated display of long vectors on and off. In this mode, vectors of six or more elements, or matrices of six or more rows or columns, will be displayed in an abbreviated form that displays only the first three elements and the last element: @samp{[a, b, c, ..., z]}. When very large vectors are involved this will substantially improve Calc's display speed. @kindex t . @pindex calc-full-trail-vectors The @kbd{t .} (@code{calc-full-trail-vectors}) command controls a similar mode for recording vectors in the Trail. If you turn on this mode, vectors of six or more elements and matrices of six or more rows or columns will be abbreviated when they are put in the Trail. The @kbd{t y} (@code{calc-trail-yank}) command will be unable to recover those vectors. If you are working with very large vectors, this mode will improve the speed of all operations that involve the trail. @kindex V / @pindex calc-break-vectors The @kbd{v /} (@code{calc-break-vectors}) command turns multi-line vector display on and off. Normally, matrices are displayed with one row per line but all other types of vectors are displayed in a single line. This mode causes all vectors, whether matrices or not, to be displayed with a single element per line. Sub-vectors within the vectors will still use the normal linear form. @node Algebra, Units, Matrix Functions, Top @chapter Algebra @noindent This section covers the Calc features that help you work with algebraic formulas. First, the general sub-formula selection mechanism is described; this works in conjunction with any Calc commands. Then, commands for specific algebraic operations are described. Finally, the flexible @dfn{rewrite rule} mechanism is discussed. The algebraic commands use the @kbd{a} key prefix; selection commands use the @kbd{j} (for ``just a letter that wasn't used for anything else'') prefix. @xref{Editing Stack Entries}, to see how to manipulate formulas using regular Emacs editing commands.@refill When doing algebraic work, you may find several of the Calculator's modes to be helpful, including algebraic-simplification mode (@kbd{m A}) or no-simplification mode (@kbd{m O}), algebraic-entry mode (@kbd{m a}), fraction mode (@kbd{m f}), and symbolic mode (@kbd{m s}). @xref{Mode Settings}, for discussions of these modes. You may also wish to select ``big'' display mode (@kbd{d B}). @xref{Normal Language Modes}.@refill @menu * Selecting Subformulas:: * Algebraic Manipulation:: * Simplifying Formulas:: * Polynomials:: * Calculus:: * Solving Equations:: * Numerical Solutions:: * Curve Fitting:: * Summations:: * Logical Operations:: * Rewrite Rules:: @end menu @node Selecting Subformulas, Algebraic Manipulation, Algebra, Algebra @section Selecting Sub-Formulas @noindent @cindex Selections @cindex Sub-formulas @cindex Parts of formulas When working with an algebraic formula it is often necessary to manipulate a portion of the formula rather than the formula as a whole. Calc allows you to ``select'' a portion of any formula on the stack. Commands which would normally operate on that stack entry will now operate only on the sub-formula, leaving the surrounding part of the stack entry alone. One common non-algebraic use for selection involves vectors. To work on one element of a vector in-place, simply select that element as a ``sub-formula'' of the vector. @menu * Making Selections:: * Changing Selections:: * Displaying Selections:: * Operating on Selections:: * Rearranging with Selections:: @end menu @node Making Selections, Changing Selections, Selecting Subformulas, Selecting Subformulas @subsection Making Selections @noindent @kindex j s @pindex calc-select-here To select a sub-formula, move the Emacs cursor to any character in that sub-formula, and press @w{@kbd{j s}} (@code{calc-select-here}). Calc will highlight the smallest portion of the formula that contains that character. By default the sub-formula is highlighted by blanking out all of the rest of the formula with dots. Selection works in any display mode but is perhaps easiest in ``big'' (@kbd{d B}) mode. Suppose you enter the following formula: @group @smallexample 3 ___ (a + b) + V c 1: --------------- 2 x + 1 @end smallexample @end group @noindent (by typing @kbd{' ((a+b)^3 + sqrt(c)) / (2x+1)}). If you move the cursor to the letter @samp{b} and press @w{@kbd{j s}}, the display changes to @group @smallexample . ... .. . b. . . . 1* ............... . . . . @end smallexample @end group @noindent Every character not part of the sub-formula @samp{b} has been changed to a dot. The @samp{*} next to the line number is to remind you that the formula has a portion of it selected. (In this case, it's very obvious, but it might not always be. If Embedded Mode is enabled, the word @samp{Sel} also appears in the mode line because the stack may not be visible. @pxref{Embedded Mode}.) If you had instead placed the cursor on the parenthesis immediately to the right of the @samp{b}, the selection would have been: @group @smallexample . ... (a + b) . . . 1* ............... . . . . @end smallexample @end group @noindent The portion selected is always large enough to be considered a complete formula all by itself, so selecting the parenthesis selects the whole formula that it encloses. Putting the cursor on the the @samp{+} sign would have had the same effect. (Strictly speaking, the Emacs cursor is really the manifestation of the Emacs ``point,'' which is a position @emph{between} two characters in the buffer. So purists would say that Calc selects the smallest sub-formula which contains the character to the right of ``point.'') If you supply a numeric prefix argument @var{n}, the selection is expanded to the @var{n}th enclosing sub-formula. Thus, positioning the cursor on the @samp{b} and typing @kbd{C-u 1 j s} will select @samp{a + b}; typing @kbd{C-u 2 j s} will select @samp{(a + b)^3}, and so on. If the cursor is not on any part of the formula, or if you give a numeric prefix that is too large, the entire formula is selected. If the cursor is on the @samp{.} line that marks the top of the stack (i.e., its normal ``rest position''), this command selects the entire formula at stack level 1. Most selection commands similarly operate on the formula at the top of the stack if you haven't positioned the cursor on any stack entry. @kindex j a @pindex calc-select-additional The @kbd{j a} (@code{calc-select-additional}) command enlarges the current selection to encompass the cursor. To select the smallest sub-formula defined by two different points, move to the first and press @kbd{j s}, then move to the other and press @kbd{j a}. This is roughly analogous to using @kbd{C-@@} (@code{set-mark-command}) to select the two ends of a region of text during normal Emacs editing. @kindex j o @pindex calc-select-once The @kbd{j o} (@code{calc-select-once}) command selects a formula in exactly the same way as @kbd{j s}, except that the selection will last only as long as the next command that uses it. For example, @kbd{j o 1 +} is a handy way to add one to the sub-formula indicated by the cursor. (A somewhat more precise definition: The @kbd{j o} command sets a flag such that the next command involving selected stack entries will clear the selections on those stack entries afterwards. All other selection commands except @kbd{j a} and @kbd{j O} clear this flag.) @kindex j S @kindex j O @pindex calc-select-here-maybe @pindex calc-select-once-maybe The @kbd{j S} (@code{calc-select-here-maybe}) and @kbd{j O} (@code{calc-select-once-maybe}) commands are equivalent to @kbd{j s} and @kbd{j o}, respectively, except that if the formula already has a selection they have no effect. This is analogous to the behavior of some commands such as @kbd{j r} (@code{calc-rewrite-selection}; @pxref{Selections with Rewrite Rules}) and is mainly intended to be used in keyboard macros that implement your own selection-oriented commands.@refill Selection of sub-formulas normally treats associative terms like @samp{a + b - c + d} and @samp{x * y * z} as single levels of the formula. If you place the cursor anywhere inside @samp{a + b - c + d} except on one of the variable names and use @kbd{j s}, you will select the entire four-term sum. @kindex j b @pindex calc-break-selections The @kbd{j b} (@code{calc-break-selections}) command controls a mode in which the ``deep structure'' of these associative formulas shows through. Calc actually stores the above formulas as @samp{((a + b) - c) + d} and @samp{x * (y * z)}. (Note that for certain obscure reasons, Calc treats multiplication as right-associative.) Once you have enabled @kbd{j b} mode, selecting with the cursor on the @samp{-} sign would only select the @samp{a + b - c} portion, which makes sense when the deep structure of the sum is considered. There is no way to select the @samp{b - c + d} portion; although this might initially look like just as legitimate a sub-formula as @samp{a + b - c}, the deep structure shows that it isn't. The @kbd{d U} command can be used to view the deep structure of any formula (@pxref{Normal Language Modes}). When @kbd{j b} mode has not been enabled, the deep structure is generally hidden by the selection commands---what you see is what you get. @kindex j u @pindex calc-unselect The @kbd{j u} (@code{calc-unselect}) command unselects the formula that the cursor is on. If there was no selection in the formula, this command has no effect. With a numeric prefix argument, it unselects the @var{n}th stack element rather than using the cursor position. @kindex j c @pindex calc-clear-selections The @kbd{j c} (@code{calc-clear-selections}) command unselects all stack elements. @node Changing Selections, Displaying Selections, Making Selections, Selecting Subformulas @subsection Changing Selections @noindent @kindex j m @pindex calc-select-more Once you have selected a sub-formula, you can expand it using the @w{@kbd{j m}} (@code{calc-select-more}) command. If @samp{a + b} is selected, pressing @w{@kbd{j m}} repeatedly works as follows: @group @smallexample 3 ... 3 ___ 3 ___ (a + b) . . . (a + b) + V c (a + b) + V c 1* ............... 1* ............... 1* --------------- . . . . . . . . 2 x + 1 @end smallexample @end group @noindent In the last example, the entire formula is selected. This is roughly the same as having no selection at all, but because there are subtle differences the @samp{*} character is still there on the line number. With a numeric prefix argument @var{n}, @kbd{j m} expands @var{n} times (or until the entire formula is selected). Note that @kbd{j s} with argument @var{n} is equivalent to plain @kbd{j s} followed by @kbd{j m} with argument @var{n}. If @w{@kbd{j m}} is used when there is no current selection, it is equivalent to @w{@kbd{j s}}. Even though @kbd{j m} does not explicitly use the location of the cursor within the formula, it nevertheless uses the cursor to determine which stack element to operate on. As usual, @kbd{j m} when the cursor is not on any stack element operates on the top stack element. @kindex j l @pindex calc-select-less The @kbd{j l} (@code{calc-select-less}) command reduces the current selection around the cursor position. That is, it selects the immediate sub-formula of the current selection which contains the cursor, the opposite of @kbd{j m}. If the cursor is not inside the current selection, the command de-selects the formula. @kindex j 1-9 @pindex calc-select-part The @kbd{j 1} through @kbd{j 9} (@code{calc-select-part}) commands select the @var{n}th sub-formula of the current selection. They are like @kbd{j l} (@code{calc-select-less}) except they use counting rather than the cursor position to decide which sub-formula to select. For example, if the current selection is @kbd{a + b + c} or @kbd{f(a, b, c)} or @kbd{[a, b, c]}, then @kbd{j 1} selects @samp{a}, @kbd{j 2} selects @samp{b}, and @kbd{j 3} selects @samp{c}; in each of these cases, @kbd{j 4} through @kbd{j 9} would be errors. If there is no current selection, @kbd{j 1} through @kbd{j 9} select the @var{n}th top-level sub-formula. (In other words, they act as if the entire stack entry were selected first.) To select the @var{n}th sub-formula where @var{n} is greater than nine, you must instead invoke @w{@kbd{j 1}} with @var{n} as a numeric prefix argument.@refill @kindex j n @kindex j p @pindex calc-select-next @pindex calc-select-previous The @kbd{j n} (@code{calc-select-next}) and @kbd{j p} (@code{calc-select-previous}) commands change the current selection to the next or previous sub-formula at the same level. For example, if @samp{b} is selected in @w{@samp{2 + a*b*c + x}}, then @kbd{j n} selects @samp{c}. Further @kbd{j n} commands would be in error because, even though there is something to the right of @samp{c} (namely, @samp{x}), it is not at the same level; in this case, it is not a term of the same product as @samp{b} and @samp{c}. However, @kbd{j m} (to select the whole product @samp{a*b*c} as a term of the sum) followed by @w{@kbd{j n}} would successfully select the @samp{x}. Similarly, @kbd{j p} moves the selection from the @samp{b} in this sample formula to the @samp{a}. Both commands accept numeric prefix arguments to move several steps at a time. It is interesting to compare Calc's selection commands with the Emacs Info system's commands for navigating through hierarchically organized documentation. Calc's @kbd{j n} command is completely analogous to Info's @kbd{n} command. Likewise, @kbd{j p} maps to @kbd{p}, @kbd{j 2} maps to @kbd{2}, and Info's @kbd{u} is like @kbd{j m}. (Note that @kbd{j u} stands for @code{calc-unselect}, not ``up''.) The Info @kbd{m} command is somewhat similar to Calc's @kbd{j s} and @kbd{j l}; in each case, you can jump directly to a sub-component of the hierarchy simply by pointing to it with the cursor. @node Displaying Selections, Operating on Selections, Changing Selections, Selecting Subformulas @subsection Displaying Selections @noindent @kindex j d @pindex calc-show-selections The @kbd{j d} (@code{calc-show-selections}) command controls how selected sub-formulas are displayed. One of the alternatives is illustrated in the above examples; if we press @kbd{j d} we switch to the other style in which the selected portion itself is obscured by @samp{#} signs: @group @smallexample 3 ... # ___ (a + b) . . . ## # ## + V c 1* ............... 1* --------------- . . . . 2 x + 1 @end smallexample @end group @node Operating on Selections, Rearranging with Selections, Displaying Selections, Selecting Subformulas @subsection Operating on Selections @noindent Once a selection is made, all Calc commands that manipulate items on the stack will operate on the selected portions of the items instead. (Note that several stack elements may have selections at once, though there can be only one selection at a time in any given stack element.) @kindex j e @pindex calc-enable-selections The @kbd{j e} (@code{calc-enable-selections}) command disables the effect that selections have on Calc commands. The current selections still exist, but Calc commands operate on whole stack elements anyway. This mode can be identified by the fact that the @samp{*} markers on the line numbers are gone, even though selections are visible. To reactivate the selections, press @kbd{j e} again. To extract a sub-formula as a new formula, simply select the sub-formula and press @key{RET}. This normally duplicates the top stack element; here it duplicates only the selected portion of that element. To replace a sub-formula with something different, you can enter the new value onto the stack and press @key{TAB}. This normally exchanges the top two stack elements; here it swaps the value you entered into the selected portion of the formula, returning the old selected portion to the top of the stack. @group @smallexample 3 ... ... ___ (a + b) . . . 17 x y . . . 17 x y + V c 2* ............... 2* ............. 2: ------------- . . . . . . . . 2 x + 1 3 3 1: 17 x y 1: (a + b) 1: (a + b) @end smallexample @end group In this example we select a sub-formula of our original example, enter a new formula, @key{TAB} it into place, then deselect to see the complete, edited formula. If you want to swap whole formulas around even though they contain selections, just use @kbd{j e} before and after. @kindex j ' @pindex calc-enter-selection The @kbd{j '} (@code{calc-enter-selection}) command is another way to replace a selected sub-formula. This command does an algebraic entry just like the regular @kbd{'} key. When you press @key{RET}, the formula you type replaces the original selection. You can use the @samp{$} symbol in the formula to refer to the original selection. If there is no selection in the formula under the cursor, the cursor is used to make a temporary selection for the purposes of the command. Thus, to change a term of a formula, all you have to do is move the Emacs cursor to that term and press @kbd{j '}. @kindex j ` @pindex calc-edit-selection The @kbd{j `} (@code{calc-edit-selection}) command is a similar analogue of the @kbd{`} (@code{calc-edit}) command. It edits the selected sub-formula in a separate buffer. If there is no selection, it edits the sub-formula indicated by the cursor. To delete a sub-formula, press @key{DEL}. This generally replaces the sub-formula with the constant zero, but in a few suitable contexts it uses the constant one instead. The @key{DEL} key automatically deselects and re-simplifies the entire formula afterwards. Thus: @group @smallexample ### 17 x y + # # 17 x y 17 # y 17 y 1* ------------- 1: ------- 1* ------- 1: ------- 2 x + 1 2 x + 1 2 x + 1 2 x + 1 @end smallexample @end group In this example, we first delete the @samp{sqrt(c)} term; Calc accomplishes this by replacing @samp{sqrt(c)} with zero and resimplifying. We then delete the @kbd{x} in the numerator; since this is part of a product, Calc replaces it with @samp{1} and resimplifies. If you select an element of a vector and press @key{DEL}, that element is deleted from the vector. If you delete one side of an equation or inequality, only the opposite side remains. @kindex j DEL @pindex calc-del-selection The @kbd{j @key{DEL}} (@code{calc-del-selection}) command is like @key{DEL} but with the auto-selecting behavior of @kbd{j '} and @kbd{j `}. It deletes the selected portion of the formula indicated by the cursor, or, in the absence of a selection, it deletes the sub-formula indicated by the cursor position. @kindex j RET @pindex calc-grab-selection (There is also an auto-selecting @kbd{j @key{RET}} (@code{calc-copy-selection}) command.) Normal arithmetic operations also apply to sub-formulas. Here we select the denominator, press @kbd{5 -} to subtract five from the denominator, press @kbd{n} to negate the denominator, then press @kbd{Q} to take the square root. @group @smallexample .. . .. . .. . .. . 1* ....... 1* ....... 1* ....... 1* .......... 2 x + 1 2 x - 4 4 - 2 x _________ V 4 - 2 x @end smallexample @end group Certain types of operations on selections are not allowed. For example, for an arithmetic function like @kbd{-} no more than one of the arguments may be a selected sub-formula. (As the above example shows, the result of the subtraction is spliced back into the argument which had the selection; if there were more than one selection involved, this would not be well-defined.) If you try to subtract two selections, the command will abort with an error message. Operations on sub-formulas sometimes leave the formula as a whole in an ``un-natural'' state. Consider negating the @samp{2 x} term of our sample formula by selecting it and pressing @kbd{n} (@code{calc-change-sign}).@refill @group @smallexample .. . .. . 1* .......... 1* ........... ......... .......... . . . 2 x . . . -2 x @end smallexample @end group Unselecting the sub-formula reveals that the minus sign, which would normally have cancelled out with the subtraction automatically, has not been able to do so because the subtraction was not part of the selected portion. Pressing @kbd{=} (@code{calc-evaluate}) or doing any other mathematical operation on the whole formula will cause it to be simplified. @group @smallexample 17 y 17 y 1: ----------- 1: ---------- __________ _________ V 4 - -2 x V 4 + 2 x @end smallexample @end group @node Rearranging with Selections, , Operating on Selections, Selecting Subformulas @subsection Rearranging Formulas using Selections @noindent @kindex j R @pindex calc-commute-right The @kbd{j R} (@code{calc-commute-right}) command moves the selected sub-formula to the right in its surrounding formula. Generally the selection is one term of a sum or product; the sum or product is rearranged according to the commutative laws of algebra. As with @kbd{j '} and @kbd{j DEL}, the term under the cursor is used if there is no selection in the current formula. All commands described in this section share this property. In this example, we place the cursor on the @samp{a} and type @kbd{j R}, then repeat. @smallexample 1: a + b - c 1: b + a - c 1: b - c + a @end smallexample @noindent Note that in the final step above, the @samp{a} is switched with the @samp{c} but the signs are adjusted accordingly. When moving terms of sums and products, @kbd{j R} will never change the mathematical meaning of the formula. The selected term may also be an element of a vector or an argument of a function. The term is exchanged with the one to its right. In this case, the ``meaning'' of the vector or function may of course be drastically changed. @smallexample 1: [a, b, c] 1: [b, a, c] 1: [b, c, a] 1: f(a, b, c) 1: f(b, a, c) 1: f(b, c, a) @end smallexample @kindex j L @pindex calc-commute-left The @kbd{j L} (@code{calc-commute-left}) command is like @kbd{j R} except that it swaps the selected term with the one to its left. With numeric prefix arguments, these commands move the selected term several steps at a time. It is an error to try to move a term left or right past the end of its enclosing formula. With numeric prefix arguments of zero, these commands move the selected term as far as possible in the given direction. @kindex j D @pindex calc-sel-distribute The @kbd{j D} (@code{calc-sel-distribute}) command mixes the selected sum or product into the surrounding formula using the distributive law. For example, in @samp{a * (b - c)} with the @samp{b - c} selected, the result is @samp{a b - a c}. This also distributes products or quotients into surrounding powers, and can also do transformations like @samp{exp(a + b)} to @samp{exp(a) exp(b)}, where @samp{a + b} is the selected term, and @samp{ln(a ^ b)} to @samp{ln(a) b}, where @samp{a ^ b} is the selected term. For multiple-term sums or products, @kbd{j D} takes off one term at a time: @samp{a * (b + c - d)} goes to @samp{a * (c - d) + a b} with the @samp{c - d} selected so that you can type @kbd{j D} repeatedly to expand completely. The @kbd{j D} command allows a numeric prefix argument which specifies the maximum number of times to expand at once; the default is one time only. @vindex DistribRules The @kbd{j D} command is implemented using rewrite rules. @xref{Selections with Rewrite Rules}. The rules are stored in the Calc variable @code{DistribRules}. A convenient way to view these rules is to use @kbd{s e} (@code{calc-edit-variable}) which displays and edits the stored value of a variable. Press @key{M-# M-#} to return from editing mode; be careful not to make any actual changes or else you will affect the behavior of future @kbd{j D} commands! To extend @kbd{j D} to handle new cases, just edit @code{DistribRules} as described above. You can then use the @kbd{s p} command to save this variable's value permanently for future Calc sessions. @xref{Operations on Variables}. @kindex j M @pindex calc-sel-merge @vindex MergeRules The @kbd{j M} (@code{calc-sel-merge}) command is the complement of @kbd{j D}; given @samp{a b - a c} with either @samp{a b} or @samp{a c} selected, the result is @samp{a * (b - c)}. Once again, @kbd{j M} can also merge calls to functions like @code{exp} and @code{ln}; examine the variable @code{MergeRules} to see all the relevant rules. @kindex j C @pindex calc-sel-commute @vindex CommuteRules The @kbd{j C} (@code{calc-sel-commute}) command swaps the arguments of the selected sum, product, or equation. It always behaves as if @kbd{j b} mode were in effect, i.e., the sum @samp{a + b + c} is treated as the nested sums @samp{(a + b) + c} by this command. If you put the cursor on the first @samp{+}, the result is @samp{(b + a) + c}; if you put the cursor on the second @samp{+}, the result is @samp{c + (a + b)} (which the default simplifications will rearrange to @samp{(c + a) + b}). The relevant rules are stored in the variable @code{CommuteRules}. You may need to turn default simplifications off (with the @kbd{m O} command) in order to get the full benefit of @kbd{j C}. For example, commuting @samp{a - b} produces @samp{-b + a}, but the default simplifications will ``simplify'' this right back to @samp{a - b} if you don't turn them off. The same is true of some of the other manipulations described in this section. @kindex j N @pindex calc-sel-negate @vindex NegateRules The @kbd{j N} (@code{calc-sel-negate}) command replaces the selected term with the negative of that term, then adjusts the surrounding formula in order to preserve the meaning. For example, given @samp{exp(a - b)} where @samp{a - b} is selected, the result is @samp{1 / exp(b - a)}. By contrast, selecting a term and using the regular @kbd{n} (@code{calc-change-sign}) command negates the term without adjusting the surroundings, thus changing the meaning of the formula as a whole. The rules variable is @code{NegateRules}. @kindex j & @pindex calc-sel-invert @vindex InvertRules The @kbd{j &} (@code{calc-sel-invert}) command is similar to @kbd{j N} except it takes the reciprocal of the selected term. For example, given @samp{a - ln(b)} with @samp{b} selected, the result is @samp{a + ln(1/b)}. The rules variable is @code{InvertRules}. @kindex j E @pindex calc-sel-jump-equals @vindex JumpRules The @kbd{j E} (@code{calc-sel-jump-equals}) command moves the selected term from one side of an equation to the other. Given @samp{a + b = c + d} with @samp{c} selected, the result is @samp{a + b - c = d}. This command also works if the selected term is part of a @samp{*}, @samp{/}, or @samp{^} formula. The relevant rules variable is @code{JumpRules}. @kindex j I @kindex H j I @pindex calc-sel-isolate The @kbd{j I} (@code{calc-sel-isolate}) command isolates the selected term on its side of an equation. It uses the @kbd{a S} (@code{calc-solve-for}) command to solve the equation, and the Hyperbolic flag affects it in the same way. @xref{Solving Equations}. When it applies, @kbd{j I} is often easier to use than @kbd{j E}. It understands more rules of algebra, and works for inequalities as well as equations. @kindex j * @kindex j / @pindex calc-sel-mult-both-sides @pindex calc-sel-div-both-sides The @kbd{j *} (@code{calc-sel-mult-both-sides}) command prompts for a formula using algebraic entry, then multiplies both sides of the selected quotient or equation by that formula. It simplifies each side with @kbd{a s} (@code{calc-simplify}) before re-forming the quotient or equation. You can suppress this simplification by providing any numeric prefix argument. There is also a @kbd{j /} (@code{calc-sel-div-both-sides}) which is similar to @kbd{j *} but dividing instead of multiplying by the factor you enter. As a special feature, if the numerator of the quotient is 1, then the denominator is expanded at the top level using the distributive law (i.e., using the @kbd{C-u -1 a x} command). Suppose the formula on the stack is @samp{1 / (sqrt(a) + 1)}, and you wish to eliminate the square root in the denominator by multiplying both sides by @samp{sqrt(a) - 1}. Calc's default simplifications would change the result @samp{(sqrt(a) - 1) / (sqrt(a) - 1) (sqrt(a) + 1)} right back to the original form by cancellation; Calc expands the denominator to @samp{sqrt(a) (sqrt(a) - 1) + sqrt(a) - 1} to prevent this. (You would now want to use an @kbd{a x} command to expand the rest of the way, whereupon the denominator would cancel out to the desired form, @samp{a - 1}.) When the numerator is not 1, this initial expansion is not necessary because Calc's default simplifications will not notice the potential cancellation. If the selection is an inequality, @kbd{j *} and @kbd{j /} will accept any factor, but will warn unless they can prove the factor is either positive or negative. (In the latter case the direction of the inequality will be switched appropriately.) @xref{Declarations}, for ways to inform Calc that a given variable is positive or negative. If Calc can't tell for sure what the sign of the factor will be, it will assume it is positive and display a warning message. For selections that are not quotients, equations, or inequalities, these commands pull out a multiplicative factor: They divide (or multiply) by the entered formula, simplify, then multiply (or divide) back by the formula. @kindex j + @kindex j - @pindex calc-sel-add-both-sides @pindex calc-sel-sub-both-sides The @kbd{j +} (@code{calc-sel-add-both-sides}) and @kbd{j -} (@code{calc-sel-sub-both-sides}) commands analogously add to or subtract from both sides of an equation or inequality. For other types of selections, they extract an additive factor. A numeric prefix argument suppresses simplification of the intermediate results. @kindex j U @pindex calc-sel-unpack The @kbd{j U} (@code{calc-sel-unpack}) command replaces the selected function call with its argument. For example, given @samp{a + sin(x^2)} with @samp{sin(x^2)} selected, the result is @samp{a + x^2}. (The @samp{x^2} will remain selected; if you wanted to change the @code{sin} to @code{cos}, just press @kbd{C} now to take the cosine of the selected part.) @kindex j v @pindex calc-sel-evaluate The @kbd{j v} (@code{calc-sel-evaluate}) command performs the normal default simplifications on the selected sub-formula. These are the simplifications that are normally done automatically on all results, but which may have been partially inhibited by previous selection-related operations, or turned off altogether by the @kbd{m O} command. This command is just an auto-selecting version of the @w{@kbd{a v}} command (@pxref{Algebraic Manipulation}). With a numeric prefix argument of 2, @kbd{C-u 2 j v} applies the @kbd{a s} (@code{calc-simplify}) command to the selected sub-formula. With a prefix argument of 3 or more, e.g., @kbd{C-u j v} applies the @kbd{a e} (@code{calc-simplify-extended}) command. @xref{Simplifying Formulas}. With a negative prefix argument it simplifies at the top level only, just as with @kbd{a v}. Here the ``top'' level refers to the top level of the selected sub-formula. @kindex j " @pindex calc-sel-expand-formula The @kbd{j "} (@code{calc-sel-expand-formula}) command is to @kbd{a "} (@pxref{Algebraic Manipulation}) what @kbd{j v} is to @kbd{a v}. You can use the @kbd{j r} (@code{calc-rewrite-selection}) command to define other algebraic operations on sub-formulas. @xref{Rewrite Rules}. @node Algebraic Manipulation, Simplifying Formulas, Selecting Subformulas, Algebra @section Algebraic Manipulation @noindent The commands in this section perform general-purpose algebraic manipulations. They work on the whole formula at the top of the stack (unless, of course, you have made a selection in that formula). Many algebra commands prompt for a variable name or formula. If you answer the prompt with a blank line, the variable or formula is taken from top-of-stack, and the normal argument for the command is taken from the second-to-top stack level. @kindex a v @pindex calc-alg-evaluate The @kbd{a v} (@code{calc-alg-evaluate}) command performs the normal default simplifications on a formula; for example, @samp{a - -b} is changed to @samp{a + b}. These simplifications are normally done automatically on all Calc results, so this command is useful only if you have turned default simplifications off with an @kbd{m O} command. @xref{Simplification Modes}. It is often more convenient to type @kbd{=}, which is like @kbd{a v} but which also substitutes stored values for variables in the formula. Use @kbd{a v} if you want the variables to ignore their stored values. If you give a numeric prefix argument of 2 to @kbd{a v}, it simplifies as if in algebraic simplification mode. This is equivalent to typing @kbd{a s}; @pxref{Simplifying Formulas}. If you give a numeric prefix of 3 or more, it uses extended simplification mode (@kbd{a e}). If you give a negative prefix argument @i{-1}, @i{-2}, or @i{-3}, it simplifies in the corresponding mode but only works on the top-level function call of the formula. For example, @samp{(2 + 3) * (2 + 3)} will simplify to @samp{(2 + 3)^2}, without simplifying the sub-formulas @samp{2 + 3}. As another example, typing @kbd{V R +} to sum the vector @samp{[1, 2, 3, 4]} produces the formula @samp{reduce(add, [1, 2, 3, 4])} in no-simplify mode. Using @kbd{a v} will evaluate this all the way to 10; using @kbd{C-u - a v} will evaluate it only to @samp{1 + 2 + 3 + 4}. (@xref{Reducing and Mapping}.) @tindex evalv @tindex evalvn The @kbd{=} command corresponds to the @code{evalv} function, and the related @kbd{N} command, which is like @kbd{=} but temporarily disables symbolic (@kbd{m s}) mode during the evaluation, corresponds to the @code{evalvn} function. (These commands interpret their prefix arguments differently than @kbd{a v}; @kbd{=} treats the prefix as the number of stack elements to evaluate at once, and @kbd{N} treats it as a temporary different working precision.) The @code{evalvn} function can take an alternate working precision as an optional second argument. This argument can be either an integer, to set the precision absolutely, or a vector containing a single integer, to adjust the precision relative to the current precision. Note that @code{evalvn} with a larger than current precision will do the calculation at this higher precision, but the result will as usual be rounded back down to the current precision afterward. For example, @samp{evalvn(pi - 3.1415)} at a precision of 12 will return @samp{9.265359e-5}; @samp{evalvn(pi - 3.1415, 30)} will return @samp{9.26535897932e-5} (computing a 25-digit result which is then rounded down to 12); and @samp{evalvn(pi - 3.1415, [-2])} will return @samp{9.2654e-5}. @kindex a " @pindex calc-expand-formula The @kbd{a "} (@code{calc-expand-formula}) command expands functions into their defining formulas wherever possible. For example, @samp{deg(x^2)} is changed to @samp{180 x^2 / pi}. Most functions, like @code{sin} and @code{gcd}, are not defined by simple formulas and so are unaffected by this command. One important class of functions which @emph{can} be expanded is the user-defined functions created by the @kbd{Z F} command. @xref{Algebraic Definitions}. Other functions which @kbd{a "} can expand include the probability distribution functions, most of the financial functions, and the hyperbolic and inverse hyperbolic functions. A numeric prefix argument affects @kbd{a "} in the same way as it does @kbd{a v}: A positive argument expands all functions in the formula and then simplifies in various ways; a negative argument expands and simplifies only the top-level function call. @kindex a M @pindex calc-map-equation @tindex mapeq The @kbd{a M} (@code{calc-map-equation}) [@code{mapeq}] command applies a given function or operator to one or more equations. It is analogous to @kbd{V M}, which operates on vectors instead of equations. @pxref{Reducing and Mapping}. For example, @kbd{a M S} changes @samp{x = y+1} to @samp{sin(x) = sin(y+1)}, and @kbd{a M +} with @samp{x = y+1} and @cite{6} on the stack produces @samp{x+6 = y+7}. With two equations on the stack, @kbd{a M +} would add the lefthand sides together and the righthand sides together to get the two respective sides of a new equation. Mapping also works on inequalities. Mapping two similar inequalities produces another inequality of the same type. Mapping an inequality with an equation produces an inequality of the same type. Mapping a @samp{<=} with a @samp{<} or @samp{!=} (not-equal) produces a @samp{<}. If inequalities with opposite direction (e.g., @samp{<} and @samp{>}) are mapped, the direction of the second inequality is reversed to match the first: Using @kbd{a M +} on @samp{a < b} and @samp{a > 2} reverses the latter to get @samp{2 < a}, which then allows the combination @samp{a + 2 < b + a}, which the @kbd{a s} command can then simplify to get @samp{2 < b}. Using @kbd{a M *}, @kbd{a M /}, @kbd{a M n}, or @kbd{a M &} to negate or invert an inequality will reverse the direction of the inequality. Other adjustments to inequalities are @emph{not} done automatically; @kbd{a M S} will change @w{@samp{x < y}} to @samp{sin(x) < sin(y)} even though this is not true for all values of the variables. @kindex H a M @tindex mapeqp With the Hyperbolic flag, @kbd{H a M} [@code{mapeqp}] does a plain mapping operation without reversing the direction of any inequalities. Thus, @kbd{H a M &} would change @kbd{x > 2} to @kbd{1/x > 0.5}. (This change is mathematically incorrect, but perhaps you were fixing an inequality which was already incorrect.) @kindex I a M @tindex mapeqr With the Inverse flag, @kbd{I a M} [@code{mapeqr}] always reverses the direction of the inequality. You might use @kbd{I a M C} to change @samp{x < y} to @samp{cos(x) > cos(y)} if you know you are working with small positive angles. @kindex a b @pindex calc-substitute @tindex subst The @kbd{a b} (@code{calc-substitute}) [@code{subst}] command substitutes all occurrences of some variable or sub-expression of an expression with a new sub-expression. For example, substituting @samp{sin(x)} with @samp{cos(y)} in @samp{2 sin(x)^2 + x sin(x) + sin(2 x)} produces @samp{2 cos(y)^2 + x cos(y) + @w{sin(2 x)}}. Note that this is a purely structural substitution; the lone @samp{x} and the @samp{sin(2 x)} stayed the same because they did not look like @samp{sin(x)}. @xref{Rewrite Rules}, for a more general method for doing substitutions.@refill The @kbd{a b} command normally prompts for two formulas, the old one and the new one. If you enter a blank line for the first prompt, all three arguments are taken from the stack (new, then old, then target expression). If you type an old formula but then enter a blank line for the new one, the new formula is taken from top-of-stack and the target from second-to-top. If you answer both prompts, the target is taken from top-of-stack as usual. Note that @kbd{a b} has no understanding of commutativity or associativity. The pattern @samp{x+y} will not match the formula @samp{y+x}. Also, @samp{y+z} will not match inside the formula @samp{x+y+z} because the @samp{+} operator is left-associative, so the ``deep structure'' of that formula is @samp{(x+y) + z}. Use @kbd{d U} (@code{calc-unformatted-language}) mode to see the true structure of a formula. The rewrite rule mechanism, discussed later, does not have these limitations. As an algebraic function, @code{subst} takes three arguments: Target expression, old, new. Note that @code{subst} is always evaluated immediately, even if its arguments are variables, so if you wish to put a call to @code{subst} onto the stack you must turn the default simplifications off first (with @kbd{m O}). @node Simplifying Formulas, Polynomials, Algebraic Manipulation, Algebra @section Simplifying Formulas @noindent @kindex a s @pindex calc-simplify @tindex simplify The @kbd{a s} (@code{calc-simplify}) [@code{simplify}] command applies various algebraic rules to simplify a formula. This includes rules which are not part of the default simplifications because they may be too slow to apply all the time, or may not be desirable all of the time. For example, non-adjacent terms of sums are combined, as in @samp{a + b + 2 a} to @samp{b + 3 a}, and some formulas like @samp{sin(arcsin(x))} are simplified to @samp{x}. The sections below describe all the various kinds of algebraic simplifications Calc provides in full detail. None of Calc's simplification commands are designed to pull rabbits out of hats; they simply apply certain specific rules to put formulas into less redundant or more pleasing forms. Serious algebra in Calc must be done manually, usually with a combination of selections and rewrite rules. @xref{Rearranging with Selections}. @xref{Rewrite Rules}. @xref{Simplification Modes}, for commands to control what level of simplification occurs automatically. Normally only the ``default simplifications'' occur. @menu * Default Simplifications:: * Algebraic Simplifications:: * Unsafe Simplifications:: * Simplification of Units:: @end menu @node Default Simplifications, Algebraic Simplifications, Simplifying Formulas, Simplifying Formulas @subsection Default Simplifications @noindent @cindex Default simplifications This section describes the ``default simplifications,'' those which are normally applied to all results. For example, if you enter the variable @cite{x} on the stack twice and push @kbd{+}, Calc's default simplifications automatically change @cite{x + x} to @cite{2 x}. The @kbd{m O} command turns off the default simplifications, so that @cite{x + x} will remain in this form unless you give an explicit ``simplify'' command like @kbd{=} or @kbd{a v}. @xref{Algebraic Manipulation}. The @kbd{m D} command turns the default simplifications back on. The most basic default simplification is the evaluation of functions. For example, @cite{2 + 3} is evaluated to @cite{5}, and @cite{@t{sqrt}(9)} is evaluated to @cite{3}. Evaluation does not occur if the arguments to a function are somehow of the wrong type (@cite{@t{tan}([2,3,4])}, range (@cite{@t{tan}(90)}), or number (@cite{@t{tan}(3,5)}), or if the function name is not recognized (@cite{@t{f}(5)}), or if ``symbolic'' mode (@pxref{Symbolic Mode}) prevents evaluation (@cite{@t{sqrt}(2)}). Calc simplifies (evaluates) the arguments to a function before it simplifies the function itself. Thus @cite{@t{sqrt}(5+4)} is simplified to @cite{@t{sqrt}(9)} before the @code{sqrt} function itself is applied. There are very few exceptions to this rule: @code{quote}, @code{lambda}, and @code{condition} (the @code{::} operator) do not evaluate their arguments, @code{if} (the @code{? :} operator) does not evaluate all of its arguments, and @code{evalto} does not evaluate its lefthand argument. Most commands apply the default simplifications to all arguments they take from the stack, perform a particular operation, then simplify the result before pushing it back on the stack. In the common special case of regular arithmetic commands like @kbd{+} and @kbd{Q} [@code{sqrt}], the arguments are simply popped from the stack and collected into a suitable function call, which is then simplified (the arguments being simplified first as part of the process, as described above). The default simplifications are too numerous to describe completely here, but this section will describe the ones that apply to the major arithmetic operators. This list will be rather technical in nature, and will probably be interesting to you only if you are a serious user of Calc's algebra facilities. @tex \bigskip @end tex As well as the simplifications described here, if you have stored any rewrite rules in the variable @code{EvalRules} then these rules will also be applied before any built-in default simplifications. @xref{Automatic Rewrites}, for details. @tex \bigskip @end tex And now, on with the default simplifications: Arithmetic operators like @kbd{+} and @kbd{*} always take two arguments in Calc's internal form. Sums and products of three or more terms are arranged by the associative law of algebra into a left-associative form for sums, @cite{((a + b) + c) + d}, and a right-associative form for products, @cite{a * (b * (c * d))}. Formulas like @cite{(a + b) + (c + d)} are rearranged to left-associative form, though this rarely matters since Calc's algebra commands are designed to hide the inner structure of sums and products as much as possible. Sums and products in their proper associative form will be written without parentheses in the examples below. Sums and products are @emph{not} rearranged according to the commutative law (@cite{a + b} to @cite{b + a}) except in a few special cases described below. Some algebra programs always rearrange terms into a canonical order, which enables them to see that @cite{a b + b a} can be simplified to @cite{2 a b}. Calc assumes you have put the terms into the order you want and generally leaves that order alone, with the consequence that formulas like the above will only be simplified if you explicitly give the @kbd{a s} command. @xref{Algebraic Simplifications}. Differences @cite{a - b} are treated like sums @cite{a + (-b)} for purposes of simplification; one of the default simplifications is to rewrite @cite{a + (-b)} or @cite{(-b) + a}, where @cite{-b} represents a ``negative-looking'' term, into @cite{a - b} form. ``Negative-looking'' means negative numbers, negated formulas like @cite{-x}, and products or quotients in which either term is negative-looking. Other simplifications involving negation are @cite{-(-x)} to @cite{x}; @cite{-(a b)} or @cite{-(a/b)} where either @cite{a} or @cite{b} is negative-looking, simplified by negating that term, or else where @cite{a} or @cite{b} is any number, by negating that number; @cite{-(a + b)} to @cite{-a - b}, and @cite{-(b - a)} to @cite{a - b}. (This, and rewriting @cite{(-b) + a} to @cite{a - b}, are the only cases where the order of terms in a sum is changed by the default simplifications.) The distributive law is used to simplify sums in some cases: @cite{a x + b x} to @cite{(a + b) x}, where @cite{a} represents a number or an implicit 1 or @i{-1} (as in @cite{x} or @cite{-x}) and similarly for @cite{b}. Use the @kbd{a c}, @w{@kbd{a f}}, or @kbd{j M} commands to merge sums with non-numeric coefficients using the distributive law. The distributive law is only used for sums of two terms, or for adjacent terms in a larger sum. Thus @cite{a + b + b + c} is simplified to @cite{a + 2 b + c}, but @cite{a + b + c + b} is not simplified. The reason is that comparing all terms of a sum with one another would require time proportional to the square of the number of terms; Calc relegates potentially slow operations like this to commands that have to be invoked explicitly, like @kbd{a s}. Finally, @cite{a + 0} and @cite{0 + a} are simplified to @cite{a}. A consequence of the above rules is that @cite{0 - a} is simplified to @cite{-a}. @tex \bigskip @end tex The products @cite{1 a} and @cite{a 1} are simplified to @cite{a}; @cite{(-1) a} and @cite{a (-1)} are simplified to @cite{-a}; @cite{0 a} and @cite{a 0} are simplified to @cite{0}, except that in matrix mode where @cite{a} is not provably scalar the result is the generic zero matrix @samp{idn(0)}, and that if @cite{a} is infinite the result is @samp{nan}. Also, @cite{(-a) b} and @cite{a (-b)} are simplified to @cite{-(a b)}, where this occurs for negated formulas but not for regular negative numbers. Products are commuted only to move numbers to the front: @cite{a b 2} is commuted to @cite{2 a b}. The product @cite{a (b + c)} is distributed over the sum only if @cite{a} and at least one of @cite{b} and @cite{c} are numbers: @cite{2 (x + 3)} goes to @cite{2 x + 6}. The formula @cite{(-a) (b - c)}, where @cite{-a} is a negative number, is rewritten to @cite{a (c - b)}. The distributive law of products and powers is used for adjacent terms of the product: @cite{x^a x^b} goes to @c{$x^{a+b}$} @cite{x^(a+b)} where @cite{a} is a number, or an implicit 1 (as in @cite{x}), or the implicit one-half of @cite{@t{sqrt}(x)}, and similarly for @cite{b}. The result is written using @samp{sqrt} or @samp{1/sqrt} if the sum of the powers is @cite{1/2} or @cite{-1/2}, respectively. If the sum of the powers is zero, the product is simplified to @cite{1} or to @samp{idn(1)} if matrix mode is enabled. The product of a negative power times anything but another negative power is changed to use division: @c{$x^{-2} y$} @cite{x^(-2) y} goes to @cite{y / x^2} unless matrix mode is in effect and neither @cite{x} nor @cite{y} are scalar (in which case it is considered unsafe to rearrange the order of the terms). Finally, @cite{a (b/c)} is rewritten to @cite{(a b)/c}, and also @cite{(a/b) c} is changed to @cite{(a c)/b} unless in matrix mode. @tex \bigskip @end tex Simplifications for quotients are analogous to those for products. The quotient @cite{0 / x} is simplified to @cite{0}, with the same exceptions that were noted for @cite{0 x}. Likewise, @cite{x / 1} and @cite{x / (-1)} are simplified to @cite{x} and @cite{-x}, respectively. The quotient @cite{x / 0} is left unsimplified or changed to an infinite quantity, as directed by the current infinite mode. @xref{Infinite Mode}. The expression @c{$a / b^{-c}$} @cite{a / b^(-c)} is changed to @cite{a b^c}, where @cite{-c} is any negative-looking power. Also, @cite{1 / b^c} is changed to @c{$b^{-c}$} @cite{b^(-c)} for any power @cite{c}. Also, @cite{(-a) / b} and @cite{a / (-b)} go to @cite{-(a/b)}; @cite{(a/b) / c} goes to @cite{a / (b c)}; and @cite{a / (b/c)} goes to @cite{(a c) / b} unless matrix mode prevents this rearrangement. Similarly, @cite{a / (b:c)} is simplified to @cite{(c:b) a} for any fraction @cite{b:c}. The distributive law is applied to @cite{(a + b) / c} only if @cite{c} and at least one of @cite{a} and @cite{b} are numbers. Quotients of powers and square roots are distributed just as described for multiplication. Quotients of products cancel only in the leading terms of the numerator and denominator. In other words, @cite{a x b / a y b} is cancelled to @cite{x b / y b} but not to @cite{x / y}. Once again this is because full cancellation can be slow; use @kbd{a s} to cancel all terms of the quotient. Quotients of negative-looking values are simplified according to @cite{(-a) / (-b)} to @cite{a / b}, @cite{(-a) / (b - c)} to @cite{a / (c - b)}, and @cite{(a - b) / (-c)} to @cite{(b - a) / c}. @tex \bigskip @end tex The formula @cite{x^0} is simplified to @cite{1}, or to @samp{idn(1)} in matrix mode. The formula @cite{0^x} is simplified to @cite{0} unless @cite{x} is a negative number or complex number, in which case the result is an infinity or an unsimplified formula according to the current infinite mode. Note that @cite{0^0} is an indeterminate form, as evidenced by the fact that the simplifications for @cite{x^0} and @cite{0^x} conflict when @cite{x=0}. Powers of products or quotients @cite{(a b)^c}, @cite{(a/b)^c} are distributed to @cite{a^c b^c}, @cite{a^c / b^c} only if @cite{c} is an integer, or if either @cite{a} or @cite{b} are nonnegative real numbers. Powers of powers @cite{(a^b)^c} are simplified to @c{$a^{b c}$} @cite{a^(b c)} only when @cite{c} is an integer and @cite{b c} also evaluates to an integer. Without these restrictions these simplifications would not be safe because of problems with principal values. (In other words, @c{$((-3)^{1/2})^2$} @cite{((-3)^1:2)^2} is safe to simplify, but @c{$((-3)^2)^{1/2}$} @cite{((-3)^2)^1:2} is not.) @xref{Declarations}, for ways to inform Calc that your variables satisfy these requirements. As a special case of this rule, @cite{@t{sqrt}(x)^n} is simplified to @c{$x^{n/2}$} @cite{x^(n/2)} only for even integers @cite{n}. If @cite{a} is known to be real, @cite{b} is an even integer, and @cite{c} is a half- or quarter-integer, then @cite{(a^b)^c} is simplified to @c{$@t{abs}(a^{b c})$} @cite{@t{abs}(a^(b c))}. Also, @cite{(-a)^b} is simplified to @cite{a^b} if @cite{b} is an even integer, or to @cite{-(a^b)} if @cite{b} is an odd integer, for any negative-looking expression @cite{-a}. Square roots @cite{@t{sqrt}(x)} generally act like one-half powers @c{$x^{1:2}$} @cite{x^1:2} for the purposes of the above-listed simplifications. Also, note that @c{$1 / x^{1:2}$} @cite{1 / x^1:2} is changed to @c{$x^{-1:2}$} @cite{x^(-1:2)}, but @cite{1 / @t{sqrt}(x)} is left alone. @tex \bigskip @end tex Generic identity matrices (@pxref{Matrix Mode}) are simplified by the following rules: @cite{@t{idn}(a) + b} to @cite{a + b} if @cite{b} is provably scalar, or expanded out if @cite{b} is a matrix; @cite{@t{idn}(a) + @t{idn}(b)} to @cite{@t{idn}(a + b)}; @cite{-@t{idn}(a)} to @cite{@t{idn}(-a)}; @cite{a @t{idn}(b)} to @cite{@t{idn}(a b)} if @cite{a} is provably scalar, or to @cite{a b} if @cite{a} is provably non-scalar; @cite{@t{idn}(a) @t{idn}(b)} to @cite{@t{idn}(a b)}; analogous simplifications for quotients involving @code{idn}; and @cite{@t{idn}(a)^n} to @cite{@t{idn}(a^n)} where @cite{n} is an integer. @tex \bigskip @end tex The @code{floor} function and other integer truncation functions vanish if the argument is provably integer-valued, so that @cite{@t{floor}(@t{round}(x))} simplifies to @cite{@t{round}(x)}. Also, combinations of @code{float}, @code{floor} and its friends, and @code{ffloor} and its friends, are simplified in appropriate ways. @xref{Integer Truncation}. The expression @cite{@t{abs}(-x)} changes to @cite{@t{abs}(x)}. The expression @cite{@t{abs}(@t{abs}(x))} changes to @cite{@t{abs}(x)}; in fact, @cite{@t{abs}(x)} changes to @cite{x} or @cite{-x} if @cite{x} is provably nonnegative or nonpositive (@pxref{Declarations}). While most functions do not recognize the variable @code{i} as an imaginary number, the @code{arg} function does handle the two cases @cite{@t{arg}(@t{i})} and @cite{@t{arg}(-@t{i})} just for convenience. The expression @cite{@t{conj}(@t{conj}(x))} simplifies to @cite{x}. Various other expressions involving @code{conj}, @code{re}, and @code{im} are simplified, especially if some of the arguments are provably real or involve the constant @code{i}. For example, @cite{@t{conj}(a + b i)} is changed to @cite{@t{conj}(a) - @t{conj}(b) i}, or to @cite{a - b i} if @cite{a} and @cite{b} are known to be real. Functions like @code{sin} and @code{arctan} generally don't have any default simplifications beyond simply evaluating the functions for suitable numeric arguments and infinity. The @kbd{a s} command described in the next section does provide some simplifications for these functions, though. One important simplification that does occur is that @cite{@t{ln}(@t{e})} is simplified to 1, and @cite{@t{ln}(@t{e}^x)} is simplified to @cite{x} for any @cite{x}. This occurs even if you have stored a different value in the Calc variable @samp{e}; but this would be a bad idea in any case if you were also using natural logarithms! Among the logical functions, @t{!}@i{(a} @t{<=} @i{b)} changes to @cite{a > b} and so on. Equations and inequalities where both sides are either negative-looking or zero are simplified by negating both sides and reversing the inequality. While it might seem reasonable to simplify @cite{!!x} to @cite{x}, this would not be valid in general because @cite{!!2} is 1, not 2. Most other Calc functions have few if any default simplifications defined, aside of course from evaluation when the arguments are suitable numbers. @node Algebraic Simplifications, Unsafe Simplifications, Default Simplifications, Simplifying Formulas @subsection Algebraic Simplifications @noindent @cindex Algebraic simplifications The @kbd{a s} command makes simplifications that may be too slow to do all the time, or that may not be desirable all of the time. If you find these simplifications are worthwhile, you can type @kbd{m A} to have Calc apply them automatically. This section describes all simplifications that are performed by the @kbd{a s} command. Note that these occur in addition to the default simplifications; even if the default simplifications have been turned off by an @kbd{m O} command, @kbd{a s} will turn them back on temporarily while it simplifies the formula. There is a variable, @code{AlgSimpRules}, in which you can put rewrites to be applied by @kbd{a s}. Its use is analogous to @code{EvalRules}, but without the special restrictions. Basically, the simplifier does @samp{@w{a r} AlgSimpRules} with an infinite repeat count on the whole expression being simplified, then it traverses the expression applying the built-in rules described below. If the result is different from the original expression, the process repeats with the default simplifications (including @code{EvalRules}), then @code{AlgSimpRules}, then the built-in simplifications, and so on. @tex \bigskip @end tex Sums are simplified in two ways. Constant terms are commuted to the end of the sum, so that @cite{a + 2 + b} changes to @cite{a + b + 2}. The only exception is that a constant will not be commuted away from the first position of a difference, i.e., @cite{2 - x} is not commuted to @cite{-x + 2}. Also, terms of sums are combined by the distributive law, as in @cite{x + y + 2 x} to @cite{y + 3 x}. This always occurs for adjacent terms, but @kbd{a s} compares all pairs of terms including non-adjacent ones. @tex \bigskip @end tex Products are sorted into a canonical order using the commutative law. For example, @cite{b c a} is commuted to @cite{a b c}. This allows easier comparison of products; for example, the default simplifications will not change @cite{x y + y x} to @cite{2 x y}, but @kbd{a s} will; it first rewrites the sum to @cite{x y + x y}, and then the default simplifications are able to recognize a sum of identical terms. The canonical ordering used to sort terms of products has the property that real-valued numbers, interval forms and infinities come first, and are sorted into increasing order. The @kbd{V S} command uses the same ordering when sorting a vector. Sorting of terms of products is inhibited when matrix mode is turned on; in this case, Calc will never exchange the order of two terms unless it knows at least one of the terms is a scalar. Products of powers are distributed by comparing all pairs of terms, using the same method that the default simplifications use for adjacent terms of products. Even though sums are not sorted, the commutative law is still taken into account when terms of a product are being compared. Thus @cite{(x + y) (y + x)} will be simplified to @cite{(x + y)^2}. A subtle point is that @cite{(x - y) (y - x)} will @emph{not} be simplified to @cite{-(x - y)^2}; Calc does not notice that one term can be written as a constant times the other, even if that constant is @i{-1}. A fraction times any expression, @cite{(a:b) x}, is changed to a quotient involving integers: @cite{a x / b}. This is not done for floating-point numbers like @cite{0.5}, however. This is one reason why you may find it convenient to turn Fraction mode on while doing algebra; @pxref{Fraction Mode}. @tex \bigskip @end tex Quotients are simplified by comparing all terms in the numerator with all terms in the denominator for possible cancellation using the distributive law. For example, @cite{a x^2 b / c x^3 d} will cancel @cite{x^2} from both sides to get @cite{a b / c x d}. (The terms in the denominator will then be rearranged to @cite{c d x} as described above.) If there is any common integer or fractional factor in the numerator and denominator, it is cancelled out; for example, @cite{(4 x + 6) / 8 x} simplifies to @cite{(2 x + 3) / 4 x}. Non-constant common factors are not found even by @kbd{a s}. To cancel the factor @cite{a} in @cite{(a x + a) / a^2} you could first use @kbd{j M} on the product @cite{a x} to Merge the numerator to @cite{a (1+x)}, which can then be simplified successfully. @tex \bigskip @end tex Integer powers of the variable @code{i} are simplified according to the identity @cite{i^2 = -1}. If you store a new value other than the complex number @cite{(0,1)} in @code{i}, this simplification will no longer occur. This is done by @kbd{a s} instead of by default in case someone (unwisely) uses the name @code{i} for a variable unrelated to complex numbers; it would be unfortunate if Calc quietly and automatically changed this formula for reasons the user might not have been thinking of. Square roots of integer or rational arguments are simplified in several ways. (Note that these will be left unevaluated only in Symbolic mode.) First, square integer or rational factors are pulled out so that @cite{@t{sqrt}(8)} is rewritten as @c{$2\,\t{sqrt}(2)$} @cite{2 sqrt(2)}. Conceptually speaking this implies factoring the argument into primes and moving pairs of primes out of the square root, but for reasons of efficiency Calc only looks for primes up to 29. Square roots in the denominator of a quotient are moved to the numerator: @cite{1 / @t{sqrt}(3)} changes to @cite{@t{sqrt}(3) / 3}. The same effect occurs for the square root of a fraction: @cite{@t{sqrt}(2:3)} changes to @cite{@t{sqrt}(6) / 3}. @tex \bigskip @end tex The @code{%} (modulo) operator is simplified in several ways when the modulus @cite{M} is a positive real number. First, if the argument is of the form @cite{x + n} for some real number @cite{n}, then @cite{n} is itself reduced modulo @cite{M}. For example, @samp{(x - 23) % 10} is simplified to @samp{(x + 7) % 10}. If the argument is multiplied by a constant, and this constant has a common integer divisor with the modulus, then this factor is cancelled out. For example, @samp{12 x % 15} is changed to @samp{3 (4 x % 5)} by factoring out 3. Also, @samp{(12 x + 1) % 15} is changed to @samp{3 ((4 x + 1:3) % 5)}. While these forms may not seem ``simpler,'' they allow Calc to discover useful information about modulo forms in the presence of declarations. If the modulus is 1, then Calc can use @code{int} declarations to evaluate the expression. For example, the idiom @samp{x % 2} is often used to check whether a number is odd or even. As described above, @w{@samp{2 n % 2}} and @samp{(2 n + 1) % 2} are simplified to @samp{2 (n % 1)} and @samp{2 ((n + 1:2) % 1)}, respectively; Calc can simplify these to 0 and 1 (respectively) if @code{n} has been declared to be an integer. @tex \bigskip @end tex Trigonometric functions are simplified in several ways. First, @cite{@t{sin}(@t{arcsin}(x))} is simplified to @cite{x}, and similarly for @code{cos} and @code{tan}. If the argument to @code{sin} is negative-looking, it is simplified to @cite{-@t{sin}(x)}, and similarly for @code{cos} and @code{tan}. Finally, certain special values of the argument are recognized; @pxref{Trigonometric and Hyperbolic Functions}. Trigonometric functions of inverses of different trigonometric functions can also be simplified, as in @cite{@t{sin}(@t{arccos}(x))} to @cite{@t{sqrt}(1 - x^2)}. Hyperbolic functions of their inverses and of negative-looking arguments are also handled, as are exponentials of inverse hyperbolic functions. No simplifications for inverse trigonometric and hyperbolic functions are known, except for negative arguments of @code{arcsin}, @code{arctan}, @code{arcsinh}, and @code{arctanh}. Note that @cite{@t{arcsin}(@t{sin}(x))} can @emph{not} safely change to @cite{x}, since this only correct within an integer multiple of @c{$2 \pi$} @cite{2 pi} radians or 360 degrees. However, @cite{@t{arcsinh}(@t{sinh}(x))} is simplified to @cite{x} if @cite{x} is known to be real. Several simplifications that apply to logarithms and exponentials are that @cite{@t{exp}(@t{ln}(x))}, @c{$@t{e}^{\ln(x)}$} @cite{e^@t{ln}(x)}, and @c{$10^{{\rm log10}(x)}$} @cite{10^@t{log10}(x)} all reduce to @cite{x}. Also, @cite{@t{ln}(@t{exp}(x))}, etc., can reduce to @cite{x} if @cite{x} is provably real. The form @cite{@t{exp}(x)^y} is simplified to @cite{@t{exp}(x y)}. If @cite{x} is a suitable multiple of @c{$\pi i$} @cite{pi i} (as described above for the trigonometric functions), then @cite{@t{exp}(x)} or @cite{e^x} will be expanded. Finally, @cite{@t{ln}(x)} is simplified to a form involving @code{pi} and @code{i} where @cite{x} is provably negative, positive imaginary, or negative imaginary. The error functions @code{erf} and @code{erfc} are simplified when their arguments are negative-looking or are calls to the @code{conj} function. @tex \bigskip @end tex Equations and inequalities are simplified by cancelling factors of products, quotients, or sums on both sides. Inequalities change sign if a negative multiplicative factor is cancelled. Non-constant multiplicative factors as in @cite{a b = a c} are cancelled from equations only if they are provably nonzero (generally because they were declared so; @pxref{Declarations}). Factors are cancelled from inequalities only if they are nonzero and their sign is known. Simplification also replaces an equation or inequality with 1 or 0 (``true'' or ``false'') if it can through the use of declarations. If @cite{x} is declared to be an integer greater than 5, then @cite{x < 3}, @cite{x = 3}, and @cite{x = 7.5} are all simplified to 0, but @cite{x > 3} is simplified to 1. By a similar analysis, @cite{abs(x) >= 0} is simplified to 1, as is @cite{x^2 >= 0} if @cite{x} is known to be real. @node Unsafe Simplifications, Simplification of Units, Algebraic Simplifications, Simplifying Formulas @subsection ``Unsafe'' Simplifications @noindent @cindex Unsafe simplifications @cindex Extended simplification @kindex a e @pindex calc-simplify-extended @c @mindex esimpl@idots @tindex esimplify The @kbd{a e} (@code{calc-simplify-extended}) [@code{esimplify}] command is like @kbd{a s} except that it applies some additional simplifications which are not ``safe'' in all cases. Use this only if you know the values in your formula lie in the restricted ranges for which these simplifications are valid. The symbolic integrator uses @kbd{a e}; one effect of this is that the integrator's results must be used with caution. Where an integral table will often attach conditions like ``for positive @cite{a} only,'' Calc (like most other symbolic integration programs) will simply produce an unqualified result.@refill Because @kbd{a e}'s simplifications are unsafe, it is sometimes better to type @kbd{C-u -3 a v}, which does extended simplification only on the top level of the formula without affecting the sub-formulas. In fact, @kbd{C-u -3 j v} allows you to target extended simplification to any specific part of a formula. The variable @code{ExtSimpRules} contains rewrites to be applied by the @kbd{a e} command. These are applied in addition to @code{EvalRules} and @code{AlgSimpRules}. (The @kbd{a r AlgSimpRules} step described above is simply followed by an @kbd{a r ExtSimpRules} step.) Following is a complete list of ``unsafe'' simplifications performed by @kbd{a e}. @tex \bigskip @end tex Inverse trigonometric or hyperbolic functions, called with their corresponding non-inverse functions as arguments, are simplified by @kbd{a e}. For example, @cite{@t{arcsin}(@t{sin}(x))} changes to @cite{x}. Also, @cite{@t{arcsin}(@t{cos}(x))} and @cite{@t{arccos}(@t{sin}(x))} both change to @cite{@t{pi}/2 - x}. These simplifications are unsafe because they are valid only for values of @cite{x} in a certain range; outside that range, values are folded down to the 360-degree range that the inverse trigonometric functions always produce. Powers of powers @cite{(x^a)^b} are simplified to @c{$x^{a b}$} @cite{x^(a b)} for all @cite{a} and @cite{b}. These results will be valid only in a restricted range of @cite{x}; for example, in @c{$(x^2)^{1:2}$} @cite{(x^2)^1:2} the powers cancel to get @cite{x}, which is valid for positive values of @cite{x} but not for negative or complex values. Similarly, @cite{@t{sqrt}(x^a)} and @cite{@t{sqrt}(x)^a} are both simplified (possibly unsafely) to @c{$x^{a/2}$} @cite{x^(a/2)}. Forms like @cite{@t{sqrt}(1 - @t{sin}(x)^2)} are simplified to, e.g., @cite{@t{cos}(x)}. Calc has identities of this sort for @code{sin}, @code{cos}, @code{tan}, @code{sinh}, and @code{cosh}. Arguments of square roots are partially factored to look for squared terms that can be extracted. For example, @cite{@t{sqrt}(a^2 b^3 + a^3 b^2)} simplifies to @cite{a b @t{sqrt}(a+b)}. The simplifications of @cite{@t{ln}(@t{exp}(x))}, @cite{@t{ln}(@t{e}^x)}, and @cite{@t{log10}(10^x)} to @cite{x} are also unsafe because of problems with principal values (although these simplifications are safe if @cite{x} is known to be real). Common factors are cancelled from products on both sides of an equation, even if those factors may be zero: @cite{a x / b x} to @cite{a / b}. Such factors are never cancelled from inequalities: Even @kbd{a e} is not bold enough to reduce @cite{a x < b x} to @cite{a < b} (or @cite{a > b}, depending on whether you believe @cite{x} is positive or negative). The @kbd{a M /} command can be used to divide a factor out of both sides of an inequality. @node Simplification of Units, , Unsafe Simplifications, Simplifying Formulas @subsection Simplification of Units @noindent The simplifications described in this section are applied by the @kbd{u s} (@code{calc-simplify-units}) command. These are in addition to the regular @kbd{a s} (but not @kbd{a e}) simplifications described earlier. @xref{Basic Operations on Units}. The variable @code{UnitSimpRules} contains rewrites to be applied by the @kbd{u s} command. These are applied in addition to @code{EvalRules} and @code{AlgSimpRules}. Scalar mode is automatically put into effect when simplifying units. @xref{Matrix Mode}. Sums @cite{a + b} involving units are simplified by extracting the units of @cite{a} as if by the @kbd{u x} command (call the result @cite{u_a}), then simplifying the expression @cite{b / u_a} using @kbd{u b} and @kbd{u s}. If the result has units then the sum is inconsistent and is left alone. Otherwise, it is rewritten in terms of the units @cite{u_a}. If units auto-ranging mode is enabled, products or quotients in which the first argument is a number which is out of range for the leading unit are modified accordingly. When cancelling and combining units in products and quotients, Calc accounts for unit names that differ only in the prefix letter. For example, @samp{2 km m} is simplified to @samp{2000 m^2}. However, compatible but different units like @code{ft} and @code{in} are not combined in this way. Quotients @cite{a / b} are simplified in three additional ways. First, if @cite{b} is a number or a product beginning with a number, Calc computes the reciprocal of this number and moves it to the numerator. Second, for each pair of unit names from the numerator and denominator of a quotient, if the units are compatible (e.g., they are both units of area) then they are replaced by the ratio between those units. For example, in @samp{3 s in N / kg cm} the units @samp{in / cm} will be replaced by @cite{2.54}. Third, if the units in the quotient exactly cancel out, so that a @kbd{u b} command on the quotient would produce a dimensionless number for an answer, then the quotient simplifies to that number. For powers and square roots, the ``unsafe'' simplifications @cite{(a b)^c} to @cite{a^c b^c}, @cite{(a/b)^c} to @cite{a^c / b^c}, and @cite{(a^b)^c} to @c{$a^{b c}$} @cite{a^(b c)} are done if the powers are real numbers. (These are safe in the context of units because all numbers involved can reasonably be assumed to be real.) Also, if a unit name is raised to a fractional power, and the base units in that unit name all occur to powers which are a multiple of the denominator of the power, then the unit name is expanded out into its base units, which can then be simplified according to the previous paragraph. For example, @samp{acre^1.5} is simplified by noting that @cite{1.5 = 3:2}, that @samp{acre} is defined in terms of @samp{m^2}, and that the 2 in the power of @code{m} is a multiple of 2 in @cite{3:2}. Thus, @code{acre^1.5} is replaced by approximately @c{$(4046 m^2)^{1.5}$} @cite{(4046 m^2)^1.5}, which is then changed to @c{$4046^{1.5} \, (m^2)^{1.5}$} @cite{4046^1.5 (m^2)^1.5}, then to @cite{257440 m^3}. The functions @code{float}, @code{frac}, @code{clean}, @code{abs}, as well as @code{floor} and the other integer truncation functions, applied to unit names or products or quotients involving units, are simplified. For example, @samp{round(1.6 in)} is changed to @samp{round(1.6) round(in)}; the lefthand term evaluates to 2, and the righthand term simplifies to @code{in}. The functions @code{sin}, @code{cos}, and @code{tan} with arguments that have angular units like @code{rad} or @code{arcmin} are simplified by converting to base units (radians), then evaluating with the angular mode temporarily set to radians. @node Polynomials, Calculus, Simplifying Formulas, Algebra @section Polynomials A @dfn{polynomial} is a sum of terms which are coefficients times various powers of a ``base'' variable. For example, @cite{2 x^2 + 3 x - 4} is a polynomial in @cite{x}. Some formulas can be considered polynomials in several different variables: @cite{1 + 2 x + 3 y + 4 x y^2} is a polynomial in both @cite{x} and @cite{y}. Polynomial coefficients are often numbers, but they may in general be any formulas not involving the base variable. @kindex a f @pindex calc-factor @tindex factor The @kbd{a f} (@code{calc-factor}) [@code{factor}] command factors a polynomial into a product of terms. For example, the polynomial @cite{x^3 + 2 x^2 + x} is factored into @samp{x*(x+1)^2}. As another example, @cite{a c + b d + b c + a d} is factored into the product @cite{(a + b) (c + d)}. Calc currently has three algorithms for factoring. Formulas which are linear in several variables, such as the second example above, are merged according to the distributive law. Formulas which are polynomials in a single variable, with constant integer or fractional coefficients, are factored into irreducible linear and/or quadratic terms. The first example above factors into three linear terms (@cite{x}, @cite{x+1}, and @cite{x+1} again). Finally, formulas which do not fit the above criteria are handled by the algebraic rewrite mechanism. Calc's polynomial factorization algorithm works by using the general root-finding command (@w{@kbd{a P}}) to solve for the roots of the polynomial. It then looks for roots which are rational numbers or complex-conjugate pairs, and converts these into linear and quadratic terms, respectively. Because it uses floating-point arithmetic, it may be unable to find terms that involve large integers (whose number of digits approaches the current precision). Also, irreducible factors of degree higher than quadratic are not found, and polynomials in more than one variable are not treated. (A more robust factorization algorithm may be included in a future version of Calc.) @vindex FactorRules @c @starindex @tindex thecoefs @c @starindex @c @mindex @idots @tindex thefactors The rewrite-based factorization method uses rules stored in the variable @code{FactorRules}. @xref{Rewrite Rules}, for a discussion of the operation of rewrite rules. The default @code{FactorRules} are able to factor quadratic forms symbolically into two linear terms, @cite{(a x + b) (c x + d)}. You can edit these rules to include other cases if you wish. To use the rules, Calc builds the formula @samp{thecoefs(x, [a, b, c, ...])} where @code{x} is the polynomial base variable and @code{a}, @code{b}, etc., are polynomial coefficients (which may be numbers or formulas). The constant term is written first, i.e., in the @code{a} position. When the rules complete, they should have changed the formula into the form @samp{thefactors(x, [f1, f2, f3, ...])} where each @code{fi} should be a factored term, e.g., @samp{x - ai}. Calc then multiplies these terms together to get the complete factored form of the polynomial. If the rules do not change the @code{thecoefs} call to a @code{thefactors} call, @kbd{a f} leaves the polynomial alone on the assumption that it is unfactorable. (Note that the function names @code{thecoefs} and @code{thefactors} are used only as placeholders; there are no actual Calc functions by those names.) @kindex H a f @tindex factors The @kbd{H a f} [@code{factors}] command also factors a polynomial, but it returns a list of factors instead of an expression which is the product of the factors. Each factor is represented by a sub-vector of the factor, and the power with which it appears. For example, @cite{x^5 + x^4 - 33 x^3 + 63 x^2} factors to @cite{(x + 7) x^2 (x - 3)^2} in @kbd{a f}, or to @cite{[ [x, 2], [x+7, 1], [x-3, 2] ]} in @kbd{H a f}. If there is an overall numeric factor, it always comes first in the list. The functions @code{factor} and @code{factors} allow a second argument when written in algebraic form; @samp{factor(x,v)} factors @cite{x} with respect to the specific variable @cite{v}. The default is to factor with respect to all the variables that appear in @cite{x}. @kindex a c @pindex calc-collect @tindex collect The @kbd{a c} (@code{calc-collect}) [@code{collect}] command rearranges a formula as a polynomial in a given variable, ordered in decreasing powers of that variable. For example, given @cite{1 + 2 x + 3 y + 4 x y^2} on the stack, @kbd{a c x} would produce @cite{(2 + 4 y^2) x + (1 + 3 y)}, and @kbd{a c y} would produce @cite{(4 x) y^2 + 3 y + (1 + 2 x)}. The polynomial will be expanded out using the distributive law as necessary: Collecting @cite{x} in @cite{(x - 1)^3} produces @cite{x^3 - 3 x^2 + 3 x - 1}. Terms not involving @cite{x} will not be expanded. The ``variable'' you specify at the prompt can actually be any expression: @kbd{a c ln(x+1)} will collect together all terms multiplied by @samp{ln(x+1)} or integer powers thereof. If @samp{x} also appears in the formula in a context other than @samp{ln(x+1)}, @kbd{a c} will treat those occurrences as unrelated to @samp{ln(x+1)}, i.e., as constants. @kindex a x @pindex calc-expand @tindex expand The @kbd{a x} (@code{calc-expand}) [@code{expand}] command expands an expression by applying the distributive law everywhere. It applies to products, quotients, and powers involving sums. By default, it fully distributes all parts of the expression. With a numeric prefix argument, the distributive law is applied only the specified number of times, then the partially expanded expression is left on the stack. The @kbd{a x} and @kbd{j D} commands are somewhat redundant. Use @kbd{a x} if you want to expand all products of sums in your formula. Use @kbd{j D} if you want to expand a particular specified term of the formula. There is an exactly analogous correspondence between @kbd{a f} and @kbd{j M}. (The @kbd{j D} and @kbd{j M} commands also know many other kinds of expansions, such as @samp{exp(a + b) = exp(a) exp(b)}, which @kbd{a x} and @kbd{a f} do not do.) Calc's automatic simplifications will sometimes reverse a partial expansion. For example, the first step in expanding @cite{(x+1)^3} is to write @cite{(x+1) (x+1)^2}. If @kbd{a x} stops there and tries to put this formula onto the stack, though, Calc will automatically simplify it back to @cite{(x+1)^3} form. The solution is to turn simplification off first (@pxref{Simplification Modes}), or to run @kbd{a x} without a numeric prefix argument so that it expands all the way in one step. @kindex a a @pindex calc-apart @tindex apart The @kbd{a a} (@code{calc-apart}) [@code{apart}] command expands a rational function by partial fractions. A rational function is the quotient of two polynomials; @code{apart} pulls this apart into a sum of rational functions with simple denominators. In algebraic notation, the @code{apart} function allows a second argument that specifies which variable to use as the ``base''; by default, Calc chooses the base variable automatically. @kindex a n @pindex calc-normalize-rat @tindex nrat The @kbd{a n} (@code{calc-normalize-rat}) [@code{nrat}] command attempts to arrange a formula into a quotient of two polynomials. For example, given @cite{1 + (a + b/c) / d}, the result would be @cite{(b + a c + c d) / c d}. The quotient is reduced, so that @kbd{a n} will simplify @cite{(x^2 + 2x + 1) / (x^2 - 1)} by dividing out the common factor @cite{x + 1}, yielding @cite{(x + 1) / (x - 1)}. @kindex a \ @pindex calc-poly-div @tindex pdiv The @kbd{a \} (@code{calc-poly-div}) [@code{pdiv}] command divides two polynomials @cite{u} and @cite{v}, yielding a new polynomial @cite{q}. If several variables occur in the inputs, the inputs are considered multivariate polynomials. (Calc divides by the variable with the largest power in @cite{u} first, or, in the case of equal powers, chooses the variables in alphabetical order.) For example, dividing @cite{x^2 + 3 x + 2} by @cite{x + 2} yields @cite{x + 1}. The remainder from the division, if any, is reported at the bottom of the screen and is also placed in the Trail along with the quotient. Using @code{pdiv} in algebraic notation, you can specify the particular variable to be used as the base: `@t{pdiv(}@i{a}@t{,}@i{b}@t{,}@i{x}@t{)}'. If @code{pdiv} is given only two arguments (as is always the case with the @kbd{a \} command), then it does a multivariate division as outlined above. @kindex a % @pindex calc-poly-rem @tindex prem The @kbd{a %} (@code{calc-poly-rem}) [@code{prem}] command divides two polynomials and keeps the remainder @cite{r}. The quotient @cite{q} is discarded. For any formulas @cite{a} and @cite{b}, the results of @kbd{a \} and @kbd{a %} satisfy @cite{a = q b + r}. (This is analogous to plain @kbd{\} and @kbd{%}, which compute the integer quotient and remainder from dividing two numbers.) @kindex a / @kindex H a / @pindex calc-poly-div-rem @tindex pdivrem @tindex pdivide The @kbd{a /} (@code{calc-poly-div-rem}) [@code{pdivrem}] command divides two polynomials and reports both the quotient and the remainder as a vector @cite{[q, r]}. The @kbd{H a /} [@code{pdivide}] command divides two polynomials and constructs the formula @cite{q + r/b} on the stack. (Naturally if the remainder is zero, this will immediately simplify to @cite{q}.) @kindex a g @pindex calc-poly-gcd @tindex pgcd The @kbd{a g} (@code{calc-poly-gcd}) [@code{pgcd}] command computes the greatest common divisor of two polynomials. (The GCD actually is unique only to within a constant multiplier; Calc attempts to choose a GCD which will be unsurprising.) For example, the @kbd{a n} command uses @kbd{a g} to take the GCD of the numerator and denominator of a quotient, then divides each by the result using @kbd{a \}. (The definition of GCD ensures that this division can take place without leaving a remainder.) While the polynomials used in operations like @kbd{a /} and @kbd{a g} often have integer coefficients, this is not required. Calc can also deal with polynomials over the rationals or floating-point reals. Polynomials with modulo-form coefficients are also useful in many applications; if you enter @samp{(x^2 + 3 x - 1) mod 5}, Calc automatically transforms this into a polynomial over the field of integers mod 5: @samp{(1 mod 5) x^2 + (3 mod 5) x + (4 mod 5)}. Congratulations and thanks go to Ove Ewerlid (@code{ewerlid@@mizar.DoCS.UU.SE}), who contributed many of the polynomial routines used in the above commands. @xref{Decomposing Polynomials}, for several useful functions for extracting the individual coefficients of a polynomial. @node Calculus, Solving Equations, Polynomials, Algebra @section Calculus @noindent The following calculus commands do not automatically simplify their inputs or outputs using @code{calc-simplify}. You may find it helps to do this by hand by typing @kbd{a s} or @kbd{a e}. It may also help to use @kbd{a x} and/or @kbd{a c} to arrange a result in the most readable way. @menu * Differentiation:: * Integration:: * Customizing the Integrator:: * Numerical Integration:: * Taylor Series:: @end menu @node Differentiation, Integration, Calculus, Calculus @subsection Differentiation @noindent @kindex a d @kindex H a d @pindex calc-derivative @tindex deriv @tindex tderiv The @kbd{a d} (@code{calc-derivative}) [@code{deriv}] command computes the derivative of the expression on the top of the stack with respect to some variable, which it will prompt you to enter. Normally, variables in the formula other than the specified differentiation variable are considered constant, i.e., @samp{deriv(y,x)} is reduced to zero. With the Hyperbolic flag, the @code{tderiv} (total derivative) operation is used instead, in which derivatives of variables are not reduced to zero unless those variables are known to be ``constant,'' i.e., independent of any other variables. (The built-in special variables like @code{pi} are considered constant, as are variables that have been declared @code{const}; @pxref{Declarations}.) With a numeric prefix argument @var{n}, this command computes the @var{n}th derivative. When working with trigonometric functions, it is best to switch to radians mode first (with @w{@kbd{m r}}). The derivative of @samp{sin(x)} in degrees is @samp{(pi/180) cos(x)}, probably not the expected answer! If you use the @code{deriv} function directly in an algebraic formula, you can write @samp{deriv(f,x,x0)} which represents the derivative of @cite{f} with respect to @cite{x}, evaluated at the point @c{$x=x_0$} @cite{x=x0}. If the formula being differentiated contains functions which Calc does not know, the derivatives of those functions are produced by adding primes (apostrophe characters). For example, @samp{deriv(f(2x), x)} produces @samp{2 f'(2 x)}, where the function @code{f'} represents the derivative of @code{f}. For functions you have defined with the @kbd{Z F} command, Calc expands the functions according to their defining formulas unless you have also defined @code{f'} suitably. For example, suppose we define @samp{sinc(x) = sin(x)/x} using @kbd{Z F}. If we then differentiate the formula @samp{sinc(2 x)}, the formula will be expanded to @samp{sin(2 x) / (2 x)} and differentiated. However, if we also define @samp{sinc'(x) = dsinc(x)}, say, then Calc will write the result as @samp{2 dsinc(2 x)}. @xref{Algebraic Definitions}. For multi-argument functions @samp{f(x,y,z)}, the derivative with respect to the first argument is written @samp{f'(x,y,z)}; derivatives with respect to the other arguments are @samp{f'2(x,y,z)} and @samp{f'3(x,y,z)}. Various higher-order derivatives can be formed in the obvious way, e.g., @samp{f'@var{}'(x)} (the second derivative of @code{f}) or @samp{f'@var{}'2'3(x,y,z)} (@code{f} differentiated with respect to each argument once).@refill @node Integration, Customizing the Integrator, Differentiation, Calculus @subsection Integration @noindent @kindex a i @pindex calc-integral @tindex integ The @kbd{a i} (@code{calc-integral}) [@code{integ}] command computes the indefinite integral of the expression on the top of the stack with respect to a variable. The integrator is not guaranteed to work for all integrable functions, but it is able to integrate several large classes of formulas. In particular, any polynomial or rational function (a polynomial divided by a polynomial) is acceptable. (Rational functions don't have to be in explicit quotient form, however; @c{$x/(1+x^{-2})$} @cite{x/(1+x^-2)} is not strictly a quotient of polynomials, but it is equivalent to @cite{x^3/(x^2+1)}, which is.) Also, square roots of terms involving @cite{x} and @cite{x^2} may appear in rational functions being integrated. Finally, rational functions involving trigonometric or hyperbolic functions can be integrated. @ifinfo If you use the @code{integ} function directly in an algebraic formula, you can also write @samp{integ(f,x,v)} which expresses the resulting indefinite integral in terms of variable @code{v} instead of @code{x}. With four arguments, @samp{integ(f(x),x,a,b)} represents a definite integral from @code{a} to @code{b}. @end ifinfo @tex If you use the @code{integ} function directly in an algebraic formula, you can also write @samp{integ(f,x,v)} which expresses the resulting indefinite integral in terms of variable @code{v} instead of @code{x}. With four arguments, @samp{integ(f(x),x,a,b)} represents a definite integral $\int_a^b f(x) \, dx$. @end tex Please note that the current implementation of Calc's integrator sometimes produces results that are significantly more complex than they need to be. For example, the integral Calc finds for @c{$1/(x+\sqrt{x^2+1})$} @cite{1/(x+sqrt(x^2+1))} is several times more complicated than the answer Mathematica returns for the same input, although the two forms are numerically equivalent. Also, any indefinite integral should be considered to have an arbitrary constant of integration added to it, although Calc does not write an explicit constant of integration in its result. For example, Calc's solution for @c{$1/(1+\tan x)$} @cite{1/(1+tan(x))} differs from the solution given in the @emph{CRC Math Tables} by a constant factor of @c{$\pi i / 2$} @cite{pi i / 2}, due to a different choice of constant of integration. The Calculator remembers all the integrals it has done. If conditions change in a way that would invalidate the old integrals, say, a switch from degrees to radians mode, then they will be thrown out. If you suspect this is not happening when it should, use the @code{calc-flush-caches} command; @pxref{Caches}. @vindex IntegLimit Calc normally will pursue integration by substitution or integration by parts up to 3 nested times before abandoning an approach as fruitless. If the integrator is taking too long, you can lower this limit by storing a number (like 2) in the variable @code{IntegLimit}. (The @kbd{s I} command is a convenient way to edit @code{IntegLimit}.) If this variable has no stored value or does not contain a nonnegative integer, a limit of 3 is used. The lower this limit is, the greater the chance that Calc will be unable to integrate a function it could otherwise handle. Raising this limit allows the Calculator to solve more integrals, though the time it takes may grow exponentially. You can monitor the integrator's actions by creating an Emacs buffer called @code{*Trace*}. If such a buffer exists, the @kbd{a i} command will write a log of its actions there. If you want to manipulate integrals in a purely symbolic way, you can set the integration nesting limit to 0 to prevent all but fast table-lookup solutions of integrals. You might then wish to define rewrite rules for integration by parts, various kinds of substitutions, and so on. @xref{Rewrite Rules}. @node Customizing the Integrator, Numerical Integration, Integration, Calculus @subsection Customizing the Integrator @noindent @vindex IntegRules Calc has two built-in rewrite rules called @code{IntegRules} and @code{IntegAfterRules} which you can edit to define new integration methods. @xref{Rewrite Rules}. At each step of the integration process, Calc wraps the current integrand in a call to the fictitious function @samp{integtry(@var{expr},@var{var})}, where @var{expr} is the integrand and @var{var} is the integration variable. If your rules rewrite this to be a plain formula (not a call to @code{integtry}), then Calc will use this formula as the integral of @var{expr}. For example, the rule @samp{integtry(mysin(x),x) := -mycos(x)} would define a rule to integrate a function @code{mysin} that acts like the sine function. Then, putting @samp{4 mysin(2y+1)} on the stack and typing @kbd{a i y} will produce the integral @samp{-2 mycos(2y+1)}. Note that Calc has automatically made various transformations on the integral to allow it to use your rule; integral tables generally give rules for @samp{mysin(a x + b)}, but you don't need to use this much generality in your @code{IntegRules}. @cindex Exponential integral Ei(x) @c @starindex @tindex Ei As a more serious example, the expression @samp{exp(x)/x} cannot be integrated in terms of the standard functions, so the ``exponential integral'' function @c{${\rm Ei}(x)$} @cite{Ei(x)} was invented to describe it. We can get Calc to do this integral in terms of a made-up @code{Ei} function by adding the rule @samp{[integtry(exp(x)/x, x) := Ei(x)]} to @code{IntegRules}. Now entering @samp{exp(2x)/x} on the stack and typing @kbd{a i x} yields @samp{Ei(2 x)}. This new rule will work with Calc's various built-in integration methods (such as integration by substitution) to solve a variety of other problems involving @code{Ei}: For example, now Calc will also be able to integrate @samp{exp(exp(x))} and @samp{ln(ln(x))} (to get @samp{Ei(exp(x))} and @samp{x ln(ln(x)) - Ei(ln(x))}, respectively). Your rule may do further integration by calling @code{integ}. For example, @samp{integtry(twice(u),x) := twice(integ(u))} allows Calc to integrate @samp{twice(sin(x))} to get @samp{twice(-cos(x))}. Note that @code{integ} was called with only one argument. This notation is allowed only within @code{IntegRules}; it means ``integrate this with respect to the same integration variable.'' If Calc is unable to integrate @code{u}, the integration that invoked @code{IntegRules} also fails. Thus integrating @samp{twice(f(x))} fails, returning the unevaluated integral @samp{integ(twice(f(x)), x)}. It is still legal to call @code{integ} with two or more arguments, however; in this case, if @code{u} is not integrable, @code{twice} itself will still be integrated: If the above rule is changed to @samp{... := twice(integ(u,x))}, then integrating @samp{twice(f(x))} will yield @samp{twice(integ(f(x),x))}. If a rule instead produces the formula @samp{integsubst(@var{sexpr}, @var{svar})}, either replacing the top-level @code{integtry} call or nested anywhere inside the expression, then Calc will apply the substitution @samp{@var{u} = @var{sexpr}(@var{svar})} to try to integrate the original @var{expr}. For example, the rule @samp{sqrt(a) := integsubst(sqrt(x),x)} says that if Calc ever finds a square root in the integrand, it should attempt the substitution @samp{u = sqrt(x)}. (This particular rule is unnecessary because Calc always tries ``obvious'' substitutions where @var{sexpr} actually appears in the integrand.) The variable @var{svar} may be the same as the @var{var} that appeared in the call to @code{integtry}, but it need not be. When integrating according to an @code{integsubst}, Calc uses the equation solver to find the inverse of @var{sexpr} (if the integrand refers to @var{var} anywhere except in subexpressions that exactly match @var{sexpr}). It uses the differentiator to find the derivative of @var{sexpr} and/or its inverse (it has two methods that use one derivative or the other). You can also specify these items by adding extra arguments to the @code{integsubst} your rules construct; the general form is @samp{integsubst(@var{sexpr}, @var{svar}, @var{sinv}, @var{sprime})}, where @var{sinv} is the inverse of @var{sexpr} (still written as a function of @var{svar}), and @var{sprime} is the derivative of @var{sexpr} with respect to @var{svar}. If you don't specify these things, and Calc is not able to work them out on its own with the information it knows, then your substitution rule will work only in very specific, simple cases. Calc applies @code{IntegRules} as if by @kbd{C-u 1 a r IntegRules}; in other words, Calc stops rewriting as soon as any rule in your rule set succeeds. (If it weren't for this, the @samp{integsubst(sqrt(x),x)} example above would keep on adding layers of @code{integsubst} calls forever!) @vindex IntegSimpRules Another set of rules, stored in @code{IntegSimpRules}, are applied every time the integrator uses @kbd{a s} to simplify an intermediate result. For example, putting the rule @samp{twice(x) := 2 x} into @code{IntegSimpRules} would tell Calc to convert the @code{twice} function into a form it knows whenever integration is attempted. One more way to influence the integrator is to define a function with the @kbd{Z F} command (@pxref{Algebraic Definitions}). Calc's integrator automatically expands such functions according to their defining formulas, even if you originally asked for the function to be left unevaluated for symbolic arguments. (Certain other Calc systems, such as the differentiator and the equation solver, also do this.) @vindex IntegAfterRules Sometimes Calc is able to find a solution to your integral, but it expresses the result in a way that is unnecessarily complicated. If this happens, you can either use @code{integsubst} as described above to try to hint at a more direct path to the desired result, or you can use @code{IntegAfterRules}. This is an extra rule set that runs after the main integrator returns its result; basically, Calc does an @kbd{a r IntegAfterRules} on the result before showing it to you. (It also does an @kbd{a s}, without @code{IntegSimpRules}, after that to further simplify the result.) For example, Calc's integrator sometimes produces expressions of the form @samp{ln(1+x) - ln(1-x)}; the default @code{IntegAfterRules} rewrite this into the more readable form @samp{2 arctanh(x)}. Note that, unlike @code{IntegRules}, @code{IntegSimpRules} and @code{IntegAfterRules} are applied any number of times until no further changes are possible. Rewriting by @code{IntegAfterRules} occurs only after the main integrator has finished, not at every step as for @code{IntegRules} and @code{IntegSimpRules}. @node Numerical Integration, Taylor Series, Customizing the Integrator, Calculus @subsection Numerical Integration @noindent @kindex a I @pindex calc-num-integral @tindex ninteg If you want a purely numerical answer to an integration problem, you can use the @kbd{a I} (@code{calc-num-integral}) [@code{ninteg}] command. This command prompts for an integration variable, a lower limit, and an upper limit. Except for the integration variable, all other variables that appear in the integrand formula must have stored values. (A stored value, if any, for the integration variable itself is ignored.) Numerical integration works by evaluating your formula at many points in the specified interval. Calc uses an ``open Romberg'' method; this means that it does not evaluate the formula actually at the endpoints (so that it is safe to integrate @samp{sin(x)/x} from zero, for example). Also, the Romberg method works especially well when the function being integrated is fairly smooth. If the function is not smooth, Calc will have to evaluate it at quite a few points before it can accurately determine the value of the integral. Integration is much faster when the current precision is small. It is best to set the precision to the smallest acceptable number of digits before you use @kbd{a I}. If Calc appears to be taking too long, press @kbd{C-g} to halt it and try a lower precision. If Calc still appears to need hundreds of evaluations, check to make sure your function is well-behaved in the specified interval. It is possible for the lower integration limit to be @samp{-inf} (minus infinity). Likewise, the upper limit may be plus infinity. Calc internally transforms the integral into an equivalent one with finite limits. However, integration to or across singularities is not supported: The integral of @samp{1/sqrt(x)} from 0 to 1 exists (it can be found by Calc's symbolic integrator, for example), but @kbd{a I} will fail because the integrand goes to infinity at one of the endpoints. @node Taylor Series, , Numerical Integration, Calculus @subsection Taylor Series @noindent @kindex a t @pindex calc-taylor @tindex taylor The @kbd{a t} (@code{calc-taylor}) [@code{taylor}] command computes a power series expansion or Taylor series of a function. You specify the variable and the desired number of terms. You may give an expression of the form @samp{@var{var} = @var{a}} or @samp{@var{var} - @var{a}} instead of just a variable to produce a Taylor expansion about the point @var{a}. You may specify the number of terms with a numeric prefix argument; otherwise the command will prompt you for the number of terms. Note that many series expansions have coefficients of zero for some terms, so you may appear to get fewer terms than you asked for.@refill If the @kbd{a i} command is unable to find a symbolic integral for a function, you can get an approximation by integrating the function's Taylor series. @node Solving Equations, Numerical Solutions, Calculus, Algebra @section Solving Equations @noindent @kindex a S @pindex calc-solve-for @tindex solve @cindex Equations, solving @cindex Solving equations The @kbd{a S} (@code{calc-solve-for}) [@code{solve}] command rearranges an equation to solve for a specific variable. An equation is an expression of the form @cite{L = R}. For example, the command @kbd{a S x} will rearrange @cite{y = 3x + 6} to the form, @cite{x = y/3 - 2}. If the input is not an equation, it is treated like an equation of the form @cite{X = 0}. This command also works for inequalities, as in @cite{y < 3x + 6}. Some inequalities cannot be solved where the analogous equation could be; for example, solving @c{$a < b \, c$} @cite{a < b c} for @cite{b} is impossible without knowing the sign of @cite{c}. In this case, @kbd{a S} will produce the result @c{$b \mathbin{\hbox{\code{!=}}} a/c$} @cite{b != a/c} (using the not-equal-to operator) to signify that the direction of the inequality is now unknown. The inequality @c{$a \le b \, c$} @cite{a <= b c} is not even partially solved. @xref{Declarations}, for a way to tell Calc that the signs of the variables in a formula are in fact known. Two useful commands for working with the result of @kbd{a S} are @kbd{a .} (@pxref{Logical Operations}), which converts @cite{x = y/3 - 2} to @cite{y/3 - 2}, and @kbd{s l} (@pxref{Let Command}) which evaluates another formula with @cite{x} set equal to @cite{y/3 - 2}. @menu * Multiple Solutions:: * Solving Systems of Equations:: * Decomposing Polynomials:: @end menu @node Multiple Solutions, Solving Systems of Equations, Solving Equations, Solving Equations @subsection Multiple Solutions @noindent @kindex H a S @tindex fsolve Some equations have more than one solution. The Hyperbolic flag (@code{H a S}) [@code{fsolve}] tells the solver to report the fully general family of solutions. It will invent variables @code{n1}, @code{n2}, @dots{}, which represent independent arbitrary integers, and @code{s1}, @code{s2}, @dots{}, which represent independent arbitrary signs (either @i{+1} or @i{-1}). If you don't use the Hyperbolic flag, Calc will use zero in place of all arbitrary integers, and plus one in place of all arbitrary signs. Note that variables like @code{n1} and @code{s1} are not given any special interpretation in Calc except by the equation solver itself. As usual, you can use the @w{@kbd{s l}} (@code{calc-let}) command to obtain solutions for various actual values of these variables. For example, @kbd{' x^2 = y @key{RET} H a S x @key{RET}} solves to get @samp{x = s1 sqrt(y)}, indicating that the two solutions to the equation are @samp{sqrt(y)} and @samp{-sqrt(y)}. Another way to think about it is that the square-root operation is really a two-valued function; since every Calc function must return a single result, @code{sqrt} chooses to return the positive result. Then @kbd{H a S} doctors this result using @code{s1} to indicate the full set of possible values of the mathematical square-root. There is a similar phenomenon going the other direction: Suppose we solve @samp{sqrt(y) = x} for @code{y}. Calc squares both sides to get @samp{y = x^2}. This is correct, except that it introduces some dubious solutions. Consider solving @samp{sqrt(y) = -3}: Calc will report @cite{y = 9} as a valid solution, which is true in the mathematical sense of square-root, but false (there is no solution) for the actual Calc positive-valued @code{sqrt}. This happens for both @kbd{a S} and @kbd{H a S}. @cindex @code{GenCount} variable @vindex GenCount @c @starindex @tindex an @c @starindex @tindex as If you store a positive integer in the Calc variable @code{GenCount}, then Calc will generate formulas of the form @samp{as(@var{n})} for arbitrary signs, and @samp{an(@var{n})} for arbitrary integers, where @var{n} represents successive values taken by incrementing @code{GenCount} by one. While the normal arbitrary sign and integer symbols start over at @code{s1} and @code{n1} with each new Calc command, the @code{GenCount} approach will give each arbitrary value a name that is unique throughout the entire Calc session. Also, the arbitrary values are function calls instead of variables, which is advantageous in some cases. For example, you can make a rewrite rule that recognizes all arbitrary signs using a pattern like @samp{as(n)}. The @kbd{s l} command only works on variables, but you can use the @kbd{a b} (@code{calc-substitute}) command to substitute actual values for function calls like @samp{as(3)}. The @kbd{s G} (@code{calc-edit-GenCount}) command is a convenient way to create or edit this variable. Press @kbd{M-# M-#} to finish. If you have not stored a value in @code{GenCount}, or if the value in that variable is not a positive integer, the regular @code{s1}/@code{n1} notation is used. @kindex I a S @kindex H I a S @tindex finv @tindex ffinv With the Inverse flag, @kbd{I a S} [@code{finv}] treats the expression on top of the stack as a function of the specified variable and solves to find the inverse function, written in terms of the same variable. For example, @kbd{I a S x} inverts @cite{2x + 6} to @cite{x/2 - 3}. You can use both Inverse and Hyperbolic [@code{ffinv}] to obtain a fully general inverse, as described above. @kindex a P @pindex calc-poly-roots @tindex roots Some equations, specifically polynomials, have a known, finite number of solutions. The @kbd{a P} (@code{calc-poly-roots}) [@code{roots}] command uses @kbd{H a S} to solve an equation in general form, then, for all arbitrary-sign variables like @code{s1}, and all arbitrary-integer variables like @code{n1} for which @code{n1} only usefully varies over a finite range, it expands these variables out to all their possible values. The results are collected into a vector, which is returned. For example, @samp{roots(x^4 = 1, x)} returns the four solutions @samp{[1, -1, (0, 1), (0, -1)]}. Generally an @var{n}th degree polynomial will always have @var{n} roots on the complex plane. (If you have given a @code{real} declaration for the solution variable, then only the real-valued solutions, if any, will be reported; @pxref{Declarations}.) Note that because @kbd{a P} uses @kbd{H a S}, it is able to deliver symbolic solutions if the polynomial has symbolic coefficients. Also note that Calc's solver is not able to get exact symbolic solutions to all polynomials. Polynomials containing powers up to @cite{x^4} can always be solved exactly; polynomials of higher degree sometimes can be: @cite{x^6 + x^3 + 1} is converted to @cite{(x^3)^2 + (x^3) + 1}, which can be solved for @cite{x^3} using the quadratic equation, and then for @cite{x} by taking cube roots. But in many cases, like @cite{x^6 + x + 1}, Calc does not know how to rewrite the polynomial into a form it can solve. The @kbd{a P} command can still deliver a list of numerical roots, however, provided that symbolic mode (@kbd{m s}) is not turned on. (If you work with symbolic mode on, recall that the @kbd{N} (@code{calc-eval-num}) key is a handy way to reevaluate the formula on the stack with symbolic mode temporarily off.) Naturally, @kbd{a P} can only provide numerical roots if the polynomial coefficents are all numbers (real or complex). @node Solving Systems of Equations, Decomposing Polynomials, Multiple Solutions, Solving Equations @subsection Solving Systems of Equations @noindent @cindex Systems of equations, symbolic You can also use the commands described above to solve systems of simultaneous equations. Just create a vector of equations, then specify a vector of variables for which to solve. (You can omit the surrounding brackets when entering the vector of variables at the prompt.) For example, putting @samp{[x + y = a, x - y = b]} on the stack and typing @kbd{a S x,y @key{RET}} produces the vector of solutions @samp{[x = a - (a-b)/2, y = (a-b)/2]}. The result vector will have the same length as the variables vector, and the variables will be listed in the same order there. Note that the solutions are not always simplified as far as possible; the solution for @cite{x} here could be improved by an application of the @kbd{a n} command. Calc's algorithm works by trying to eliminate one variable at a time by solving one of the equations for that variable and then substituting into the other equations. Calc will try all the possibilities, but you can speed things up by noting that Calc first tries to eliminate the first variable with the first equation, then the second variable with the second equation, and so on. It also helps to put the simpler (e.g., more linear) equations toward the front of the list. Calc's algorithm will solve any system of linear equations, and also many kinds of nonlinear systems. @c @starindex @tindex elim Normally there will be as many variables as equations. If you give fewer variables than equations (an ``over-determined'' system of equations), Calc will find a partial solution. For example, typing @kbd{a S y @key{RET}} with the above system of equations would produce @samp{[y = a - x]}. There are now several ways to express this solution in terms of the original variables; Calc uses the first one that it finds. You can control the choice by adding variable specifiers of the form @samp{elim(@var{v})} to the variables list. This says that @var{v} should be eliminated from the equations; the variable will not appear at all in the solution. For example, typing @kbd{a S y,elim(x)} would yield @samp{[y = a - (b+a)/2]}. If the variables list contains only @code{elim} specifiers, Calc simply eliminates those variables from the equations and then returns the resulting set of equations. For example, @kbd{a S elim(x)} produces @samp{[a - 2 y = b]}. Every variable eliminated will reduce the number of equations in the system by one. Again, @kbd{a S} gives you one solution to the system of equations. If there are several solutions, you can use @kbd{H a S} to get a general family of solutions, or, if there is a finite number of solutions, you can use @kbd{a P} to get a list. (In the latter case, the result will take the form of a matrix where the rows are different solutions and the columns correspond to the variables you requested.) Another way to deal with certain kinds of overdetermined systems of equations is the @kbd{a F} command, which does least-squares fitting to satisfy the equations. @xref{Curve Fitting}. @node Decomposing Polynomials, , Solving Systems of Equations, Solving Equations @subsection Decomposing Polynomials @noindent @c @starindex @tindex poly The @code{poly} function takes a polynomial and a variable as arguments, and returns a vector of polynomial coefficients (constant coefficient first). For example, @samp{poly(x^3 + 2 x, x)} returns @cite{[0, 2, 0, 1]}. If the input is not a polynomial in @cite{x}, the call to @code{poly} is left in symbolic form. If the input does not involve the variable @cite{x}, the input is returned in a list of length one, representing a polynomial with only a constant coefficient. The call @samp{poly(x, x)} returns the vector @cite{[0, 1]}. The last element of the returned vector is guaranteed to be nonzero; note that @samp{poly(0, x)} returns the empty vector @cite{[]}. Note also that @cite{x} may actually be any formula; for example, @samp{poly(sin(x)^2 - sin(x) + 3, sin(x))} returns @cite{[3, -1, 1]}. @cindex Coefficients of polynomial @cindex Degree of polynomial To get the @cite{x^k} coefficient of polynomial @cite{p}, use @samp{poly(p, x)_(k+1)}. To get the degree of polynomial @cite{p}, use @samp{vlen(poly(p, x)) - 1}. For example, @samp{poly((x+1)^4, x)} returns @samp{[1, 4, 6, 4, 1]}, so @samp{poly((x+1)^4, x)_(2+1)} gives the @cite{x^2} coefficient of this polynomial, 6. @c @starindex @tindex gpoly One important feature of the solver is its ability to recognize formulas which are ``essentially'' polynomials. This ability is made available to the user through the @code{gpoly} function, which is used just like @code{poly}: @samp{gpoly(@var{expr}, @var{var})}. If @var{expr} is a polynomial in some term which includes @var{var}, then this function will return a vector @samp{[@var{x}, @var{c}, @var{a}]} where @var{x} is the term that depends on @var{var}, @var{c} is a vector of polynomial coefficients (like the one returned by @code{poly}), and @var{a} is a multiplier which is usually 1. Basically, @samp{@var{expr} = @var{a}*(@var{c}_1 + @var{c}_2 @var{x} + @var{c}_3 @var{x}^2 + ...)}. The last element of @var{c} is guaranteed to be non-zero, and @var{c} will not equal @samp{[1]} (i.e., the trivial decomposition @var{expr} = @var{x} is not considered a polynomial). One side effect is that @samp{gpoly(x, x)} and @samp{gpoly(6, x)}, both of which might be expected to recognize their arguments as polynomials, will not because the decomposition is considered trivial. For example, @samp{gpoly((x-2)^2, x)} returns @samp{[x, [4, -4, 1], 1]}, since the expanded form of this polynomial is @cite{4 - 4 x + x^2}. The term @var{x} may itself be a polynomial in @var{var}. This is done to reduce the size of the @var{c} vector. For example, @samp{gpoly(x^4 + x^2 - 1, x)} returns @samp{[x^2, [-1, 1, 1], 1]}, since a quadratic polynomial in @cite{x^2} is easier to solve than a quartic polynomial in @cite{x}. A few more examples of the kinds of polynomials @code{gpoly} can discover: @smallexample sin(x) - 1 [sin(x), [-1, 1], 1] x + 1/x - 1 [x, [1, -1, 1], 1/x] x + 1/x [x^2, [1, 1], 1/x] x^3 + 2 x [x^2, [2, 1], x] x + x^2:3 + sqrt(x) [x^1:6, [1, 1, 0, 1], x^1:2] x^(2a) + 2 x^a + 5 [x^a, [5, 2, 1], 1] (exp(-x) + exp(x)) / 2 [e^(2 x), [0.5, 0.5], e^-x] @end smallexample The @code{poly} and @code{gpoly} functions accept a third integer argument which specifies the largest degree of polynomial that is acceptable. If this is @cite{n}, then only @var{c} vectors of length @cite{n+1} or less will be returned. Otherwise, the @code{poly} or @code{gpoly} call will remain in symbolic form. For example, the equation solver can handle quartics and smaller polynomials, so it calls @samp{gpoly(@var{expr}, @var{var}, 4)} to discover whether @var{expr} can be treated by its linear, quadratic, cubic, or quartic formulas. @c @starindex @tindex pdeg The @code{pdeg} function computes the degree of a polynomial; @samp{pdeg(p,x)} is the highest power of @code{x} that appears in @code{p}. This is the same as @samp{vlen(poly(p,x))-1}, but is much more efficient. If @code{p} is constant with respect to @code{x}, then @samp{pdeg(p,x) = 0}. If @code{p} is not a polynomial in @code{x} (e.g., @samp{pdeg(2 cos(x), x)}, the function remains unevaluated. It is possible to omit the second argument @code{x}, in which case @samp{pdeg(p)} returns the highest total degree of any term of the polynomial, counting all variables that appear in @code{p}. Note that @code{pdeg(c) = pdeg(c,x) = 0} for any nonzero constant @code{c}; the degree of the constant zero is considered to be @code{-inf} (minus infinity). @c @starindex @tindex plead The @code{plead} function finds the leading term of a polynomial. Thus @samp{plead(p,x)} is equivalent to @samp{poly(p,x)_vlen(poly(p,x))}, though again more efficient. In particular, @samp{plead((2x+1)^10, x)} returns 1024 without expanding out the list of coefficients. The value of @code{plead(p,x)} will be zero only if @cite{p = 0}. @c @starindex @tindex pcont The @code{pcont} function finds the @dfn{content} of a polynomial. This is the greatest common divisor of all the coefficients of the polynomial. With two arguments, @code{pcont(p,x)} effectively uses @samp{poly(p,x)} to get a list of coefficients, then uses @code{pgcd} (the polynomial GCD function) to combine these into an answer. For example, @samp{pcont(4 x y^2 + 6 x^2 y, x)} is @samp{2 y}. The content is basically the ``biggest'' polynomial that can be divided into @code{p} exactly. The sign of the content is the same as the sign of the leading coefficient. With only one argument, @samp{pcont(p)} computes the numerical content of the polynomial, i.e., the @code{gcd} of the numerical coefficients of all the terms in the formula. Note that @code{gcd} is defined on rational numbers as well as integers; it computes the @code{gcd} of the numerators and the @code{lcm} of the denominators. Thus @samp{pcont(4:3 x y^2 + 6 x^2 y)} returns 2:3. Dividing the polynomial by this number will clear all the denominators, as well as dividing by any common content in the numerators. The numerical content of a polynomial is negative only if all the coefficients in the polynomial are negative. @c @starindex @tindex pprim The @code{pprim} function finds the @dfn{primitive part} of a polynomial, which is simply the polynomial divided (using @code{pdiv} if necessary) by its content. If the input polynomial has rational coefficients, the result will have integer coefficients in simplest terms. @node Numerical Solutions, Curve Fitting, Solving Equations, Algebra @section Numerical Solutions @noindent Not all equations can be solved symbolically. The commands in this section use numerical algorithms that can find a solution to a specific instance of an equation to any desired accuracy. Note that the numerical commands are slower than their algebraic cousins; it is a good idea to try @kbd{a S} before resorting to these commands. (@xref{Curve Fitting}, for some other, more specialized, operations on numerical data.) @menu * Root Finding:: * Minimization:: * Numerical Systems of Equations:: @end menu @node Root Finding, Minimization, Numerical Solutions, Numerical Solutions @subsection Root Finding @noindent @kindex a R @pindex calc-find-root @tindex root @cindex Newton's method @cindex Roots of equations @cindex Numerical root-finding The @kbd{a R} (@code{calc-find-root}) [@code{root}] command finds a numerical solution (or @dfn{root}) of an equation. (This command treats inequalities the same as equations. If the input is any other kind of formula, it is interpreted as an equation of the form @cite{X = 0}.) The @kbd{a R} command requires an initial guess on the top of the stack, and a formula in the second-to-top position. It prompts for a solution variable, which must appear in the formula. All other variables that appear in the formula must have assigned values, i.e., when a value is assigned to the solution variable and the formula is evaluated with @kbd{=}, it should evaluate to a number. Any assigned value for the solution variable itself is ignored and unaffected by this command. When the command completes, the initial guess is replaced on the stack by a vector of two numbers: The value of the solution variable that solves the equation, and the difference between the lefthand and righthand sides of the equation at that value. Ordinarily, the second number will be zero or very nearly zero. (Note that Calc uses a slightly higher precision while finding the root, and thus the second number may be slightly different from the value you would compute from the equation yourself.) The @kbd{v h} (@code{calc-head}) command is a handy way to extract the first element of the result vector, discarding the error term. The initial guess can be a real number, in which case Calc searches for a real solution near that number, or a complex number, in which case Calc searches the whole complex plane near that number for a solution, or it can be an interval form which restricts the search to real numbers inside that interval. Calc tries to use @kbd{a d} to take the derivative of the equation. If this succeeds, it uses Newton's method. If the equation is not differentiable Calc uses a bisection method. (If Newton's method appears to be going astray, Calc switches over to bisection if it can, or otherwise gives up. In this case it may help to try again with a slightly different initial guess.) If the initial guess is a complex number, the function must be differentiable. If the formula (or the difference between the sides of an equation) is negative at one end of the interval you specify and positive at the other end, the root finder is guaranteed to find a root. Otherwise, Calc subdivides the interval into small parts looking for positive and negative values to bracket the root. When your guess is an interval, Calc will not look outside that interval for a root. @kindex H a R @tindex wroot The @kbd{H a R} [@code{wroot}] command is similar to @kbd{a R}, except that if the initial guess is an interval for which the function has the same sign at both ends, then rather than subdividing the interval Calc attempts to widen it to enclose a root. Use this mode if you are not sure if the function has a root in your interval. If the function is not differentiable, and you give a simple number instead of an interval as your initial guess, Calc uses this widening process even if you did not type the Hyperbolic flag. (If the function @emph{is} differentiable, Calc uses Newton's method which does not require a bounding interval in order to work.) If Calc leaves the @code{root} or @code{wroot} function in symbolic form on the stack, it will normally display an explanation for why no root was found. If you miss this explanation, press @kbd{w} (@code{calc-why}) to get it back. @node Minimization, Numerical Systems of Equations, Root Finding, Numerical Solutions @subsection Minimization @noindent @kindex a N @kindex H a N @kindex a X @kindex H a X @pindex calc-find-minimum @pindex calc-find-maximum @tindex minimize @tindex maximize @cindex Minimization, numerical The @kbd{a N} (@code{calc-find-minimum}) [@code{minimize}] command finds a minimum value for a formula. It is very similar in operation to @kbd{a R} (@code{calc-find-root}): You give the formula and an initial guess on the stack, and are prompted for the name of a variable. The guess may be either a number near the desired minimum, or an interval enclosing the desired minimum. The function returns a vector containing the value of the the variable which minimizes the formula's value, along with the minimum value itself. Note that this command looks for a @emph{local} minimum. Many functions have more than one minimum; some, like @c{$x \sin x$} @cite{x sin(x)}, have infinitely many. In fact, there is no easy way to define the ``global'' minimum of @c{$x \sin x$} @cite{x sin(x)} but Calc can still locate any particular local minimum for you. Calc basically goes downhill from the initial guess until it finds a point at which the function's value is greater both to the left and to the right. Calc does not use derivatives when minimizing a function. If your initial guess is an interval and it looks like the minimum occurs at one or the other endpoint of the interval, Calc will return that endpoint only if that endpoint is closed; thus, minimizing @cite{17 x} over @cite{[2..3]} will return @cite{[2, 38]}, but minimizing over @cite{(2..3]} would report no minimum found. In general, you should use closed intervals to find literally the minimum value in that range of @cite{x}, or open intervals to find the local minimum, if any, that happens to lie in that range. Most functions are smooth and flat near their minimum values. Because of this flatness, if the current precision is, say, 12 digits, the variable can only be determined meaningfully to about six digits. Thus you should set the precision to twice as many digits as you need in your answer. @c @mindex wmin@idots @tindex wminimize @c @mindex wmax@idots @tindex wmaximize The @kbd{H a N} [@code{wminimize}] command, analogously to @kbd{H a R}, expands the guess interval to enclose a minimum rather than requiring that the minimum lie inside the interval you supply. The @kbd{a X} (@code{calc-find-maximum}) [@code{maximize}] and @kbd{H a X} [@code{wmaximize}] commands effectively minimize the negative of the formula you supply. The formula must evaluate to a real number at all points inside the interval (or near the initial guess if the guess is a number). If the initial guess is a complex number the variable will be minimized over the complex numbers; if it is real or an interval it will be minimized over the reals. @node Numerical Systems of Equations, , Minimization, Numerical Solutions @subsection Systems of Equations @noindent @cindex Systems of equations, numerical The @kbd{a R} command can also solve systems of equations. In this case, the equation should instead be a vector of equations, the guess should instead be a vector of numbers (intervals are not supported), and the variable should be a vector of variables. You can omit the brackets while entering the list of variables. Each equation must be differentiable by each variable for this mode to work. The result will be a vector of two vectors: The variable values that solved the system of equations, and the differences between the sides of the equations with those variable values. There must be the same number of equations as variables. Since only plain numbers are allowed as guesses, the Hyperbolic flag has no effect when solving a system of equations. It is also possible to minimize over many variables with @kbd{a N} (or maximize with @kbd{a X}). Once again the variable name should be replaced by a vector of variables, and the initial guess should be an equal-sized vector of initial guesses. But, unlike the case of multidimensional @kbd{a R}, the formula being minimized should still be a single formula, @emph{not} a vector. Beware that multidimensional minimization is currently @emph{very} slow. @node Curve Fitting, Summations, Numerical Solutions, Algebra @section Curve Fitting @noindent The @kbd{a F} command fits a set of data to a @dfn{model formula}, such as @cite{y = m x + b} where @cite{m} and @cite{b} are parameters to be determined. For a typical set of measured data there will be no single @cite{m} and @cite{b} that exactly fit the data; in this case, Calc chooses values of the parameters that provide the closest possible fit. @menu * Linear Fits:: * Polynomial and Multilinear Fits:: * Error Estimates for Fits:: * Standard Nonlinear Models:: * Curve Fitting Details:: * Interpolation:: @end menu @node Linear Fits, Polynomial and Multilinear Fits, Curve Fitting, Curve Fitting @subsection Linear Fits @noindent @kindex a F @pindex calc-curve-fit @tindex fit @cindex Linear regression @cindex Least-squares fits The @kbd{a F} (@code{calc-curve-fit}) [@code{fit}] command attempts to fit a set of data (@cite{x} and @cite{y} vectors of numbers) to a straight line, polynomial, or other function of @cite{x}. For the moment we will consider only the case of fitting to a line, and we will ignore the issue of whether or not the model was in fact a good fit for the data. In a standard linear least-squares fit, we have a set of @cite{(x,y)} data points that we wish to fit to the model @cite{y = m x + b} by adjusting the parameters @cite{m} and @cite{b} to make the @cite{y} values calculated from the formula be as close as possible to the actual @cite{y} values in the data set. (In a polynomial fit, the model is instead, say, @cite{y = a x^3 + b x^2 + c x + d}. In a multilinear fit, we have data points of the form @cite{(x_1,x_2,x_3,y)} and our model is @cite{y = a x_1 + b x_2 + c x_3 + d}. These will be discussed later.) In the model formula, variables like @cite{x} and @cite{x_2} are called the @dfn{independent variables}, and @cite{y} is the @dfn{dependent variable}. Variables like @cite{m}, @cite{a}, and @cite{b} are called the @dfn{parameters} of the model. The @kbd{a F} command takes the data set to be fitted from the stack. By default, it expects the data in the form of a matrix. For example, for a linear or polynomial fit, this would be a @c{$2\times N$} @asis{2xN} matrix where the first row is a list of @cite{x} values and the second row has the corresponding @cite{y} values. For the multilinear fit shown above, the matrix would have four rows (@cite{x_1}, @cite{x_2}, @cite{x_3}, and @cite{y}, respectively). If you happen to have an @c{$N\times2$} @asis{Nx2} matrix instead of a @c{$2\times N$} @asis{2xN} matrix, just press @kbd{v t} first to transpose the matrix. After you type @kbd{a F}, Calc prompts you to select a model. For a linear fit, press the digit @kbd{1}. Calc then prompts for you to name the variables. By default it chooses high letters like @cite{x} and @cite{y} for independent variables and low letters like @cite{a} and @cite{b} for parameters. (The dependent variable doesn't need a name.) The two kinds of variables are separated by a semicolon. Since you generally care more about the names of the independent variables than of the parameters, Calc also allows you to name only those and let the parameters use default names. For example, suppose the data matrix @ifinfo @group @example [ [ 1, 2, 3, 4, 5 ] [ 5, 7, 9, 11, 13 ] ] @end example @end group @end ifinfo @tex \turnoffactive \turnoffactive \beforedisplay $$ \pmatrix{ 1 & 2 & 3 & 4 & 5 \cr 5 & 7 & 9 & 11 & 13 } $$ \afterdisplay @end tex @noindent is on the stack and we wish to do a simple linear fit. Type @kbd{a F}, then @kbd{1} for the model, then @kbd{RET} to use the default names. The result will be the formula @cite{3 + 2 x} on the stack. Calc has created the model expression @kbd{a + b x}, then found the optimal values of @cite{a} and @cite{b} to fit the data. (In this case, it was able to find an exact fit.) Calc then substituted those values for @cite{a} and @cite{b} in the model formula. The @kbd{a F} command puts two entries in the trail. One is, as always, a copy of the result that went to the stack; the other is a vector of the actual parameter values, written as equations: @cite{[a = 3, b = 2]}, in case you'd rather read them in a list than pick them out of the formula. (You can type @kbd{t y} to move this vector to the stack; @pxref{Trail Commands}.) Specifying a different independent variable name will affect the resulting formula: @kbd{a F 1 k RET} produces @kbd{3 + 2 k}. Changing the parameter names (say, @kbd{a F 1 k;b,m RET}) will affect the equations that go into the trail. @tex \bigskip @end tex To see what happens when the fit is not exact, we could change the number 13 in the data matrix to 14 and try the fit again. The result is: @example 2.6 + 2.2 x @end example Evaluating this formula, say with @kbd{v x 5 RET TAB V M $ RET}, shows a reasonably close match to the y-values in the data. @example [4.8, 7., 9.2, 11.4, 13.6] @end example Since there is no line which passes through all the @i{N} data points, Calc has chosen a line that best approximates the data points using the method of least squares. The idea is to define the @dfn{chi-square} error measure @ifinfo @example chi^2 = sum((y_i - (a + b x_i))^2, i, 1, N) @end example @end ifinfo @tex \turnoffactive \beforedisplay $$ \chi^2 = \sum_{i=1}^N (y_i - (a + b x_i))^2 $$ \afterdisplay @end tex @noindent which is clearly zero if @cite{a + b x} exactly fits all data points, and increases as various @cite{a + b x_i} values fail to match the corresponding @cite{y_i} values. There are several reasons why the summand is squared, one of them being to ensure that @c{$\chi^2 \ge 0$} @cite{chi^2 >= 0}. Least-squares fitting simply chooses the values of @cite{a} and @cite{b} for which the error @c{$\chi^2$} @cite{chi^2} is as small as possible. Other kinds of models do the same thing but with a different model formula in place of @cite{a + b x_i}. @tex \bigskip @end tex A numeric prefix argument causes the @kbd{a F} command to take the data in some other form than one big matrix. A positive argument @i{N} will take @i{N} items from the stack, corresponding to the @i{N} rows of a data matrix. In the linear case, @i{N} must be 2 since there is always one independent variable and one dependent variable. A prefix of zero or plain @kbd{C-u} is a compromise; Calc takes two items from the stack, an @i{N}-row matrix of @cite{x} values, and a vector of @cite{y} values. If there is only one independent variable, the @cite{x} values can be either a one-row matrix or a plain vector, in which case the @kbd{C-u} prefix is the same as a @w{@kbd{C-u 2}} prefix. @node Polynomial and Multilinear Fits, Error Estimates for Fits, Linear Fits, Curve Fitting @subsection Polynomial and Multilinear Fits @noindent To fit the data to higher-order polynomials, just type one of the digits @kbd{2} through @kbd{9} when prompted for a model. For example, we could fit the original data matrix from the previous section (with 13, not 14) to a parabola instead of a line by typing @kbd{a F 2 RET}. @example 2.00000000001 x - 1.5e-12 x^2 + 2.99999999999 @end example Note that since the constant and linear terms are enough to fit the data exactly, it's no surprise that Calc chose a tiny contribution for @cite{x^2}. (The fact that it's not exactly zero is due only to roundoff error. Since our data are exact integers, we could get an exact answer by typing @kbd{m f} first to get fraction mode. Then the @cite{x^2} term would vanish altogether. Usually, though, the data being fitted will be approximate floats so fraction mode won't help.) Doing the @kbd{a F 2} fit on the data set with 14 instead of 13 gives a much larger @cite{x^2} contribution, as Calc bends the line slightly to improve the fit. @example 0.142857142855 x^2 + 1.34285714287 x + 3.59999999998 @end example An important result from the theory of polynomial fitting is that it is always possible to fit @i{N} data points exactly using a polynomial of degree @i{N-1}, sometimes called an @dfn{interpolating polynomial}. Using the modified (14) data matrix, a model number of 4 gives a polynomial that exactly matches all five data points: @example 0.04167 x^4 - 0.4167 x^3 + 1.458 x^2 - 0.08333 x + 4. @end example The actual coefficients we get with a precision of 12, like @cite{0.0416666663588}, clearly suffer from loss of precision. It is a good idea to increase the working precision to several digits beyond what you need when you do a fitting operation. Or, if your data are exact, use fraction mode to get exact results. You can type @kbd{i} instead of a digit at the model prompt to fit the data exactly to a polynomial. This just counts the number of columns of the data matrix to choose the degree of the polynomial automatically. Fitting data ``exactly'' to high-degree polynomials is not always a good idea, though. High-degree polynomials have a tendency to wiggle uncontrollably in between the fitting data points. Also, if the exact-fit polynomial is going to be used to interpolate or extrapolate the data, it is numerically better to use the @kbd{a p} command described below. @xref{Interpolation}. @tex \bigskip @end tex Another generalization of the linear model is to assume the @cite{y} values are a sum of linear contributions from several @cite{x} values. This is a @dfn{multilinear} fit, and it is also selected by the @kbd{1} digit key. (Calc decides whether the fit is linear or multilinear by counting the rows in the data matrix.) Given the data matrix, @group @example [ [ 1, 2, 3, 4, 5 ] [ 7, 2, 3, 5, 2 ] [ 14.5, 15, 18.5, 22.5, 24 ] ] @end example @end group @noindent the command @kbd{a F 1 RET} will call the first row @cite{x} and the second row @cite{y}, and will fit the values in the third row to the model @cite{a + b x + c y}. @example 8. + 3. x + 0.5 y @end example Calc can do multilinear fits with any number of independent variables (i.e., with any number of data rows). @tex \bigskip @end tex Yet another variation is @dfn{homogeneous} linear models, in which the constant term is known to be zero. In the linear case, this means the model formula is simply @cite{a x}; in the multilinear case, the model might be @cite{a x + b y + c z}; and in the polynomial case, the model could be @cite{a x + b x^2 + c x^3}. You can get a homogeneous linear or multilinear model by pressing the letter @kbd{h} followed by a regular model key, like @kbd{1} or @kbd{2}. It is certainly possible to have other constrained linear models, like @cite{2.3 + a x} or @cite{a - 4 x}. While there is no single key to select models like these, a later section shows how to enter any desired model by hand. In the first case, for example, you would enter @kbd{a F ' 2.3 + a x}. Another class of models that will work but must be entered by hand are multinomial fits, e.g., @cite{a + b x + c y + d x^2 + e y^2 + f x y}. @node Error Estimates for Fits, Standard Nonlinear Models, Polynomial and Multilinear Fits, Curve Fitting @subsection Error Estimates for Fits @noindent @kindex H a F @tindex efit With the Hyperbolic flag, @kbd{H a F} [@code{efit}] performs the same fitting operation as @kbd{a F}, but reports the coefficients as error forms instead of plain numbers. Fitting our two data matrices (first with 13, then with 14) to a line with @kbd{H a F} gives the results, @example 3. + 2. x 2.6 +/- 0.382970843103 + 2.2 +/- 0.115470053838 x @end example In the first case the estimated errors are zero because the linear fit is perfect. In the second case, the errors are nonzero but moderately small, because the data are still very close to linear. It is also possible for the @emph{input} to a fitting operation to contain error forms. The data values must either all include errors or all be plain numbers. Error forms can go anywhere but generally go on the numbers in the last row of the data matrix. If the last row contains error forms `@i{y_i}@w{ @t{+/-} }@c{$\sigma_i$} @i{sigma_i}', then the @c{$\chi^2$} @cite{chi^2} statistic is now, @ifinfo @example chi^2 = sum(((y_i - (a + b x_i)) / sigma_i)^2, i, 1, N) @end example @end ifinfo @tex \turnoffactive \beforedisplay $$ \chi^2 = \sum_{i=1}^N \left(y_i - (a + b x_i) \over \sigma_i\right)^2 $$ \afterdisplay @end tex @noindent so that data points with larger error estimates contribute less to the fitting operation. If there are error forms on other rows of the data matrix, all the errors for a given data point are combined; the square root of the sum of the squares of the errors forms the @c{$\sigma_i$} @cite{sigma_i} used for the data point. Both @kbd{a F} and @kbd{H a F} can accept error forms in the input matrix, although if you are concerned about error analysis you will probably use @kbd{H a F} so that the output also contains error estimates. If the input contains error forms but all the @c{$\sigma_i$} @cite{sigma_i} values are the same, it is easy to see that the resulting fitted model will be the same as if the input did not have error forms at all (@c{$\chi^2$} @cite{chi^2} is simply scaled uniformly by @c{$1 / \sigma^2$} @cite{1 / sigma^2}, which doesn't affect where it has a minimum). But there @emph{will} be a difference in the estimated errors of the coefficients reported by @kbd{H a F}. Consult any text on statistical modelling of data for a discussion of where these error estimates come from and how they should be interpreted. @tex \bigskip @end tex @kindex I a F @tindex xfit With the Inverse flag, @kbd{I a F} [@code{xfit}] produces even more information. The result is a vector of six items: @enumerate @item The model formula with error forms for its coefficients or parameters. This is the result that @kbd{H a F} would have produced. @item A vector of ``raw'' parameter values for the model. These are the polynomial coefficients or other parameters as plain numbers, in the same order as the parameters appeared in the final prompt of the @kbd{I a F} command. For polynomials of degree @cite{d}, this vector will have length @cite{M = d+1} with the constant term first. @item The covariance matrix @cite{C} computed from the fit. This is an @i{M}x@i{M} symmetric matrix; the diagonal elements @c{$C_{jj}$} @cite{C_j_j} are the variances @c{$\sigma_j^2$} @cite{sigma_j^2} of the parameters. The other elements are covariances @c{$\sigma_{ij}^2$} @cite{sigma_i_j^2} that describe the correlation between pairs of parameters. (A related set of numbers, the @dfn{linear correlation coefficients} @c{$r_{ij}$} @cite{r_i_j}, are defined as @c{$\sigma_{ij}^2 / \sigma_i \, \sigma_j$} @cite{sigma_i_j^2 / sigma_i sigma_j}.) @item A vector of @cite{M} ``parameter filter'' functions whose meanings are described below. If no filters are necessary this will instead be an empty vector; this is always the case for the polynomial and multilinear fits described so far. @item The value of @c{$\chi^2$} @cite{chi^2} for the fit, calculated by the formulas shown above. This gives a measure of the quality of the fit; statisticians consider @c{$\chi^2 \approx N - M$} @cite{chi^2 = N - M} to indicate a moderately good fit (where again @cite{N} is the number of data points and @cite{M} is the number of parameters). @item A measure of goodness of fit expressed as a probability @cite{Q}. This is computed from the @code{utpc} probability distribution function using @c{$\chi^2$} @cite{chi^2} with @cite{N - M} degrees of freedom. A value of 0.5 implies a good fit; some texts recommend that often @cite{Q = 0.1} or even 0.001 can signify an acceptable fit. In particular, @c{$\chi^2$} @cite{chi^2} statistics assume the errors in your inputs follow a normal (Gaussian) distribution; if they don't, you may have to accept smaller values of @cite{Q}. The @cite{Q} value is computed only if the input included error estimates. Otherwise, Calc will report the symbol @code{nan} for @cite{Q}. The reason is that in this case the @c{$\chi^2$} @cite{chi^2} value has effectively been used to estimate the original errors in the input, and thus there is no redundant information left over to use for a confidence test. @end enumerate @node Standard Nonlinear Models, Curve Fitting Details, Error Estimates for Fits, Curve Fitting @subsection Standard Nonlinear Models @noindent The @kbd{a F} command also accepts other kinds of models besides lines and polynomials. Some common models have quick single-key abbreviations; others must be entered by hand as algebraic formulas. Here is a complete list of the standard models recognized by @kbd{a F}: @table @kbd @item 1 Linear or multilinear. @i{a + b x + c y + d z}. @item 2-9 Polynomials. @i{a + b x + c x^2 + d x^3}. @item e Exponential. @i{a} @t{exp}@i{(b x)} @t{exp}@i{(c y)}. @item E Base-10 exponential. @i{a} @t{10^}@i{(b x)} @t{10^}@i{(c y)}. @item x Exponential (alternate notation). @t{exp}@i{(a + b x + c y)}. @item X Base-10 exponential (alternate). @t{10^}@i{(a + b x + c y)}. @item l Logarithmic. @i{a + b} @t{ln}@i{(x) + c} @t{ln}@i{(y)}. @item L Base-10 logarithmic. @i{a + b} @t{log10}@i{(x) + c} @t{log10}@i{(y)}. @item ^ General exponential. @i{a b^x c^y}. @item p Power law. @i{a x^b y^c}. @item q Quadratic. @i{a + b (x-c)^2 + d (x-e)^2}. @item g Gaussian. @c{${a \over b \sqrt{2 \pi}} \exp\left( -{1 \over 2} \left( x - c \over b \right)^2 \right)$} @i{(a / b sqrt(2 pi)) exp(-0.5*((x-c)/b)^2)}. @end table All of these models are used in the usual way; just press the appropriate letter at the model prompt, and choose variable names if you wish. The result will be a formula as shown in the above table, with the best-fit values of the parameters substituted. (You may find it easier to read the parameter values from the vector that is placed in the trail.) All models except Gaussian and polynomials can generalize as shown to any number of independent variables. Also, all the built-in models have an additive or multiplicative parameter shown as @cite{a} in the above table which can be replaced by zero or one, as appropriate, by typing @kbd{h} before the model key. Note that many of these models are essentially equivalent, but express the parameters slightly differently. For example, @cite{a b^x} and the other two exponential models are all algebraic rearrangements of each other. Also, the ``quadratic'' model is just a degree-2 polynomial with the parameters expressed differently. Use whichever form best matches the problem. The HP-28/48 calculators support four different models for curve fitting, called @code{LIN}, @code{LOG}, @code{EXP}, and @code{PWR}. These correspond to Calc models @samp{a + b x}, @samp{a + b ln(x)}, @samp{a exp(b x)}, and @samp{a x^b}, respectively. In each case, @cite{a} is what the HP-48 identifies as the ``intercept,'' and @cite{b} is what it calls the ``slope.'' @tex \bigskip @end tex If the model you want doesn't appear on this list, press @kbd{'} (the apostrophe key) at the model prompt to enter any algebraic formula, such as @kbd{m x - b}, as the model. (Not all models will work, though---see the next section for details.) The model can also be an equation like @cite{y = m x + b}. In this case, Calc thinks of all the rows of the data matrix on equal terms; this model effectively has two parameters (@cite{m} and @cite{b}) and two independent variables (@cite{x} and @cite{y}), with no ``dependent'' variables. Model equations do not need to take this @cite{y =} form. For example, the implicit line equation @cite{a x + b y = 1} works fine as a model. When you enter a model, Calc makes an alphabetical list of all the variables that appear in the model. These are used for the default parameters, independent variables, and dependent variable (in that order). If you enter a plain formula (not an equation), Calc assumes the dependent variable does not appear in the formula and thus does not need a name. For example, if the model formula has the variables @cite{a,mu,sigma,t,x}, and the data matrix has three rows (meaning two independent variables), Calc will use @cite{a,mu,sigma} as the default parameters, and the data rows will be named @cite{t} and @cite{x}, respectively. If you enter an equation instead of a plain formula, Calc will use @cite{a,mu} as the parameters, and @cite{sigma,t,x} as the three independent variables. You can, of course, override these choices by entering something different at the prompt. If you leave some variables out of the list, those variables must have stored values and those stored values will be used as constants in the model. (Stored values for the parameters and independent variables are ignored by the @kbd{a F} command.) If you list only independent variables, all the remaining variables in the model formula will become parameters. If there are @kbd{$} signs in the model you type, they will stand for parameters and all other variables (in alphabetical order) will be independent. Use @kbd{$} for one parameter, @kbd{$$} for another, and so on. Thus @kbd{$ x + $$} is another way to describe a linear model. If you type a @kbd{$} instead of @kbd{'} at the model prompt itself, Calc will take the model formula from the stack. (The data must then appear at the second stack level.) The same conventions are used to choose which variables in the formula are independent by default and which are parameters. Models taken from the stack can also be expressed as vectors of two or three elements, @cite{[@var{model}, @var{vars}]} or @cite{[@var{model}, @var{vars}, @var{params}]}. Each of @var{vars} and @var{params} may be either a variable or a vector of variables. (If @var{params} is omitted, all variables in @var{model} except those listed as @var{vars} are parameters.)@refill When you enter a model manually with @kbd{'}, Calc puts a 3-vector describing the model in the trail so you can get it back if you wish. @tex \bigskip @end tex @vindex Model1 @vindex Model2 Finally, you can store a model in one of the Calc variables @code{Model1} or @code{Model2}, then use this model by typing @kbd{a F u} or @kbd{a F U} (respectively). The value stored in the variable can be any of the formats that @kbd{a F $} would accept for a model on the stack. @tex \bigskip @end tex Calc uses the principal values of inverse functions like @code{ln} and @code{arcsin} when doing fits. For example, when you enter the model @samp{y = sin(a t + b)} Calc actually uses the easier form @samp{arcsin(y) = a t + b}. The @code{arcsin} function always returns results in the range from @i{-90} to 90 degrees (or the equivalent range in radians). Suppose you had data that you believed to represent roughly three oscillations of a sine wave, so that the argument of the sine might go from zero to @c{$3\times360$} @i{3*360} degrees. The above model would appear to be a good way to determine the true frequency and phase of the sine wave, but in practice it would fail utterly. The righthand side of the actual model @samp{arcsin(y) = a t + b} will grow smoothly with @cite{t}, but the lefthand side will bounce back and forth between @i{-90} and 90. No values of @cite{a} and @cite{b} can make the two sides match, even approximately. There is no good solution to this problem at present. You could restrict your data to small enough ranges so that the above problem doesn't occur (i.e., not straddling any peaks in the sine wave). Or, in this case, you could use a totally different method such as Fourier analysis, which is beyond the scope of the @kbd{a F} command. (Unfortunately, Calc does not currently have any facilities for taking Fourier and related transforms.) @node Curve Fitting Details, Interpolation, Standard Nonlinear Models, Curve Fitting @subsection Curve Fitting Details @noindent Calc's internal least-squares fitter can only handle multilinear models. More precisely, it can handle any model of the form @cite{a f(x,y,z) + b g(x,y,z) + c h(x,y,z)}, where @cite{a,b,c} are the parameters and @cite{x,y,z} are the independent variables (of course there can be any number of each, not just three). In a simple multilinear or polynomial fit, it is easy to see how to convert the model into this form. For example, if the model is @cite{a + b x + c x^2}, then @cite{f(x) = 1}, @cite{g(x) = x}, and @cite{h(x) = x^2} are suitable functions. For other models, Calc uses a variety of algebraic manipulations to try to put the problem into the form @smallexample Y(x,y,z) = A(a,b,c) F(x,y,z) + B(a,b,c) G(x,y,z) + C(a,b,c) H(x,y,z) @end smallexample @noindent where @cite{Y,A,B,C,F,G,H} are arbitrary functions. It computes @cite{Y}, @cite{F}, @cite{G}, and @cite{H} for all the data points, does a standard linear fit to find the values of @cite{A}, @cite{B}, and @cite{C}, then uses the equation solver to solve for @cite{a,b,c} in terms of @cite{A,B,C}. A remarkable number of models can be cast into this general form. We'll look at two examples here to see how it works. The power-law model @cite{y = a x^b} with two independent variables and two parameters can be rewritten as follows: @example y = a x^b y = a exp(b ln(x)) y = exp(ln(a) + b ln(x)) ln(y) = ln(a) + b ln(x) @end example @noindent which matches the desired form with @c{$Y = \ln(y)$} @cite{Y = ln(y)}, @c{$A = \ln(a)$} @cite{A = ln(a)}, @cite{F = 1}, @cite{B = b}, and @c{$G = \ln(x)$} @cite{G = ln(x)}. Calc thus computes the logarithms of your @cite{y} and @cite{x} values, does a linear fit for @cite{A} and @cite{B}, then solves to get @c{$a = \exp(A)$} @cite{a = exp(A)} and @cite{b = B}. Another interesting example is the ``quadratic'' model, which can be handled by expanding according to the distributive law. @example y = a + b*(x - c)^2 y = a + b c^2 - 2 b c x + b x^2 @end example @noindent which matches with @cite{Y = y}, @cite{A = a + b c^2}, @cite{F = 1}, @cite{B = -2 b c}, @cite{G = x} (the @i{-2} factor could just as easily have been put into @cite{G} instead of @cite{B}), @cite{C = b}, and @cite{H = x^2}. The Gaussian model looks quite complicated, but a closer examination shows that it's actually similar to the quadratic model but with an exponential that can be brought to the top and moved into @cite{Y}. An example of a model that cannot be put into general linear form is a Gaussian with a constant background added on, i.e., @cite{d} + the regular Gaussian formula. If you have a model like this, your best bet is to replace enough of your parameters with constants to make the model linearizable, then adjust the constants manually by doing a series of fits. You can compare the fits by graphing them, by examining the goodness-of-fit measures returned by @kbd{I a F}, or by some other method suitable to your application. Note that some models can be linearized in several ways. The Gaussian-plus-@i{d} model can be linearized by setting @cite{d} (the background) to a constant, or by setting @cite{b} (the standard deviation) and @cite{c} (the mean) to constants. To fit a model with constants substituted for some parameters, just store suitable values in those parameter variables, then omit them from the list of parameters when you answer the variables prompt. @tex \bigskip @end tex A last desperate step would be to use the general-purpose @code{minimize} function rather than @code{fit}. After all, both functions solve the problem of minimizing an expression (the @c{$\chi^2$} @cite{chi^2} sum) by adjusting certain parameters in the expression. The @kbd{a F} command is able to use a vastly more efficient algorithm due to its special knowledge about linear chi-square sums, but the @kbd{a N} command can do the same thing by brute force. A compromise would be to pick out a few parameters without which the fit is linearizable, and use @code{minimize} on a call to @code{fit} which efficiently takes care of the rest of the parameters. The thing to be minimized would be the value of @c{$\chi^2$} @cite{chi^2} returned as the fifth result of the @code{xfit} function: @smallexample minimize(xfit(gaus(a,b,c,d,x), x, [a,b,c], data)_5, d, guess) @end smallexample @noindent where @code{gaus} represents the Gaussian model with background, @code{data} represents the data matrix, and @code{guess} represents the initial guess for @cite{d} that @code{minimize} requires. This operation will only be, shall we say, extraordinarily slow rather than astronomically slow (as would be the case if @code{minimize} were used by itself to solve the problem). @tex \bigskip @end tex The @kbd{I a F} [@code{xfit}] command is somewhat trickier when nonlinear models are used. The second item in the result is the vector of ``raw'' parameters @cite{A}, @cite{B}, @cite{C}. The covariance matrix is written in terms of those raw parameters. The fifth item is a vector of @dfn{filter} expressions. This is the empty vector @samp{[]} if the raw parameters were the same as the requested parameters, i.e., if @cite{A = a}, @cite{B = b}, and so on (which is always true if the model is already linear in the parameters as written, e.g., for polynomial fits). If the parameters had to be rearranged, the fifth item is instead a vector of one formula per parameter in the original model. The raw parameters are expressed in these ``filter'' formulas as @samp{fitdummy(1)} for @cite{A}, @samp{fitdummy(2)} for @cite{B}, and so on. When Calc needs to modify the model to return the result, it replaces @samp{fitdummy(1)} in all the filters with the first item in the raw parameters list, and so on for the other raw parameters, then evaluates the resulting filter formulas to get the actual parameter values to be substituted into the original model. In the case of @kbd{H a F} and @kbd{I a F} where the parameters must be error forms, Calc uses the square roots of the diagonal entries of the covariance matrix as error values for the raw parameters, then lets Calc's standard error-form arithmetic take it from there. If you use @kbd{I a F} with a nonlinear model, be sure to remember that the covariance matrix is in terms of the raw parameters, @emph{not} the actual requested parameters. It's up to you to figure out how to interpret the covariances in the presence of nontrivial filter functions. Things are also complicated when the input contains error forms. Suppose there are three independent and dependent variables, @cite{x}, @cite{y}, and @cite{z}, one or more of which are error forms in the data. Calc combines all the error values by taking the square root of the sum of the squares of the errors. It then changes @cite{x} and @cite{y} to be plain numbers, and makes @cite{z} into an error form with this combined error. The @cite{Y(x,y,z)} part of the linearized model is evaluated, and the result should be an error form. The error part of that result is used for @c{$\sigma_i$} @cite{sigma_i} for the data point. If for some reason @cite{Y(x,y,z)} does not return an error form, the combined error from @cite{z} is used directly for @c{$\sigma_i$} @cite{sigma_i}. Finally, @cite{z} is also stripped of its error for use in computing @cite{F(x,y,z)}, @cite{G(x,y,z)} and so on; the righthand side of the linearized model is computed in regular arithmetic with no error forms. (While these rules may seem complicated, they are designed to do the most reasonable thing in the typical case that @cite{Y(x,y,z)} depends only on the dependent variable @cite{z}, and in fact is often simply equal to @cite{z}. For common cases like polynomials and multilinear models, the combined error is simply used as the @c{$\sigma$} @cite{sigma} for the data point with no further ado.) @tex \bigskip @end tex @vindex FitRules It may be the case that the model you wish to use is linearizable, but Calc's built-in rules are unable to figure it out. Calc uses its algebraic rewrite mechanism to linearize a model. The rewrite rules are kept in the variable @code{FitRules}. You can edit this variable using the @kbd{s e FitRules} command; in fact, there is a special @kbd{s F} command just for editing @code{FitRules}. @xref{Operations on Variables}. @xref{Rewrite Rules}, for a discussion of rewrite rules. @c @starindex @tindex fitvar @c @starindex @c @mindex @idots @tindex fitparam @c @starindex @c @mindex @null @tindex fitmodel @c @starindex @c @mindex @null @tindex fitsystem @c @starindex @c @mindex @null @tindex fitdummy Calc uses @code{FitRules} as follows. First, it converts the model to an equation if necessary and encloses the model equation in a call to the function @code{fitmodel} (which is not actually a defined function in Calc; it is only used as a placeholder by the rewrite rules). Parameter variables are renamed to function calls @samp{fitparam(1)}, @samp{fitparam(2)}, and so on, and independent variables are renamed to @samp{fitvar(1)}, @samp{fitvar(2)}, etc. The dependent variable is the highest-numbered @code{fitvar}. For example, the power law model @cite{a x^b} is converted to @cite{y = a x^b}, then to @group @smallexample fitmodel(fitvar(2) = fitparam(1) fitvar(1)^fitparam(2)) @end smallexample @end group Calc then applies the rewrites as if by @samp{C-u 0 a r FitRules}. (The zero prefix means that rewriting should continue until no further changes are possible.) When rewriting is complete, the @code{fitmodel} call should have been replaced by a @code{fitsystem} call that looks like this: @example fitsystem(@var{Y}, @var{FGH}, @var{abc}) @end example @noindent where @var{Y} is a formula that describes the function @cite{Y(x,y,z)}, @var{FGH} is the vector of formulas @cite{[F(x,y,z), G(x,y,z), H(x,y,z)]}, and @var{abc} is the vector of parameter filters which refer to the raw parameters as @samp{fitdummy(1)} for @cite{A}, @samp{fitdummy(2)} for @cite{B}, etc. While the number of raw parameters (the length of the @var{FGH} vector) is usually the same as the number of original parameters (the length of the @var{abc} vector), this is not required. The power law model eventually boils down to @group @smallexample fitsystem(ln(fitvar(2)), [1, ln(fitvar(1))], [exp(fitdummy(1)), fitdummy(2)]) @end smallexample @end group The actual implementation of @code{FitRules} is complicated; it proceeds in four phases. First, common rearrangements are done to try to bring linear terms together and to isolate functions like @code{exp} and @code{ln} either all the way ``out'' (so that they can be put into @var{Y}) or all the way ``in'' (so that they can be put into @var{abc} or @var{FGH}). In particular, all non-constant powers are converted to logs-and-exponentials form, and the distributive law is used to expand products of sums. Quotients are rewritten to use the @samp{fitinv} function, where @samp{fitinv(x)} represents @cite{1/x} while the @code{FitRules} are operating. (The use of @code{fitinv} makes recognition of linear-looking forms easier.) If you modify @code{FitRules}, you will probably only need to modify the rules for this phase. Phase two, whose rules can actually also apply during phases one and three, first rewrites @code{fitmodel} to a two-argument form @samp{fitmodel(@var{Y}, @var{model})}, where @var{Y} is initially zero and @var{model} has been changed from @cite{a=b} to @cite{a-b} form. It then tries to peel off invertible functions from the outside of @var{model} and put them into @var{Y} instead, calling the equation solver to invert the functions. Finally, when this is no longer possible, the @code{fitmodel} is changed to a four-argument @code{fitsystem}, where the fourth argument is @var{model} and the @var{FGH} and @var{abc} vectors are initially empty. (The last vector is really @var{ABC}, corresponding to raw parameters, for now.) Phase three converts a sum of items in the @var{model} to a sum of @samp{fitpart(@var{a}, @var{b}, @var{c})} terms which represent terms @samp{@var{a}*@var{b}*@var{c}} of the sum, where @var{a} is all factors that do not involve any variables, @var{b} is all factors that involve only parameters, and @var{c} is the factors that involve only independent variables. (If this decomposition is not possible, the rule set will not complete and Calc will complain that the model is too complex.) Then @code{fitpart}s with equal @var{b} or @var{c} components are merged back together using the distributive law in order to minimize the number of raw parameters needed. Phase four moves the @code{fitpart} terms into the @var{FGH} and @var{ABC} vectors. Also, some of the algebraic expansions that were done in phase 1 are undone now to make the formulas more computationally efficient. Finally, it calls the solver one more time to convert the @var{ABC} vector to an @var{abc} vector, and removes the fourth @var{model} argument (which by now will be zero) to obtain the three-argument @code{fitsystem} that the linear least-squares solver wants to see. @c @starindex @c @mindex hasfit@idots @tindex hasfitparams @c @starindex @c @mindex @null @tindex hasfitvars Two functions which are useful in connection with @code{FitRules} are @samp{hasfitparams(x)} and @samp{hasfitvars(x)}, which check whether @cite{x} refers to any parameters or independent variables, respectively. Specifically, these functions return ``true'' if the argument contains any @code{fitparam} (or @code{fitvar}) function calls, and ``false'' otherwise. (Recall that ``true'' means a nonzero number, and ``false'' means zero. The actual nonzero number returned is the largest @var{n} from all the @samp{fitparam(@var{n})}s or @samp{fitvar(@var{n})}s, respectively, that appear in the formula.) @tex \bigskip @end tex The @code{fit} function in algebraic notation normally takes four arguments, @samp{fit(@var{model}, @var{vars}, @var{params}, @var{data})}, where @var{model} is the model formula as it would be typed after @kbd{a F '}, @var{vars} is the independent variable or a vector of independent variables, @var{params} likewise gives the parameter(s), and @var{data} is the data matrix. Note that the length of @var{vars} must be equal to the number of rows in @var{data} if @var{model} is an equation, or one less than the number of rows if @var{model} is a plain formula. (Actually, a name for the dependent variable is allowed but will be ignored in the plain-formula case.) If @var{params} is omitted, the parameters are all variables in @var{model} except those that appear in @var{vars}. If @var{vars} is also omitted, Calc sorts all the variables that appear in @var{model} alphabetically and uses the higher ones for @var{vars} and the lower ones for @var{params}. Alternatively, @samp{fit(@var{modelvec}, @var{data})} is allowed where @var{modelvec} is a 2- or 3-vector describing the model and variables, as discussed previously. If Calc is unable to do the fit, the @code{fit} function is left in symbolic form, ordinarily with an explanatory message. The message will be ``Model expression is too complex'' if the linearizer was unable to put the model into the required form. The @code{efit} (corresponding to @kbd{H a F}) and @code{xfit} (for @kbd{I a F}) functions are completely analogous. @node Interpolation, , Curve Fitting Details, Curve Fitting @subsection Polynomial Interpolation @kindex a p @pindex calc-poly-interp @tindex polint The @kbd{a p} (@code{calc-poly-interp}) [@code{polint}] command does a polynomial interpolation at a particular @cite{x} value. It takes two arguments from the stack: A data matrix of the sort used by @kbd{a F}, and a single number which represents the desired @cite{x} value. Calc effectively does an exact polynomial fit as if by @kbd{a F i}, then substitutes the @cite{x} value into the result in order to get an approximate @cite{y} value based on the fit. (Calc does not actually use @kbd{a F i}, however; it uses a direct method which is both more efficient and more numerically stable.) The result of @kbd{a p} is actually a vector of two values: The @cite{y} value approximation, and an error measure @cite{dy} that reflects Calc's estimation of the probable error of the approximation at that value of @cite{x}. If the input @cite{x} is equal to any of the @cite{x} values in the data matrix, the output @cite{y} will be the corresponding @cite{y} value from the matrix, and the output @cite{dy} will be exactly zero. A prefix argument of 2 causes @kbd{a p} to take separate x- and y-vectors from the stack instead of one data matrix. If @cite{x} is a vector of numbers, @kbd{a p} will return a matrix of interpolated results for each of those @cite{x} values. (The matrix will have two columns, the @cite{y} values and the @cite{dy} values.) If @cite{x} is a formula instead of a number, the @code{polint} function remains in symbolic form; use the @kbd{a "} command to expand it out to a formula that describes the fit in symbolic terms. In all cases, the @kbd{a p} command leaves the data vectors or matrix on the stack. Only the @cite{x} value is replaced by the result. @kindex H a p @tindex ratint The @kbd{H a p} [@code{ratint}] command does a rational function interpolation. It is used exactly like @kbd{a p}, except that it uses as its model the quotient of two polynomials. If there are @cite{N} data points, the numerator and denominator polynomials will each have degree @cite{N/2} (if @cite{N} is odd, the denominator will have degree one higher than the numerator). Rational approximations have the advantage that they can accurately describe functions that have poles (points at which the function's value goes to infinity, so that the denominator polynomial of the approximation goes to zero). If @cite{x} corresponds to a pole of the fitted rational function, then the result will be a division by zero. If Infinite mode is enabled, the result will be @samp{[uinf, uinf]}. There is no way to get the actual coefficients of the rational function used by @kbd{H a p}. (The algorithm never generates these coefficients explicitly, and quotients of polynomials are beyond @w{@kbd{a F}}'s capabilities to fit.) @node Summations, Logical Operations, Curve Fitting, Algebra @section Summations @noindent @cindex Summation of a series @kindex a + @pindex calc-summation @tindex sum The @kbd{a +} (@code{calc-summation}) [@code{sum}] command computes the sum of a formula over a certain range of index values. The formula is taken from the top of the stack; the command prompts for the name of the summation index variable, the lower limit of the sum (any formula), and the upper limit of the sum. If you enter a blank line at any of these prompts, that prompt and any later ones are answered by reading additional elements from the stack. Thus, @kbd{' k^2 RET ' k RET 1 RET 5 RET a + RET} produces the result 55. @tex \turnoffactive $$ \sum_{k=1}^5 k^2 = 55 $$ @end tex The choice of index variable is arbitrary, but it's best not to use a variable with a stored value. In particular, while @code{i} is often a favorite index variable, it should be avoided in Calc because @code{i} has the imaginary constant @cite{(0, 1)} as a value. If you pressed @kbd{=} on a sum over @code{i}, it would be changed to a nonsensical sum over the ``variable'' @cite{(0, 1)}! If you really want to use @code{i} as an index variable, use @w{@kbd{s u i RET}} first to ``unstore'' this variable. (@xref{Storing Variables}.) A numeric prefix argument steps the index by that amount rather than by one. Thus @kbd{' a_k RET C-u -2 a + k RET 10 RET 0 RET} yields @samp{a_10 + a_8 + a_6 + a_4 + a_2 + a_0}. A prefix argument of plain @kbd{C-u} causes @kbd{a +} to prompt for the step value, in which case you can enter any formula or enter a blank line to take the step value from the stack. With the @kbd{C-u} prefix, @kbd{a +} can take up to five arguments from the stack: The formula, the variable, the lower limit, the upper limit, and (at the top of the stack), the step value. Calc knows how to do certain sums in closed form. For example, @samp{sum(6 k^2, k, 1, n) = @w{2 n^3} + 3 n^2 + n}. In particular, this is possible if the formula being summed is polynomial or exponential in the index variable. Sums of logarithms are transformed into logarithms of products. Sums of trigonometric and hyperbolic functions are transformed to sums of exponentials and then done in closed form. Also, of course, sums in which the lower and upper limits are both numbers can always be evaluated just by grinding them out, although Calc will use closed forms whenever it can for the sake of efficiency. The notation for sums in algebraic formulas is @samp{sum(@var{expr}, @var{var}, @var{low}, @var{high}, @var{step})}. If @var{step} is omitted, it defaults to one. If @var{high} is omitted, @var{low} is actually the upper limit and the lower limit is one. If @var{low} is also omitted, the limits are @samp{-inf} and @samp{inf}, respectively. Infinite sums can sometimes be evaluated: @samp{sum(.5^k, k, 1, inf)} returns @cite{1}. This is done by evaluating the sum in closed form (to @samp{1. - 0.5^n} in this case), then evaluating this formula with @code{n} set to @code{inf}. Calc's usual rules for ``infinite'' arithmetic can find the answer from there. If infinite arithmetic yields a @samp{nan}, or if the sum cannot be solved in closed form, Calc leaves the @code{sum} function in symbolic form. @xref{Infinities}. As a special feature, if the limits are infinite (or omitted, as described above) but the formula includes vectors subscripted by expressions that involve the iteration variable, Calc narrows the limits to include only the range of integers which result in legal subscripts for the vector. For example, the sum @samp{sum(k [a,b,c,d,e,f,g]_(2k),k)} evaluates to @samp{b + 2 d + 3 f}. The limits of a sum do not need to be integers. For example, @samp{sum(a_k, k, 0, 2 n, n)} produces @samp{a_0 + a_n + a_(2 n)}. Calc computes the number of iterations using the formula @samp{1 + (@var{high} - @var{low}) / @var{step}}, which must, after simplification as if by @kbd{a s}, evaluate to an integer. If the number of iterations according to the above formula does not come out to an integer, the sum is illegal and will be left in symbolic form. However, closed forms are still supplied, and you are on your honor not to misuse the resulting formulas by substituting mismatched bounds into them. For example, @samp{sum(k, k, 1, 10, 2)} is invalid, but Calc will go ahead and evaluate the closed form solution for the limits 1 and 10 to get the rather dubious answer, 29.25. If the lower limit is greater than the upper limit (assuming a positive step size), the result is generally zero. However, Calc only guarantees a zero result when the upper limit is exactly one step less than the lower limit, i.e., if the number of iterations is @i{-1}. Thus @samp{sum(f(k), k, n, n-1)} is zero but the sum from @samp{n} to @samp{n-2} may report a nonzero value if Calc used a closed form solution. Calc's logical predicates like @cite{a < b} return 1 for ``true'' and 0 for ``false.'' @xref{Logical Operations}. This can be used to advantage for building conditional sums. For example, @samp{sum(prime(k)*k^2, k, 1, 20)} is the sum of the squares of all prime numbers from 1 to 20; the @code{prime} predicate returns 1 if its argument is prime and 0 otherwise. You can read this expression as ``the sum of @cite{k^2}, where @cite{k} is prime.'' Indeed, @samp{sum(prime(k)*k^2, k)} would represent the sum of @emph{all} primes squared, since the limits default to plus and minus infinity, but there are no such sums that Calc's built-in rules can do in closed form. As another example, @samp{sum((k != k_0) * f(k), k, 1, n)} is the sum of @cite{f(k)} for all @cite{k} from 1 to @cite{n}, excluding one value @cite{k_0}. Slightly more tricky is the summand @samp{(k != k_0) / (k - k_0)}, which is an attempt to describe the sum of all @cite{1/(k-k_0)} except at @cite{k = k_0}, where this would be a division by zero. But at @cite{k = k_0}, this formula works out to the indeterminate form @cite{0 / 0}, which Calc will not assume is zero. Better would be to use @samp{(k != k_0) ? 1/(k-k_0) : 0}; the @samp{? :} operator does an ``if-then-else'' test: This expression says, ``if @c{$k \ne k_0$} @cite{k != k_0}, then @cite{1/(k-k_0)}, else zero.'' Now the formula @cite{1/(k-k_0)} will not even be evaluated by Calc when @cite{k = k_0}. @cindex Alternating sums @kindex a - @pindex calc-alt-summation @tindex asum The @kbd{a -} (@code{calc-alt-summation}) [@code{asum}] command computes an alternating sum. Successive terms of the sequence are given alternating signs, with the first term (corresponding to the lower index value) being positive. Alternating sums are converted to normal sums with an extra term of the form @samp{(-1)^(k-@var{low})}. This formula is adjusted appropriately if the step value is other than one. For example, the Taylor series for the sine function is @samp{asum(x^k / k!, k, 1, inf, 2)}. (Calc cannot evaluate this infinite series, but it can approximate it if you replace @code{inf} with any particular odd number.) Calc converts this series to a regular sum with a step of one, namely @samp{sum((-1)^k x^(2k+1) / (2k+1)!, k, 0, inf)}. @cindex Product of a sequence @kindex a * @pindex calc-product @tindex prod The @kbd{a *} (@code{calc-product}) [@code{prod}] command is the analogous way to take a product of many terms. Calc also knows some closed forms for products, such as @samp{prod(k, k, 1, n) = n!}. Conditional products can be written @samp{prod(k^prime(k), k, 1, n)} or @samp{prod(prime(k) ? k : 1, k, 1, n)}. @kindex a T @pindex calc-tabulate @tindex table The @kbd{a T} (@code{calc-tabulate}) [@code{table}] command evaluates a formula at a series of iterated index values, just like @code{sum} and @code{prod}, but its result is simply a vector of the results. For example, @samp{table(a_i, i, 1, 7, 2)} produces @samp{[a_1, a_3, a_5, a_7]}. @node Logical Operations, Rewrite Rules, Summations, Algebra @section Logical Operations @noindent The following commands and algebraic functions return true/false values, where 1 represents ``true'' and 0 represents ``false.'' In cases where a truth value is required (such as for the condition part of a rewrite rule, or as the condition for a @w{@kbd{Z [ Z ]}} control structure), any nonzero value is accepted to mean ``true.'' (Specifically, anything for which @code{dnonzero} returns 1 is ``true,'' and anything for which @code{dnonzero} returns 0 or cannot decide is assumed ``false.'' Note that this means that @w{@kbd{Z [ Z ]}} will execute the ``then'' portion if its condition is provably true, but it will execute the ``else'' portion for any condition like @cite{a = b} that is not provably true, even if it might be true. Algebraic functions that have conditions as arguments, like @code{? :} and @code{&&}, remain unevaluated if the condition is neither provably true nor provably false. @xref{Declarations}.) @kindex a = @pindex calc-equal-to @tindex eq @tindex = @tindex == The @kbd{a =} (@code{calc-equal-to}) command, or @samp{eq(a,b)} function (which can also be written @samp{a = b} or @samp{a == b} in an algebraic formula) is true if @cite{a} and @cite{b} are equal, either because they are identical expressions, or because they are numbers which are numerically equal. (Thus the integer 1 is considered equal to the float 1.0.) If the equality of @cite{a} and @cite{b} cannot be determined, the comparison is left in symbolic form. Note that as a command, this operation pops two values from the stack and pushes back either a 1 or a 0, or a formula @samp{a = b} if the values' equality cannot be determined. Many Calc commands use @samp{=} formulas to represent @dfn{equations}. For example, the @kbd{a S} (@code{calc-solve-for}) command rearranges an equation to solve for a given variable. The @kbd{a M} (@code{calc-map-equation}) command can be used to apply any function to both sides of an equation; for example, @kbd{2 a M *} multiplies both sides of the equation by two. Note that just @kbd{2 *} would not do the same thing; it would produce the formula @samp{2 (a = b)} which represents 2 if the equality is true or zero if not. The @code{eq} function with more than two arguments (e.g., @kbd{C-u 3 a =} or @samp{a = b = c}) tests if all of its arguments are equal. In algebraic notation, the @samp{=} operator is unusual in that it is neither left- nor right-associative: @samp{a = b = c} is not the same as @samp{(a = b) = c} or @samp{a = (b = c)} (which each compare one variable with the 1 or 0 that results from comparing two other variables). @kindex a # @pindex calc-not-equal-to @tindex neq @tindex != The @kbd{a #} (@code{calc-not-equal-to}) command, or @samp{neq(a,b)} or @samp{a != b} function, is true if @cite{a} and @cite{b} are not equal. This also works with more than two arguments; @samp{a != b != c != d} tests that all four of @cite{a}, @cite{b}, @cite{c}, and @cite{d} are distinct numbers. @kindex a < @tindex lt @c @mindex @idots @kindex a > @c @mindex @null @kindex a [ @c @mindex @null @kindex a ] @pindex calc-less-than @pindex calc-greater-than @pindex calc-less-equal @pindex calc-greater-equal @c @mindex @null @tindex gt @c @mindex @null @tindex leq @c @mindex @null @tindex geq @c @mindex @null @tindex < @c @mindex @null @tindex > @c @mindex @null @tindex <= @c @mindex @null @tindex >= The @kbd{a <} (@code{calc-less-than}) [@samp{lt(a,b)} or @samp{a < b}] operation is true if @cite{a} is less than @cite{b}. Similar functions are @kbd{a >} (@code{calc-greater-than}) [@samp{gt(a,b)} or @samp{a > b}], @kbd{a [} (@code{calc-less-equal}) [@samp{leq(a,b)} or @samp{a <= b}], and @kbd{a ]} (@code{calc-greater-equal}) [@samp{geq(a,b)} or @samp{a >= b}]. While the inequality functions like @code{lt} do not accept more than two arguments, the syntax @w{@samp{a <= b < c}} is translated to an equivalent expression involving intervals: @samp{b in [a .. c)}. (See the description of @code{in} below.) All four combinations of @samp{<} and @samp{<=} are allowed, or any of the four combinations of @samp{>} and @samp{>=}. Four-argument constructions like @samp{a < b < c < d}, and mixtures like @w{@samp{a < b = c}} that involve both equalities and inequalities, are not allowed. @kindex a . @pindex calc-remove-equal @tindex rmeq The @kbd{a .} (@code{calc-remove-equal}) [@code{rmeq}] command extracts the righthand side of the equation or inequality on the top of the stack. It also works elementwise on vectors. For example, if @samp{[x = 2.34, y = z / 2]} is on the stack, then @kbd{a .} produces @samp{[2.34, z / 2]}. As a special case, if the righthand side is a variable and the lefthand side is a number (as in @samp{2.34 = x}), then Calc keeps the lefthand side instead. Finally, this command works with assignments @samp{x := 2.34} as well as equations, always taking the the righthand side, and for @samp{=>} (evaluates-to) operators, always taking the lefthand side. @kindex a & @pindex calc-logical-and @tindex land @tindex && The @kbd{a &} (@code{calc-logical-and}) [@samp{land(a,b)} or @samp{a && b}] function is true if both of its arguments are true, i.e., are non-zero numbers. In this case, the result will be either @cite{a} or @cite{b}, chosen arbitrarily. If either argument is zero, the result is zero. Otherwise, the formula is left in symbolic form. @kindex a | @pindex calc-logical-or @tindex lor @tindex || The @kbd{a |} (@code{calc-logical-or}) [@samp{lor(a,b)} or @samp{a || b}] function is true if either or both of its arguments are true (nonzero). The result is whichever argument was nonzero, choosing arbitrarily if both are nonzero. If both @cite{a} and @cite{b} are zero, the result is zero. @kindex a ! @pindex calc-logical-not @tindex lnot @tindex ! The @kbd{a !} (@code{calc-logical-not}) [@samp{lnot(a)} or @samp{!@: a}] function is true if @cite{a} is false (zero), or false if @cite{a} is true (nonzero). It is left in symbolic form if @cite{a} is not a number. @kindex a : @pindex calc-logical-if @tindex if @c @mindex ? : @tindex ? @c @mindex @null @tindex : @cindex Arguments, not evaluated The @kbd{a :} (@code{calc-logical-if}) [@samp{if(a,b,c)} or @samp{a ? b :@: c}] function is equal to either @cite{b} or @cite{c} if @cite{a} is a nonzero number or zero, respectively. If @cite{a} is not a number, the test is left in symbolic form and neither @cite{b} nor @cite{c} is evaluated in any way. In algebraic formulas, this is one of the few Calc functions whose arguments are not automatically evaluated when the function itself is evaluated. The others are @code{lambda}, @code{quote}, and @code{condition}. One minor surprise to watch out for is that the formula @samp{a?3:4} will not work because the @samp{3:4} is parsed as a fraction instead of as three separate symbols. Type something like @samp{a ? 3 : 4} or @samp{a?(3):4} instead. As a special case, if @cite{a} evaluates to a vector, then both @cite{b} and @cite{c} are evaluated; the result is a vector of the same length as @cite{a} whose elements are chosen from corresponding elements of @cite{b} and @cite{c} according to whether each element of @cite{a} is zero or nonzero. Each of @cite{b} and @cite{c} must be either a vector of the same length as @cite{a}, or a non-vector which is matched with all elements of @cite{a}. @kindex a @{ @pindex calc-in-set @tindex in The @kbd{a @{} (@code{calc-in-set}) [@samp{in(a,b)}] function is true if the number @cite{a} is in the set of numbers represented by @cite{b}. If @cite{b} is an interval form, @cite{a} must be one of the values encompassed by the interval. If @cite{b} is a vector, @cite{a} must be equal to one of the elements of the vector. (If any vector elements are intervals, @cite{a} must be in any of the intervals.) If @cite{b} is a plain number, @cite{a} must be numerically equal to @cite{b}. @xref{Set Operations}, for a group of commands that manipulate sets of this sort. @c @starindex @tindex typeof The @samp{typeof(a)} function produces an integer or variable which characterizes @cite{a}. If @cite{a} is a number, vector, or variable, the result will be one of the following numbers: @example 1 Integer 2 Fraction 3 Floating-point number 4 HMS form 5 Rectangular complex number 6 Polar complex number 7 Error form 8 Interval form 9 Modulo form 10 Date-only form 11 Date/time form 12 Infinity (inf, uinf, or nan) 100 Variable 101 Vector (but not a matrix) 102 Matrix @end example Otherwise, @cite{a} is a formula, and the result is a variable which represents the name of the top-level function call. @c @starindex @tindex integer @c @starindex @tindex real @c @starindex @tindex constant The @samp{integer(a)} function returns true if @cite{a} is an integer. The @samp{real(a)} function is true if @cite{a} is a real number, either integer, fraction, or float. The @samp{constant(a)} function returns true if @cite{a} is any of the objects for which @code{typeof} would produce an integer code result except for variables, and provided that the components of an object like a vector or error form are themselves constant. Note that infinities do not satisfy any of these tests, nor do special constants like @code{pi} and @code{e}.@refill @xref{Declarations}, for a set of similar functions that recognize formulas as well as actual numbers. For example, @samp{dint(floor(x))} is true because @samp{floor(x)} is provably integer-valued, but @samp{integer(floor(x))} does not because @samp{floor(x)} is not literally an integer constant. @c @starindex @tindex refers The @samp{refers(a,b)} function is true if the variable (or sub-expression) @cite{b} appears in @cite{a}, or false otherwise. Unlike the other tests described here, this function returns a definite ``no'' answer even if its arguments are still in symbolic form. The only case where @code{refers} will be left unevaluated is if @cite{a} is a plain variable (different from @cite{b}). @c @starindex @tindex negative The @samp{negative(a)} function returns true if @cite{a} ``looks'' negative, because it is a negative number, because it is of the form @cite{-x}, or because it is a product or quotient with a term that looks negative. This is most useful in rewrite rules. Beware that @samp{negative(a)} evaluates to 1 or 0 for @emph{any} argument @cite{a}, so it can only be stored in a formula if the default simplifications are turned off first with @kbd{m O} (or if it appears in an unevaluated context such as a rewrite rule condition). @c @starindex @tindex variable The @samp{variable(a)} function is true if @cite{a} is a variable, or false if not. If @cite{a} is a function call, this test is left in symbolic form. Built-in variables like @code{pi} and @code{inf} are considered variables like any others by this test. @c @starindex @tindex nonvar The @samp{nonvar(a)} function is true if @cite{a} is a non-variable. If its argument is a variable it is left unsimplified; it never actually returns zero. However, since Calc's condition-testing commands consider ``false'' anything not provably true, this is often good enough. @c @starindex @tindex lin @c @starindex @tindex linnt @c @starindex @tindex islin @c @starindex @tindex islinnt @cindex Linearity testing The functions @code{lin}, @code{linnt}, @code{islin}, and @code{islinnt} check if an expression is ``linear,'' i.e., can be written in the form @cite{a + b x} for some constants @cite{a} and @cite{b}, and some variable or subformula @cite{x}. The function @samp{islin(f,x)} checks if formula @cite{f} is linear in @cite{x}, returning 1 if so. For example, @samp{islin(x,x)}, @samp{islin(-x,x)}, @samp{islin(3,x)}, and @samp{islin(x y / 3 - 2, x)} all return 1. The @samp{lin(f,x)} function is similar, except that instead of returning 1 it returns the vector @cite{[a, b, x]}. For the above examples, this vector would be @cite{[0, 1, x]}, @cite{[0, -1, x]}, @cite{[3, 0, x]}, and @cite{[-2, y/3, x]}, respectively. Both @code{lin} and @code{islin} generally remain unevaluated for expressions which are not linear, e.g., @samp{lin(2 x^2, x)} and @samp{lin(sin(x), x)}. The second argument can also be a formula; @samp{islin(2 + 3 sin(x), sin(x))} returns true. The @code{linnt} and @code{islinnt} functions perform a similar check, but require a ``non-trivial'' linear form, which means that the @cite{b} coefficient must be non-zero. For example, @samp{lin(2,x)} returns @cite{[2, 0, x]} and @samp{lin(y,x)} returns @cite{[y, 0, x]}, but @samp{linnt(2,x)} and @samp{linnt(y,x)} are left unevaluated (in other words, these formulas are considered to be only ``trivially'' linear in @cite{x}). All four linearity-testing functions allow you to omit the second argument, in which case the input may be linear in any non-constant formula. Here, the @cite{a=0}, @cite{b=1} case is also considered trivial, and only constant values for @cite{a} and @cite{b} are recognized. Thus, @samp{lin(2 x y)} returns @cite{[0, 2, x y]}, @samp{lin(2 - x y)} returns @cite{[2, -1, x y]}, and @samp{lin(x y)} returns @cite{[0, 1, x y]}. The @code{linnt} function would allow the first two cases but not the third. Also, neither @code{lin} nor @code{linnt} accept plain constants as linear in the one-argument case: @samp{islin(2,x)} is true, but @samp{islin(2)} is false. @c @starindex @tindex istrue The @samp{istrue(a)} function returns 1 if @cite{a} is a nonzero number or provably nonzero formula, or 0 if @cite{a} is anything else. Calls to @code{istrue} can only be manipulated if @kbd{m O} mode is used to make sure they are not evaluated prematurely. (Note that declarations are used when deciding whether a formula is true; @code{istrue} returns 1 when @code{dnonzero} would return 1, and it returns 0 when @code{dnonzero} would return 0 or leave itself in symbolic form.) @node Rewrite Rules, , Logical Operations, Algebra @section Rewrite Rules @noindent @cindex Rewrite rules @cindex Transformations @cindex Pattern matching @kindex a r @pindex calc-rewrite @tindex rewrite The @kbd{a r} (@code{calc-rewrite}) [@code{rewrite}] command makes substitutions in a formula according to a specified pattern or patterns known as @dfn{rewrite rules}. Whereas @kbd{a b} (@code{calc-substitute}) matches literally, so that substituting @samp{sin(x)} with @samp{cos(x)} matches only the @code{sin} function applied to the variable @code{x}, rewrite rules match general kinds of formulas; rewriting using the rule @samp{sin(x) := cos(x)} matches @code{sin} of any argument and replaces it with @code{cos} of that same argument. The only significance of the name @code{x} is that the same name is used on both sides of the rule. Rewrite rules rearrange formulas already in Calc's memory. @xref{Syntax Tables}, to read about @dfn{syntax rules}, which are similar to algebraic rewrite rules but operate when new algebraic entries are being parsed, converting strings of characters into Calc formulas. @menu * Entering Rewrite Rules:: * Basic Rewrite Rules:: * Conditional Rewrite Rules:: * Algebraic Properties of Rewrite Rules:: * Other Features of Rewrite Rules:: * Composing Patterns in Rewrite Rules:: * Nested Formulas with Rewrite Rules:: * Multi-Phase Rewrite Rules:: * Selections with Rewrite Rules:: * Matching Commands:: * Automatic Rewrites:: * Debugging Rewrites:: * Examples of Rewrite Rules:: @end menu @node Entering Rewrite Rules, Basic Rewrite Rules, Rewrite Rules, Rewrite Rules @subsection Entering Rewrite Rules @noindent Rewrite rules normally use the ``assignment'' operator @samp{@var{old} := @var{new}}. This operator is equivalent to the function call @samp{assign(old, new)}. The @code{assign} function is undefined by itself in Calc, so an assignment formula such as a rewrite rule will be left alone by ordinary Calc commands. But certain commands, like the rewrite system, interpret assignments in special ways.@refill For example, the rule @samp{sin(x)^2 := 1-cos(x)^2} says to replace every occurrence of the sine of something, squared, with one minus the square of the cosine of that same thing. All by itself as a formula on the stack it does nothing, but when given to the @kbd{a r} command it turns that command into a sine-squared-to-cosine-squared converter. To specify a set of rules to be applied all at once, make a vector of rules. When @kbd{a r} prompts you to enter the rewrite rules, you can answer in several ways: @enumerate @item With a rule: @kbd{f(x) := g(x) RET}. @item With a vector of rules: @kbd{[f1(x) := g1(x), f2(x) := g2(x)] RET}. (You can omit the enclosing square brackets if you wish.) @item With the name of a variable that contains the rule or rules vector: @kbd{myrules RET}. @item With any formula except a rule, a vector, or a variable name; this will be interpreted as the @var{old} half of a rewrite rule, and you will be prompted a second time for the @var{new} half: @kbd{f(x) @key{RET} g(x) @key{RET}}. @item With a blank line, in which case the rule, rules vector, or variable will be taken from the top of the stack (and the formula to be rewritten will come from the second-to-top position). @end enumerate If you enter the rules directly (as opposed to using rules stored in a variable), those rules will be put into the Trail so that you can retrieve them later. @xref{Trail Commands}. It is most convenient to store rules you use often in a variable and invoke them by giving the variable name. The @kbd{s e} (@code{calc-edit-variable}) command is an easy way to create or edit a rule set stored in a variable. You may also wish to use @kbd{s p} (@code{calc-permanent-variable}) to save your rules permanently; @pxref{Operations on Variables}.@refill Rewrite rules are compiled into a special internal form for faster matching. If you enter a rule set directly it must be recompiled every time. If you store the rules in a variable and refer to them through that variable, they will be compiled once and saved away along with the variable for later reference. This is another good reason to store your rules in a variable. Calc also accepts an obsolete notation for rules, as vectors @samp{[@var{old}, @var{new}]}. But because it is easily confused with a vector of two rules, the use of this notation is no longer recommended. @node Basic Rewrite Rules, Conditional Rewrite Rules, Entering Rewrite Rules, Rewrite Rules @subsection Basic Rewrite Rules @noindent To match a particular formula @cite{x} with a particular rewrite rule @samp{@var{old} := @var{new}}, Calc compares the structure of @cite{x} with the structure of @var{old}. Variables that appear in @var{old} are treated as @dfn{meta-variables}; the corresponding positions in @cite{x} may contain any sub-formulas. For example, the pattern @samp{f(x,y)} would match the expression @samp{f(12, a+1)} with the meta-variable @samp{x} corresponding to 12 and with @samp{y} corresponding to @samp{a+1}. However, this pattern would not match @samp{f(12)} or @samp{g(12, a+1)}, since there is no assignment of the meta-variables that will make the pattern match these expressions. Notice that if the pattern is a single meta-variable, it will match any expression. If a given meta-variable appears more than once in @var{old}, the corresponding sub-formulas of @cite{x} must be identical. Thus the pattern @samp{f(x,x)} would match @samp{f(12, 12)} and @samp{f(a+1, a+1)} but not @samp{f(12, a+1)} or @samp{f(a+b, b+a)}. (@xref{Conditional Rewrite Rules}, for a way to match the latter.) Things other than variables must match exactly between the pattern and the target formula. To match a particular variable exactly, use the pseudo-function @samp{quote(v)} in the pattern. For example, the pattern @samp{x+quote(y)} matches @samp{x+y}, @samp{2+y}, or @samp{sin(a)+y}. The special variable names @samp{e}, @samp{pi}, @samp{i}, @samp{phi}, @samp{gamma}, @samp{inf}, @samp{uinf}, and @samp{nan} always match literally. Thus the pattern @samp{sin(d + e + f)} acts exactly like @samp{sin(d + quote(e) + f)}. If the @var{old} pattern is found to match a given formula, that formula is replaced by @var{new}, where any occurrences in @var{new} of meta-variables from the pattern are replaced with the sub-formulas that they matched. Thus, applying the rule @samp{f(x,y) := g(y+x,x)} to @samp{f(12, a+1)} would produce @samp{g(a+13, 12)}. The normal @kbd{a r} command applies rewrite rules over and over throughout the target formula until no further changes are possible (up to a limit of 100 times). Use @kbd{C-u 1 a r} to make only one change at a time. @node Conditional Rewrite Rules, Algebraic Properties of Rewrite Rules, Basic Rewrite Rules, Rewrite Rules @subsection Conditional Rewrite Rules @noindent A rewrite rule can also be @dfn{conditional}, written in the form @samp{@var{old} := @var{new} :: @var{cond}}. (There is also the obsolete form @samp{[@var{old}, @var{new}, @var{cond}]}.) If a @var{cond} part is present in the rule, this is an additional condition that must be satisfied before the rule is accepted. Once @var{old} has been successfully matched to the target expression, @var{cond} is evaluated (with all the meta-variables substituted for the values they matched) and simplified with @kbd{a s} (@code{calc-simplify}). If the result is a nonzero number or any other object known to be nonzero (@pxref{Declarations}), the rule is accepted. If the result is zero or if it is a symbolic formula that is not known to be nonzero, the rule is rejected. @xref{Logical Operations}, for a number of functions that return 1 or 0 according to the results of various tests.@refill For example, the formula @samp{n > 0} simplifies to 1 or 0 if @cite{n} is replaced by a positive or nonpositive number, respectively (or if @cite{n} has been declared to be positive or nonpositive). Thus, the rule @samp{f(x,y) := g(y+x,x) :: x+y > 0} would apply to @samp{f(0, 4)} but not to @samp{f(-3, 2)} or @samp{f(12, a+1)} (assuming no outstanding declarations for @cite{a}). In the case of @samp{f(-3, 2)}, the condition can be shown not to be satisfied; in the case of @samp{f(12, a+1)}, the condition merely cannot be shown to be satisfied, but that is enough to reject the rule. While Calc will use declarations to reason about variables in the formula being rewritten, declarations do not apply to meta-variables. For example, the rule @samp{f(a) := g(a+1)} will match for any values of @samp{a}, such as complex numbers, vectors, or formulas, even if @samp{a} has been declared to be real or scalar. If you want the meta-variable @samp{a} to match only literal real numbers, use @samp{f(a) := g(a+1) :: real(a)}. If you want @samp{a} to match only reals and formulas which are provably real, use @samp{dreal(a)} as the condition. The @samp{::} operator is a shorthand for the @code{condition} function; @samp{@var{old} := @var{new} :: @var{cond}} is equivalent to the formula @samp{condition(assign(@var{old}, @var{new}), @var{cond})}. If you have several conditions, you can use @samp{... :: c1 :: c2 :: c3} or @samp{... :: c1 && c2 && c3}. The two are entirely equivalent. It is also possible to embed conditions inside the pattern: @samp{f(x :: x>0, y) := g(y+x, x)}. This is purely a notational convenience, though; where a condition appears in a rule has no effect on when it is tested. The rewrite-rule compiler automatically decides when it is best to test each condition while a rule is being matched. Certain conditions are handled as special cases by the rewrite rule system and are tested very efficiently: Where @cite{x} is any meta-variable, these conditions are @samp{integer(x)}, @samp{real(x)}, @samp{constant(x)}, @samp{negative(x)}, @samp{x >= y} where @cite{y} is either a constant or another meta-variable and @samp{>=} may be replaced by any of the six relational operators, and @samp{x % a = b} where @cite{a} and @cite{b} are constants. Other conditions, like @samp{x >= y+1} or @samp{dreal(x)}, will be less efficient to check since Calc must bring the whole evaluator and simplifier into play. An interesting property of @samp{::} is that neither of its arguments will be touched by Calc's default simplifications. This is important because conditions often are expressions that cannot safely be evaluated early. For example, the @code{typeof} function never remains in symbolic form; entering @samp{typeof(a)} will put the number 100 (the type code for variables like @samp{a}) on the stack. But putting the condition @samp{... :: typeof(a) = 6} on the stack is safe since @samp{::} prevents the @code{typeof} from being evaluated until the condition is actually used by the rewrite system. Since @samp{::} protects its lefthand side, too, you can use a dummy condition to protect a rule that must itself not evaluate early. For example, it's not safe to put @samp{a(f,x) := apply(f, [x])} on the stack because it will immediately evaluate to @samp{a(f,x) := f(x)}, where the meta-variable-ness of @code{f} on the righthand side has been lost. But @samp{a(f,x) := apply(f, [x]) :: 1} is safe, and of course the condition @samp{1} is always true (nonzero) so it has no effect on the functioning of the rule. (The rewrite compiler will ensure that it doesn't even impact the speed of matching the rule.) @node Algebraic Properties of Rewrite Rules, Other Features of Rewrite Rules, Conditional Rewrite Rules, Rewrite Rules @subsection Algebraic Properties of Rewrite Rules @noindent The rewrite mechanism understands the algebraic properties of functions like @samp{+} and @samp{*}. In particular, pattern matching takes the associativity and commutativity of the following functions into account: @smallexample + - * = != && || and or xor vint vunion vxor gcd lcm max min beta @end smallexample For example, the rewrite rule: @example a x + b x := (a + b) x @end example @noindent will match formulas of the form, @example a x + b x, x a + x b, a x + x b, x a + b x @end example Rewrites also understand the relationship between the @samp{+} and @samp{-} operators. The above rewrite rule will also match the formulas, @example a x - b x, x a - x b, a x - x b, x a - b x @end example @noindent by matching @samp{b} in the pattern to @samp{-b} from the formula. Applied to a sum of many terms like @samp{r + a x + s + b x + t}, this pattern will check all pairs of terms for possible matches. The rewrite will take whichever suitable pair it discovers first. In general, a pattern using an associative operator like @samp{a + b} will try @i{2 n} different ways to match a sum of @i{n} terms like @samp{x + y + z - w}. First, @samp{a} is matched against each of @samp{x}, @samp{y}, @samp{z}, and @samp{-w} in turn, with @samp{b} being matched to the remainders @samp{y + z - w}, @samp{x + z - w}, etc. If none of these succeed, then @samp{b} is matched against each of the four terms with @samp{a} matching the remainder. Half-and-half matches, like @samp{(x + y) + (z - w)}, are not tried. Note that @samp{*} is not commutative when applied to matrices, but rewrite rules pretend that it is. If you type @kbd{m v} to enable matrix mode (@pxref{Matrix Mode}), rewrite rules will match @samp{*} literally, ignoring its usual commutativity property. (In the current implementation, the associativity also vanishes---it is as if the pattern had been enclosed in a @code{plain} marker; see below.) If you are applying rewrites to formulas with matrices, it's best to enable matrix mode first to prevent algebraically incorrect rewrites from occurring. The pattern @samp{-x} will actually match any expression. For example, the rule @example f(-x) := -f(x) @end example @noindent will rewrite @samp{f(a)} to @samp{-f(-a)}. To avoid this, either use a @code{plain} marker as described below, or add a @samp{negative(x)} condition. The @code{negative} function is true if its argument ``looks'' negative, for example, because it is a negative number or because it is a formula like @samp{-x}. The new rule using this condition is: @example f(x) := -f(-x) :: negative(x) @r{or, equivalently,} f(-x) := -f(x) :: negative(-x) @end example In the same way, the pattern @samp{x - y} will match the sum @samp{a + b} by matching @samp{y} to @samp{-b}. The pattern @samp{a b} will also match the formula @samp{x/y} if @samp{y} is a number. Thus the rule @samp{a x + @w{b x} := (a+b) x} will also convert @samp{a x + x / 2} to @samp{(a + 0.5) x} (or @samp{(a + 1:2) x}, depending on the current fraction mode). Calc will @emph{not} take other liberties with @samp{*}, @samp{/}, and @samp{^}. For example, the pattern @samp{f(a b)} will not match @samp{f(x^2)}, and @samp{f(a + b)} will not match @samp{f(2 x)}, even though conceivably these patterns could match with @samp{a = b = x}. Nor will @samp{f(a b)} match @samp{f(x / y)} if @samp{y} is not a constant, even though it could be considered to match with @samp{a = x} and @samp{b = 1/y}. The reasons are partly for efficiency, and partly because while few mathematical operations are substantively different for addition and subtraction, often it is preferable to treat the cases of multiplication, division, and integer powers separately. Even more subtle is the rule set @example [ f(a) + f(b) := f(a + b), -f(a) := f(-a) ] @end example @noindent attempting to match @samp{f(x) - f(y)}. You might think that Calc will view this subtraction as @samp{f(x) + (-f(y))} and then apply the above two rules in turn, but actually this will not work because Calc only does this when considering rules for @samp{+} (like the first rule in this set). So it will see first that @samp{f(x) + (-f(y))} does not match @samp{f(a) + f(b)} for any assignments of the meta-variables, and then it will see that @samp{f(x) - f(y)} does not match @samp{-f(a)} for any assignment of @samp{a}. Because Calc tries only one rule at a time, it will not be able to rewrite @samp{f(x) - f(y)} with this rule set. An explicit @samp{f(a) - f(b)} rule will have to be added. Another thing patterns will @emph{not} do is break up complex numbers. The pattern @samp{myconj(a + @w{b i)} := a - b i} will work for formulas involving the special constant @samp{i} (such as @samp{3 - 4 i}), but it will not match actual complex numbers like @samp{(3, -4)}. A version of the above rule for complex numbers would be @example myconj(a) := re(a) - im(a) (0,1) :: im(a) != 0 @end example @noindent (Because the @code{re} and @code{im} functions understand the properties of the special constant @samp{i}, this rule will also work for @samp{3 - 4 i}. In fact, this particular rule would probably be better without the @samp{im(a) != 0} condition, since if @samp{im(a) = 0} the righthand side of the rule will still give the correct answer for the conjugate of a real number.) It is also possible to specify optional arguments in patterns. The rule @example opt(a) x + opt(b) (x^opt(c) + opt(d)) := f(a, b, c, d) @end example @noindent will match the formula @example 5 (x^2 - 4) + 3 x @end example @noindent in a fairly straightforward manner, but it will also match reduced formulas like @example x + x^2, 2(x + 1) - x, x + x @end example @noindent producing, respectively, @example f(1, 1, 2, 0), f(-1, 2, 1, 1), f(1, 1, 1, 0) @end example (The latter two formulas can be entered only if default simplifications have been turned off with @kbd{m O}.) The default value for a term of a sum is zero. The default value for a part of a product, for a power, or for the denominator of a quotient, is one. Also, @samp{-x} matches the pattern @samp{opt(a) b} with @samp{a = -1}. In particular, the distributive-law rule can be refined to @example opt(a) x + opt(b) x := (a + b) x @end example @noindent so that it will convert, e.g., @samp{a x - x}, to @samp{(a - 1) x}. The pattern @samp{opt(a) + opt(b) x} matches almost any formulas which are linear in @samp{x}. You can also use the @code{lin} and @code{islin} functions with rewrite conditions to test for this; @pxref{Logical Operations}. These functions are not as convenient to use in rewrite rules, but they recognize more kinds of formulas as linear: @samp{x/z} is considered linear with @cite{b = 1/z} by @code{lin}, but it will not match the above pattern because that pattern calls for a multiplication, not a division. As another example, the obvious rule to replace @samp{sin(x)^2 + cos(x)^2} by 1, @example sin(x)^2 + cos(x)^2 := 1 @end example @noindent misses many cases because the sine and cosine may both be multiplied by an equal factor. Here's a more successful rule: @example opt(a) sin(x)^2 + opt(a) cos(x)^2 := a @end example Note that this rule will @emph{not} match @samp{sin(x)^2 + 6 cos(x)^2} because one @cite{a} would have ``matched'' 1 while the other matched 6. Calc automatically converts a rule like @example f(x-1, x) := g(x) @end example @noindent into the form @example f(temp, x) := g(x) :: temp = x-1 @end example @noindent (where @code{temp} stands for a new, invented meta-variable that doesn't actually have a name). This modified rule will successfully match @samp{f(6, 7)}, binding @samp{temp} and @samp{x} to 6 and 7, respectively, then verifying that they differ by one even though @samp{6} does not superficially look like @samp{x-1}. However, Calc does not solve equations to interpret a rule. The following rule, @example f(x-1, x+1) := g(x) @end example @noindent will not work. That is, it will match @samp{f(a - 1 + b, a + 1 + b)} but not @samp{f(6, 8)}. Calc always interprets at least one occurrence of a variable by literal matching. If the variable appears ``isolated'' then Calc is smart enough to use it for literal matching. But in this last example, Calc is forced to rewrite the rule to @samp{f(x-1, temp) := g(x) :: temp = x+1} where the @samp{x-1} term must correspond to an actual ``something-minus-one'' in the target formula. A successful way to write this would be @samp{f(x, x+2) := g(x+1)}. You could make this resemble the original form more closely by using @code{let} notation, which is described in the next section: @example f(xm1, x+1) := g(x) :: let(x := xm1+1) @end example Calc does this rewriting or ``conditionalizing'' for any sub-pattern which involves only the functions in the following list, operating only on constants and meta-variables which have already been matched elsewhere in the pattern. When matching a function call, Calc is careful to match arguments which are plain variables before arguments which are calls to any of the functions below, so that a pattern like @samp{f(x-1, x)} can be conditionalized even though the isolated @samp{x} comes after the @samp{x-1}. @smallexample + - * / \ % ^ abs sign round rounde roundu trunc floor ceil max min re im conj arg @end smallexample You can suppress all of the special treatments described in this section by surrounding a function call with a @code{plain} marker. This marker causes the function call which is its argument to be matched literally, without regard to commutativity, associativity, negation, or conditionalization. When you use @code{plain}, the ``deep structure'' of the formula being matched can show through. For example, @example plain(a - a b) := f(a, b) @end example @noindent will match only literal subtractions. However, the @code{plain} marker does not affect its arguments' arguments. In this case, commutativity and associativity is still considered while matching the @w{@samp{a b}} sub-pattern, so the whole pattern will match @samp{x - y x} as well as @samp{x - x y}. We could go still further and use @example plain(a - plain(a b)) := f(a, b) @end example @noindent which would do a completely strict match for the pattern. By contrast, the @code{quote} marker means that not only the function name but also the arguments must be literally the same. The above pattern will match @samp{x - x y} but @example quote(a - a b) := f(a, b) @end example @noindent will match only the single formula @samp{a - a b}. Also, @example quote(a - quote(a b)) := f(a, b) @end example @noindent will match only @samp{a - quote(a b)}---probably not the desired effect! A certain amount of algebra is also done when substituting the meta-variables on the righthand side of a rule. For example, in the rule @example a + f(b) := f(a + b) @end example @noindent matching @samp{f(x) - y} would produce @samp{f((-y) + x)} if taken literally, but the rewrite mechanism will simplify the righthand side to @samp{f(x - y)} automatically. (Of course, the default simplifications would do this anyway, so this special simplification is only noticeable if you have turned the default simplifications off.) This rewriting is done only when a meta-variable expands to a ``negative-looking'' expression. If this simplification is not desirable, you can use a @code{plain} marker on the righthand side: @example a + f(b) := f(plain(a + b)) @end example @noindent In this example, we are still allowing the pattern-matcher to use all the algebra it can muster, but the righthand side will always simplify to a literal addition like @samp{f((-y) + x)}. @node Other Features of Rewrite Rules, Composing Patterns in Rewrite Rules, Algebraic Properties of Rewrite Rules, Rewrite Rules @subsection Other Features of Rewrite Rules @noindent Certain ``function names'' serve as markers in rewrite rules. Here is a complete list of these markers. First are listed the markers that work inside a pattern; then come the markers that work in the righthand side of a rule. @c @starindex @tindex import One kind of marker, @samp{import(x)}, takes the place of a whole rule. Here @cite{x} is the name of a variable containing another rule set; those rules are ``spliced into'' the rule set that imports them. For example, if @samp{[f(a+b) := f(a) + f(b), f(a b) := a f(b) :: real(a)]} is stored in variable @samp{linearF}, then the rule set @samp{[f(0) := 0, import(linearF)]} will apply all three rules. It is possible to modify the imported rules slightly: @samp{import(x, v1, x1, v2, x2, @dots{})} imports the rule set @cite{x} with all occurrences of @c{$v_1$} @cite{v1}, as either a variable name or a function name, replaced with @c{$x_1$} @cite{x1} and so on. (If @c{$v_1$} @cite{v1} is used as a function name, then @c{$x_1$} @cite{x1} must be either a function name itself or a @w{@samp{< >}} nameless function; @pxref{Specifying Operators}.) For example, @samp{[g(0) := 0, import(linearF, f, g)]} applies the linearity rules to the function @samp{g} instead of @samp{f}. Imports can be nested, but the import-with-renaming feature may fail to rename sub-imports properly. The special functions allowed in patterns are: @table @samp @item quote(x) @c @starindex @tindex quote This pattern matches exactly @cite{x}; variable names in @cite{x} are not interpreted as meta-variables. The only flexibility is that numbers are compared for numeric equality, so that the pattern @samp{f(quote(12))} will match both @samp{f(12)} and @samp{f(12.0)}. (Numbers are always treated this way by the rewrite mechanism: The rule @samp{f(x,x) := g(x)} will match @samp{f(12, 12.0)}. The rewrite may produce either @samp{g(12)} or @samp{g(12.0)} as a result in this case.) @item plain(x) @c @starindex @tindex plain Here @cite{x} must be a function call @samp{f(x1,x2,@dots{})}. This pattern matches a call to function @cite{f} with the specified argument patterns. No special knowledge of the properties of the function @cite{f} is used in this case; @samp{+} is not commutative or associative. Unlike @code{quote}, the arguments @samp{x1,x2,@dots{}} are treated as patterns. If you wish them to be treated ``plainly'' as well, you must enclose them with more @code{plain} markers: @samp{plain(plain(@w{-a}) + plain(b c))}. @item opt(x,def) @c @starindex @tindex opt Here @cite{x} must be a variable name. This must appear as an argument to a function or an element of a vector; it specifies that the argument or element is optional. As an argument to @samp{+}, @samp{-}, @samp{*}, @samp{&&}, or @samp{||}, or as the second argument to @samp{/} or @samp{^}, the value @var{def} may be omitted. The pattern @samp{x + opt(y)} matches a sum by binding one summand to @cite{x} and the other to @cite{y}, and it matches anything else by binding the whole expression to @cite{x} and zero to @cite{y}. The other operators above work similarly.@refill For general miscellanous functions, the default value @code{def} must be specified. Optional arguments are dropped starting with the rightmost one during matching. For example, the pattern @samp{f(opt(a,0), b, opt(c,b))} will match @samp{f(b)}, @samp{f(a,b)}, or @samp{f(a,b,c)}. Default values of zero and @cite{b} are supplied in this example for the omitted arguments. Note that the literal variable @cite{b} will be the default in the latter case, @emph{not} the value that matched the meta-variable @cite{b}. In other words, the default @var{def} is effectively quoted. @item condition(x,c) @c @starindex @tindex condition @tindex :: This matches the pattern @cite{x}, with the attached condition @cite{c}. It is the same as @samp{x :: c}. @item pand(x,y) @c @starindex @tindex pand @tindex &&& This matches anything that matches both pattern @cite{x} and pattern @cite{y}. It is the same as @samp{x &&& y}. @pxref{Composing Patterns in Rewrite Rules}. @item por(x,y) @c @starindex @tindex por @tindex ||| This matches anything that matches either pattern @cite{x} or pattern @cite{y}. It is the same as @w{@samp{x ||| y}}. @item pnot(x) @c @starindex @tindex pnot @tindex !!! This matches anything that does not match pattern @cite{x}. It is the same as @samp{!!! x}. @item cons(h,t) @c @mindex cons @tindex cons (rewrites) This matches any vector of one or more elements. The first element is matched to @cite{h}; a vector of the remaining elements is matched to @cite{t}. Note that vectors of fixed length can also be matched as actual vectors: The rule @samp{cons(a,cons(b,[])) := cons(a+b,[])} is equivalent to the rule @samp{[a,b] := [a+b]}. @item rcons(t,h) @c @mindex rcons @tindex rcons (rewrites) This is like @code{cons}, except that the @emph{last} element is matched to @cite{h}, with the remaining elements matched to @cite{t}. @item apply(f,args) @c @mindex apply @tindex apply (rewrites) This matches any function call. The name of the function, in the form of a variable, is matched to @cite{f}. The arguments of the function, as a vector of zero or more objects, are matched to @samp{args}. Constants, variables, and vectors do @emph{not} match an @code{apply} pattern. For example, @samp{apply(f,x)} matches any function call, @samp{apply(quote(f),x)} matches any call to the function @samp{f}, @samp{apply(f,[a,b])} matches any function call with exactly two arguments, and @samp{apply(quote(f), cons(a,cons(b,x)))} matches any call to the function @samp{f} with two or more arguments. Another way to implement the latter, if the rest of the rule does not need to refer to the first two arguments of @samp{f} by name, would be @samp{apply(quote(f), x :: vlen(x) >= 2)}. Here's a more interesting sample use of @code{apply}: @example apply(f,[x+n]) := n + apply(f,[x]) :: in(f, [floor,ceil,round,trunc]) :: integer(n) @end example Note, however, that this will be slower to match than a rule set with four separate rules. The reason is that Calc sorts the rules of a rule set according to top-level function name; if the top-level function is @code{apply}, Calc must try the rule for every single formula and sub-formula. If the top-level function in the pattern is, say, @code{floor}, then Calc invokes the rule only for sub-formulas which are calls to @code{floor}. Formulas normally written with operators like @code{+} are still considered function calls: @code{apply(f,x)} matches @samp{a+b} with @samp{f = add}, @samp{x = [a,b]}. You must use @code{apply} for meta-variables with function names on both sides of a rewrite rule: @samp{apply(f, [x]) := f(x+1)} is @emph{not} correct, because it rewrites @samp{spam(6)} into @samp{f(7)}. The righthand side should be @samp{apply(f, [x+1])}. Also note that you will have to use no-simplify (@kbd{m O}) mode when entering this rule so that the @code{apply} isn't evaluated immediately to get the new rule @samp{f(x) := f(x+1)}. Or, use @kbd{s e} to enter the rule without going through the stack, or enter the rule as @samp{apply(f, [x]) := apply(f, [x+1]) @w{:: 1}}. @xref{Conditional Rewrite Rules}. @item select(x) @c @starindex @tindex select This is used for applying rules to formulas with selections; @pxref{Selections with Rewrite Rules}. @end table Special functions for the righthand sides of rules are: @table @samp @item quote(x) The notation @samp{quote(x)} is changed to @samp{x} when the righthand side is used. As far as the rewrite rule is concerned, @code{quote} is invisible. However, @code{quote} has the special property in Calc that its argument is not evaluated. Thus, while it will not work to put the rule @samp{t(a) := typeof(a)} on the stack because @samp{typeof(a)} is evaluated immediately to produce @samp{t(a) := 100}, you can use @code{quote} to protect the righthand side: @samp{t(a) := quote(typeof(a))}. (@xref{Conditional Rewrite Rules}, for another trick for protecting rules from evaluation.) @item plain(x) Special properties of and simplifications for the function call @cite{x} are not used. One interesting case where @code{plain} is useful is the rule, @samp{q(x) := quote(x)}, trying to expand a shorthand notation for the @code{quote} function. This rule will not work as shown; instead of replacing @samp{q(foo)} with @samp{quote(foo)}, it will replace it with @samp{foo}! The correct rule would be @samp{q(x) := plain(quote(x))}. @item cons(h,t) Where @cite{t} is a vector, this is converted into an expanded vector during rewrite processing. Note that @code{cons} is a regular Calc function which normally does this anyway; the only way @code{cons} is treated specially by rewrites is that @code{cons} on the righthand side of a rule will be evaluated even if default simplifications have been turned off. @item rcons(t,h) Analogous to @code{cons} except putting @cite{h} at the @emph{end} of the vector @cite{t}. @item apply(f,args) Where @cite{f} is a variable and @var{args} is a vector, this is converted to a function call. Once again, note that @code{apply} is also a regular Calc function. @item eval(x) @c @starindex @tindex eval The formula @cite{x} is handled in the usual way, then the default simplifications are applied to it even if they have been turned off normally. This allows you to treat any function similarly to the way @code{cons} and @code{apply} are always treated. However, there is a slight difference: @samp{cons(2+3, [])} with default simplifications off will be converted to @samp{[2+3]}, whereas @samp{eval(cons(2+3, []))} will be converted to @samp{[5]}. @item evalsimp(x) @c @starindex @tindex evalsimp The formula @cite{x} has meta-variables substituted in the usual way, then algebraically simplified as if by the @kbd{a s} command. @item evalextsimp(x) @c @starindex @tindex evalextsimp The formula @cite{x} has meta-variables substituted in the normal way, then ``extendedly'' simplified as if by the @kbd{a e} command. @item select(x) @xref{Selections with Rewrite Rules}. @end table There are also some special functions you can use in conditions. @table @samp @item let(v := x) @c @starindex @tindex let The expression @cite{x} is evaluated with meta-variables substituted. The @kbd{a s} command's simplifications are @emph{not} applied by default, but @cite{x} can include calls to @code{evalsimp} or @code{evalextsimp} as described above to invoke higher levels of simplification. The result of @cite{x} is then bound to the meta-variable @cite{v}. As usual, if this meta-variable has already been matched to something else the two values must be equal; if the meta-variable is new then it is bound to the result of the expression. This variable can then appear in later conditions, and on the righthand side of the rule. In fact, @cite{v} may be any pattern in which case the result of evaluating @cite{x} is matched to that pattern, binding any meta-variables that appear in that pattern. Note that @code{let} can only appear by itself as a condition, or as one term of an @samp{&&} which is a whole condition: It cannot be inside an @samp{||} term or otherwise buried.@refill The alternate, equivalent form @samp{let(v, x)} is also recognized. Note that the use of @samp{:=} by @code{let}, while still being assignment-like in character, is unrelated to the use of @samp{:=} in the main part of a rewrite rule. As an example, @samp{f(a) := g(ia) :: let(ia := 1/a) :: constant(ia)} replaces @samp{f(a)} with @samp{g} of the inverse of @samp{a}, if that inverse exists and is constant. For example, if @samp{a} is a singular matrix the operation @samp{1/a} is left unsimplified and @samp{constant(ia)} fails, but if @samp{a} is an invertible matrix then the rule succeeds. Without @code{let} there would be no way to express this rule that didn't have to invert the matrix twice. Note that, because the meta-variable @samp{ia} is otherwise unbound in this rule, the @code{let} condition itself always ``succeeds'' because no matter what @samp{1/a} evaluates to, it can successfully be bound to @code{ia}.@refill Here's another example, for integrating cosines of linear terms: @samp{myint(cos(y),x) := sin(y)/b :: let([a,b,x] := lin(y,x))}. The @code{lin} function returns a 3-vector if its argument is linear, or leaves itself unevaluated if not. But an unevaluated @code{lin} call will not match the 3-vector on the lefthand side of the @code{let}, so this @code{let} both verifies that @code{y} is linear, and binds the coefficients @code{a} and @code{b} for use elsewhere in the rule. (It would have been possible to use @samp{sin(a x + b)/b} for the righthand side instead, but using @samp{sin(y)/b} avoids gratuitous rearrangement of the argument of the sine.)@refill @c @starindex @tindex ierf Similarly, here is a rule that implements an inverse-@code{erf} function. It uses @code{root} to search for a solution. If @code{root} succeeds, it will return a vector of two numbers where the first number is the desired solution. If no solution is found, @code{root} remains in symbolic form. So we use @code{let} to check that the result was indeed a vector. @example ierf(x) := y :: let([y,z] := root(erf(a) = x, a, .5)) @end example @item matches(v,p) The meta-variable @var{v}, which must already have been matched to something elsewhere in the rule, is compared against pattern @var{p}. Since @code{matches} is a standard Calc function, it can appear anywhere in a condition. But if it appears alone or as a term of a top-level @samp{&&}, then you get the special extra feature that meta-variables which are bound to things inside @var{p} can be used elsewhere in the surrounding rewrite rule. The only real difference between @samp{let(p := v)} and @samp{matches(v, p)} is that the former evaluates @samp{v} using the default simplifications, while the latter does not. @item remember @vindex remember This is actually a variable, not a function. If @code{remember} appears as a condition in a rule, then when that rule succeeds the original expression and rewritten expression are added to the front of the rule set that contained the rule. If the rule set was not stored in a variable, @code{remember} is ignored. The lefthand side is enclosed in @code{quote} in the added rule if it contains any variables. For example, the rule @samp{f(n) := n f(n-1) :: remember} applied to @samp{f(7)} will add the rule @samp{f(7) := 7 f(6)} to the front of the rule set. The rule set @code{EvalRules} works slightly differently: There, the evaluation of @samp{f(6)} will complete before the result is added to the rule set, in this case as @samp{f(7) := 5040}. Thus @code{remember} is most useful inside @code{EvalRules}. It is up to you to ensure that the optimization performed by @code{remember} is safe. For example, the rule @samp{foo(n) := n :: evalv(eatfoo) > 0 :: remember} is a bad idea (@code{evalv} is the function equivalent of the @kbd{=} command); if the variable @code{eatfoo} ever contains 1, rules like @samp{foo(7) := 7} will be added to the rule set and will continue to operate even if @code{eatfoo} is later changed to 0. @item remember(c) @c @starindex @tindex remember Remember the match as described above, but only if condition @cite{c} is true. For example, @samp{remember(n % 4 = 0)} in the above factorial rule remembers only every fourth result. Note that @samp{remember(1)} is equivalent to @samp{remember}, and @samp{remember(0)} has no effect. @end table @node Composing Patterns in Rewrite Rules, Nested Formulas with Rewrite Rules, Other Features of Rewrite Rules, Rewrite Rules @subsection Composing Patterns in Rewrite Rules @noindent There are three operators, @samp{&&&}, @samp{|||}, and @samp{!!!}, that combine rewrite patterns to make larger patterns. The combinations are ``and,'' ``or,'' and ``not,'' respectively, and these operators are the pattern equivalents of @samp{&&}, @samp{||} and @samp{!} (which operate on zero-or-nonzero logical values). Note that @samp{&&&}, @samp{|||}, and @samp{!!!} are left in symbolic form by all regular Calc features; they have special meaning only in the context of rewrite rule patterns. The pattern @samp{@var{p1} &&& @var{p2}} matches anything that matches both @var{p1} and @var{p2}. One especially useful case is when one of @var{p1} or @var{p2} is a meta-variable. For example, here is a rule that operates on error forms: @example f(x &&& a +/- b, x) := g(x) @end example This does the same thing, but is arguably simpler than, the rule @example f(a +/- b, a +/- b) := g(a +/- b) @end example @c @starindex @tindex ends Here's another interesting example: @example ends(cons(a, x) &&& rcons(y, b)) := [a, b] @end example @noindent which effectively clips out the middle of a vector leaving just the first and last elements. This rule will change a one-element vector @samp{[a]} to @samp{[a, a]}. The similar rule @example ends(cons(a, rcons(y, b))) := [a, b] @end example @noindent would do the same thing except that it would fail to match a one-element vector. @tex \bigskip @end tex The pattern @samp{@var{p1} ||| @var{p2}} matches anything that matches either @var{p1} or @var{p2}. Calc first tries matching against @var{p1}; if that fails, it goes on to try @var{p2}. @c @starindex @tindex curve A simple example of @samp{|||} is @example curve(inf ||| -inf) := 0 @end example @noindent which converts both @samp{curve(inf)} and @samp{curve(-inf)} to zero. Here is a larger example: @example log(a, b) ||| (ln(a) :: let(b := e)) := mylog(a, b) @end example This matches both generalized and natural logarithms in a single rule. Note that the @samp{::} term must be enclosed in parentheses because that operator has lower precedence than @samp{|||} or @samp{:=}. (In practice this rule would probably include a third alternative, omitted here for brevity, to take care of @code{log10}.) While Calc generally treats interior conditions exactly the same as conditions on the outside of a rule, it does guarantee that if all the variables in the condition are special names like @code{e}, or already bound in the pattern to which the condition is attached (say, if @samp{a} had appeared in this condition), then Calc will process this condition right after matching the pattern to the left of the @samp{::}. Thus, we know that @samp{b} will be bound to @samp{e} only if the @code{ln} branch of the @samp{|||} was taken. Note that this rule was careful to bind the same set of meta-variables on both sides of the @samp{|||}. Calc does not check this, but if you bind a certain meta-variable only in one branch and then use that meta-variable elsewhere in the rule, results are unpredictable: @example f(a,b) ||| g(b) := h(a,b) @end example Here if the pattern matches @samp{g(17)}, Calc makes no promises about the value that will be substituted for @samp{a} on the righthand side. @tex \bigskip @end tex The pattern @samp{!!! @var{pat}} matches anything that does not match @var{pat}. Any meta-variables that are bound while matching @var{pat} remain unbound outside of @var{pat}. For example, @example f(x &&& !!! a +/- b, !!![]) := g(x) @end example @noindent converts @code{f} whose first argument is anything @emph{except} an error form, and whose second argument is not the empty vector, into a similar call to @code{g} (but without the second argument). If we know that the second argument will be a vector (empty or not), then an equivalent rule would be: @example f(x, y) := g(x) :: typeof(x) != 7 :: vlen(y) > 0 @end example @noindent where of course 7 is the @code{typeof} code for error forms. Another final condition, that works for any kind of @samp{y}, would be @samp{!istrue(y == [])}. (The @code{istrue} function returns an explicit 0 if its argument was left in symbolic form; plain @samp{!(y == [])} or @samp{y != []} would not work to replace @samp{!!![]} since these would be left unsimplified, and thus cause the rule to fail, if @samp{y} was something like a variable name.) It is possible for a @samp{!!!} to refer to meta-variables bound elsewhere in the pattern. For example, @example f(a, !!!a) := g(a) @end example @noindent matches any call to @code{f} with different arguments, changing this to @code{g} with only the first argument. If a function call is to be matched and one of the argument patterns contains a @samp{!!!} somewhere inside it, that argument will be matched last. Thus @example f(!!!a, a) := g(a) @end example @noindent will be careful to bind @samp{a} to the second argument of @code{f} before testing the first argument. If Calc had tried to match the first argument of @code{f} first, the results would have been disasterous: Since @code{a} was unbound so far, the pattern @samp{a} would have matched anything at all, and the pattern @samp{!!!a} therefore would @emph{not} have matched anything at all! @node Nested Formulas with Rewrite Rules, Multi-Phase Rewrite Rules, Composing Patterns in Rewrite Rules, Rewrite Rules @subsection Nested Formulas with Rewrite Rules @noindent When @kbd{a r} (@code{calc-rewrite}) is used, it takes an expression from the top of the stack and attempts to match any of the specified rules to any part of the expression, starting with the whole expression and then, if that fails, trying deeper and deeper sub-expressions. For each part of the expression, the rules are tried in the order they appear in the rules vector. The first rule to match the first sub-expression wins; it replaces the matched sub-expression according to the @var{new} part of the rule. Often, the rule set will match and change the formula several times. The top-level formula is first matched and substituted repeatedly until it no longer matches the pattern; then, sub-formulas are tried, and so on. Once every part of the formula has gotten its chance, the rewrite mechanism starts over again with the top-level formula (in case a substitution of one of its arguments has caused it again to match). This continues until no further matches can be made anywhere in the formula. It is possible for a rule set to get into an infinite loop. The most obvious case, replacing a formula with itself, is not a problem because a rule is not considered to ``succeed'' unless the righthand side actually comes out to something different than the original formula or sub-formula that was matched. But if you accidentally had both @samp{ln(a b) := ln(a) + ln(b)} and the reverse @samp{ln(a) + ln(b) := ln(a b)} in your rule set, Calc would run forever switching a formula back and forth between the two forms. To avoid disaster, Calc normally stops after 100 changes have been made to the formula. This will be enough for most multiple rewrites, but it will keep an endless loop of rewrites from locking up the computer forever. (On most systems, you can also type @kbd{C-g} to halt any Emacs command prematurely.) To change this limit, give a positive numeric prefix argument. In particular, @kbd{M-1 a r} applies only one rewrite at a time, useful when you are first testing your rule (or just if repeated rewriting is not what is called for by your application). @c @starindex @c @mindex iter@idots @tindex iterations You can also put a ``function call'' @samp{iterations(@var{n})} in place of a rule anywhere in your rules vector (but usually at the top). Then, @var{n} will be used instead of 100 as the default number of iterations for this rule set. You can use @samp{iterations(inf)} if you want no iteration limit by default. A prefix argument will override the @code{iterations} limit in the rule set. @example [ iterations(1), f(x) := f(x+1) ] @end example More precisely, the limit controls the number of ``iterations,'' where each iteration is a successful matching of a rule pattern whose righthand side, after substituting meta-variables and applying the default simplifications, is different from the original sub-formula that was matched. A prefix argument of zero sets the limit to infinity. Use with caution! Given a negative numeric prefix argument, @kbd{a r} will match and substitute the top-level expression up to that many times, but will not attempt to match the rules to any sub-expressions. In a formula, @code{rewrite(@var{expr}, @var{rules}, @var{n})} does a rewriting operation. Here @var{expr} is the expression being rewritten, @var{rules} is the rule, vector of rules, or variable containing the rules, and @var{n} is the optional iteration limit, which may be a positive integer, a negative integer, or @samp{inf} or @samp{-inf}. If @var{n} is omitted the @code{iterations} value from the rule set is used; if both are omitted, 100 is used. @node Multi-Phase Rewrite Rules, Selections with Rewrite Rules, Nested Formulas with Rewrite Rules, Rewrite Rules @subsection Multi-Phase Rewrite Rules @noindent It is possible to separate a rewrite rule set into several @dfn{phases}. During each phase, certain rules will be enabled while certain others will be disabled. A @dfn{phase schedule} controls the order in which phases occur during the rewriting process. @c @starindex @tindex phase @vindex all If a call to the marker function @code{phase} appears in the rules vector in place of a rule, all rules following that point will be members of the phase(s) identified in the arguments to @code{phase}. Phases are given integer numbers. The markers @samp{phase()} and @samp{phase(all)} both mean the following rules belong to all phases; this is the default at the start of the rule set. If you do not explicitly schedule the phases, Calc sorts all phase numbers that appear in the rule set and executes the phases in ascending order. For example, the rule set @group @example [ f0(x) := g0(x), phase(1), f1(x) := g1(x), phase(2), f2(x) := g2(x), phase(3), f3(x) := g3(x), phase(1,2), f4(x) := g4(x) ] @end example @end group @noindent has three phases, 1 through 3. Phase 1 consists of the @code{f0}, @code{f1}, and @code{f4} rules (in that order). Phase 2 consists of @code{f0}, @code{f2}, and @code{f4}. Phase 3 consists of @code{f0} and @code{f3}. When Calc rewrites a formula using this rule set, it first rewrites the formula using only the phase 1 rules until no further changes are possible. Then it switches to the phase 2 rule set and continues until no further changes occur, then finally rewrites with phase 3. When no more phase 3 rules apply, rewriting finishes. (This is assuming @kbd{a r} with a large enough prefix argument to allow the rewriting to run to completion; the sequence just described stops early if the number of iterations specified in the prefix argument, 100 by default, is reached.) During each phase, Calc descends through the nested levels of the formula as described previously. (@xref{Nested Formulas with Rewrite Rules}.) Rewriting starts at the top of the formula, then works its way down to the parts, then goes back to the top and works down again. The phase 2 rules do not begin until no phase 1 rules apply anywhere in the formula. @c @starindex @tindex schedule A @code{schedule} marker appearing in the rule set (anywhere, but conventionally at the top) changes the default schedule of phases. In the simplest case, @code{schedule} has a sequence of phase numbers for arguments; each phase number is invoked in turn until the arguments to @code{schedule} are exhausted. Thus adding @samp{schedule(3,2,1)} at the top of the above rule set would reverse the order of the phases; @samp{schedule(1,2,3)} would have no effect since this is the default schedule; and @samp{schedule(1,2,1,3)} would give phase 1 a second chance after phase 2 has completed, before moving on to phase 3. Any argument to @code{schedule} can instead be a vector of phase numbers (or even of sub-vectors). Then the sub-sequence of phases described by the vector are tried repeatedly until no change occurs in any phase in the sequence. For example, @samp{schedule([1, 2], 3)} tries phase 1, then phase 2, then, if either phase made any changes to the formula, repeats these two phases until they can make no further progress. Finally, it goes on to phase 3 for finishing touches. Also, items in @code{schedule} can be variable names as well as numbers. A variable name is interpreted as the name of a function to call on the whole formula. For example, @samp{schedule(1, simplify)} says to apply the phase-1 rules (presumably, all of them), then to call @code{simplify} which is the function name equivalent of @kbd{a s}. Likewise, @samp{schedule([1, simplify])} says to alternate between phase 1 and @kbd{a s} until no further changes occur. Phases can be used purely to improve efficiency; if it is known that a certain group of rules will apply only at the beginning of rewriting, and a certain other group will apply only at the end, then rewriting will be faster if these groups are identified as separate phases. Once the phase 1 rules are done, Calc can put them aside and no longer spend any time on them while it works on phase 2. There are also some problems that can only be solved with several rewrite phases. For a real-world example of a multi-phase rule set, examine the set @code{FitRules}, which is used by the curve-fitting command to convert a model expression to linear form. @xref{Curve Fitting Details}. This set is divided into four phases. The first phase rewrites certain kinds of expressions to be more easily linearizable, but less computationally efficient. After the linear components have been picked out, the final phase includes the opposite rewrites to put each component back into an efficient form. If both sets of rules were included in one big phase, Calc could get into an infinite loop going back and forth between the two forms. Elsewhere in @code{FitRules}, the components are first isolated, then recombined where possible to reduce the complexity of the linear fit, then finally packaged one component at a time into vectors. If the packaging rules were allowed to begin before the recombining rules were finished, some components might be put away into vectors before they had a chance to recombine. By putting these rules in two separate phases, this problem is neatly avoided. @node Selections with Rewrite Rules, Matching Commands, Multi-Phase Rewrite Rules, Rewrite Rules @subsection Selections with Rewrite Rules @noindent If a sub-formula of the current formula is selected (as by @kbd{j s}; @pxref{Selecting Subformulas}), the @kbd{a r} (@code{calc-rewrite}) command applies only to that sub-formula. Together with a negative prefix argument, you can use this fact to apply a rewrite to one specific part of a formula without affecting any other parts. @kindex j r @pindex calc-rewrite-selection The @kbd{j r} (@code{calc-rewrite-selection}) command allows more sophisticated operations on selections. This command prompts for the rules in the same way as @kbd{a r}, but it then applies those rules to the whole formula in question even though a sub-formula of it has been selected. However, the selected sub-formula will first have been surrounded by a @samp{select( )} function call. (Calc's evaluator does not understand the function name @code{select}; this is only a tag used by the @kbd{j r} command.) For example, suppose the formula on the stack is @samp{2 (a + b)^2} and the sub-formula @samp{a + b} is selected. This formula will be rewritten to @samp{2 select(a + b)^2} and then the rewrite rules will be applied in the usual way. The rewrite rules can include references to @code{select} to tell where in the pattern the selected sub-formula should appear. If there is still exactly one @samp{select( )} function call in the formula after rewriting is done, it indicates which part of the formula should be selected afterwards. Otherwise, the formula will be unselected. You can make @kbd{j r} act much like @kbd{a r} by enclosing both parts of the rewrite rule with @samp{select()}. However, @kbd{j r} allows you to use the current selection in more flexible ways. Suppose you wished to make a rule which removed the exponent from the selected term; the rule @samp{select(a)^x := select(a)} would work. In the above example, it would rewrite @samp{2 select(a + b)^2} to @samp{2 select(a + b)}. This would then be returned to the stack as @samp{2 (a + b)} with the @samp{a + b} selected. The @kbd{j r} command uses one iteration by default, unlike @kbd{a r} which defaults to 100 iterations. A numeric prefix argument affects @kbd{j r} in the same way as @kbd{a r}. @xref{Nested Formulas with Rewrite Rules}. As with other selection commands, @kbd{j r} operates on the stack entry that contains the cursor. (If the cursor is on the top-of-stack @samp{.} marker, it works as if the cursor were on the formula at stack level 1.) If you don't specify a set of rules, the rules are taken from the top of the stack, just as with @kbd{a r}. In this case, the cursor must indicate stack entry 2 or above as the formula to be rewritten (otherwise the same formula would be used as both the target and the rewrite rules). If the indicated formula has no selection, the cursor position within the formula temporarily selects a sub-formula for the purposes of this command. If the cursor is not on any sub-formula (e.g., it is in the line-number area to the left of the formula), the @samp{select( )} markers are ignored by the rewrite mechanism and the rules are allowed to apply anywhere in the formula. As a special feature, the normal @kbd{a r} command also ignores @samp{select( )} calls in rewrite rules. For example, if you used the above rule @samp{select(a)^x := select(a)} with @kbd{a r}, it would apply the rule as if it were @samp{a^x := a}. Thus, you can write general purpose rules with @samp{select( )} hints inside them so that they will ``do the right thing'' in both @kbd{a r} and @kbd{j r}, both with and without selections. @node Matching Commands, Automatic Rewrites, Selections with Rewrite Rules, Rewrite Rules @subsection Matching Commands @noindent @kindex a m @pindex calc-match @tindex match The @kbd{a m} (@code{calc-match}) [@code{match}] function takes a vector of formulas and a rewrite-rule-style pattern, and produces a vector of all formulas which match the pattern. The command prompts you to enter the pattern; as for @kbd{a r}, you can enter a single pattern (i.e., a formula with meta-variables), or a vector of patterns, or a variable which contains patterns, or you can give a blank response in which case the patterns are taken from the top of the stack. The pattern set will be compiled once and saved if it is stored in a variable. If there are several patterns in the set, vector elements are kept if they match any of the patterns. For example, @samp{match(a+b, [x, x+y, x-y, 7, x+y+z])} will return @samp{[x+y, x-y, x+y+z]}. The @code{import} mechanism is not available for pattern sets. The @kbd{a m} command can also be used to extract all vector elements which satisfy any condition: The pattern @samp{x :: x>0} will select all the positive vector elements. @kindex I a m @tindex matchnot With the Inverse flag [@code{matchnot}], this command extracts all vector elements which do @emph{not} match the given pattern. @c @starindex @tindex matches There is also a function @samp{matches(@var{x}, @var{p})} which evaluates to 1 if expression @var{x} matches pattern @var{p}, or to 0 otherwise. This is sometimes useful for including into the conditional clauses of other rewrite rules. @c @starindex @tindex vmatches The function @code{vmatches} is just like @code{matches}, except that if the match succeeds it returns a vector of assignments to the meta-variables instead of the number 1. For example, @samp{vmatches(f(1,2), f(a,b))} returns @samp{[a := 1, b := 2]}. If the match fails, the function returns the number 0. @node Automatic Rewrites, Debugging Rewrites, Matching Commands, Rewrite Rules @subsection Automatic Rewrites @noindent @cindex @code{EvalRules} variable @vindex EvalRules It is possible to get Calc to apply a set of rewrite rules on all results, effectively adding to the built-in set of default simplifications. To do this, simply store your rule set in the variable @code{EvalRules}. There is a convenient @kbd{s E} command for editing @code{EvalRules}; @pxref{Operations on Variables}. For example, suppose you want @samp{sin(a + b)} to be expanded out to @samp{sin(b) cos(a) + cos(b) sin(a)} wherever it appears, and similarly for @samp{cos(a + b)}. The corresponding rewrite rule set would be, @group @smallexample [ sin(a + b) := cos(a) sin(b) + sin(a) cos(b), cos(a + b) := cos(a) cos(b) - sin(a) sin(b) ] @end smallexample @end group To apply these manually, you could put them in a variable called @code{trigexp} and then use @kbd{a r trigexp} every time you wanted to expand trig functions. But if instead you store them in the variable @code{EvalRules}, they will automatically be applied to all sines and cosines of sums. Then, with @samp{2 x} and @samp{45} on the stack, typing @kbd{+ S} will (assuming degrees mode) result in @samp{0.7071 sin(2 x) + 0.7071 cos(2 x)} automatically. As each level of a formula is evaluated, the rules from @code{EvalRules} are applied before the default simplifications. Rewriting continues until no further @code{EvalRules} apply. Note that this is different from the usual order of application of rewrite rules: @code{EvalRules} works from the bottom up, simplifying the arguments to a function before the function itself, while @kbd{a r} applies rules from the top down. Because the @code{EvalRules} are tried first, you can use them to override the normal behavior of any built-in Calc function. It is important not to write a rule that will get into an infinite loop. For example, the rule set @samp{[f(0) := 1, f(n) := n f(n-1)]} appears to be a good definition of a factorial function, but it is unsafe. Imagine what happens if @samp{f(2.5)} is simplified. Calc will continue to subtract 1 from this argument forever without reaching zero. A safer second rule would be @samp{f(n) := n f(n-1) :: n>0}. Another dangerous rule is @samp{g(x, y) := g(y, x)}. Rewriting @samp{g(2, 4)}, this would bounce back and forth between that and @samp{g(4, 2)} forever. If an infinite loop in @code{EvalRules} occurs, Emacs will eventually stop with a ``Computation got stuck or ran too long'' message. Another subtle difference between @code{EvalRules} and regular rewrites concerns rules that rewrite a formula into an identical formula. For example, @samp{f(n) := f(floor(n))} ``fails to match'' when @cite{n} is already an integer. But in @code{EvalRules} this case is detected only if the righthand side literally becomes the original formula before any further simplification. This means that @samp{f(n) := f(floor(n))} will get into an infinite loop if it occurs in @code{EvalRules}. Calc will replace @samp{f(6)} with @samp{f(floor(6))}, which is different from @samp{f(6)}, so it will consider the rule to have matched and will continue simplifying that formula; first the argument is simplified to get @samp{f(6)}, then the rule matches again to get @samp{f(floor(6))} again, ad infinitum. A much safer rule would check its argument first, say, with @samp{f(n) := f(floor(n)) :: !dint(n)}. (What really happens is that the rewrite mechanism substitutes the meta-variables in the righthand side of a rule, compares to see if the result is the same as the original formula and fails if so, then uses the default simplifications to simplify the result and compares again (and again fails if the formula has simplified back to its original form). The only special wrinkle for the @code{EvalRules} is that the same rules will come back into play when the default simplifications are used. What Calc wants to do is build @samp{f(floor(6))}, see that this is different from the original formula, simplify to @samp{f(6)}, see that this is the same as the original formula, and thus halt the rewriting. But while simplifying, @samp{f(6)} will again trigger the same @code{EvalRules} rule and Calc will get into a loop inside the rewrite mechanism itself.) The @code{phase}, @code{schedule}, and @code{iterations} markers do not work in @code{EvalRules}. If the rule set is divided into phases, only the phase 1 rules are applied, and the schedule is ignored. The rules are always repeated as many times as possible. The @code{EvalRules} are applied to all function calls in a formula, but not to numbers (and other number-like objects like error forms), nor to vectors or individual variable names. (Though they will apply to @emph{components} of vectors and error forms when appropriate.) You might try to make a variable @code{phihat} which automatically expands to its definition without the need to press @kbd{=} by writing the rule @samp{quote(phihat) := (1-sqrt(5))/2}, but unfortunately this rule will not work as part of @code{EvalRules}. Finally, another limitation is that Calc sometimes calls its built-in functions directly rather than going through the default simplifications. When it does this, @code{EvalRules} will not be able to override those functions. For example, when you take the absolute value of the complex number @cite{(2, 3)}, Calc computes @samp{sqrt(2*2 + 3*3)} by calling the multiplication, addition, and square root functions directly rather than applying the default simplifications to this formula. So an @code{EvalRules} rule that (perversely) rewrites @samp{sqrt(13) := 6} would not apply. (However, if you put Calc into symbolic mode so that @samp{sqrt(13)} will be left in symbolic form by the built-in square root function, your rule will be able to apply. But if the complex number were @cite{(3,4)}, so that @samp{sqrt(25)} must be calculated, then symbolic mode will not help because @samp{sqrt(25)} can be evaluated exactly to 5.) One subtle restriction that normally only manifests itself with @code{EvalRules} is that while a given rewrite rule is in the process of being checked, that same rule cannot be recursively applied. Calc effectively removes the rule from its rule set while checking the rule, then puts it back once the match succeeds or fails. (The technical reason for this is that compiled pattern programs are not reentrant.) For example, consider the rule @samp{foo(x) := x :: foo(x/2) > 0} attempting to match @samp{foo(8)}. This rule will be inactive while the condition @samp{foo(4) > 0} is checked, even though it might be an integral part of evaluating that condition. Note that this is not a problem for the more usual recursive type of rule, such as @samp{foo(x) := foo(x/2)}, because there the rule has succeeded and been reactivated by the time the righthand side is evaluated. If @code{EvalRules} has no stored value (its default state), or if anything but a vector is stored in it, then it is ignored. Even though Calc's rewrite mechanism is designed to compare rewrite rules to formulas as quickly as possible, storing rules in @code{EvalRules} may make Calc run substantially slower. This is particularly true of rules where the top-level call is a commonly used function, or is not fixed. The rule @samp{f(n) := n f(n-1) :: n>0} will only activate the rewrite mechanism for calls to the function @code{f}, but @samp{lg(n) + lg(m) := lg(n m)} will check every @samp{+} operator. And @samp{apply(f, [a*b]) := apply(f, [a]) + apply(f, [b]) :: in(f, [ln, log10])} may seem more ``efficient'' than two separate rules for @code{ln} and @code{log10}, but actually it is vastly less efficient because rules with @code{apply} as the top-level pattern must be tested against @emph{every} function call that is simplified. @cindex @code{AlgSimpRules} variable @vindex AlgSimpRules Suppose you want @samp{sin(a + b)} to be expanded out not all the time, but only when @kbd{a s} is used to simplify the formula. The variable @code{AlgSimpRules} holds rules for this purpose. The @kbd{a s} command will apply @code{EvalRules} and @code{AlgSimpRules} to the formula, as well as all of its built-in simplifications. Most of the special limitations for @code{EvalRules} don't apply to @code{AlgSimpRules}. Calc simply does an @kbd{a r AlgSimpRules} command with an infinite repeat count as the first step of @kbd{a s}. It then applies its own built-in simplifications throughout the formula, and then repeats these two steps (along with applying the default simplifications) until no further changes are possible. @cindex @code{ExtSimpRules} variable @cindex @code{UnitSimpRules} variable @vindex ExtSimpRules @vindex UnitSimpRules There are also @code{ExtSimpRules} and @code{UnitSimpRules} variables that are used by @kbd{a e} and @kbd{u s}, respectively; these commands also apply @code{EvalRules} and @code{AlgSimpRules}. The variable @code{IntegSimpRules} contains simplification rules that are used only during integration by @kbd{a i}. @node Debugging Rewrites, Examples of Rewrite Rules, Automatic Rewrites, Rewrite Rules @subsection Debugging Rewrites @noindent If a buffer named @samp{*Trace*} exists, the rewrite mechanism will record some useful information there as it operates. The original formula is written there, as is the result of each successful rewrite, and the final result of the rewriting. All phase changes are also noted. Calc always appends to @samp{*Trace*}. You must empty this buffer yourself periodically if it is in danger of growing unwieldy. Note that the rewriting mechanism is substantially slower when the @samp{*Trace*} buffer exists, even if the buffer is not visible on the screen. Once you are done, you will probably want to kill this buffer (with @kbd{C-x k *Trace* @key{RET}}). If you leave it in existence and forget about it, all your future rewrite commands will be needlessly slow. @node Examples of Rewrite Rules, , Debugging Rewrites, Rewrite Rules @subsection Examples of Rewrite Rules @noindent Returning to the example of substituting the pattern @samp{sin(x)^2 + cos(x)^2} with 1, we saw that the rule @samp{opt(a) sin(x)^2 + opt(a) cos(x)^2 := a} does a good job of finding suitable cases. Another solution would be to use the rule @samp{cos(x)^2 := 1 - sin(x)^2}, followed by algebraic simplification if necessary. This rule will be the most effective way to do the job, but at the expense of making some changes that you might not desire.@refill Another algebraic rewrite rule is @samp{exp(x+y) := exp(x) exp(y)}. To make this work with the @w{@kbd{j r}} command so that it can be easily targeted to a particular exponential in a large formula, you might wish to write the rule as @samp{select(exp(x+y)) := select(exp(x) exp(y))}. The @samp{select} markers will be ignored by the regular @kbd{a r} command (@pxref{Selections with Rewrite Rules}).@refill A surprisingly useful rewrite rule is @samp{a/(b-c) := a*(b+c)/(b^2-c^2)}. This will simplify the formula whenever @cite{b} and/or @cite{c} can be made simpler by squaring. For example, applying this rule to @samp{2 / (sqrt(2) + 3)} yields @samp{6:7 - 2:7 sqrt(2)} (assuming Symbolic Mode has been enabled to keep the square root from being evaulated to a floating-point approximation). This rule is also useful when working with symbolic complex numbers, e.g., @samp{(a + b i) / (c + d i)}. As another example, we could define our own ``triangular numbers'' function with the rules @samp{[tri(0) := 0, tri(n) := n + tri(n-1) :: n>0]}. Enter this vector and store it in a variable: @kbd{@w{s t} trirules}. Now, given a suitable formula like @samp{tri(5)} on the stack, type @samp{a r trirules} to apply these rules repeatedly. After six applications, @kbd{a r} will stop with 15 on the stack. Once these rules are debugged, it would probably be most useful to add them to @code{EvalRules} so that Calc will evaluate the new @code{tri} function automatically. We could then use @kbd{Z K} on the keyboard macro @kbd{' tri($) RET} to make a command that applies @code{tri} to the value on the top of the stack. @xref{Programming}. @cindex Quaternions The following rule set, contributed by @c{Fran\c cois} @asis{Francois} Pinard, implements @dfn{quaternions}, a generalization of the concept of complex numbers. Quaternions have four components, and are here represented by function calls @samp{quat(@var{w}, [@var{x}, @var{y}, @var{z}])} with ``real part'' @var{w} and the three ``imaginary'' parts collected into a vector. Various arithmetical operations on quaternions are supported. To use these rules, either add them to @code{EvalRules}, or create a command based on @kbd{a r} for simplifying quaternion formulas. A convenient way to enter quaternions would be a command defined by a keyboard macro containing: @kbd{' quat($$$$, [$$$, $$, $]) @key{RET}}. @smallexample [ quat(w, x, y, z) := quat(w, [x, y, z]), quat(w, [0, 0, 0]) := w, abs(quat(w, v)) := hypot(w, v), -quat(w, v) := quat(-w, -v), r + quat(w, v) := quat(r + w, v) :: real(r), r - quat(w, v) := quat(r - w, -v) :: real(r), quat(w1, v1) + quat(w2, v2) := quat(w1 + w2, v1 + v2), r * quat(w, v) := quat(r * w, r * v) :: real(r), plain(quat(w1, v1) * quat(w2, v2)) := quat(w1 * w2 - v1 * v2, w1 * v2 + w2 * v1 + cross(v1, v2)), quat(w1, v1) / r := quat(w1 / r, v1 / r) :: real(r), z / quat(w, v) := z * quatinv(quat(w, v)), quatinv(quat(w, v)) := quat(w, -v) / (w^2 + v^2), quatsqr(quat(w, v)) := quat(w^2 - v^2, 2 * w * v), quat(w, v)^k := quatsqr(quat(w, v)^(k / 2)) :: integer(k) :: k > 0 :: k % 2 = 0, quat(w, v)^k := quatsqr(quat(w, v)^((k - 1) / 2)) * quat(w, v) :: integer(k) :: k > 2, quat(w, v)^-k := quatinv(quat(w, v)^k) :: integer(k) :: k > 0 ] @end smallexample Quaternions, like matrices, have non-commutative multiplication. In other words, @cite{q1 * q2 = q2 * q1} is not necessarily true if @cite{q1} and @cite{q2} are @code{quat} forms. The @samp{quat*quat} rule above uses @code{plain} to prevent Calc from rearranging the product. It may also be wise to add the line @samp{[quat(), matrix]} to the @code{Decls} matrix, to ensure that Calc's other algebraic operations will not rearrange a quaternion product. @xref{Declarations}. These rules also accept a four-argument @code{quat} form, converting it to the preferred form in the first rule. If you would rather see results in the four-argument form, just append the two items @samp{phase(2), quat(w, [x, y, z]) := quat(w, x, y, z)} to the end of the rule set. (But remember that multi-phase rule sets don't work in @code{EvalRules}.) @node Units, Store and Recall, Algebra, Top @chapter Operating on Units @noindent One special interpretation of algebraic formulas is as numbers with units. For example, the formula @samp{5 m / s^2} can be read ``five meters per second squared.'' The commands in this chapter help you manipulate units expressions in this form. Units-related commands begin with the @kbd{u} prefix key. @menu * Basic Operations on Units:: * The Units Table:: * Predefined Units:: * User-Defined Units:: @end menu @node Basic Operations on Units, The Units Table, Units, Units @section Basic Operations on Units @noindent A @dfn{units expression} is a formula which is basically a number multiplied and/or divided by one or more @dfn{unit names}, which may optionally be raised to integer powers. Actually, the value part need not be a number; any product or quotient involving unit names is a units expression. Many of the units commands will also accept any formula, where the command applies to all units expressions which appear in the formula. A unit name is a variable whose name appears in the @dfn{unit table}, or a variable whose name is a prefix character like @samp{k} (for ``kilo'') or @samp{u} (for ``micro'') followed by a name in the unit table. A substantial table of built-in units is provided with Calc; @pxref{Predefined Units}. You can also define your own unit names; @pxref{User-Defined Units}.@refill Note that if the value part of a units expression is exactly @samp{1}, it will be removed by the Calculator's automatic algebra routines: The formula @samp{1 mm} is ``simplified'' to @samp{mm}. This is only a display anomaly, however; @samp{mm} will work just fine as a representation of one millimeter.@refill You may find that Algebraic Mode (@pxref{Algebraic Entry}) makes working with units expressions easier. Otherwise, you will have to remember to hit the apostrophe key every time you wish to enter units. @kindex u s @pindex calc-simplify-units @c @mindex usimpl@idots @tindex usimplify The @kbd{u s} (@code{calc-simplify-units}) [@code{usimplify}] command simplifies a units expression. It uses @kbd{a s} (@code{calc-simplify}) to simplify the expression first as a regular algebraic formula; it then looks for features that can be further simplified by converting one object's units to be compatible with another's. For example, @samp{5 m + 23 mm} will simplify to @samp{5.023 m}. When different but compatible units are added, the righthand term's units are converted to match those of the lefthand term. @xref{Simplification Modes}, for a way to have this done automatically at all times.@refill Units simplification also handles quotients of two units with the same dimensionality, as in @w{@samp{2 in s/L cm}} to @samp{5.08 s/L}; fractional powers of unit expressions, as in @samp{sqrt(9 mm^2)} to @samp{3 mm} and @samp{sqrt(9 acre)} to a quantity in meters; and @code{floor}, @code{ceil}, @code{round}, @code{rounde}, @code{roundu}, @code{trunc}, @code{float}, @code{frac}, @code{abs}, and @code{clean} applied to units expressions, in which case the operation in question is applied only to the numeric part of the expression. Finally, trigonometric functions of quantities with units of angle are evaluated, regardless of the current angular mode.@refill @kindex u c @pindex calc-convert-units The @kbd{u c} (@code{calc-convert-units}) command converts a units expression to new, compatible units. For example, given the units expression @samp{55 mph}, typing @kbd{u c m/s @key{RET}} produces @samp{24.5872 m/s}. If the units you request are inconsistent with the original units, the number will be converted into your units times whatever ``remainder'' units are left over. For example, converting @samp{55 mph} into acres produces @samp{6.08e-3 acre / m s}. (Recall that multiplication binds more strongly than division in Calc formulas, so the units here are acres per meter-second.) Remainder units are expressed in terms of ``fundamental'' units like @samp{m} and @samp{s}, regardless of the input units. One special exception is that if you specify a single unit name, and a compatible unit appears somewhere in the units expression, then that compatible unit will be converted to the new unit and the remaining units in the expression will be left alone. For example, given the input @samp{980 cm/s^2}, the command @kbd{u c ms} will change the @samp{s} to @samp{ms} to get @samp{9.8e-4 cm/ms^2}. The ``remainder unit'' @samp{cm} is left alone rather than being changed to the base unit @samp{m}. You can use explicit unit conversion instead of the @kbd{u s} command to gain more control over the units of the result of an expression. For example, given @samp{5 m + 23 mm}, you can type @kbd{u c m} or @kbd{u c mm} to express the result in either meters or millimeters. (For that matter, you could type @kbd{u c fath} to express the result in fathoms, if you preferred!) In place of a specific set of units, you can also enter one of the units system names @code{si}, @code{mks} (equivalent), or @code{cgs}. For example, @kbd{u c si @key{RET}} converts the expression into International System of Units (SI) base units. Also, @kbd{u c base} converts to Calc's base units, which are the same as @code{si} units except that @code{base} uses @samp{g} as the fundamental unit of mass whereas @code{si} uses @samp{kg}. @cindex Composite units The @kbd{u c} command also accepts @dfn{composite units}, which are expressed as the sum of several compatible unit names. For example, converting @samp{30.5 in} to units @samp{mi+ft+in} (miles, feet, and inches) produces @samp{2 ft + 6.5 in}. Calc first sorts the unit names into order of decreasing relative size. It then accounts for as much of the input quantity as it can using an integer number times the largest unit, then moves on to the next smaller unit, and so on. Only the smallest unit may have a non-integer amount attached in the result. A few standard unit names exist for common combinations, such as @code{mfi} for @samp{mi+ft+in}, and @code{tpo} for @samp{ton+lb+oz}. Composite units are expanded as if by @kbd{a x}, so that @samp{(ft+in)/hr} is first converted to @samp{ft/hr+in/hr}. If the value on the stack does not contain any units, @kbd{u c} will prompt first for the old units which this value should be considered to have, then for the new units. Assuming the old and new units you give are consistent with each other, the result also will not contain any units. For example, @kbd{@w{u c} cm RET in RET} converts the number 2 on the stack to 5.08. @kindex u b @pindex calc-base-units The @kbd{u b} (@code{calc-base-units}) command is shorthand for @kbd{u c base}; it converts the units expression on the top of the stack into @code{base} units. If @kbd{u s} does not simplify a units expression as far as you would like, try @kbd{u b}. The @kbd{u c} and @kbd{u b} commands treat temperature units (like @samp{degC} and @samp{K}) as relative temperatures. For example, @kbd{u c} converts @samp{10 degC} to @samp{18 degF}: A change of 10 degrees Celsius corresponds to a change of 18 degrees Fahrenheit. @kindex u t @pindex calc-convert-temperature @cindex Temperature conversion The @kbd{u t} (@code{calc-convert-temperature}) command converts absolute temperatures. The value on the stack must be a simple units expression with units of temperature only. This command would convert @samp{10 degC} to @samp{50 degF}, the equivalent temperature on the Fahrenheit scale.@refill @kindex u r @pindex calc-remove-units @kindex u x @pindex calc-extract-units The @kbd{u r} (@code{calc-remove-units}) command removes units from the formula at the top of the stack. The @kbd{u x} (@code{calc-extract-units}) command extracts only the units portion of a formula. These commands essentially replace every term of the formula that does or doesn't (respectively) look like a unit name by the constant 1, then resimplify the formula.@refill @kindex u a @pindex calc-autorange-units The @kbd{u a} (@code{calc-autorange-units}) command turns on and off a mode in which unit prefixes like @code{k} (``kilo'') are automatically applied to keep the numeric part of a units expression in a reasonable range. This mode affects @kbd{u s} and all units conversion commands except @kbd{u b}. For example, with autoranging on, @samp{12345 Hz} will be simplified to @samp{12.345 kHz}. Autoranging is useful for some kinds of units (like @code{Hz} and @code{m}), but is probably undesirable for non-metric units like @code{ft} and @code{tbsp}. (Composite units are more appropriate for those; see above.) Autoranging always applies the prefix to the leftmost unit name. Calc chooses the largest prefix that causes the number to be greater than or equal to 1.0. Thus an increasing sequence of adjusted times would be @samp{1 ms, 10 ms, 100 ms, 1 s, 10 s, 100 s, 1 ks}. Generally the rule of thumb is that the number will be adjusted to be in the interval @samp{[1 .. 1000)}, although there are several exceptions to this rule. First, if the unit has a power then this is not possible; @samp{0.1 s^2} simplifies to @samp{100000 ms^2}. Second, the ``centi-'' prefix is allowed to form @code{cm} (centimeters), but will not apply to other units. The ``deci-,'' ``deka-,'' and ``hecto-'' prefixes are never used. Thus the allowable interval is @samp{[1 .. 10)} for millimeters and @samp{[1 .. 100)} for centimeters. Finally, a prefix will not be added to a unit if the resulting name is also the actual name of another unit; @samp{1e-15 t} would normally be considered a ``femto-ton,'' but it is written as @samp{1000 at} (1000 atto-tons) instead because @code{ft} would be confused with feet. @node The Units Table, Predefined Units, Basic Operations on Units, Units @section The Units Table @noindent @kindex u v @pindex calc-enter-units-table The @kbd{u v} (@code{calc-enter-units-table}) command displays the units table in another buffer called @code{*Units Table*}. Each entry in this table gives the unit name as it would appear in an expression, the definition of the unit in terms of simpler units, and a full name or description of the unit. Fundamental units are defined as themselves; these are the units produced by the @kbd{u b} command. The fundamental units are meters, seconds, grams, kelvins, amperes, candelas, moles, radians, and steradians. The Units Table buffer also displays the Unit Prefix Table. Note that two prefixes, ``kilo'' and ``hecto,'' accept either upper- or lower-case prefix letters. @samp{Meg} is also accepted as a synonym for the @samp{M} prefix. Whenever a unit name can be interpreted as either a built-in name or a prefix followed by another built-in name, the former interpretation wins. For example, @samp{2 pt} means two pints, not two pico-tons. The Units Table buffer, once created, is not rebuilt unless you define new units. To force the buffer to be rebuilt, give any numeric prefix argument to @kbd{u v}. @kindex u V @pindex calc-view-units-table The @kbd{u V} (@code{calc-view-units-table}) command is like @kbd{u v} except that the cursor is not moved into the Units Table buffer. You can type @kbd{u V} again to remove the Units Table from the display. To return from the Units Table buffer after a @kbd{u v}, type @kbd{M-# c} again or use the regular Emacs @w{@kbd{C-x o}} (@code{other-window}) command. You can also kill the buffer with @kbd{C-x k} if you wish; the actual units table is safely stored inside the Calculator. @kindex u g @pindex calc-get-unit-definition The @kbd{u g} (@code{calc-get-unit-definition}) command retrieves a unit's defining expression and pushes it onto the Calculator stack. For example, @kbd{u g in} will produce the expression @samp{2.54 cm}. This is the same definition for the unit that would appear in the Units Table buffer. Note that this command works only for actual unit names; @kbd{u g km} will report that no such unit exists, for example, because @code{km} is really the unit @code{m} with a @code{k} (``kilo'') prefix. To see a definition of a unit in terms of base units, it is easier to push the unit name on the stack and then reduce it to base units with @kbd{u b}. @kindex u e @pindex calc-explain-units The @kbd{u e} (@code{calc-explain-units}) command displays an English description of the units of the expression on the stack. For example, for the expression @samp{62 km^2 g / s^2 mol K}, the description is ``Square-Kilometer Gram per (Second-squared Mole Degree-Kelvin).'' This command uses the English descriptions that appear in the righthand column of the Units Table. @node Predefined Units, User-Defined Units, The Units Table, Units @section Predefined Units @noindent Since the exact definitions of many kinds of units have evolved over the years, and since certain countries sometimes have local differences in their definitions, it is a good idea to examine Calc's definition of a unit before depending on its exact value. For example, there are three different units for gallons, corresponding to the US (@code{gal}), Canadian (@code{galC}), and British (@code{galUK}) definitions. Also, note that @code{oz} is a standard ounce of mass, @code{ozt} is a Troy ounce, and @code{ozfl} is a fluid ounce. The temperature units corresponding to degrees Kelvin and Centigrade (Celsius) are the same in this table, since most units commands treat temperatures as being relative. The @code{calc-convert-temperature} command has special rules for handling the different absolute magnitudes of the various temperature scales. The unit of volume ``liters'' can be referred to by either the lower-case @code{l} or the upper-case @code{L}. The unit @code{A} stands for Amperes; the name @code{Ang} is used @tex for \AA ngstroms. @end tex @ifinfo for Angstroms. @end ifinfo The unit @code{pt} stands for pints; the name @code{point} stands for a typographical point, defined by @samp{72 point = 1 in}. There is also @code{tpt}, which stands for a printer's point as defined by the @TeX{} typesetting system: @samp{72.27 tpt = 1 in}. The unit @code{e} stands for the elementary (electron) unit of charge; because algebra command could mistake this for the special constant @cite{e}, Calc provides the alternate unit name @code{ech} which is preferable to @code{e}. The name @code{g} stands for one gram of mass; there is also @code{gf}, one gram of force. (Likewise for @kbd{lb}, pounds, and @kbd{lbf}.) Meanwhile, one ``@cite{g}'' of acceleration is denoted @code{ga}. The unit @code{ton} is a U.S. ton of @samp{2000 lb}, and @code{t} is a metric ton of @samp{1000 kg}. The names @code{s} (or @code{sec}) and @code{min} refer to units of time; @code{arcsec} and @code{arcmin} are units of angle. Some ``units'' are really physical constants; for example, @code{c} represents the speed of light, and @code{h} represents Planck's constant. You can use these just like other units: converting @samp{.5 c} to @samp{m/s} expresses one-half the speed of light in meters per second. You can also use this merely as a handy reference; the @kbd{u g} command gets the definition of one of these constants in its normal terms, and @kbd{u b} expresses the definition in base units. Two units, @code{pi} and @code{fsc} (the fine structure constant, approximately @i{1/137}) are dimensionless. The units simplification commands simply treat these names as equivalent to their corresponding values. However you can, for example, use @kbd{u c} to convert a pure number into multiples of the fine structure constant, or @kbd{u b} to convert this back into a pure number. (When @kbd{u c} prompts for the ``old units,'' just enter a blank line to signify that the value really is unitless.) @c Describe angular units, luminosity vs. steradians problem. @node User-Defined Units, , Predefined Units, Units @section User-Defined Units @noindent Calc provides ways to get quick access to your selected ``favorite'' units, as well as ways to define your own new units. @kindex u 0-9 @pindex calc-quick-units @vindex Units @cindex @code{Units} variable @cindex Quick units To select your favorite units, store a vector of unit names or expressions in the Calc variable @code{Units}. The @kbd{u 1} through @kbd{u 9} commands (@code{calc-quick-units}) provide access to these units. If the value on the top of the stack is a plain number (with no units attached), then @kbd{u 1} gives it the specified units. (Basically, it multiplies the number by the first item in the @code{Units} vector.) If the number on the stack @emph{does} have units, then @kbd{u 1} converts that number to the new units. For example, suppose the vector @samp{[in, ft]} is stored in @code{Units}. Then @kbd{30 u 1} will create the expression @samp{30 in}, and @kbd{u 2} will convert that expression to @samp{2.5 ft}. The @kbd{u 0} command accesses the tenth element of @code{Units}. Only ten quick units may be defined at a time. If the @code{Units} variable has no stored value (the default), or if its value is not a vector, then the quick-units commands will not function. The @kbd{s U} command is a convenient way to edit the @code{Units} variable; @pxref{Operations on Variables}. @kindex u d @pindex calc-define-unit @cindex User-defined units The @kbd{u d} (@code{calc-define-unit}) command records the units expression on the top of the stack as the definition for a new, user-defined unit. For example, putting @samp{16.5 ft} on the stack and typing @kbd{u d rod} defines the new unit @samp{rod} to be equivalent to 16.5 feet. The unit conversion and simplification commands will now treat @code{rod} just like any other unit of length. You will also be prompted for an optional English description of the unit, which will appear in the Units Table. @kindex u u @pindex calc-undefine-unit The @kbd{u u} (@code{calc-undefine-unit}) command removes a user-defined unit. It is not possible to remove one of the predefined units, however. If you define a unit with an existing unit name, your new definition will replace the original definition of that unit. If the unit was a predefined unit, the old definition will not be replaced, only ``shadowed.'' The built-in definition will reappear if you later use @kbd{u u} to remove the shadowing definition. To create a new fundamental unit, use either 1 or the unit name itself as the defining expression. Otherwise the expression can involve any other units that you like (except for composite units like @samp{mfi}). You can create a new composite unit with a sum of other units as the defining expression. The next unit operation like @kbd{u c} or @kbd{u v} will rebuild the internal unit table incorporating your modifications. Note that erroneous definitions (such as two units defined in terms of each other) will not be detected until the unit table is next rebuilt; @kbd{u v} is a convenient way to force this to happen. Temperature units are treated specially inside the Calculator; it is not possible to create user-defined temperature units. @kindex u p @pindex calc-permanent-units @cindex @file{.emacs} file, user-defined units The @kbd{u p} (@code{calc-permanent-units}) command stores the user-defined units in your @file{.emacs} file, so that the units will still be available in subsequent Emacs sessions. If there was already a set of user-defined units in your @file{.emacs} file, it is replaced by the new set. (@xref{General Mode Commands}, for a way to tell Calc to use a different file instead of @file{.emacs}.) @node Store and Recall, Graphics, Units, Top @chapter Storing and Recalling @noindent Calculator variables are really just Lisp variables that contain numbers or formulas in a form that Calc can understand. The commands in this section allow you to manipulate variables conveniently. Commands related to variables use the @kbd{s} prefix key. @menu * Storing Variables:: * Recalling Variables:: * Operations on Variables:: * Let Command:: * Evaluates-To Operator:: @end menu @node Storing Variables, Recalling Variables, Store and Recall, Store and Recall @section Storing Variables @noindent @kindex s s @pindex calc-store @cindex Storing variables @cindex Quick variables @vindex q0 @vindex q9 The @kbd{s s} (@code{calc-store}) command stores the value at the top of the stack into a specified variable. It prompts you to enter the name of the variable. If you press a single digit, the value is stored immediately in one of the ``quick'' variables @code{var-q0} through @code{var-q9}. Or you can enter any variable name. The prefix @samp{var-} is supplied for you; when a name appears in a formula (as in @samp{a+q2}) the prefix @samp{var-} is also supplied there, so normally you can simply forget about @samp{var-} everywhere. Its only purpose is to enable you to use Calc variables without fear of accidentally clobbering some variable in another Emacs package. If you really want to store in an arbitrary Lisp variable, just backspace over the @samp{var-}. @kindex s t @pindex calc-store-into The @kbd{s s} command leaves the stored value on the stack. There is also an @kbd{s t} (@code{calc-store-into}) command, which removes a value from the stack and stores it in a variable. If the top of stack value is an equation @samp{a = 7} or assignment @samp{a := 7} with a variable on the lefthand side, then Calc will assign that variable with that value by default, i.e., if you type @kbd{s s @key{RET}} or @kbd{s t @key{RET}}. In this example, the value 7 would be stored in the variable @samp{a}. (If you do type a variable name at the prompt, the top-of-stack value is stored in its entirety, even if it is an equation: @samp{s s b @key{RET}} with @samp{a := 7} on the stack stores @samp{a := 7} in @code{b}.) In fact, the top of stack value can be a vector of equations or assignments with different variables on their lefthand sides; the default will be to store all the variables with their corresponding righthand sides simultaneously. It is also possible to type an equation or assignment directly at the prompt for the @kbd{s s} or @kbd{s t} command: @kbd{s s foo = 7}. In this case the expression to the right of the @kbd{=} or @kbd{:=} symbol is evaluated as if by the @kbd{=} command, and that value is stored in the variable. No value is taken from the stack; @kbd{s s} and @kbd{s t} are equivalent when used in this way. @kindex s 0-9 @kindex t 0-9 The prefix keys @kbd{s} and @kbd{t} may be followed immediately by a digit; @kbd{s 9} is equivalent to @kbd{s s 9}, and @kbd{t 9} is equivalent to @kbd{s t 9}. (The @kbd{t} prefix is otherwise used for trail and time/date commands.) @kindex s + @kindex s - @c @mindex @idots @kindex s * @c @mindex @null @kindex s / @c @mindex @null @kindex s ^ @c @mindex @null @kindex s | @c @mindex @null @kindex s n @c @mindex @null @kindex s & @c @mindex @null @kindex s [ @c @mindex @null @kindex s ] @pindex calc-store-plus @pindex calc-store-minus @pindex calc-store-times @pindex calc-store-div @pindex calc-store-power @pindex calc-store-concat @pindex calc-store-neg @pindex calc-store-inv @pindex calc-store-decr @pindex calc-store-incr There are also several ``arithmetic store'' commands. For example, @kbd{s +} removes a value from the stack and adds it to the specified variable. The other arithmetic stores are @kbd{s -}, @kbd{s *}, @kbd{s /}, @kbd{s ^}, and @w{@kbd{s |}} (vector concatenation), plus @kbd{s n} and @kbd{s &} which negate or invert the value in a variable, and @w{@kbd{s [}} and @kbd{s ]} which decrease or increase a variable by one. All the arithmetic stores accept the Inverse prefix to reverse the order of the operands. If @cite{v} represents the contents of the variable, and @cite{a} is the value drawn from the stack, then regular @w{@kbd{s -}} assigns @c{$v \coloneq v - a$} @cite{v := v - a}, but @kbd{I s -} assigns @c{$v \coloneq a - v$} @cite{v := a - v}. While @kbd{I s *} might seem pointless, it is useful if matrix multiplication is involved. Actually, all the arithmetic stores use formulas designed to behave usefully both forwards and backwards: @group @example s + v := v + a v := a + v s - v := v - a v := a - v s * v := v * a v := a * v s / v := v / a v := a / v s ^ v := v ^ a v := a ^ v s | v := v | a v := a | v s n v := v / (-1) v := (-1) / v s & v := v ^ (-1) v := (-1) ^ v s [ v := v - 1 v := 1 - v s ] v := v - (-1) v := (-1) - v @end example @end group In the last four cases, a numeric prefix argument will be used in place of the number one. (For example, @kbd{M-2 s ]} increases a variable by 2, and @kbd{M-2 I s ]} replaces a variable by minus-two minus the variable. The first six arithmetic stores can also be typed @kbd{s t +}, @kbd{s t -}, etc. The commands @kbd{s s +}, @kbd{s s -}, and so on are analogous arithmetic stores that don't remove the value @cite{a} from the stack. All arithmetic stores report the new value of the variable in the Trail for your information. They signal an error if the variable previously had no stored value. If default simplifications have been turned off, the arithmetic stores temporarily turn them on for numeric arguments only (i.e., they temporarily do an @kbd{m N} command). @xref{Simplification Modes}. Large vectors put in the trail by these commands always use abbreviated (@kbd{t .}) mode. @kindex s m @pindex calc-store-map The @kbd{s m} command is a general way to adjust a variable's value using any Calc function. It is a ``mapping'' command analogous to @kbd{V M}, @kbd{V R}, etc. @xref{Reducing and Mapping}, to see how to specify a function for a mapping command. Basically, all you do is type the Calc command key that would invoke that function normally. For example, @kbd{s m n} applies the @kbd{n} key to negate the contents of the variable, so @kbd{s m n} is equivalent to @kbd{s n}. Also, @kbd{s m Q} takes the square root of the value stored in a variable, @kbd{s m v v} uses @kbd{v v} to reverse the vector stored in the variable, and @kbd{s m H I S} takes the hyperbolic arcsine of the variable contents. If the mapping function takes two or more arguments, the additional arguments are taken from the stack; the old value of the variable is provided as the first argument. Thus @kbd{s m -} with @cite{a} on the stack computes @cite{v - a}, just like @kbd{s -}. With the Inverse prefix, the variable's original value becomes the @emph{last} argument instead of the first. Thus @kbd{I s m -} is also equivalent to @kbd{I s -}. @kindex s x @pindex calc-store-exchange The @kbd{s x} (@code{calc-store-exchange}) command exchanges the value of a variable with the value on the top of the stack. Naturally, the variable must already have a stored value for this to work. You can type an equation or assignment at the @kbd{s x} prompt. The command @kbd{s x a=6} takes no values from the stack; instead, it pushes the old value of @samp{a} on the stack and stores @samp{a = 6}. @kindex s u @pindex calc-unstore @cindex Void variables @cindex Un-storing variables Until you store something in them, variables are ``void,'' that is, they contain no value at all. If they appear in an algebraic formula they will be left alone even if you press @kbd{=} (@code{calc-evaluate}). The @kbd{s u} (@code{calc-unstore}) command returns a variable to the void state.@refill The only variables with predefined values are the ``special constants'' @code{pi}, @code{e}, @code{i}, @code{phi}, and @code{gamma}. You are free to unstore these variables or to store new values into them if you like, although some of the algebraic-manipulation functions may assume these variables represent their standard values. Calc displays a warning if you change the value of one of these variables, or of one of the other special variables @code{inf}, @code{uinf}, and @code{nan} (which are normally void). Note that @code{var-pi} doesn't actually have 3.14159265359 stored in it, but rather a special magic value that evaluates to @c{$\pi$} @cite{pi} at the current precision. Likewise @code{var-e}, @code{var-i}, and @code{var-phi} evaluate according to the current precision or polar mode. If you recall a value from @code{pi} and store it back, this magic property will be lost. @kindex s c @pindex calc-copy-variable The @kbd{s c} (@code{calc-copy-variable}) command copies the stored value of one variable to another. It differs from a simple @kbd{s r} followed by an @kbd{s t} in two important ways. First, the value never goes on the stack and thus is never rounded, evaluated, or simplified in any way; it is not even rounded down to the current precision. Second, the ``magic'' contents of a variable like @code{var-e} can be copied into another variable with this command, perhaps because you need to unstore @code{var-e} right now but you wish to put it back when you're done. The @kbd{s c} command is the only way to manipulate these magic values intact. @node Recalling Variables, Operations on Variables, Storing Variables, Store and Recall @section Recalling Variables @noindent @kindex s r @pindex calc-recall @cindex Recalling variables The most straightforward way to extract the stored value from a variable is to use the @kbd{s r} (@code{calc-recall}) command. This command prompts for a variable name (similarly to @code{calc-store}), looks up the value of the specified variable, and pushes that value onto the stack. It is an error to try to recall a void variable. It is also possible to recall the value from a variable by evaluating a formula containing that variable. For example, @kbd{' a @key{RET} =} is the same as @kbd{s r a @key{RET}} except that if the variable is void, the former will simply leave the formula @samp{a} on the stack whereas the latter will produce an error message. @kindex r 0-9 The @kbd{r} prefix may be followed by a digit, so that @kbd{r 9} is equivalent to @kbd{s r 9}. (The @kbd{r} prefix is otherwise unused in the current version of Calc.) @node Operations on Variables, Let Command, Recalling Variables, Store and Recall @section Other Operations on Variables @noindent @kindex s e @pindex calc-edit-variable The @kbd{s e} (@code{calc-edit-variable}) command edits the stored value of a variable without ever putting that value on the stack or simplifying or evaluating the value. It prompts for the name of the variable to edit. If the variable has no stored value, the editing buffer will start out empty. If the editing buffer is empty when you press @key{M-# M-#} to finish, the variable will be made void. @xref{Editing Stack Entries}, for a general description of editing. The @kbd{s e} command is especially useful for creating and editing rewrite rules which are stored in variables. Sometimes these rules contain formulas which must not be evaluated until the rules are actually used. (For example, they may refer to @samp{deriv(x,y)}, where @code{x} will someday become some expression involving @code{y}; if you let Calc evaluate the rule while you are defining it, Calc will replace @samp{deriv(x,y)} with 0 because the formula @code{x} does not itself refer to @code{y}.) By contrast, recalling the variable, editing with @kbd{`}, and storing will evaluate the variable's value as a side effect of putting the value on the stack. @kindex s A @kindex s D @c @mindex @idots @kindex s E @c @mindex @null @kindex s F @c @mindex @null @kindex s G @c @mindex @null @kindex s H @c @mindex @null @kindex s I @c @mindex @null @kindex s L @c @mindex @null @kindex s P @c @mindex @null @kindex s R @c @mindex @null @kindex s T @c @mindex @null @kindex s U @c @mindex @null @kindex s X @pindex calc-store-AlgSimpRules @pindex calc-store-Decls @pindex calc-store-EvalRules @pindex calc-store-FitRules @pindex calc-store-GenCount @pindex calc-store-Holidays @pindex calc-store-IntegLimit @pindex calc-store-LineStyles @pindex calc-store-PointStyles @pindex calc-store-PlotRejects @pindex calc-store-TimeZone @pindex calc-store-Units @pindex calc-store-ExtSimpRules There are several special-purpose variable-editing commands that use the @kbd{s} prefix followed by a shifted letter: @table @kbd @item s A Edit @code{AlgSimpRules}. @xref{Algebraic Simplifications}. @item s D Edit @code{Decls}. @xref{Declarations}. @item s E Edit @code{EvalRules}. @xref{Default Simplifications}. @item s F Edit @code{FitRules}. @xref{Curve Fitting}. @item s G Edit @code{GenCount}. @xref{Solving Equations}. @item s H Edit @code{Holidays}. @xref{Business Days}. @item s I Edit @code{IntegLimit}. @xref{Calculus}. @item s L Edit @code{LineStyles}. @xref{Graphics}. @item s P Edit @code{PointStyles}. @xref{Graphics}. @item s R Edit @code{PlotRejects}. @xref{Graphics}. @item s T Edit @code{TimeZone}. @xref{Time Zones}. @item s U Edit @code{Units}. @xref{User-Defined Units}. @item s X Edit @code{ExtSimpRules}. @xref{Unsafe Simplifications}. @end table These commands are just versions of @kbd{s e} that use fixed variable names rather than prompting for the variable name. @kindex s p @pindex calc-permanent-variable @cindex Storing variables @cindex Permanent variables @cindex @file{.emacs} file, veriables The @kbd{s p} (@code{calc-permanent-variable}) command saves a variable's value permanently in your @file{.emacs} file, so that its value will still be available in future Emacs sessions. You can re-execute @w{@kbd{s p}} later on to update the saved value, but the only way to remove a saved variable is to edit your @file{.emacs} file by hand. (@xref{General Mode Commands}, for a way to tell Calc to use a different file instead of @file{.emacs}.) If you do not specify the name of a variable to save (i.e., @kbd{s p @key{RET}}), all @samp{var-} variables with defined values are saved except for the special constants @code{pi}, @code{e}, @code{i}, @code{phi}, and @code{gamma}; the variables @code{TimeZone} and @code{PlotRejects}; @code{FitRules}, @code{DistribRules}, and other built-in rewrite rules; and @code{PlotData@var{n}} variables generated by the graphics commands. (You can still save these variables by explicitly naming them in an @kbd{s p} command.)@refill @kindex s i @pindex calc-insert-variables The @kbd{s i} (@code{calc-insert-variables}) command writes the values of all @samp{var-} variables into a specified buffer. The variables are written in the form of Lisp @code{setq} commands which store the values in string form. You can place these commands in your @file{.emacs} buffer if you wish, though in this case it would be easier to use @kbd{s p @key{RET}}. (Note that @kbd{s i} omits the same set of variables as @w{@kbd{s p @key{RET}}}; the difference is that @kbd{s i} will store the variables in any buffer, and it also stores in a more human-readable format.) @node Let Command, Evaluates-To Operator, Operations on Variables, Store and Recall @section The Let Command @noindent @kindex s l @pindex calc-let @cindex Variables, temporary assignment @cindex Temporary assignment to variables If you have an expression like @samp{a+b^2} on the stack and you wish to compute its value where @cite{b=3}, you can simply store 3 in @cite{b} and then press @kbd{=} to reevaluate the formula. This has the side-effect of leaving the stored value of 3 in @cite{b} for future operations. The @kbd{s l} (@code{calc-let}) command evaluates a formula under a @emph{temporary} assignment of a variable. It stores the value on the top of the stack into the specified variable, then evaluates the second-to-top stack entry, then restores the original value (or lack of one) in the variable. Thus after @kbd{'@w{ }a+b^2 @key{RET} 3 s l b @key{RET}}, the stack will contain the formula @samp{a + 9}. The subsequent command @kbd{@w{5 s l a} @key{RET}} will replace this formula with the number 14. The variables @samp{a} and @samp{b} are not permanently affected in any way by these commands. The value on the top of the stack may be an equation or assignment, or a vector of equations or assignments, in which case the default will be analogous to the case of @kbd{s t @key{RET}}. @xref{Storing Variables}. Also, you can answer the variable-name prompt with an equation or assignment: @kbd{s l b=3 RET} is the same as storing 3 on the stack and typing @kbd{s l b RET}. The @kbd{a b} (@code{calc-substitute}) command is another way to substitute a variable with a value in a formula. It does an actual substitution rather than temporarily assigning the variable and evaluating. For example, letting @cite{n=2} in @samp{f(n pi)} with @kbd{a b} will produce @samp{f(2 pi)}, whereas @kbd{s l} would give @samp{f(6.28)} since the evaluation step will also evaluate @code{pi}. @node Evaluates-To Operator, , Let Command, Store and Recall @section The Evaluates-To Operator @noindent @tindex evalto @tindex => @cindex Evaluates-to operator @cindex @samp{=>} operator The special algebraic symbol @samp{=>} is known as the @dfn{evaluates-to operator}. (It will show up as an @code{evalto} function call in other language modes like Pascal and @TeX{}.) This is a binary operator, that is, it has a lefthand and a righthand argument, although it can be entered with the righthand argument omitted. A formula like @samp{@var{a} => @var{b}} is evaluated by Calc as follows: First, @var{a} is not simplified or modified in any way. The previous value of argument @var{b} is thrown away; the formula @var{a} is then copied and evaluated as if by the @kbd{=} command according to all current modes and stored variable values, and the result is installed as the new value of @var{b}. For example, suppose you enter the algebraic formula @samp{2 + 3 => 17}. The number 17 is ignored, and the lefthand argument is left in its unevaluated form; the result is the formula @samp{2 + 3 => 5}. @kindex s = @pindex calc-evalto You can enter an @samp{=>} formula either directly using algebraic entry (in which case the righthand side may be omitted since it is going to be replaced right away anyhow), or by using the @kbd{s =} (@code{calc-evalto}) command, which takes @var{a} from the stack and replaces it with @samp{@var{a} => @var{b}}. Calc keeps track of all @samp{=>} operators on the stack, and recomputes them whenever anything changes that might affect their values, i.e., a mode setting or variable value. This occurs only if the @samp{=>} operator is at the top level of the formula, or if it is part of a top-level vector. In other words, pushing @samp{2 + (a => 17)} will change the 17 to the actual value of @samp{a} when you enter the formula, but the result will not be dynamically updated when @samp{a} is changed later because the @samp{=>} operator is buried inside a sum. However, a vector of @samp{=>} operators will be recomputed, since it is convenient to push a vector like @samp{[a =>, b =>, c =>]} on the stack to make a concise display of all the variables in your problem. (Another way to do this would be to use @samp{[a, b, c] =>}, which provides a slightly different format of display. You can use whichever you find easiest to read.) @kindex m C @pindex calc-auto-recompute The @kbd{m C} (@code{calc-auto-recompute}) command allows you to turn this automatic recomputation on or off. If you turn recomputation off, you must explicitly recompute an @samp{=>} operator on the stack in one of the usual ways, such as by pressing @kbd{=}. Turning recomputation off temporarily can save a lot of time if you will be changing several modes or variables before you look at the @samp{=>} entries again. Most commands are not especially useful with @samp{=>} operators as arguments. For example, given @samp{x + 2 => 17}, it won't work to type @kbd{1 +} to get @samp{x + 3 => 18}. If you want to operate on the lefthand side of the @samp{=>} operator on the top of the stack, type @kbd{j 1} (that's the digit ``one'') to select the lefthand side, execute your commands, then type @kbd{j u} to unselect. All current modes apply when an @samp{=>} operator is computed, including the current simplification mode. Recall that the formula @samp{x + y + x} is not handled by Calc's default simplifications, but the @kbd{a s} command will reduce it to the simpler form @samp{y + 2 x}. You can also type @kbd{m A} to enable an algebraic-simplification mode in which the equivalent of @kbd{a s} is used on all of Calc's results. If you enter @samp{x + y + x =>} normally, the result will be @samp{x + y + x => x + y + x}. If you change to algebraic-simplification mode, the result will be @samp{x + y + x => y + 2 x}. However, just pressing @kbd{a s} once will have no effect on @samp{x + y + x => x + y + x}, because the righthand side depends only on the lefthand side and the current mode settings, and the lefthand side is not affected by commands like @kbd{a s}. The ``let'' command (@kbd{s l}) has an interesting interaction with the @samp{=>} operator. The @kbd{s l} command evaluates the second-to-top stack entry with the top stack entry supplying a temporary value for a given variable. As you might expect, if that stack entry is an @samp{=>} operator its righthand side will temporarily show this value for the variable. In fact, all @samp{=>}s on the stack will be updated if they refer to that variable. But this change is temporary in the sense that the next command that causes Calc to look at those stack entries will make them revert to the old variable value. @group @smallexample 2: a => a 2: a => 17 2: a => a 1: a + 1 => a + 1 1: a + 1 => 18 1: a + 1 => a + 1 . . . 17 s l a RET p 8 RET @end smallexample @end group Here the @kbd{p 8} command changes the current precision, thus causing the @samp{=>} forms to be recomputed after the influence of the ``let'' is gone. The @kbd{d SPC} command (@code{calc-refresh}) is a handy way to force the @samp{=>} operators on the stack to be recomputed without any other side effects. @kindex s : @pindex calc-assign @tindex assign @tindex := Embedded Mode also uses @samp{=>} operators. In embedded mode, the lefthand side of an @samp{=>} operator can refer to variables assigned elsewhere in the file by @samp{:=} operators. The assignment operator @samp{a := 17} does not actually do anything by itself. But Embedded Mode recognizes it and marks it as a sort of file-local definition of the variable. You can enter @samp{:=} operators in algebraic mode, or by using the @kbd{s :} (@code{calc-assign}) [@code{assign}] command which takes a variable and value from the stack and replaces them with an assignment. @xref{TeX Language Mode}, for the way @samp{=>} appears in @TeX{} language output. The @dfn{eqn} mode gives similar treatment to @samp{=>}. @node Graphics, Kill and Yank, Store and Recall, Top @chapter Graphics @noindent The commands for graphing data begin with the @kbd{g} prefix key. Calc uses GNUPLOT 2.0 or 3.0 to do graphics. These commands will only work if GNUPLOT is available on your system. (While GNUPLOT sounds like a relative of GNU Emacs, it is actually completely unrelated. However, it is free software and can be obtained from the Free Software Foundation's machine @samp{prep.ai.mit.edu}.) @vindex calc-gnuplot-name If you have GNUPLOT installed on your system but Calc is unable to find it, you may need to set the @code{calc-gnuplot-name} variable in your @file{.emacs} file. You may also need to set some Lisp variables to show Calc how to run GNUPLOT on your system; these are described under @kbd{g D} and @kbd{g O} below. If you are using the X window system, Calc will configure GNUPLOT for you automatically. If you have GNUPLOT 3.0 and you are not using X, Calc will configure GNUPLOT to display graphs using simple character graphics that will work on any terminal. @menu * Basic Graphics:: * Three Dimensional Graphics:: * Managing Curves:: * Graphics Options:: * Devices:: @end menu @node Basic Graphics, Three Dimensional Graphics, Graphics, Graphics @section Basic Graphics @noindent @kindex g f @pindex calc-graph-fast The easiest graphics command is @kbd{g f} (@code{calc-graph-fast}). This command takes two vectors of equal length from the stack. The vector at the top of the stack represents the ``y'' values of the various data points. The vector in the second-to-top position represents the corresponding ``x'' values. This command runs GNUPLOT (if it has not already been started by previous graphing commands) and displays the set of data points. The points will be connected by lines, and there will also be some kind of symbol to indicate the points themselves. The ``x'' entry may instead be an interval form, in which case suitable ``x'' values are interpolated between the minimum and maximum values of the interval (whether the interval is open or closed is ignored). The ``x'' entry may also be a number, in which case Calc uses the sequence of ``x'' values @cite{x}, @cite{x+1}, @cite{x+2}, etc. (Generally the number 0 or 1 would be used for @cite{x} in this case.) The ``y'' entry may be any formula instead of a vector. Calc effectively uses @kbd{N} (@code{calc-eval-num}) to evaluate variables in the formula; the result of this must be a formula in a single (unassigned) variable. The formula is plotted with this variable taking on the various ``x'' values. Graphs of formulas by default use lines without symbols at the computed data points. Note that if neither ``x'' nor ``y'' is a vector, Calc guesses at a reasonable number of data points to use. See the @kbd{g N} command below. (The ``x'' values must be either a vector or an interval if ``y'' is a formula.) @c @starindex @tindex xy If ``y'' is (or evaluates to) a formula of the form @samp{xy(@var{x}, @var{y})} then the result is a parametric plot. The two arguments of the fictitious @code{xy} function are used as the ``x'' and ``y'' coordinates of the curve, respectively. In this case the ``x'' vector or interval you specified is not directly visible in the graph. For example, if ``x'' is the interval @samp{[0..360]} and ``y'' is the formula @samp{xy(sin(t), cos(t))}, the resulting graph will be a circle.@refill Also, ``x'' and ``y'' may each be variable names, in which case Calc looks for suitable vectors, intervals, or formulas stored in those variables. The ``x'' and ``y'' values for the data points (as pulled from the vectors, calculated from the formulas, or interpolated from the intervals) should be real numbers (integers, fractions, or floats). If either the ``x'' value or the ``y'' value of a given data point is not a real number, that data point will be omitted from the graph. The points on either side of the invalid point will @emph{not} be connected by a line. See the documentation for @kbd{g a} below for a description of the way numeric prefix arguments affect @kbd{g f}. @cindex @code{PlotRejects} variable @vindex PlotRejects If you store an empty vector in the variable @code{PlotRejects} (i.e., @kbd{[ ] s t PlotRejects}), Calc will append information to this vector for every data point which was rejected because its ``x'' or ``y'' values were not real numbers. The result will be a matrix where each row holds the curve number, data point number, ``x'' value, and ``y'' value for a rejected data point. @xref{Evaluates-To Operator}, for a handy way to keep tabs on the current value of @code{PlotRejects}. @xref{Operations on Variables}, for the @kbd{s R} command which is another easy way to examine @code{PlotRejects}. @kindex g c @pindex calc-graph-clear To clear the graphics display, type @kbd{g c} (@code{calc-graph-clear}). If the GNUPLOT output device is an X window, the window will go away. Effects on other kinds of output devices will vary. You don't need to use @kbd{g c} if you don't want to---if you give another @kbd{g f} or @kbd{g p} command later on, it will reuse the existing graphics window if there is one. @node Three Dimensional Graphics, Managing Curves, Basic Graphics, Graphics @section Three-Dimensional Graphics @kindex g F @pindex calc-graph-fast-3d The @kbd{g F} (@code{calc-graph-fast-3d}) command makes a three-dimensional graph. It works only if you have GNUPLOT 3.0 or later; with GNUPLOT 2.0, you will see a GNUPLOT error message if you try this command. The @kbd{g F} command takes three values from the stack, called ``x'', ``y'', and ``z'', respectively. As was the case for 2D graphs, there are several options for these values. In the first case, ``x'' and ``y'' are each vectors (not necessarily of the same length); either or both may instead be interval forms. The ``z'' value must be a matrix with the same number of rows as elements in ``x'', and the same number of columns as elements in ``y''. The result is a surface plot where @c{$z_{ij}$} @cite{z_ij} is the height of the point at coordinate @cite{(x_i, y_j)} on the surface. The 3D graph will be displayed from a certain default viewpoint; you can change this viewpoint by adding a @samp{set view} to the @samp{*Gnuplot Commands*} buffer as described later. See the GNUPLOT 3.0 documentation for a description of the @samp{set view} command. Each point in the matrix will be displayed as a dot in the graph, and these points will be connected by a grid of lines (@dfn{isolines}). In the second case, ``x'', ``y'', and ``z'' are all vectors of equal length. The resulting graph displays a 3D line instead of a surface, where the coordinates of points along the line are successive triplets of values from the input vectors. In the third case, ``x'' and ``y'' are vectors or interval forms, and ``z'' is any formula involving two variables (not counting variables with assigned values). These variables are sorted into alphabetical order; the first takes on values from ``x'' and the second takes on values from ``y'' to form a matrix of results that are graphed as a 3D surface. @c @starindex @tindex xyz If the ``z'' formula evaluates to a call to the fictitious function @samp{xyz(@var{x}, @var{y}, @var{z})}, then the result is a ``parametric surface.'' In this case, the axes of the graph are taken from the @var{x} and @var{y} values in these calls, and the ``x'' and ``y'' values from the input vectors or intervals are used only to specify the range of inputs to the formula. For example, plotting @samp{[0..360], [0..180], xyz(sin(x)*sin(y), cos(x)*sin(y), cos(y))} will draw a sphere. (Since the default resolution for 3D plots is 5 steps in each of ``x'' and ``y'', this will draw a very crude sphere. You could use the @kbd{g N} command, described below, to increase this resolution, or specify the ``x'' and ``y'' values as vectors with more than 5 elements. It is also possible to have a function in a regular @kbd{g f} plot evaluate to an @code{xyz} call. Since @kbd{g f} plots a line, not a surface, the result will be a 3D parametric line. For example, @samp{[[0..720], xyz(sin(x), cos(x), x)]} will plot two turns of a helix (a three-dimensional spiral). As for @kbd{g f}, each of ``x'', ``y'', and ``z'' may instead be variables containing the relevant data. @node Managing Curves, Graphics Options, Three Dimensional Graphics, Graphics @section Managing Curves @noindent The @kbd{g f} command is really shorthand for the following commands: @kbd{C-u g d g a g p}. Likewise, @w{@kbd{g F}} is shorthand for @kbd{C-u g d g A g p}. You can gain more control over your graph by using these commands directly. @kindex g a @pindex calc-graph-add The @kbd{g a} (@code{calc-graph-add}) command adds the ``curve'' represented by the two values on the top of the stack to the current graph. You can have any number of curves in the same graph. When you give the @kbd{g p} command, all the curves will be drawn superimposed on the same axes. The @kbd{g a} command (and many others that affect the current graph) will cause a special buffer, @samp{*Gnuplot Commands*}, to be displayed in another window. This buffer is a template of the commands that will be sent to GNUPLOT when it is time to draw the graph. The first @kbd{g a} command adds a @code{plot} command to this buffer. Succeeding @kbd{g a} commands add extra curves onto that @code{plot} command. Other graph-related commands put other GNUPLOT commands into this buffer. In normal usage you never need to work with this buffer directly, but you can if you wish. The only constraint is that there must be only one @code{plot} command, and it must be the last command in the buffer. If you want to save and later restore a complete graph configuration, you can use regular Emacs commands to save and restore the contents of the @samp{*Gnuplot Commands*} buffer. @vindex PlotData1 @vindex PlotData2 If the values on the stack are not variable names, @kbd{g a} will invent variable names for them (of the form @samp{PlotData@var{n}}) and store the values in those variables. The ``x'' and ``y'' variables are what go into the @code{plot} command in the template. If you add a curve that uses a certain variable and then later change that variable, you can replot the graph without having to delete and re-add the curve. That's because the variable name, not the vector, interval or formula itself, is what was added by @kbd{g a}. A numeric prefix argument on @kbd{g a} or @kbd{g f} changes the way stack entries are interpreted as curves. With a positive prefix argument @cite{n}, the top @cite{n} stack entries are ``y'' values for @cite{n} different curves which share a common ``x'' value in the @cite{n+1}st stack entry. (Thus @kbd{g a} with no prefix argument is equivalent to @kbd{C-u 1 g a}.) A prefix of zero or plain @kbd{C-u} means to take two stack entries, ``x'' and ``y'' as usual, but to interpret ``y'' as a vector of ``y'' values for several curves that share a common ``x''. A negative prefix argument tells Calc to read @cite{n} vectors from the stack; each vector @cite{[x, y]} describes an independent curve. This is the only form of @kbd{g a} that creates several curves at once that don't have common ``x'' values. (Of course, the range of ``x'' values covered by all the curves ought to be roughly the same if they are to look nice on the same graph.) For example, to plot @c{$\sin n x$} @cite{sin(n x)} for integers @cite{n} from 1 to 5, you could use @kbd{v x} to create a vector of integers (@cite{n}), then @kbd{V M '} or @kbd{V M $} to map @samp{sin(n x)} across this vector. The resulting vector of formulas is suitable for use as the ``y'' argument to a @kbd{C-u g a} or @kbd{C-u g f} command. @kindex g A @pindex calc-graph-add-3d The @kbd{g A} (@code{calc-graph-add-3d}) command adds a 3D curve to the graph. It is not legal to intermix 2D and 3D curves in a single graph. This command takes three arguments, ``x'', ``y'', and ``z'', from the stack. With a positive prefix @cite{n}, it takes @cite{n+2} arguments (common ``x'' and ``y'', plus @cite{n} separate ``z''s). With a zero prefix, it takes three stack entries but the ``z'' entry is a vector of curve values. With a negative prefix @cite{-n}, it takes @cite{n} vectors of the form @cite{[x, y, z]}. The @kbd{g A} command works by adding a @code{splot} (surface-plot) command to the @samp{*Gnuplot Commands*} buffer. (Although @kbd{g a} adds a 2D @code{plot} command to the @samp{*Gnuplot Commands*} buffer, Calc changes this to @code{splot} before sending it to GNUPLOT if it notices that the data points are evaluating to @code{xyz} calls. It will not work to mix 2D and 3D @kbd{g a} curves in a single graph, although Calc does not currently check for this.) @kindex g d @pindex calc-graph-delete The @kbd{g d} (@code{calc-graph-delete}) command deletes the most recently added curve from the graph. It has no effect if there are no curves in the graph. With a numeric prefix argument of any kind, it deletes all of the curves from the graph. @kindex g H @pindex calc-graph-hide The @kbd{g H} (@code{calc-graph-hide}) command ``hides'' or ``unhides'' the most recently added curve. A hidden curve will not appear in the actual plot, but information about it such as its name and line and point styles will be retained. @kindex g j @pindex calc-graph-juggle The @kbd{g j} (@code{calc-graph-juggle}) command moves the curve at the end of the list (the ``most recently added curve'') to the front of the list. The next-most-recent curve is thus exposed for @w{@kbd{g d}} or similar commands to use. With @kbd{g j} you can work with any curve in the graph even though curve-related commands only affect the last curve in the list. @kindex g p @pindex calc-graph-plot The @kbd{g p} (@code{calc-graph-plot}) command uses GNUPLOT to draw the graph described in the @samp{*Gnuplot Commands*} buffer. Any GNUPLOT parameters which are not defined by commands in this buffer are reset to their default values. The variables named in the @code{plot} command are written to a temporary data file and the variable names are then replaced by the file name in the template. The resulting plotting commands are fed to the GNUPLOT program. See the documentation for the GNUPLOT program for more specific information. All temporary files are removed when Emacs or GNUPLOT exits. If you give a formula for ``y'', Calc will remember all the values that it calculates for the formula so that later plots can reuse these values. Calc throws out these saved values when you change any circumstances that may affect the data, such as switching from Degrees to Radians mode, or changing the value of a parameter in the formula. You can force Calc to recompute the data from scratch by giving a negative numeric prefix argument to @kbd{g p}. Calc uses a fairly rough step size when graphing formulas over intervals. This is to ensure quick response. You can ``refine'' a plot by giving a positive numeric prefix argument to @kbd{g p}. Calc goes through the data points it has computed and saved from previous plots of the function, and computes and inserts a new data point midway between each of the existing points. You can refine a plot any number of times, but beware that the amount of calculation involved doubles each time. Calc does not remember computed values for 3D graphs. This means the numerix prefix argument, if any, to @kbd{g p} is effectively ignored if the current graph is three-dimensional. @kindex g P @pindex calc-graph-print The @kbd{g P} (@code{calc-graph-print}) command is like @kbd{g p}, except that it sends the output to a printer instead of to the screen. More precisely, @kbd{g p} looks for @samp{set terminal} or @samp{set output} commands in the @samp{*Gnuplot Commands*} buffer; lacking these it uses the default settings. However, @kbd{g P} ignores @samp{set terminal} and @samp{set output} commands and uses a different set of default values. All of these values are controlled by the @kbd{g D} and @kbd{g O} commands discussed below. Provided everything is set up properly, @kbd{g p} will plot to the screen unless you have specified otherwise and @kbd{g P} will always plot to the printer. @node Graphics Options, Devices, Managing Curves, Graphics @section Graphics Options @noindent @kindex g g @pindex calc-graph-grid The @kbd{g g} (@code{calc-graph-grid}) command turns the ``grid'' on and off. It is off by default; tick marks appear only at the edges of the graph. With the grid turned on, dotted lines appear across the graph at each tick mark. Note that this command only changes the setting in @samp{*Gnuplot Commands*}; to see the effects of the change you must give another @kbd{g p} command. @kindex g b @pindex calc-graph-border The @kbd{g b} (@code{calc-graph-border}) command turns the border (the box that surrounds the graph) on and off. It is on by default. This command will only work with GNUPLOT 3.0 and later versions. @kindex g k @pindex calc-graph-key The @kbd{g k} (@code{calc-graph-key}) command turns the ``key'' on and off. The key is a chart in the corner of the graph that shows the correspondence between curves and line styles. It is off by default, and is only really useful if you have several curves on the same graph. @kindex g N @pindex calc-graph-num-points The @kbd{g N} (@code{calc-graph-num-points}) command allows you to select the number of data points in the graph. This only affects curves where neither ``x'' nor ``y'' is specified as a vector. Enter a blank line to revert to the default value (initially 15). With no prefix argument, this command affects only the current graph. With a positive prefix argument this command changes or, if you enter a blank line, displays the default number of points used for all graphs created by @kbd{g a} that don't specify the resolution explicitly. With a negative prefix argument, this command changes or displays the default value (initially 5) used for 3D graphs created by @kbd{g A}. Note that a 3D setting of 5 means that a total of @cite{5^2 = 25} points will be computed for the surface. Data values in the graph of a function are normally computed to a precision of five digits, regardless of the current precision at the time. This is usually more than adequate, but there are cases where it will not be. For example, plotting @cite{1 + x} with @cite{x} in the interval @samp{[0 ..@: 1e-6]} will round all the data points down to 1.0! Putting the command @samp{set precision @var{n}} in the @samp{*Gnuplot Commands*} buffer will cause the data to be computed at precision @var{n} instead of 5. Since this is such a rare case, there is no keystroke-based command to set the precision. @kindex g h @pindex calc-graph-header The @kbd{g h} (@code{calc-graph-header}) command sets the title for the graph. This will show up centered above the graph. The default title is blank (no title). @kindex g n @pindex calc-graph-name The @kbd{g n} (@code{calc-graph-name}) command sets the title of an individual curve. Like the other curve-manipulating commands, it affects the most recently added curve, i.e., the last curve on the list in the @samp{*Gnuplot Commands*} buffer. To set the title of the other curves you must first juggle them to the end of the list with @kbd{g j}, or edit the @samp{*Gnuplot Commands*} buffer by hand. Curve titles appear in the key; if the key is turned off they are not used. @kindex g t @kindex g T @pindex calc-graph-title-x @pindex calc-graph-title-y The @kbd{g t} (@code{calc-graph-title-x}) and @kbd{g T} (@code{calc-graph-title-y}) commands set the titles on the ``x'' and ``y'' axes, respectively. These titles appear next to the tick marks on the left and bottom edges of the graph, respectively. Calc does not have commands to control the tick marks themselves, but you can edit them into the @samp{*Gnuplot Commands*} buffer if you wish. See the GNUPLOT documentation for details. @kindex g r @kindex g R @pindex calc-graph-range-x @pindex calc-graph-range-y The @kbd{g r} (@code{calc-graph-range-x}) and @kbd{g R} (@code{calc-graph-range-y}) commands set the range of values on the ``x'' and ``y'' axes, respectively. You are prompted to enter a suitable range. This should be either a pair of numbers of the form, @samp{@var{min}:@var{max}}, or a blank line to revert to the default behavior of setting the range based on the range of values in the data, or @samp{$} to take the range from the top of the stack. Ranges on the stack can be represented as either interval forms or vectors: @samp{[@var{min} ..@: @var{max}]} or @samp{[@var{min}, @var{max}]}. @kindex g l @kindex g L @pindex calc-graph-log-x @pindex calc-graph-log-y The @kbd{g l} (@code{calc-graph-log-x}) and @kbd{g L} (@code{calc-graph-log-y}) commands allow you to set either or both of the axes of the graph to be logarithmic instead of linear. @kindex g C-l @kindex g C-r @kindex g C-t @pindex calc-graph-log-z @pindex calc-graph-range-z @pindex calc-graph-title-z For 3D plots, @kbd{g C-t}, @kbd{g C-r}, and @kbd{g C-l} (those are letters with the Control key held down) are the corresponding commands for the ``z'' axis. @kindex g z @kindex g Z @pindex calc-graph-zero-x @pindex calc-graph-zero-y The @kbd{g z} (@code{calc-graph-zero-x}) and @kbd{g Z} (@code{calc-graph-zero-y}) commands control whether a dotted line is drawn to indicate the ``x'' and/or ``y'' zero axes. (These are the same dotted lines that would be drawn there anyway if you used @kbd{g g} to turn the ``grid'' feature on.) Zero-axis lines are on by default, and may be turned off only in GNUPLOT 3.0 and later versions. They are not available for 3D plots. @kindex g s @pindex calc-graph-line-style The @kbd{g s} (@code{calc-graph-line-style}) command turns the connecting lines on or off for the most recently added curve, and optionally selects the style of lines to be used for that curve. Plain @kbd{g s} simply toggles the lines on and off. With a numeric prefix argument, @kbd{g s} turns lines on and sets a particular line style. Line style numbers start at one and their meanings vary depending on the output device. GNUPLOT guarantees that there will be at least six different line styles available for any device. @kindex g S @pindex calc-graph-point-style The @kbd{g S} (@code{calc-graph-point-style}) command similarly turns the symbols at the data points on or off, or sets the point style. If you turn both lines and points off, the data points will show as tiny dots. @cindex @code{LineStyles} variable @cindex @code{PointStyles} variable @vindex LineStyles @vindex PointStyles Another way to specify curve styles is with the @code{LineStyles} and @code{PointStyles} variables. These variables initially have no stored values, but if you store a vector of integers in one of these variables, the @kbd{g a} and @kbd{g f} commands will use those style numbers instead of the defaults for new curves that are added to the graph. An entry should be a positive integer for a specific style, or 0 to let the style be chosen automatically, or @i{-1} to turn off lines or points altogether. If there are more curves than elements in the vector, the last few curves will continue to have the default styles. Of course, you can later use @kbd{g s} and @kbd{g S} to change any of these styles. For example, @kbd{'[2 -1 3] RET s t LineStyles} causes the first curve to have lines in style number 2, the second curve to have no connecting lines, and the third curve to have lines in style 3. Point styles will still be assigned automatically, but you could store another vector in @code{PointStyles} to define them, too. @node Devices, , Graphics Options, Graphics @section Graphical Devices @noindent @kindex g D @pindex calc-graph-device The @kbd{g D} (@code{calc-graph-device}) command sets the device name (or ``terminal name'' in GNUPLOT lingo) to be used by @kbd{g p} commands on this graph. It does not affect the permanent default device name. If you enter a blank name, the device name reverts to the default. Enter @samp{?} to see a list of supported devices. With a positive numeric prefix argument, @kbd{g D} instead sets the default device name, used by all plots in the future which do not override it with a plain @kbd{g D} command. If you enter a blank line this command shows you the current default. The special name @code{default} signifies that Calc should choose @code{x11} if the X window system is in use (as indicated by the presence of a @code{DISPLAY} environment variable), or otherwise @code{dumb} under GNUPLOT 3.0 and later, or @code{postscript} under GNUPLOT 2.0. This is the initial default value. The @code{dumb} device is an interface to ``dumb terminals,'' i.e., terminals with no special graphics facilities. It writes a crude picture of the graph composed of characters like @code{-} and @code{|} to a buffer called @samp{*Gnuplot Trail*}, which Calc then displays. The graph is made the same size as the Emacs screen, which on most dumb terminals will be @c{$80\times24$} @asis{80x24} characters. The graph is displayed in an Emacs ``recursive edit''; type @kbd{q} or @kbd{M-# M-#} to exit the recursive edit and return to Calc. Note that the @code{dumb} device is present only in GNUPLOT 3.0 and later versions. The word @code{dumb} may be followed by two numbers separated by spaces. These are the desired width and height of the graph in characters. Also, the device name @code{big} is like @code{dumb} but creates a graph four times the width and height of the Emacs screen. You will then have to scroll around to view the entire graph. In the @samp{*Gnuplot Trail*} buffer, @key{SPC}, @key{DEL}, @kbd{<}, and @kbd{>} are defined to scroll by one screenful in each of the four directions. With a negative numeric prefix argument, @kbd{g D} sets or displays the device name used by @kbd{g P} (@code{calc-graph-print}). This is initially @code{postscript}. If you don't have a PostScript printer, you may decide once again to use @code{dumb} to create a plot on any text-only printer. @kindex g O @pindex calc-graph-output The @kbd{g O} (@code{calc-graph-output}) command sets the name of the output file used by GNUPLOT. For some devices, notably @code{x11}, there is no output file and this information is not used. Many other ``devices'' are really file formats like @code{postscript}; in these cases the output in the desired format goes into the file you name with @kbd{g O}. Type @kbd{g O stdout RET} to set GNUPLOT to write to its standard output stream, i.e., to @samp{*Gnuplot Trail*}. This is the default setting. Another special output name is @code{tty}, which means that GNUPLOT is going to write graphics commands directly to its standard output, which you wish Emacs to pass through to your terminal. Tektronix graphics terminals, among other devices, operate this way. Calc does this by telling GNUPLOT to write to a temporary file, then running a sub-shell executing the command @samp{cat tempfile >/dev/tty}. On typical Unix systems, this will copy the temporary file directly to the terminal, bypassing Emacs entirely. You will have to type @kbd{C-l} to Emacs afterwards to refresh the screen. Once again, @kbd{g O} with a positive or negative prefix argument sets the default or printer output file names, respectively. In each case you can specify @code{auto}, which causes Calc to invent a temporary file name for each @kbd{g p} (or @kbd{g P}) command. This temporary file will be deleted once it has been displayed or printed. If the output file name is not @code{auto}, the file is not automatically deleted. The default and printer devices and output files can be saved permanently by the @kbd{m m} (@code{calc-save-modes}) command. The default number of data points (see @kbd{g N}) and the X geometry (see @kbd{g X}) are also saved. Other graph information is @emph{not} saved; you can save a graph's configuration simply by saving the contents of the @samp{*Gnuplot Commands*} buffer. @vindex calc-gnuplot-plot-command @vindex calc-gnuplot-default-device @vindex calc-gnuplot-default-output @vindex calc-gnuplot-print-command @vindex calc-gnuplot-print-device @vindex calc-gnuplot-print-output If you are installing Calc you may wish to configure the default and printer devices and output files for the whole system. The relevant Lisp variables are @code{calc-gnuplot-default-device} and @code{-output}, and @code{calc-gnuplot-print-device} and @code{-output}. The output file names must be either strings as described above, or Lisp expressions which are evaluated on the fly to get the output file names. Other important Lisp variables are @code{calc-gnuplot-plot-command} and @code{calc-gnuplot-print-command}, which give the system commands to display or print the output of GNUPLOT, respectively. These may be @code{nil} if no command is necessary, or strings which can include @samp{%s} to signify the name of the file to be displayed or printed. Or, these variables may contain Lisp expressions which are evaluated to display or print the output. @kindex g x @pindex calc-graph-display The @kbd{g x} (@code{calc-graph-display}) command lets you specify on which X window system display your graphs should be drawn. Enter a blank line to see the current display name. This command has no effect unless the current device is @code{x11}. @kindex g X @pindex calc-graph-geometry The @kbd{g X} (@code{calc-graph-geometry}) command is a similar command for specifying the position and size of the X window. The normal value is @code{default}, which generally means your window manager will let you place the window interactively. Entering @samp{800x500+0+0} would create an 800-by-500 pixel window in the upper-left corner of the screen. The buffer called @samp{*Gnuplot Trail*} holds a transcript of the session with GNUPLOT. This shows the commands Calc has ``typed'' to GNUPLOT and the responses it has received. Calc tries to notice when an error message has appeared here and display the buffer for you when this happens. You can check this buffer yourself if you suspect something has gone wrong. @kindex g C @pindex calc-graph-command The @kbd{g C} (@code{calc-graph-command}) command prompts you to enter any line of text, then simply sends that line to the current GNUPLOT process. The @samp{*Gnuplot Trail*} buffer looks deceptively like a Shell buffer but you can't type commands in it yourself. Instead, you must use @kbd{g C} for this purpose. @kindex g v @kindex g V @pindex calc-graph-view-commands @pindex calc-graph-view-trail The @kbd{g v} (@code{calc-graph-view-commands}) and @kbd{g V} (@code{calc-graph-view-trail}) commands display the @samp{*Gnuplot Commands*} and @samp{*Gnuplot Trail*} buffers, respectively, in another window. This happens automatically when Calc thinks there is something you will want to see in either of these buffers. If you type @kbd{g v} or @kbd{g V} when the relevant buffer is already displayed, the buffer is hidden again. One reason to use @kbd{g v} is to add your own commands to the @samp{*Gnuplot Commands*} buffer. Press @kbd{g v}, then use @kbd{C-x o} to switch into that window. For example, GNUPLOT has @samp{set label} and @samp{set arrow} commands that allow you to annotate your plots. Since Calc doesn't understand these commands, you have to add them to the @samp{*Gnuplot Commands*} buffer yourself, then use @w{@kbd{g p}} to replot using these new commands. Note that your commands must appear @emph{before} the @code{plot} command. To get help on any GNUPLOT feature, type, e.g., @kbd{g C help set label}. You may have to type @kbd{g C RET} a few times to clear the ``press return for more'' or ``subtopic of @dots{}'' requests. Note that Calc always sends commands (like @samp{set nolabel}) to reset all plotting parameters to the defaults before each plot, so to delete a label all you need to do is delete the @samp{set label} line you added (or comment it out with @samp{#}) and then replot with @kbd{g p}. @kindex g q @pindex calc-graph-quit You can use @kbd{g q} (@code{calc-graph-quit}) to kill the GNUPLOT process that is running. The next graphing command you give will start a fresh GNUPLOT process. The word @samp{Graph} appears in the Calc window's mode line whenever a GNUPLOT process is currently running. The GNUPLOT process is automatically killed when you exit Emacs if you haven't killed it manually by then. @kindex g K @pindex calc-graph-kill The @kbd{g K} (@code{calc-graph-kill}) command is like @kbd{g q} except that it also views the @samp{*Gnuplot Trail*} buffer so that you can see the process being killed. This is better if you are killing GNUPLOT because you think it has gotten stuck. @node Kill and Yank, Keypad Mode, Graphics, Top @chapter Kill and Yank Functions @noindent The commands in this chapter move information between the Calculator and other Emacs editing buffers. In many cases Embedded Mode is an easier and more natural way to work with Calc from a regular editing buffer. @xref{Embedded Mode}. @menu * Killing From Stack:: * Yanking Into Stack:: * Grabbing From Buffers:: * Yanking Into Buffers:: * X Cut and Paste:: @end menu @node Killing From Stack, Yanking Into Stack, Kill and Yank, Kill and Yank @section Killing from the Stack @noindent @kindex C-k @pindex calc-kill @kindex M-k @pindex calc-copy-as-kill @kindex C-w @pindex calc-kill-region @kindex M-w @pindex calc-copy-region-as-kill @cindex Kill ring @dfn{Kill} commands are Emacs commands that insert text into the ``kill ring,'' from which it can later be ``yanked'' by a @kbd{C-y} command. Three common kill commands in normal Emacs are @kbd{C-k}, which kills one line, @kbd{C-w}, which kills the region between mark and point, and @kbd{M-w}, which puts the region into the kill ring without actually deleting it. All of these commands work in the Calculator, too. Also, @kbd{M-k} has been provided to complete the set; it puts the current line into the kill ring without deleting anything. The kill commands are unusual in that they pay attention to the location of the cursor in the Calculator buffer. If the cursor is on or below the bottom line, the kill commands operate on the top of the stack. Otherwise, they operate on whatever stack element the cursor is on. Calc's kill commands always operate on whole stack entries. (They act the same as their standard Emacs cousins except they ``round up'' the specified region to encompass full lines.) The text is copied into the kill ring exactly as it appears on the screen, including line numbers if they are enabled. A numeric prefix argument to @kbd{C-k} or @kbd{M-k} affects the number of lines killed. A positive argument kills the current line and @cite{n-1} lines below it. A negative argument kills the @cite{-n} lines above the current line. Again this mirrors the behavior of the standard Emacs @kbd{C-k} command. Although a whole line is always deleted, @kbd{C-k} with no argument copies only the number itself into the kill ring, whereas @kbd{C-k} with a prefix argument of 1 copies the number with its trailing newline. @node Yanking Into Stack, Grabbing From Buffers, Killing From Stack, Kill and Yank @section Yanking into the Stack @noindent @kindex C-y @pindex calc-yank The @kbd{C-y} command yanks the most recently killed text back into the Calculator. It pushes this value onto the top of the stack regardless of the cursor position. In general it re-parses the killed text as a number or formula (or a list of these separated by commas or newlines). However if the thing being yanked is something that was just killed from the Calculator itself, its full internal structure is yanked. For example, if you have set the floating-point display mode to show only four significant digits, then killing and re-yanking 3.14159 (which displays as 3.142) will yank the full 3.14159, even though yanking it into any other buffer would yank the number in its displayed form, 3.142. (Since the default display modes show all objects to their full precision, this feature normally makes no difference.) @node Grabbing From Buffers, Yanking Into Buffers, Yanking Into Stack, Kill and Yank @section Grabbing from Other Buffers @noindent @kindex M-# g @pindex calc-grab-region The @kbd{M-# g} (@code{calc-grab-region}) command takes the text between point and mark in the current buffer and attempts to parse it as a vector of values. Basically, it wraps the text in vector brackets @samp{[ ]} unless the text already is enclosed in vector brackets, then reads the text as if it were an algebraic entry. The contents of the vector may be numbers, formulas, or any other Calc objects. If the @kbd{M-# g} command works successfully, it does an automatic @kbd{M-# c} to enter the Calculator buffer. A numeric prefix argument grabs the specified number of lines around point, ignoring the mark. A positive prefix grabs from point to the @cite{n}th following newline (so that @kbd{M-1 M-# g} grabs from point to the end of the current line); a negative prefix grabs from point back to the @cite{n+1}st preceding newline. In these cases the text that is grabbed is exactly the same as the text that @kbd{C-k} would delete given that prefix argument. A prefix of zero grabs the current line; point may be anywhere on the line. A plain @kbd{C-u} prefix interprets the region between point and mark as a single number or formula rather than a vector. For example, @kbd{M-# g} on the text @samp{2 a b} produces the vector of three values @samp{[2, a, b]}, but @kbd{C-u M-# g} on the same region reads a formula which is a product of three things: @samp{2 a b}. (The text @samp{a + b}, on the other hand, will be grabbed as a vector of one element by plain @kbd{M-# g} because the interpretation @samp{[a, +, b]} would be a syntax error.) If a different language has been specified (@pxref{Language Modes}), the grabbed text will be interpreted according to that language. @kindex M-# r @pindex calc-grab-rectangle The @kbd{M-# r} (@code{calc-grab-rectangle}) command takes the text between point and mark and attempts to parse it as a matrix. If point and mark are both in the leftmost column, the lines in between are parsed in their entirety. Otherwise, point and mark define the corners of a rectangle whose contents are parsed. Each line of the grabbed area becomes a row of the matrix. The result will actually be a vector of vectors, which Calc will treat as a matrix only if every row contains the same number of values. If a line contains a portion surrounded by square brackets (or curly braces), that portion is interpreted as a vector which becomes a row of the matrix. Any text surrounding the bracketed portion on the line is ignored. Otherwise, the entire line is interpreted as a row vector as if it were surrounded by square brackets. Leading line numbers (in the format used in the Calc stack buffer) are ignored. If you wish to force this interpretation (even if the line contains bracketed portions), give a negative numeric prefix argument to the @kbd{M-# r} command. If you give a numeric prefix argument of zero or plain @kbd{C-u}, each line is instead interpreted as a single formula which is converted into a one-element vector. Thus the result of @kbd{C-u M-# r} will be a one-column matrix. For example, suppose one line of the data is the expression @samp{2 a}. A plain @w{@kbd{M-# r}} will interpret this as @samp{[2 a]}, which in turn is read as a two-element vector that forms one row of the matrix. But a @kbd{C-u M-# r} will interpret this row as @samp{[2*a]}. If you give a positive numeric prefix argument @var{n}, then each line will be split up into columns of width @var{n}; each column is parsed separately as a matrix element. If a line contained @w{@samp{2 +/- 3 4 +/- 5}}, then grabbing with a prefix argument of 8 would correctly split the line into two error forms.@refill @xref{Matrix Functions}, to see how to pull the matrix apart into its constituent rows and columns. (If it is a @c{$1\times1$} @asis{1x1} matrix, just hit @kbd{v u} (@code{calc-unpack}) twice.) @kindex M-# : @kindex M-# _ @pindex calc-grab-sum-across @pindex calc-grab-sum-down @cindex Summing rows and columns of data The @kbd{M-# :} (@code{calc-grab-sum-down}) command is a handy way to grab a rectangle of data and sum its columns. It is equivalent to typing @kbd{M-# r}, followed by @kbd{V R : +} (the vector reduction command that sums the columns of a matrix; @pxref{Reducing}). The result of the command will be a vector of numbers, one for each column in the input data. The @kbd{M-# _} (@code{calc-grab-sum-across}) command similarly grabs a rectangle and sums its rows by executing @w{@kbd{V R _ +}}. As well as being more convenient, @kbd{M-# :} and @kbd{M-# _} are also much faster because they don't actually place the grabbed vector on the stack. In a @kbd{M-# r V R : +} sequence, formatting the vector for display on the stack takes a large fraction of the total time (unless you have planned ahead and used @kbd{v .} and @kbd{t .} modes). For example, suppose we have a column of numbers in a file which we wish to sum. Go to one corner of the column and press @kbd{C-@@} to set the mark; go to the other corner and type @kbd{M-# :}. Since there is only one column, the result will be a vector of one number, the sum. (You can type @kbd{v u} to unpack this vector into a plain number if you want to do further arithmetic with it.) To compute the product of the column of numbers, we would have to do it ``by hand'' since there's no special grab-and-multiply command. Use @kbd{M-# r} to grab the column of numbers into the calculator in the form of a column matrix. The statistics command @kbd{u *} is a handy way to find the product of a vector or matrix of numbers. @xref{Statistical Operations}. Another approach would be to use an explicit column reduction command, @kbd{V R : *}. @node Yanking Into Buffers, X Cut and Paste, Grabbing From Buffers, Kill and Yank @section Yanking into Other Buffers @noindent @kindex y @pindex calc-copy-to-buffer The plain @kbd{y} (@code{calc-copy-to-buffer}) command inserts the number at the top of the stack into the most recently used normal editing buffer. (More specifically, this is the most recently used buffer which is displayed in a window and whose name does not begin with @samp{*}. If there is no such buffer, this is the most recently used buffer except for Calculator and Calc Trail buffers.) The number is inserted exactly as it appears and without a newline. (If line-numbering is enabled, the line number is normally not included.) The number is @emph{not} removed from the stack. With a prefix argument, @kbd{y} inserts several numbers, one per line. A positive argument inserts the specified number of values from the top of the stack. A negative argument inserts the @cite{n}th value from the top of the stack. An argument of zero inserts the entire stack. Note that @kbd{y} with an argument of 1 is slightly different from @kbd{y} with no argument; the former always copies full lines, whereas the latter strips off the trailing newline. With a lone @kbd{C-u} as a prefix argument, @kbd{y} @emph{replaces} the region in the other buffer with the yanked text, then quits the Calculator, leaving you in that buffer. A typical use would be to use @kbd{M-# g} to read a region of data into the Calculator, operate on the data to produce a new matrix, then type @kbd{C-u y} to replace the original data with the new data. One might wish to alter the matrix display style (@pxref{Vector and Matrix Formats}) or change the current display language (@pxref{Language Modes}) before doing this. Also, note that this command replaces a linear region of text (as grabbed by @kbd{M-# g}), not a rectangle (as grabbed by @kbd{M-# r}).@refill If the editing buffer is in overwrite (as opposed to insert) mode, and the @kbd{C-u} prefix was not used, then the yanked number will overwrite the characters following point rather than being inserted before those characters. The usual conventions of overwrite mode are observed; for example, characters will be inserted at the end of a line rather than overflowing onto the next line. Yanking a multi-line object such as a matrix in overwrite mode overwrites the next @var{n} lines in the buffer, lengthening or shortening each line as necessary. Finally, if the thing being yanked is a simple integer or floating-point number (like @samp{-1.2345e-3}) and the characters following point also make up such a number, then Calc will replace that number with the new number, lengthening or shortening as necessary. The concept of ``overwrite mode'' has thus been generalized from overwriting characters to overwriting one complete number with another. @kindex M-# y The @kbd{M-# y} key sequence is equivalent to @kbd{y} except that it can be typed anywhere, not just in Calc. This provides an easy way to guarantee that Calc knows which editing buffer you want to use! @node X Cut and Paste, , Yanking Into Buffers, Kill and Yank @section X Cut and Paste @noindent If you are using Emacs with the X window system, there is an easier way to move small amounts of data into and out of the calculator: Use the mouse-oriented cut and paste facilities of X. The default bindings for a three-button mouse cause the left button to move the Emacs cursor to the given place, the right button to select the text between the cursor and the clicked location, and the middle button to yank the selection into the buffer at the clicked location. So, if you have a Calc window and an editing window on your Emacs screen, you can use left-click/right-click to select a number, vector, or formula from one window, then middle-click to paste that value into the other window. When you paste text into the Calc window, Calc interprets it as an algebraic entry. It doesn't matter where you click in the Calc window; the new value is always pushed onto the top of the stack. The @code{xterm} program that is typically used for general-purpose shell windows in X interprets the mouse buttons in the same way. So you can use the mouse to move data between Calc and any other Unix program. One nice feature of @code{xterm} is that a double left-click selects one word, and a triple left-click selects a whole line. So you can usually transfer a single number into Calc just by double-clicking on it in the shell, then middle-clicking in the Calc window. @node Keypad Mode, Embedded Mode, Kill and Yank, Introduction @chapter ``Keypad'' Mode @noindent @kindex M-# k @pindex calc-keypad The @kbd{M-# k} (@code{calc-keypad}) command starts the Calculator and displays a picture of a calculator-style keypad. If you are using the X window system, you can click on any of the ``keys'' in the keypad using the left mouse button to operate the calculator. The original window remains the selected window; in keypad mode you can type in your file while simultaneously performing calculations with the mouse. @pindex full-calc-keypad If you have used @kbd{M-# b} first, @kbd{M-# k} instead invokes the @code{full-calc-keypad} command, which takes over the whole Emacs screen and displays the keypad, the Calc stack, and the Calc trail all at once. This mode would normally be used when running Calc standalone (@pxref{Standalone Operation}). If you aren't using the X window system, you must switch into the @samp{*Calc Keypad*} window, place the cursor on the desired ``key,'' and type @key{SPC} or @key{RET}. If you think this is easier than using Calc normally, go right ahead. Calc commands are more or less the same in keypad mode. Certain keypad keys differ slightly from the corresponding normal Calc keystrokes; all such deviations are described below. Keypad Mode includes many more commands than will fit on the keypad at once. Click the right mouse button [@code{calc-keypad-menu}] to switch to the next menu. The bottom five rows of the keypad stay the same; the top three rows change to a new set of commands. To return to earlier menus, click the middle mouse button [@code{calc-keypad-menu-back}] or simply advance through the menus until you wrap around. Typing @key{TAB} inside the keypad window is equivalent to clicking the right mouse button there. You can always click the @key{EXEC} button and type any normal Calc key sequence. This is equivalent to switching into the Calc buffer, typing the keys, then switching back to your original buffer. @menu * Keypad Main Menu:: * Keypad Functions Menu:: * Keypad Binary Menu:: * Keypad Vectors Menu:: * Keypad Modes Menu:: @end menu @node Keypad Main Menu, Keypad Functions Menu, Keypad Mode, Keypad Mode @section Main Menu @group @smallexample |----+-----Calc 2.00-----+----1 |FLR |CEIL|RND |TRNC|CLN2|FLT | |----+----+----+----+----+----| | LN |EXP | |ABS |IDIV|MOD | |----+----+----+----+----+----| |SIN |COS |TAN |SQRT|y^x |1/x | |----+----+----+----+----+----| | ENTER |+/- |EEX |UNDO| <- | |-----+---+-+--+--+-+---++----| | INV | 7 | 8 | 9 | / | |-----+-----+-----+-----+-----| | HYP | 4 | 5 | 6 | * | |-----+-----+-----+-----+-----| |EXEC | 1 | 2 | 3 | - | |-----+-----+-----+-----+-----| | OFF | 0 | . | PI | + | |-----+-----+-----+-----+-----+ @end smallexample @end group @noindent This is the menu that appears the first time you start Keypad Mode. It will show up in a vertical window on the right side of your screen. Above this menu is the traditional Calc stack display. On a 24-line screen you will be able to see the top three stack entries. The ten digit keys, decimal point, and @key{EEX} key are used for entering numbers in the obvious way. @key{EEX} begins entry of an exponent in scientific notation. Just as with regular Calc, the number is pushed onto the stack as soon as you press @key{ENTER} or any other function key. The @key{+/-} key corresponds to normal Calc's @kbd{n} key. During numeric entry it changes the sign of the number or of the exponent. At other times it changes the sign of the number on the top of the stack. The @key{INV} and @key{HYP} keys modify other keys. As well as having the effects described elsewhere in this manual, Keypad Mode defines several other ``inverse'' operations. These are described below and in the following sections. The @key{ENTER} key finishes the current numeric entry, or otherwise duplicates the top entry on the stack. The @key{UNDO} key undoes the most recent Calc operation. @kbd{INV UNDO} is the ``redo'' command, and @kbd{HYP UNDO} is ``last arguments'' (@kbd{M-RET}). The @key{<-} key acts as a ``backspace'' during numeric entry. At other times it removes the top stack entry. @kbd{INV <-} clears the entire stack. @kbd{HYP <-} takes an integer from the stack, then removes that many additional stack elements. The @key{EXEC} key prompts you to enter any keystroke sequence that would normally work in Calc mode. This can include a numeric prefix if you wish. It is also possible simply to switch into the Calc window and type commands in it; there is nothing ``magic'' about this window when Keypad Mode is active. The other keys in this display perform their obvious calculator functions. @key{CLN2} rounds the top-of-stack by temporarily reducing the precision by 2 digits. @key{FLT} converts an integer or fraction on the top of the stack to floating-point. The @key{INV} and @key{HYP} keys combined with several of these keys give you access to some common functions even if the appropriate menu is not displayed. Obviously you don't need to learn these keys unless you find yourself wasting time switching among the menus. @table @kbd @item INV +/- is the same as @key{1/x}. @item INV + is the same as @key{SQRT}. @item INV - is the same as @key{CONJ}. @item INV * is the same as @key{y^x}. @item INV / is the same as @key{INV y^x} (the @cite{x}th root of @cite{y}). @item HYP/INV 1 are the same as @key{SIN} / @kbd{INV SIN}. @item HYP/INV 2 are the same as @key{COS} / @kbd{INV COS}. @item HYP/INV 3 are the same as @key{TAN} / @kbd{INV TAN}. @item INV/HYP 4 are the same as @key{LN} / @kbd{HYP LN}. @item INV/HYP 5 are the same as @key{EXP} / @kbd{HYP EXP}. @item INV 6 is the same as @key{ABS}. @item INV 7 is the same as @key{RND} (@code{calc-round}). @item INV 8 is the same as @key{CLN2}. @item INV 9 is the same as @key{FLT} (@code{calc-float}). @item INV 0 is the same as @key{IMAG}. @item INV . is the same as @key{PREC}. @item INV ENTER is the same as @key{SWAP}. @item HYP ENTER is the same as @key{RLL3}. @item INV HYP ENTER is the same as @key{OVER}. @item HYP +/- packs the top two stack entries as an error form. @item HYP EEX packs the top two stack entries as a modulo form. @item INV EEX creates an interval form; this removes an integer which is one of 0 @samp{[]}, 1 @samp{[)}, 2 @samp{(]} or 3 @samp{()}, followed by the two limits of the interval. @end table The @kbd{OFF} key turns Calc off; typing @kbd{M-# k} or @kbd{M-# M-#} again has the same effect. This is analogous to typing @kbd{q} or hitting @kbd{M-# c} again in the normal calculator. If Calc is running standalone (the @code{full-calc-keypad} command appeared in the command line that started Emacs), then @kbd{OFF} is replaced with @kbd{EXIT}; clicking on this actually exits Emacs itself. @node Keypad Functions Menu, Keypad Binary Menu, Keypad Main Menu, Keypad Mode @section Functions Menu @group @smallexample |----+----+----+----+----+----2 |IGAM|BETA|IBET|ERF |BESJ|BESY| |----+----+----+----+----+----| |IMAG|CONJ| RE |ATN2|RAND|RAGN| |----+----+----+----+----+----| |GCD |FACT|DFCT|BNOM|PERM|NXTP| |----+----+----+----+----+----| @end smallexample @end group @noindent This menu provides various operations from the @kbd{f} and @kbd{k} prefix keys. @key{IMAG} multiplies the number on the stack by the imaginary number @cite{i = (0, 1)}. @key{RE} extracts the real part a complex number. @kbd{INV RE} extracts the imaginary part. @key{RAND} takes a number from the top of the stack and computes a random number greater than or equal to zero but less than that number. (@xref{Random Numbers}.) @key{RAGN} is the ``random again'' command; it computes another random number using the same limit as last time. @key{INV GCD} computes the LCM (least common multiple) function. @key{INV FACT} is the gamma function. @c{$\Gamma(x) = (x-1)!$} @cite{gamma(x) = (x-1)!}. @key{PERM} is the number-of-permutations function, which is on the @kbd{H k c} key in normal Calc. @key{NXTP} finds the next prime after a number. @kbd{INV NXTP} finds the previous prime. @node Keypad Binary Menu, Keypad Vectors Menu, Keypad Functions Menu, Keypad Mode @section Binary Menu @group @smallexample |----+----+----+----+----+----3 |AND | OR |XOR |NOT |LSH |RSH | |----+----+----+----+----+----| |DEC |HEX |OCT |BIN |WSIZ|ARSH| |----+----+----+----+----+----| | A | B | C | D | E | F | |----+----+----+----+----+----| @end smallexample @end group @noindent The keys in this menu perform operations on binary integers. Note that both logical and arithmetic right-shifts are provided. @key{INV LSH} rotates one bit to the left. The ``difference'' function (normally on @kbd{b d}) is on @key{INV AND}. The ``clip'' function (normally on @w{@kbd{b c}}) is on @key{INV NOT}. The @key{DEC}, @key{HEX}, @key{OCT}, and @key{BIN} keys select the current radix for display and entry of numbers: Decimal, hexadecimal, octal, or binary. The six letter keys @key{A} through @key{F} are used for entering hexadecimal numbers. The @key{WSIZ} key displays the current word size for binary operations and allows you to enter a new word size. You can respond to the prompt using either the keyboard or the digits and @key{ENTER} from the keypad. The initial word size is 32 bits. @node Keypad Vectors Menu, Keypad Modes Menu, Keypad Binary Menu, Keypad Mode @section Vectors Menu @group @smallexample |----+----+----+----+----+----4 |SUM |PROD|MAX |MAP*|MAP^|MAP$| |----+----+----+----+----+----| |MINV|MDET|MTRN|IDNT|CRSS|"x" | |----+----+----+----+----+----| |PACK|UNPK|INDX|BLD |LEN |... | |----+----+----+----+----+----| @end smallexample @end group @noindent The keys in this menu operate on vectors and matrices. @key{PACK} removes an integer @var{n} from the top of the stack; the next @var{n} stack elements are removed and packed into a vector, which is replaced onto the stack. Thus the sequence @kbd{1 ENTER 3 ENTER 5 ENTER 3 PACK} enters the vector @samp{[1, 3, 5]} onto the stack. To enter a matrix, build each row on the stack as a vector, then use a final @key{PACK} to collect the rows into a matrix. @key{UNPK} unpacks the vector on the stack, pushing each of its components separately. @key{INDX} removes an integer @var{n}, then builds a vector of integers from 1 to @var{n}. @kbd{INV INDX} takes three numbers from the stack: The vector size @var{n}, the starting number, and the increment. @kbd{BLD} takes an integer @var{n} and any value @var{x} and builds a vector of @var{n} copies of @var{x}. @key{IDNT} removes an integer @var{n}, then builds an @var{n}-by-@var{n} identity matrix. @key{LEN} replaces a vector by its length, an integer. @key{...} turns on or off ``abbreviated'' display mode for large vectors. @key{MINV}, @key{MDET}, @key{MTRN}, and @key{CROSS} are the matrix inverse, determinant, and transpose, and vector cross product. @key{SUM} replaces a vector by the sum of its elements. It is equivalent to @kbd{u +} in normal Calc (@pxref{Statistical Operations}). @key{PROD} computes the product of the elements of a vector, and @key{MAX} computes the maximum of all the elements of a vector. @key{INV SUM} computes the alternating sum of the first element minus the second, plus the third, minus the fourth, and so on. @key{INV MAX} computes the minimum of the vector elements. @key{HYP SUM} computes the mean of the vector elements. @key{HYP PROD} computes the sample standard deviation. @key{HYP MAX} computes the median. @key{MAP*} multiplies two vectors elementwise. It is equivalent to the @kbd{V M *} command. @key{MAP^} computes powers elementwise. The arguments must be vectors of equal length, or one must be a vector and the other must be a plain number. For example, @kbd{2 MAP^} squares all the elements of a vector. @key{MAP$} maps the formula on the top of the stack across the vector in the second-to-top position. If the formula contains several variables, Calc takes that many vectors starting at the second-to-top position and matches them to the variables in alphabetical order. The result is a vector of the same size as the input vectors, whose elements are the formula evaluated with the variables set to the various sets of numbers in those vectors. For example, you could simulate @key{MAP^} using @key{MAP$} with the formula @samp{x^y}. The @kbd{"x"} key pushes the variable name @cite{x} onto the stack. To build the formula @cite{x^2 + 6}, you would use the key sequence @kbd{"x" 2 y^x 6 +}. This formula would then be suitable for use with the @key{MAP$} key described above. With @key{INV}, @key{HYP}, or @key{INV} and @key{HYP}, the @kbd{"x"} key pushes the variable names @cite{y}, @cite{z}, and @cite{t}, respectively. @node Keypad Modes Menu, , Keypad Vectors Menu, Keypad Mode @section Modes Menu @group @smallexample |----+----+----+----+----+----5 |FLT |FIX |SCI |ENG |GRP | | |----+----+----+----+----+----| |RAD |DEG |FRAC|POLR|SYMB|PREC| |----+----+----+----+----+----| |SWAP|RLL3|RLL4|OVER|STO |RCL | |----+----+----+----+----+----| @end smallexample @end group @noindent The keys in this menu manipulate modes, variables, and the stack. The @key{FLT}, @key{FIX}, @key{SCI}, and @key{ENG} keys select floating-point, fixed-point, scientific, or engineering notation. @key{FIX} displays two digits after the decimal by default; the others display full precision. With the @key{INV} prefix, these keys pop a number-of-digits argument from the stack. The @key{GRP} key turns grouping of digits with commas on or off. @kbd{INV GRP} enables grouping to the right of the decimal point as well as to the left. The @key{RAD} and @key{DEG} keys switch between radians and degrees for trigonometric functions. The @key{FRAC} key turns Fraction mode on or off. This affects whether commands like @kbd{/} with integer arguments produce fractional or floating-point results. The @key{POLR} key turns Polar mode on or off, determining whether polar or rectangular complex numbers are used by default. The @key{SYMB} key turns Symbolic mode on or off, in which operations that would produce inexact floating-point results are left unevaluated as algebraic formulas. The @key{PREC} key selects the current precision. Answer with the keyboard or with the keypad digit and @key{ENTER} keys. The @key{SWAP} key exchanges the top two stack elements. The @key{RLL3} key rotates the top three stack elements upwards. The @key{RLL4} key rotates the top four stack elements upwards. The @key{OVER} key duplicates the second-to-top stack element. The @key{STO} and @key{RCL} keys are analogous to @kbd{s t} and @kbd{s r} in regular Calc. @xref{Store and Recall}. Click the @key{STO} or @key{RCL} key, then one of the ten digits. (Named variables are not available in Keypad Mode.) You can also use, for example, @kbd{STO + 3} to add to register 3. @node Embedded Mode, Programming, Keypad Mode, Top @chapter Embedded Mode @noindent Embedded Mode in Calc provides an alternative to copying numbers and formulas back and forth between editing buffers and the Calc stack. In Embedded Mode, your editing buffer becomes temporarily linked to the stack and this copying is taken care of automatically. @menu * Basic Embedded Mode:: * More About Embedded Mode:: * Assignments in Embedded Mode:: * Mode Settings in Embedded Mode:: * Customizing Embedded Mode:: @end menu @node Basic Embedded Mode, More About Embedded Mode, Embedded Mode, Embedded Mode @section Basic Embedded Mode @noindent @kindex M-# e @pindex calc-embedded To enter Embedded mode, position the Emacs point (cursor) on a formula in any buffer and press @kbd{M-# e} (@code{calc-embedded}). Note that @kbd{M-# e} is not to be used in the Calc stack buffer like most Calc commands, but rather in regular editing buffers that are visiting your own files. Calc normally scans backward and forward in the buffer for the nearest opening and closing @dfn{formula delimiters}. The simplest delimiters are blank lines. Other delimiters that Embedded Mode understands are: @enumerate @item The @TeX{} and La@TeX{} math delimiters @samp{$ $}, @samp{$$ $$}, @samp{\[ \]}, and @samp{\( \)}; @item Lines beginning with @samp{\begin} and @samp{\end}; @item Lines beginning with @samp{@@} (Texinfo delimiters). @item Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters); @item Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else. @end enumerate @xref{Customizing Embedded Mode}, to see how to make Calc recognize your own favorite delimiters. Delimiters like @samp{$ $} can appear on their own separate lines or in-line with the formula. If you give a positive or negative numeric prefix argument, Calc instead uses the current point as one end of the formula, and moves forward or backward (respectively) by that many lines to find the other end. Explicit delimiters are not necessary in this case. With a prefix argument of zero, Calc uses the current region (delimited by point and mark) instead of formula delimiters. @kindex M-# w @pindex calc-embedded-word With a prefix argument of @kbd{C-u} only, Calc scans for the first non-numeric character (i.e., the first character that is not a digit, sign, decimal point, or upper- or lower-case @samp{e}) forward and backward to delimit the formula. @kbd{M-# w} (@code{calc-embedded-word}) is equivalent to @kbd{C-u M-# e}. When you enable Embedded mode for a formula, Calc reads the text between the delimiters and tries to interpret it as a Calc formula. It's best if the current Calc language mode is correct for the formula, but Calc can generally identify @TeX{} formulas and Big-style formulas even if the language mode is wrong. If Calc can't make sense of the formula, it beeps and refuses to enter Embedded mode. But if the current language is wrong, Calc can sometimes parse the formula successfully (but incorrectly); for example, the C expression @samp{atan(a[1])} can be parsed in Normal language mode, but the @code{atan} won't correspond to the built-in @code{arctan} function, and the @samp{a[1]} will be interpreted as @samp{a} times the vector @samp{[1]}! If you press @kbd{M-# e} or @kbd{M-# w} to activate an embedded formula which is blank, say with the cursor on the space between the two delimiters @samp{$ $}, Calc will immediately prompt for an algebraic entry. Only one formula in one buffer can be enabled at a time. If you move to another area of the current buffer and give Calc commands, Calc turns Embedded mode off for the old formula and then tries to restart Embedded mode at the new position. Other buffers are not affected by Embedded mode. When Embedded mode begins, Calc pushes the current formula onto the stack. No Calc stack window is created; however, Calc copies the top-of-stack position into the original buffer at all times. You can create a Calc window by hand with @kbd{M-# o} if you find you need to see the entire stack. For example, typing @kbd{M-# e} while somewhere in the formula @samp{n>2} in the following line enables Embedded mode on that inequality: @example We define $F_n = F_(n-1)+F_(n-2)$ for all $n>2$. @end example @noindent The formula @cite{n>2} will be pushed onto the Calc stack, and the top of stack will be copied back into the editing buffer. This means that spaces will appear around the @samp{>} symbol to match Calc's usual display style: @example We define $F_n = F_(n-1)+F_(n-2)$ for all $n > 2$. @end example @noindent No spaces have appeared around the @samp{+} sign because it's in a different formula, one which we have not yet touched with Embedded mode. Now that Embedded mode is enabled, keys you type in this buffer are interpreted as Calc commands. At this point we might use the ``commute'' command @kbd{j C} to reverse the inequality. This is a selection-based command for which we first need to move the cursor onto the operator (@samp{>} in this case) that needs to be commuted. @example We define $F_n = F_(n-1)+F_(n-2)$ for all $2 < n$. @end example The @kbd{M-# o} command is a useful way to open a Calc window without actually selecting that window. Giving this command verifies that @samp{2 < n} is also on the Calc stack. Typing @kbd{17 RET} would produce: @example We define $F_n = F_(n-1)+F_(n-2)$ for all $17$. @end example @noindent with @samp{2 < n} and @samp{17} on the stack; typing @key{TAB} at this point will exchange the two stack values and restore @samp{2 < n} to the embedded formula. Even though you can't normally see the stack in Embedded mode, it is still there and it still operates in the same way. But, as with old-fashioned RPN calculators, you can only see the value at the top of the stack at any given time (unless you use @kbd{M-# o}). Typing @kbd{M-# e} again turns Embedded mode off. The Calc window reveals that the formula @w{@samp{2 < n}} is automatically removed from the stack, but the @samp{17} is not. Entering Embedded mode always pushes one thing onto the stack, and leaving Embedded mode always removes one thing. Anything else that happens on the stack is entirely your business as far as Embedded mode is concerned. If you press @kbd{M-# e} in the wrong place by accident, it is possible that Calc will be able to parse the nearby text as a formula and will mangle that text in an attempt to redisplay it ``properly'' in the current language mode. If this happens, press @kbd{M-# e} again to exit Embedded mode, then give the regular Emacs ``undo'' command (@kbd{C-_} or @kbd{C-x u}) to put the text back the way it was before Calc edited it. Note that Calc's own Undo command (typed before you turn Embedded mode back off) will not do you any good, because as far as Calc is concerned you haven't done anything with this formula yet. @node More About Embedded Mode, Assignments in Embedded Mode, Basic Embedded Mode, Embedded Mode @section More About Embedded Mode @noindent When Embedded mode ``activates'' a formula, i.e., when it examines the formula for the first time since the buffer was created or loaded, Calc tries to sense the language in which the formula was written. If the formula contains any @TeX{}-like @samp{\} sequences, it is parsed (i.e., read) in @TeX{} mode. If the formula appears to be written in multi-line Big mode, it is parsed in Big mode. Otherwise, it is parsed according to the current language mode. Note that Calc does not change the current language mode according to what it finds. Even though it can read a @TeX{} formula when not in @TeX{} mode, it will immediately rewrite this formula using whatever language mode is in effect. You must then type @kbd{d T} to switch Calc permanently into @TeX{} mode if that is what you desire. @tex \bigskip @end tex @kindex d p @pindex calc-show-plain Calc's parser is unable to read certain kinds of formulas. For example, with @kbd{v ]} (@code{calc-matrix-brackets}) you can specify matrix display styles which the parser is unable to recognize as matrices. The @kbd{d p} (@code{calc-show-plain}) command turns on a mode in which a ``plain'' version of a formula is placed in front of the fully-formatted version. When Calc reads a formula that has such a plain version in front, it reads the plain version and ignores the formatted version. Plain formulas are preceded and followed by @samp{%%%} signs by default. This notation has the advantage that the @samp{%} character begins a comment in @TeX{}, so if your formula is embedded in a @TeX{} document its plain version will be invisible in the final printed copy. @xref{Customizing Embedded Mode}, to see how to change the ``plain'' formula delimiters, say to something that @dfn{eqn} or some other formatter will treat as a comment. There are several notations which Calc's parser for ``big'' formatted formulas can't yet recognize. In particular, it can't read the large symbols for @code{sum}, @code{prod}, and @code{integ}, and it can't handle @samp{=>} with the righthand argument omitted. Also, Calc won't recognize special formats you have defined with the @kbd{Z C} command (@pxref{User-Defined Compositions}). In these cases it is important to use ``plain'' mode to make sure Calc will be able to read your formula later. Another example where ``plain'' mode is important is if you have specified a float mode with few digits of precision. Normally any digits that are computed but not displayed will simply be lost when you save and re-load your embedded buffer, but ``plain'' mode allows you to make sure that the complete number is present in the file as well as the rounded-down number. @tex \bigskip @end tex Embedded buffers remember active formulas for as long as they exist in Emacs memory. Suppose you have an embedded formula which is @c{$\pi$} @cite{pi} to the normal 12 decimal places, and then type @w{@kbd{C-u 5 d n}} to display only five decimal places. If you then type @kbd{d n}, all 12 places reappear because the full number is still there on the Calc stack. More surprisingly, even if you exit Embedded mode and later re-enter it for that formula, typing @kbd{d n} will restore all 12 places because each buffer remembers all its active formulas. However, if you save the buffer in a file and reload it in a new Emacs session, all non-displayed digits will have been lost unless you used ``plain'' mode. @tex \bigskip @end tex In some applications of Embedded mode, you will want to have a sequence of copies of a formula that show its evolution as you work on it. For example, you might want to have a sequence like this in your file (elaborating here on the example from the ``Getting Started'' chapter): @smallexample The derivative of ln(ln(x)) is @r{(the derivative of }ln(ln(x))@r{)} whose value at x = 2 is @r{(the value)} and at x = 3 is @r{(the value)} @end smallexample @kindex M-# d @pindex calc-embedded-duplicate The @kbd{M-# d} (@code{calc-embedded-duplicate}) command is a handy way to make sequences like this. If you type @kbd{M-# d}, the formula under the cursor (which may or may not have Embedded mode enabled for it at the time) is copied immediately below and Embedded mode is then enabled for that copy. For this example, you would start with just @smallexample The derivative of ln(ln(x)) @end smallexample @noindent and press @kbd{M-# d} with the cursor on this formula. The result is @smallexample The derivative of ln(ln(x)) ln(ln(x)) @end smallexample @noindent with the second copy of the formula enabled in Embedded mode. You can now press @kbd{a d x RET} to take the derivative, and @kbd{M-# d M-# d} to make two more copies of the derivative. To complete the computations, type @kbd{3 s l x RET} to evaluate the last formula, then move up to the second-to-last formula and type @kbd{2 s l x RET}. Finally, you would want to press @kbd{M-# e} to exit Embedded mode, then go up and insert the necessary text in between the various formulas and numbers. @tex \bigskip @end tex @kindex M-# f @kindex M-# ' @pindex calc-embedded-new-formula The @kbd{M-# f} (@code{calc-embedded-new-formula}) command creates a new embedded formula at the current point. It inserts some default delimiters, which are usually just blank lines, and then does an algebraic entry to get the formula (which is then enabled for Embedded mode). This is just shorthand for typing the delimiters yourself, positioning the cursor between the new delimiters, and pressing @kbd{M-# e}. The key sequence @kbd{M-# '} is equivalent to @kbd{M-# f}. @kindex M-# n @kindex M-# p @pindex calc-embedded-next @pindex calc-embedded-previous The @kbd{M-# n} (@code{calc-embedded-next}) and @kbd{M-# p} (@code{calc-embedded-previous}) commands move the cursor to the next or previous active embedded formula in the buffer. They can take positive or negative prefix arguments to move by several formulas. Note that these commands do not actually examine the text of the buffer looking for formulas; they only see formulas which have previously been activated in Embedded mode. In fact, @kbd{M-# n} and @kbd{M-# p} are a useful way to tell which embedded formulas are currently active. Also, note that these commands do not enable Embedded mode on the next or previous formula, they just move the cursor. (By the way, @kbd{M-# n} is not as awkward to type as it may seem, because @kbd{M-#} ignores Shift and Meta on the second keystroke: @kbd{M-# M-N} can be typed by holding down Shift and Meta and alternately typing two keys.) @kindex M-# ` @pindex calc-embedded-edit The @kbd{M-# `} (@code{calc-embedded-edit}) command edits the embedded formula at the current point as if by @kbd{`} (@code{calc-edit}). Embedded mode does not have to be enabled for this to work. Press @kbd{M-# M-#} to finish the edit, or @kbd{M-# x} to cancel. @node Assignments in Embedded Mode, Mode Settings in Embedded Mode, More About Embedded Mode, Embedded Mode @section Assignments in Embedded Mode @noindent The @samp{:=} (assignment) and @samp{=>} (``evaluates-to'') operators are especially useful in Embedded mode. They allow you to make a definition in one formula, then refer to that definition in other formulas embedded in the same buffer. An embedded formula which is an assignment to a variable, as in @example foo := 5 @end example @noindent records @cite{5} as the stored value of @code{foo} for the purposes of Embedded mode operations in the current buffer. It does @emph{not} actually store @cite{5} as the ``global'' value of @code{foo}, however. Regular Calc operations, and Embedded formulas in other buffers, will not see this assignment. One way to use this assigned value is simply to create an Embedded formula elsewhere that refers to @code{foo}, and to press @kbd{=} in that formula. However, this permanently replaces the @code{foo} in the formula with its current value. More interesting is to use @samp{=>} elsewhere: @example foo + 7 => 12 @end example @xref{Evaluates-To Operator}, for a general discussion of @samp{=>}. If you move back and change the assignment to @code{foo}, any @samp{=>} formulas which refer to it are automatically updated. @example foo := 17 foo + 7 => 24 @end example The obvious question then is, @emph{how} can one easily change the assignment to @code{foo}? If you simply select the formula in Embedded mode and type 17, the assignment itself will be replaced by the 17. The effect on the other formula will be that the variable @code{foo} becomes unassigned: @example 17 foo + 7 => foo + 7 @end example The right thing to do is first to use a selection command (@kbd{j 2} will do the trick) to select the righthand side of the assignment. Then, @kbd{17 TAB DEL} will swap the 17 into place (@pxref{Selecting Subformulas}, to see how this works). @kindex M-# j @pindex calc-embedded-select The @kbd{M-# j} (@code{calc-embedded-select}) command provides an easy way to operate on assigments. It is just like @kbd{M-# e}, except that if the enabled formula is an assignment, it uses @kbd{j 2} to select the righthand side. If the enabled formula is an evaluates-to, it uses @kbd{j 1} to select the lefthand side. A formula can also be a combination of both: @example bar := foo + 3 => 20 @end example @noindent in which case @kbd{M-# j} will select the middle part (@samp{foo + 3}). The formula is automatically deselected when you leave Embedded mode. @kindex M-# u @kindex M-# = @pindex calc-embedded-update Another way to change the assignment to @code{foo} would simply be to edit the number using regular Emacs editing rather than Embedded mode. Then, we have to find a way to get Embedded mode to notice the change. The @kbd{M-# u} or @kbd{M-# =} (@code{calc-embedded-update-formula}) command is a convenient way to do this.@refill @example foo := 6 foo + 7 => 13 @end example Pressing @kbd{M-# u} is much like pressing @kbd{M-# e = M-# e}, that is, temporarily enabling Embedded mode for the formula under the cursor and then evaluating it with @kbd{=}. But @kbd{M-# u} does not actually use @kbd{M-# e}, and in fact another formula somewhere else can be enabled in Embedded mode while you use @kbd{M-# u} and that formula will not be disturbed. With a numeric prefix argument, @kbd{M-# u} updates all active @samp{=>} formulas in the buffer. Formulas which have not yet been activated in Embedded mode, and formulas which do not have @samp{=>} as their top-level operator, are not affected by this. (This is useful only if you have used @kbd{m C}; see below.) With a plain @kbd{C-u} prefix, @kbd{C-u M-# u} updates only in the region between mark and point rather than in the whole buffer. @kbd{M-# u} is also a handy way to activate a formula, such as an @samp{=>} formula that has freshly been typed in or loaded from a file. @kindex M-# a @pindex calc-embedded-activate The @kbd{M-# a} (@code{calc-embedded-activate}) command scans through the current buffer and activates all embedded formulas that contain @samp{:=} or @samp{=>} symbols. This does not mean that Embedded mode is actually turned on, but only that the formulas' positions are registered with Embedded mode so that the @samp{=>} values can be properly updated as assignments are changed. It is a good idea to type @kbd{M-# a} right after loading a file that uses embedded @samp{=>} operators. Emacs includes a nifty ``buffer-local variables'' feature that you can use to do this automatically. The idea is to place near the end of your file a few lines that look like this: @example --- Local Variables: --- --- eval:(calc-embedded-activate) --- --- End: --- @end example @noindent where the leading and trailing @samp{---} can be replaced by any suitable strings (which must be the same on all three lines) or omitted altogether; in a @TeX{} file, @samp{%} would be a good leading string and no trailing string would be necessary. In a C program, @samp{/*} and @samp{*/} would be good leading and trailing strings. When Emacs loads a file into memory, it checks for a Local Variables section like this one at the end of the file. If it finds this section, it does the specified things (in this case, running @kbd{M-# a} automatically) before editing of the file begins. The Local Variables section must be within 3000 characters of the end of the file for Emacs to find it, and it must be in the last page of the file if the file has any page separators. @xref{File Variables, , Local Variables in Files, emacs, the Emacs manual}. Note that @kbd{M-# a} does not update the formulas it finds. To do this, type, say, @kbd{M-1 M-# u} after @w{@kbd{M-# a}}. Generally this should not be a problem, though, because the formulas will have been up-to-date already when the file was saved. Normally, @kbd{M-# a} activates all the formulas it finds, but any previous active formulas remain active as well. With a positive numeric prefix argument, @kbd{M-# a} first deactivates all current active formulas, then actives the ones it finds in its scan of the buffer. With a negative prefix argument, @kbd{M-# a} simply deactivates all formulas. Embedded mode has two symbols, @samp{Active} and @samp{~Active}, which it puts next to the major mode name in a buffer's mode line. It puts @samp{Active} if it has reason to believe that all formulas in the buffer are active, because you have typed @kbd{M-# a} and Calc has not since had to deactivate any formulas (which can happen if Calc goes to update an @samp{=>} formula somewhere because a variable changed, and finds that the formula is no longer there due to some kind of editing outside of Embedded mode). Calc puts @samp{~Active} in the mode line if some, but probably not all, formulas in the buffer are active. This happens if you activate a few formulas one at a time but never use @kbd{M-# a}, or if you used @kbd{M-# a} but then Calc had to deactivate a formula because it lost track of it. If neither of these symbols appears in the mode line, no embedded formulas are active in the buffer (e.g., before Embedded mode has been used, or after a @kbd{M-- M-# a}). Embedded formulas can refer to assignments both before and after them in the buffer. If there are several assignments to a variable, the nearest preceding assignment is used if there is one, otherwise the following assignment is used. @example x => 1 x := 1 x => 1 x := 2 x => 2 @end example As well as simple variables, you can also assign to subscript expressions of the form @samp{@var{var}_@var{number}} (as in @code{x_0}), or @samp{@var{var}_@var{var}} (as in @code{x_max}). Assignments to other kinds of objects can be represented by Calc, but the automatic linkage between assignments and references works only for plain variables and these two kinds of subscript expressions. If there are no assignments to a given variable, the global stored value for the variable is used (@pxref{Storing Variables}), or, if no value is stored, the variable is left in symbolic form. Note that global stored values will be lost when the file is saved and loaded in a later Emacs session, unless you have used the @kbd{s p} (@code{calc-permanent-variable}) command to save them; @pxref{Operations on Variables}. The @kbd{m C} (@code{calc-auto-recompute}) command turns automatic recomputation of @samp{=>} forms on and off. If you turn automatic recomputation off, you will have to use @kbd{M-# u} to update these formulas manually after an assignment has been changed. If you plan to change several assignments at once, it may be more efficient to type @kbd{m C}, change all the assignments, then use @kbd{M-1 M-# u} to update the entire buffer afterwards. The @kbd{m C} command also controls @samp{=>} formulas on the stack; @pxref{Evaluates-To Operator}. When you turn automatic recomputation back on, the stack will be updated but the Embedded buffer will not; you must use @kbd{M-# u} to update the buffer by hand. @node Mode Settings in Embedded Mode, Customizing Embedded Mode, Assignments in Embedded Mode, Embedded Mode @section Mode Settings in Embedded Mode @noindent Embedded Mode has a rather complicated mechanism for handling mode settings in Embedded formulas. It is possible to put annotations in the file that specify mode settings either global to the entire file or local to a particular formula or formulas. In the latter case, different modes can be specified for use when a formula is the enabled Embedded Mode formula. When you give any mode-setting command, like @kbd{m f} (for fraction mode) or @kbd{d s} (for scientific notation), Embedded Mode adds a line like the following one to the file just before the opening delimiter of the formula. @example % [calc-mode: fractions: t] % [calc-mode: float-format: (sci 0)] @end example When Calc interprets an embedded formula, it scans the text before the formula for mode-setting annotations like these and sets the Calc buffer to match these modes. Modes not explicitly described in the file are not changed. Calc scans all the way to the top of the file, or up to a line of the form @example % [calc-defaults] @end example @noindent which you can insert at strategic places in the file if this backward scan is getting too slow, or just to provide a barrier between one ``zone'' of mode settings and another. If the file contains several annotations for the same mode, the closest one before the formula is used. Annotations after the formula are never used (except for global annotations, described below). The scan does not look for the leading @samp{% }, only for the square brackets and the text they enclose. You can edit the mode annotations to a style that works better in context if you wish. @xref{Customizing Embedded Mode}, to see how to change the style that Calc uses when it generates the annotations. You can write mode annotations into the file yourself if you know the syntax; the easiest way to find the syntax for a given mode is to let Calc write the annotation for it once and see what it does. If you give a mode-changing command for a mode that already has a suitable annotation just above the current formula, Calc will modify that annotation rather than generating a new, conflicting one. Mode annotations have three parts, separated by colons. (Spaces after the colons are optional.) The first identifies the kind of mode setting, the second is a name for the mode itself, and the third is the value in the form of a Lisp symbol, number, or list. Annotations with unrecognizable text in the first or second parts are ignored. The third part is not checked to make sure the value is of a legal type or range; if you write an annotation by hand, be sure to give a proper value or results will be unpredictable. Mode-setting annotations are case-sensitive. While Embedded Mode is enabled, the word @code{Local} appears in the mode line. This is to show that mode setting commands generate annotations that are ``local'' to the current formula or set of formulas. The @kbd{m R} (@code{calc-mode-record-mode}) command causes Calc to generate different kinds of annotations. Pressing @kbd{m R} repeatedly cycles through the possible modes. @code{LocEdit} and @code{LocPerm} modes generate annotations that look like this, respectively: @example % [calc-edit-mode: float-format: (sci 0)] % [calc-perm-mode: float-format: (sci 5)] @end example The first kind of annotation will be used only while a formula is enabled in Embedded Mode. The second kind will be used only when the formula is @emph{not} enabled. (Whether the formula is ``active'' or not, i.e., whether Calc has seen this formula yet, is not relevant here.) @code{Global} mode generates an annotation like this at the end of the file: @example % [calc-global-mode: fractions t] @end example Global mode annotations affect all formulas throughout the file, and may appear anywhere in the file. This allows you to tuck your mode annotations somewhere out of the way, say, on a new page of the file, as long as those mode settings are suitable for all formulas in the file. Enabling a formula with @kbd{M-# e} causes a fresh scan for local mode annotations; you will have to use this after adding annotations above a formula by hand to get the formula to notice them. Updating a formula with @kbd{M-# u} will also re-scan the local modes, but global modes are only re-scanned by @kbd{M-# a}. Another way that modes can get out of date is if you add a local mode annotation to a formula that has another formula after it. In this example, we have used the @kbd{d s} command while the first of the two embedded formulas is active. But the second formula has not changed its style to match, even though by the rules of reading annotations the @samp{(sci 0)} applies to it, too. @example % [calc-mode: float-format: (sci 0)] 1.23e2 456. @end example We would have to go down to the other formula and press @kbd{M-# u} on it in order to get it to notice the new annotation. Two more mode-recording modes selectable by @kbd{m R} are @code{Save} (which works even outside of Embedded Mode), in which mode settings are recorded permanently in your Emacs startup file @file{~/.emacs} rather than by annotating the current document, and no-recording mode (where there is no symbol like @code{Save} or @code{Local} in the mode line), in which mode-changing commands do not leave any annotations at all. When Embedded Mode is not enabled, mode-recording modes except for @code{Save} have no effect. @node Customizing Embedded Mode, , Mode Settings in Embedded Mode, Embedded Mode @section Customizing Embedded Mode @noindent You can modify Embedded Mode's behavior by setting various Lisp variables described here. Use @kbd{M-x set-variable} or @kbd{M-x edit-options} to adjust a variable on the fly, or put a suitable @code{setq} statement in your @file{~/.emacs} file to set a variable permanently. (Another possibility would be to use a file-local variable annotation at the end of the file; @pxref{File Variables, , Local Variables in Files, emacs, the Emacs manual}.) While none of these variables will be buffer-local by default, you can make any of them local to any embedded-mode buffer. (Their values in the @samp{*Calculator*} buffer are never used.) @vindex calc-embedded-open-formula The @code{calc-embedded-open-formula} variable holds a regular expression for the opening delimiter of a formula. @xref{Regexp Search, , Regular Expression Search, emacs, the Emacs manual}, to see how regular expressions work. Basically, a regular expression is a pattern that Calc can search for. A regular expression that considers blank lines, @samp{$}, and @samp{$$} to be opening delimiters is @code{"\\`\\|^\n\\|\\$\\$?"}. Just in case the meaning of this regular expression is not completely plain, let's go through it in detail. The surrounding @samp{" "} marks quote the text between them as a Lisp string. If you left them off, @code{set-variable} or @code{edit-options} would try to read the regular expression as a Lisp program. The most obvious property of this regular expression is that it contains indecently many backslashes. There are actually two levels of backslash usage going on here. First, when Lisp reads a quoted string, all pairs of characters beginning with a backslash are interpreted as special characters. Here, @code{\n} changes to a new-line character, and @code{\\} changes to a single backslash. So the actual regular expression seen by Calc is @samp{\`\|^ @r{(newline)} \|\$\$?}. Regular expressions also consider pairs beginning with backslash to have special meanings. Sometimes the backslash is used to quote a character that otherwise would have a special meaning in a regular expression, like @samp{$}, which normally means ``end-of-line,'' or @samp{?}, which means that the preceding item is optional. So @samp{\$\$?} matches either one or two dollar signs. The other codes in this regular expression are @samp{^}, which matches ``beginning-of-line,'' @samp{\|}, which means ``or,'' and @samp{\`}, which matches ``beginning-of-buffer.'' So the whole pattern means that a formula begins at the beginning of the buffer, or on a newline that occurs at the beginning of a line (i.e., a blank line), or at one or two dollar signs. The default value of @code{calc-embedded-open-formula} looks just like this example, with several more alternatives added on to recognize various other common kinds of delimiters. By the way, the reason to use @samp{^\n} rather than @samp{^$} or @samp{\n\n}, which also would appear to match blank lines, is that the former expression actually ``consumes'' only one newline character as @emph{part of} the delimiter, whereas the latter expressions consume zero or two newlines, respectively. The former choice gives the most natural behavior when Calc must operate on a whole formula including its delimiters. See the Emacs manual for complete details on regular expressions. But just for your convenience, here is a list of all characters which must be quoted with backslash (like @samp{\$}) to avoid some special interpretation: @samp{. * + ? [ ] ^ $ \}. (Note the backslash in this list; for example, to match @samp{\[} you must use @code{"\\\\\\["}. An exercise for the reader is to account for each of these six backslashes!) @vindex calc-embedded-close-formula The @code{calc-embedded-close-formula} variable holds a regular expression for the closing delimiter of a formula. A closing regular expression to match the above example would be @code{"\\'\\|\n$\\|\\$\\$?"}. This is almost the same as the other one, except it now uses @samp{\'} (``end-of-buffer'') and @samp{\n$} (newline occurring at end of line, yet another way of describing a blank line that is more appropriate for this case). @vindex calc-embedded-open-word @vindex calc-embedded-close-word The @code{calc-embedded-open-word} and @code{calc-embedded-close-word} variables are similar expressions used when you type @kbd{M-# w} instead of @kbd{M-# e} to enable Embedded mode. @vindex calc-embedded-open-plain The @code{calc-embedded-open-plain} variable is a string which begins a ``plain'' formula written in front of the formatted formula when @kbd{d p} mode is turned on. Note that this is an actual string, not a regular expression, because Calc must be able to write this string into a buffer as well as to recognize it. The default string is @code{"%%% "} (note the trailing space). @vindex calc-embedded-close-plain The @code{calc-embedded-close-plain} variable is a string which ends a ``plain'' formula. The default is @code{" %%%\n"}. Without the trailing newline here, the first line of a ``big'' mode formula that followed might be shifted over with respect to the other lines. @vindex calc-embedded-open-new-formula The @code{calc-embedded-open-new-formula} variable is a string which is inserted at the front of a new formula when you type @kbd{M-# f}. Its default value is @code{"\n\n"}. If this string begins with a newline character and the @kbd{M-# f} is typed at the beginning of a line, @kbd{M-# f} will skip this first newline to avoid introducing unnecessary blank lines in the file. @vindex calc-embedded-close-new-formula The @code{calc-embedded-close-new-formula} variable is the corresponding string which is inserted at the end of a new formula. Its default value is also @code{"\n\n"}. The final newline is omitted by @w{@kbd{M-# f}} if typed at the end of a line. (It follows that if @kbd{M-# f} is typed on a blank line, both a leading opening newline and a trailing closing newline are omitted.) @vindex calc-embedded-announce-formula The @code{calc-embedded-announce-formula} variable is a regular expression which is sure to be followed by an embedded formula. The @kbd{M-# a} command searches for this pattern as well as for @samp{=>} and @samp{:=} operators. Note that @kbd{M-# a} will not activate just anything surrounded by formula delimiters; after all, blank lines are considered formula delimiters by default! But if your language includes a delimiter which can only occur actually in front of a formula, you can take advantage of it here. The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, which checks for @samp{%Embed} followed by any number of lines beginning with @samp{%} and a space. This last is important to make Calc consider mode annotations part of the pattern, so that the formula's opening delimiter really is sure to follow the pattern. @vindex calc-embedded-open-mode The @code{calc-embedded-open-mode} variable is a string (not a regular expression) which should precede a mode annotation. Calc never scans for this string; Calc always looks for the annotation itself. But this is the string that is inserted before the opening bracket when Calc adds an annotation on its own. The default is @code{"% "}. @vindex calc-embedded-close-mode The @code{calc-embedded-close-mode} variable is a string which follows a mode annotation written by Calc. Its default value is simply a newline, @code{"\n"}. If you change this, it is a good idea still to end with a newline so that mode annotations will appear on lines by themselves. @node Programming, Installation, Embedded Mode, Top @chapter Programming @noindent There are several ways to ``program'' the Emacs Calculator, depending on the nature of the problem you need to solve. @enumerate @item @dfn{Keyboard macros} allow you to record a sequence of keystrokes and play them back at a later time. This is just the standard Emacs keyboard macro mechanism, dressed up with a few more features such as loops and conditionals. @item @dfn{Algebraic definitions} allow you to use any formula to define a new function. This function can then be used in algebraic formulas or as an interactive command. @item @dfn{Rewrite rules} are discussed in the section on algebra commands. @xref{Rewrite Rules}. If you put your rewrite rules in the variable @code{EvalRules}, they will be applied automatically to all Calc results in just the same way as an internal ``rule'' is applied to evaluate @samp{sqrt(9)} to 3 and so on. @xref{Automatic Rewrites}. @item @dfn{Lisp} is the programming language that Calc (and most of Emacs) is written in. If the above techniques aren't powerful enough, you can write Lisp functions to do anything that built-in Calc commands can do. Lisp code is also somewhat faster than keyboard macros or rewrite rules. @end enumerate @kindex z Programming features are available through the @kbd{z} and @kbd{Z} prefix keys. New commands that you define are two-key sequences beginning with @kbd{z}. Commands for managing these definitions use the shift-@kbd{Z} prefix. (The @kbd{Z T} (@code{calc-timing}) command is described elsewhere; @pxref{Troubleshooting Commands}. The @kbd{Z C} (@code{calc-user-define-composition}) command is also described elsewhere; @pxref{User-Defined Compositions}.) @menu * Creating User Keys:: * Keyboard Macros:: * Invocation Macros:: * Algebraic Definitions:: * Lisp Definitions:: @end menu @node Creating User Keys, Keyboard Macros, Programming, Programming @section Creating User Keys @noindent @kindex Z D @pindex calc-user-define Any Calculator command may be bound to a key using the @kbd{Z D} (@code{calc-user-define}) command. Actually, it is bound to a two-key sequence beginning with the lower-case @kbd{z} prefix. The @kbd{Z D} command first prompts for the key to define. For example, press @kbd{Z D a} to define the new key sequence @kbd{z a}. You are then prompted for the name of the Calculator command that this key should run. For example, the @code{calc-sincos} command is not normally available on a key. Typing @kbd{Z D s sincos @key{RET}} programs the @kbd{z s} key sequence to run @code{calc-sincos}. This definition will remain in effect for the rest of this Emacs session, or until you redefine @kbd{z s} to be something else. You can actually bind any Emacs command to a @kbd{z} key sequence by backspacing over the @samp{calc-} when you are prompted for the command name. As with any other prefix key, you can type @kbd{z ?} to see a list of all the two-key sequences you have defined that start with @kbd{z}. Initially, no @kbd{z} sequences (except @kbd{z ?} itself) are defined. User keys are typically letters, but may in fact be any key. (@key{META}-keys are not permitted, nor are a terminal's special function keys which generate multi-character sequences when pressed.) You can define different commands on the shifted and unshifted versions of a letter if you wish. @kindex Z U @pindex calc-user-undefine The @kbd{Z U} (@code{calc-user-undefine}) command unbinds a user key. For example, the key sequence @kbd{Z U s} will undefine the @code{sincos} key we defined above. @kindex Z P @pindex calc-user-define-permanent @cindex Storing user definitions @cindex Permanent user definitions @cindex @file{.emacs} file, user-defined commands The @kbd{Z P} (@code{calc-user-define-permanent}) command makes a key binding permanent so that it will remain in effect even in future Emacs sessions. (It does this by adding a suitable bit of Lisp code into your @file{.emacs} file.) For example, @kbd{Z P s} would register our @code{sincos} command permanently. If you later wish to unregister this command you must edit your @file{.emacs} file by hand. (@xref{General Mode Commands}, for a way to tell Calc to use a different file instead of @file{.emacs}.) The @kbd{Z P} command also saves the user definition, if any, for the command bound to the key. After @kbd{Z F} and @kbd{Z C}, a given user key could invoke a command, which in turn calls an algebraic function, which might have one or more special display formats. A single @kbd{Z P} command will save all of these definitions. To save a command or function without its key binding (or if there is no key binding for the command or function), type @kbd{'} (the apostrophe) when prompted for a key. Then, type the function name, or backspace to change the @samp{calcFunc-} prefix to @samp{calc-} and enter a command name. (If the command you give implies a function, the function will be saved, and if the function has any display formats, those will be saved, but not the other way around: Saving a function will not save any commands or key bindings associated with the function.) @kindex Z E @pindex calc-user-define-edit @cindex Editing user definitions The @kbd{Z E} (@code{calc-user-define-edit}) command edits the definition of a user key. This works for keys that have been defined by either keyboard macros or formulas; further details are contained in the relevant following sections. @node Keyboard Macros, Invocation Macros, Creating User Keys, Programming @section Programming with Keyboard Macros @noindent @kindex X @cindex Programming with keyboard macros @cindex Keyboard macros The easiest way to ``program'' the Emacs Calculator is to use standard keyboard macros. Press @w{@kbd{C-x (}} to begin recording a macro. From this point on, keystrokes you type will be saved away as well as performing their usual functions. Press @kbd{C-x )} to end recording. Press shift-@kbd{X} (or the standard Emacs key sequence @kbd{C-x e}) to execute your keyboard macro by replaying the recorded keystrokes. @xref{Keyboard Macros, , , emacs, the Emacs Manual}, for further information.@refill When you use @kbd{X} to invoke a keyboard macro, the entire macro is treated as a single command by the undo and trail features. The stack display buffer is not updated during macro execution, but is instead fixed up once the macro completes. Thus, commands defined with keyboard macros are convenient and efficient. The @kbd{C-x e} command, on the other hand, invokes the keyboard macro with no special treatment: Each command in the macro will record its own undo information and trail entry, and update the stack buffer accordingly. If your macro uses features outside of Calc's control to operate on the contents of the Calc stack buffer, or if it includes Undo, Redo, or last-arguments commands, you must use @kbd{C-x e} to make sure the buffer and undo list are up-to-date at all times. You could also consider using @kbd{K} (@code{calc-keep-args}) instead of @kbd{M-@key{RET}} (@code{calc-last-args}). Calc extends the standard Emacs keyboard macros in several ways. Keyboard macros can be used to create user-defined commands. Keyboard macros can include conditional and iteration structures, somewhat analogous to those provided by a traditional programmable calculator. @menu * Naming Keyboard Macros:: * Conditionals in Macros:: * Loops in Macros:: * Local Values in Macros:: * Queries in Macros:: @end menu @node Naming Keyboard Macros, Conditionals in Macros, Keyboard Macros, Keyboard Macros @subsection Naming Keyboard Macros @noindent @kindex Z K @pindex calc-user-define-kbd-macro Once you have defined a keyboard macro, you can bind it to a @kbd{z} key sequence with the @kbd{Z K} (@code{calc-user-define-kbd-macro}) command. This command prompts first for a key, then for a command name. For example, if you type @kbd{C-x ( n @key{TAB} n @key{TAB} C-x )} you will define a keyboard macro which negates the top two numbers on the stack (@key{TAB} swaps the top two stack elements). Now you can type @kbd{Z K n @key{RET}} to define this keyboard macro onto the @kbd{z n} key sequence. The default command name (if you answer the second prompt with just the @key{RET} key as in this example) will be something like @samp{calc-User-n}. The keyboard macro will now be available as both @kbd{z n} and @kbd{M-x calc-User-n}. You can backspace and enter a more descriptive command name if you wish.@refill Macros defined by @kbd{Z K} act like single commands; they are executed in the same way as by the @kbd{X} key. If you wish to define the macro as a standard no-frills Emacs macro (to be executed as if by @kbd{C-x e}), give a negative prefix argument to @kbd{Z K}. Once you have bound your keyboard macro to a key, you can use @kbd{Z P} to register it permanently with Emacs. @xref{Creating User Keys}. @cindex Keyboard macros, editing The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has been defined by a keyboard macro tries to use the @code{edit-kbd-macro} command to edit the macro. This command may be found in the @file{macedit} package, a copy of which comes with Calc. It decomposes the macro definition into full Emacs command names, like @code{calc-pop} and @code{calc-add}. Type @kbd{M-# M-#} to finish editing and update the definition stored on the key, or, to cancel the edit, type @kbd{M-# x}.@refill If you give a negative numeric prefix argument to @kbd{Z E}, the keyboard macro is edited in spelled-out keystroke form. For example, the editing buffer might contain the nine characters @w{@samp{1 RET 2 +}}. When you press @kbd{M-# M-#}, the @code{read-kbd-macro} feature of the @file{macedit} package is used to reinterpret these key names. The notations @code{RET}, @code{LFD}, @code{TAB}, @code{SPC}, @code{DEL}, and @code{NUL} must be written in all uppercase, as must the prefixes @code{C-} and @code{M-}. Spaces and line breaks are ignored. Other characters are copied verbatim into the keyboard macro. Basically, the notation is the same as is used in all of this manual's examples, except that the manual takes some liberties with spaces: When we say @kbd{' [1 2 3] RET}, we take it for granted that it is clear we really mean @kbd{' [1 SPC 2 SPC 3] RET}, which is what @code{read-kbd-macro} wants to see.@refill If @file{macedit} is not available, @kbd{Z E} edits the keyboard macro in ``raw'' form; the editing buffer simply contains characters like @samp{1^M2+} (here @samp{^M} represents the carriage-return character). Editing in this mode, you will have to use @kbd{C-q} to enter new control characters into the buffer.@refill @kindex M-# m @pindex read-kbd-macro The @kbd{M-# m} (@code{read-kbd-macro}) command reads an Emacs ``region'' of spelled-out keystrokes and defines it as the current keyboard macro. It is a convenient way to define a keyboard macro that has been stored in a file, or to define a macro without executing it at the same time. The @kbd{M-# m} command works only if @file{macedit} is present. @node Conditionals in Macros, Loops in Macros, Naming Keyboard Macros, Keyboard Macros @subsection Conditionals in Keyboard Macros @noindent @kindex Z [ @kindex Z ] @pindex calc-kbd-if @pindex calc-kbd-else @pindex calc-kbd-else-if @pindex calc-kbd-end-if @cindex Conditional structures The @kbd{Z [} (@code{calc-kbd-if}) and @kbd{Z ]} (@code{calc-kbd-end-if}) commands allow you to put simple tests in a keyboard macro. When Calc sees the @kbd{Z [}, it pops an object from the stack and, if the object is a non-zero value, continues executing keystrokes. But if the object is zero, or if it is not provably nonzero, Calc skips ahead to the matching @kbd{Z ]} keystroke. @xref{Logical Operations}, for a set of commands for performing tests which conveniently produce 1 for true and 0 for false. For example, @kbd{@key{RET} 0 a < Z [ n Z ]} implements an absolute-value function in the form of a keyboard macro. This macro duplicates the number on the top of the stack, pushes zero and compares using @kbd{a <} (@code{calc-less-than}), then, if the number was less than zero, executes @kbd{n} (@code{calc-change-sign}). Otherwise, the change-sign command is skipped. To program this macro, type @kbd{C-x (}, type the above sequence of keystrokes, then type @kbd{C-x )}. Note that the keystrokes will be executed while you are making the definition as well as when you later re-execute the macro by typing @kbd{X}. Thus you should make sure a suitable number is on the stack before defining the macro so that you don't get a stack-underflow error during the definition process. Conditionals can be nested arbitrarily. However, there should be exactly one @kbd{Z ]} for each @kbd{Z [} in a keyboard macro. @kindex Z : The @kbd{Z :} (@code{calc-kbd-else}) command allows you to choose between two keystroke sequences. The general format is @kbd{@var{cond} Z [ @var{then-part} Z : @var{else-part} Z ]}. If @var{cond} is true (i.e., if the top of stack contains a non-zero number after @var{cond} has been executed), the @var{then-part} will be executed and the @var{else-part} will be skipped. Otherwise, the @var{then-part} will be skipped and the @var{else-part} will be executed. @kindex Z | The @kbd{Z |} (@code{calc-kbd-else-if}) command allows you to choose between any number of alternatives. For example, @kbd{@var{cond1} Z [ @var{part1} Z : @var{cond2} Z | @var{part2} Z : @var{part3} Z ]} will execute @var{part1} if @var{cond1} is true, otherwise it will execute @var{part2} if @var{cond2} is true, otherwise it will execute @var{part3}. More precisely, @kbd{Z [} pops a number and conditionally skips to the next matching @kbd{Z :} or @kbd{Z ]} key. @w{@kbd{Z ]}} has no effect when actually executed. @kbd{Z :} skips to the next matching @kbd{Z ]}. @kbd{Z |} pops a number and conditionally skips to the next matching @kbd{Z :} or @kbd{Z ]}; thus, @kbd{Z [} and @kbd{Z |} are functionally equivalent except that @kbd{Z [} participates in nesting but @kbd{Z |} does not. Calc's conditional and looping constructs work by scanning the keyboard macro for occurrences of character sequences like @samp{Z:} and @samp{Z]}. One side-effect of this is that if you use these constructs you must be careful that these character pairs do not occur by accident in other parts of the macros. Since Calc rarely uses shift-@kbd{Z} for any purpose except as a prefix character, this is not likely to be a problem. Another side-effect is that it will not work to define your own custom key bindings for these commands. Only the standard shift-@kbd{Z} bindings will work correctly. @kindex Z C-g If Calc gets stuck while skipping characters during the definition of a macro, type @kbd{Z C-g} to cancel the definition. (Typing plain @kbd{C-g} actually adds a @kbd{C-g} keystroke to the macro.) @node Loops in Macros, Local Values in Macros, Conditionals in Macros, Keyboard Macros @subsection Loops in Keyboard Macros @noindent @kindex Z < @kindex Z > @pindex calc-kbd-repeat @pindex calc-kbd-end-repeat @cindex Looping structures @cindex Iterative structures The @kbd{Z <} (@code{calc-kbd-repeat}) and @kbd{Z >} (@code{calc-kbd-end-repeat}) commands pop a number from the stack, which must be an integer, then repeat the keystrokes between the brackets the specified number of times. If the integer is zero or negative, the body is skipped altogether. For example, @kbd{1 @key{TAB} Z < 2 * Z >} computes two to a nonnegative integer power. First, we push 1 on the stack and then swap the integer argument back to the top. The @kbd{Z <} pops that argument leaving the 1 back on top of the stack. Then, we repeat a multiply-by-two step however many times.@refill Once again, the keyboard macro is executed as it is being entered. In this case it is especially important to set up reasonable initial conditions before making the definition: Suppose the integer 1000 just happened to be sitting on the stack before we typed the above definition! Another approach is to enter a harmless dummy definition for the macro, then go back and edit in the real one with a @kbd{Z E} command. Yet another approach is to type the macro as written-out keystroke names in a buffer, then use @kbd{M-# m} (@code{read-kbd-macro}) to read the macro. @kindex Z / @pindex calc-break The @kbd{Z /} (@code{calc-kbd-break}) command allows you to break out of a keyboard macro loop prematurely. It pops an object from the stack; if that object is true (a non-zero number), control jumps out of the innermost enclosing @kbd{Z <} @dots{} @kbd{Z >} loop and continues after the @kbd{Z >}. If the object is false, the @kbd{Z /} has no effect. Thus @kbd{@var{cond} Z /} is similar to @samp{if (@var{cond}) break;} in the C language.@refill @kindex Z ( @kindex Z ) @pindex calc-kbd-for @pindex calc-kbd-end-for The @kbd{Z (} (@code{calc-kbd-for}) and @kbd{Z )} (@code{calc-kbd-end-for}) commands are similar to @kbd{Z <} and @kbd{Z >}, except that they make the value of the counter available inside the loop. The general layout is @kbd{@var{init} @var{final} Z ( @var{body} @var{step} Z )}. The @kbd{Z (} command pops initial and final values from the stack. It then creates a temporary internal counter and initializes it with the value @var{init}. The @kbd{Z (} command then repeatedly pushes the counter value onto the stack and executes @var{body} and @var{step}, adding @var{step} to the counter each time until the loop finishes.@refill @cindex Summations (by keyboard macros) By default, the loop finishes when the counter becomes greater than (or less than) @var{final}, assuming @var{initial} is less than (greater than) @var{final}. If @var{initial} is equal to @var{final}, the body executes exactly once. The body of the loop always executes at least once. For example, @kbd{0 1 10 Z ( 2 ^ + 1 Z )} computes the sum of the squares of the integers from 1 to 10, in steps of 1. If you give a numeric prefix argument of 1 to @kbd{Z (}, the loop is forced to use upward-counting conventions. In this case, if @var{initial} is greater than @var{final} the body will not be executed at all. Note that @var{step} may still be negative in this loop; the prefix argument merely constrains the loop-finished test. Likewise, a prefix argument of @i{-1} forces downward-counting conventions. @kindex Z @{ @kindex Z @} @pindex calc-kbd-loop @pindex calc-kbd-end-loop The @kbd{Z @{} (@code{calc-kbd-loop}) and @kbd{Z @}} (@code{calc-kbd-end-loop}) commands are similar to @kbd{Z <} and @kbd{Z >}, except that they do not pop a count from the stack---they effectively create an infinite loop. Every @kbd{Z @{} @dots{} @kbd{Z @}} loop ought to include at least one @kbd{Z /} to make sure the loop doesn't run forever. (If any error message occurs which causes Emacs to beep, the keyboard macro will also be halted; this is a standard feature of Emacs. You can also generally press @kbd{C-g} to halt a running keyboard macro, although not all versions of Unix support this feature.) The conditional and looping constructs are not actually tied to keyboard macros, but they are most often used in that context. For example, the keystrokes @kbd{10 Z < 23 @key{RET} Z >} push ten copies of 23 onto the stack. This can be typed ``live'' just as easily as in a macro definition. @xref{Conditionals in Macros}, for some additional notes about conditional and looping commands. @node Local Values in Macros, Queries in Macros, Loops in Macros, Keyboard Macros @subsection Local Values in Macros @noindent @cindex Local variables @cindex Restoring saved modes Keyboard macros sometimes want to operate under known conditions without affecting surrounding conditions. For example, a keyboard macro may wish to turn on Fraction Mode, or set a particular precision, independent of the user's normal setting for those modes. @kindex Z ` @kindex Z ' @pindex calc-kbd-push @pindex calc-kbd-pop Macros also sometimes need to use local variables. Assignments to local variables inside the macro should not affect any variables outside the macro. The @kbd{Z `} (@code{calc-kbd-push}) and @kbd{Z '} (@code{calc-kbd-pop}) commands give you both of these capabilities. When you type @kbd{Z `} (with a backquote or accent grave character), the values of various mode settings are saved away. The ten ``quick'' variables @code{q0} through @code{q9} are also saved. When you type @w{@kbd{Z '}} (with an apostrophe), these values are restored. Pairs of @kbd{Z `} and @kbd{Z '} commands may be nested. If a keyboard macro halts due to an error in between a @kbd{Z `} and a @kbd{Z '}, the saved values will be restored correctly even though the macro never reaches the @kbd{Z '} command. Thus you can use @kbd{Z `} and @kbd{Z '} without having to worry about what happens in exceptional conditions. If you type @kbd{Z `} ``live'' (not in a keyboard macro), Calc puts you into a ``recursive edit.'' You can tell you are in a recursive edit because there will be extra square brackets in the mode line, as in @samp{[(Calculator)]}. These brackets will go away when you type the matching @kbd{Z '} command. The modes and quick variables will be saved and restored in just the same way as if actual keyboard macros were involved. The modes saved by @kbd{Z `} and @kbd{Z '} are the current precision and binary word size, the angular mode (Deg, Rad, or HMS), the simplification mode, Algebraic mode, Symbolic mode, Infinite mode, Matrix or Scalar mode, Fraction mode, and the current complex mode (Polar or Rectangular). The ten ``quick'' variables' values (or lack thereof) are also saved. Most mode-setting commands act as toggles, but with a numeric prefix they force the mode either on (positive prefix) or off (negative or zero prefix). Since you don't know what the environment might be when you invoke your macro, it's best to use prefix arguments for all mode-setting commands inside the macro. In fact, @kbd{C-u Z `} is like @kbd{Z `} except that it sets the modes listed above to their default values. As usual, the matching @kbd{Z '} will restore the modes to their settings from before the @kbd{C-u Z `}. Also, @w{@kbd{Z `}} with a negative prefix argument resets algebraic mode to its default (off) but leaves the other modes the same as they were outside the construct. The contents of the stack and trail, values of non-quick variables, and other settings such as the language mode and the various display modes, are @emph{not} affected by @kbd{Z `} and @kbd{Z '}. @node Queries in Macros, , Local Values in Macros, Keyboard Macros @subsection Queries in Keyboard Macros @noindent @kindex Z = @pindex calc-kbd-report The @kbd{Z =} (@code{calc-kbd-report}) command displays an informative message including the value on the top of the stack. You are prompted to enter a string. That string, along with the top-of-stack value, is displayed unless @kbd{m w} (@code{calc-working}) has been used to turn such messages off. @kindex Z # @pindex calc-kbd-query The @kbd{Z #} (@code{calc-kbd-query}) command displays a prompt message (which you enter during macro definition), then does an algebraic entry which takes its input from the keyboard, even during macro execution. This command allows your keyboard macros to accept numbers or formulas as interactive input. All the normal conventions of algebraic input, including the use of @kbd{$} characters, are supported. @xref{Kbd Macro Query, , , emacs, the Emacs Manual}, for a description of @kbd{C-x q} (@code{kbd-macro-query}), the standard Emacs way to accept keyboard input during a keyboard macro. In particular, you can use @kbd{C-x q} to enter a recursive edit, which allows the user to perform any Calculator operations interactively before pressing @kbd{C-M-c} to return control to the keyboard macro. @node Invocation Macros, Algebraic Definitions, Keyboard Macros, Programming @section Invocation Macros @kindex M-# z @kindex Z I @pindex calc-user-invocation @pindex calc-user-define-invocation Calc provides one special keyboard macro, called up by @kbd{M-# z} (@code{calc-user-invocation}), that is intended to allow you to define your own special way of starting Calc. To define this ``invocation macro,'' create the macro in the usual way with @kbd{C-x (} and @kbd{C-x )}, then type @kbd{Z I} (@code{calc-user-define-invocation}). There is only one invocation macro, so you don't need to type any additional letters after @kbd{Z I}. From now on, you can type @kbd{M-# z} at any time to execute your invocation macro. For example, suppose you find yourself often grabbing rectangles of numbers into Calc and multiplying their columns. You can do this by typing @kbd{M-# r} to grab, and @kbd{V R : *} to multiply columns. To make this into an invocation macro, just type @kbd{C-x ( M-# r V R : * C-x )}, then @kbd{Z I}. Then, to multiply a rectangle of data, just mark the data in its buffer in the usual way and type @kbd{M-# z}. Invocation macros are treated like regular Emacs keyboard macros; all the special features described above for @kbd{Z K}-style macros do not apply. @kbd{M-# z} is just like @kbd{C-x e}, except that it uses the macro that was last stored by @kbd{Z I}. (In fact, the macro does not even have to have anything to do with Calc!) The @kbd{m m} command saves the last invocation macro defined by @kbd{Z I} along with all the other Calc mode settings. @xref{General Mode Commands}. @node Algebraic Definitions, Lisp Definitions, Invocation Macros, Programming @section Programming with Formulas @noindent @kindex Z F @pindex calc-user-define-formula @cindex Programming with algebraic formulas Another way to create a new Calculator command uses algebraic formulas. The @kbd{Z F} (@code{calc-user-define-formula}) command stores the formula at the top of the stack as the definition for a key. This command prompts for five things: The key, the command name, the function name, the argument list, and the behavior of the command when given non-numeric arguments. For example, suppose we type @kbd{' a+2b @key{RET}} to push the formula @samp{a + 2*b} onto the stack. We now type @kbd{Z F m} to define this formula on the @kbd{z m} key sequence. The next prompt is for a command name, beginning with @samp{calc-}, which should be the long (@kbd{M-x}) form for the new command. If you simply press @key{RET}, a default name like @code{calc-User-m} will be constructed. In our example, suppose we enter @kbd{spam @key{RET}} to define the new command as @code{calc-spam}. If you want to give the formula a long-style name only, you can press @key{SPC} or @key{RET} when asked which single key to use. For example @kbd{Z F @key{RET} spam @key{RET}} defines the new command as @kbd{M-x calc-spam}, with no keyboard equivalent. The third prompt is for a function name. The default is to use the same name as the command name but with @samp{calcFunc-} in place of @samp{calc-}. This is the name you will use if you want to enter your new function in an algebraic formula. Suppose we enter @kbd{yow @key{RET}}. Then the new function can be invoked by pushing two numbers on the stack and typing @kbd{z m} or @kbd{x spam}, or by entering the algebraic formula @samp{yow(x,y)}.@refill The fourth prompt is for the function's argument list. This is used to associate values on the stack with the variables that appear in the formula. The default is a list of all variables which appear in the formula, sorted into alphabetical order. In our case, the default would be @samp{(a b)}. This means that, when the user types @kbd{z m}, the Calculator will remove two numbers from the stack, substitute these numbers for @samp{a} and @samp{b} (respectively) in the formula, then simplify the formula and push the result on the stack. In other words, @kbd{10 @key{RET} 100 z m} would replace the 10 and 100 on the stack with the number 210, which is @cite{a + 2 b} with @cite{a=10} and @cite{b=100}. Likewise, the formula @samp{yow(10, 100)} will be evaluated by substituting @cite{a=10} and @cite{b=100} in the definition. You can rearrange the order of the names before pressing @key{RET} to control which stack positions go to which variables in the formula. If you remove a variable from the argument list, that variable will be left in symbolic form by the command. Thus using an argument list of @samp{(b)} for our function would cause @kbd{10 z m} to replace the 10 on the stack with the formula @samp{a + 20}. If we had used an argument list of @samp{(b a)}, the result with inputs 10 and 100 would have been 120. You can also put a nameless function on the stack instead of just a formula, as in @samp{}. @xref{Specifying Operators}. In this example, the command will be defined by the formula @samp{a + 2 b} using the argument list @samp{(a b)}. The final prompt is a y-or-n question concerning what to do if symbolic arguments are given to your function. If you answer @kbd{y}, then executing @kbd{z m} (using the original argument list @samp{(a b)}) with arguments @cite{10} and @cite{x} will leave the function in symbolic form, i.e., @samp{yow(10,x)}. On the other hand, if you answer @kbd{n}, then the formula will always be expanded, even for non-constant arguments: @samp{10 + 2 x}. If you never plan to feed algebraic formulas to your new function, it doesn't matter how you answer this question.@refill If you answered @kbd{y} to this question you can still cause a function call to be expanded by typing @kbd{a "} (@code{calc-expand-formula}). Also, Calc will expand the function if necessary when you take a derivative or integral or solve an equation involving the function. @kindex Z G @pindex calc-get-user-defn Once you have defined a formula on a key, you can retrieve this formula with the @kbd{Z G} (@code{calc-user-define-get-defn}) command. Press a key, and this command pushes the formula that was used to define that key onto the stack. Actually, it pushes a nameless function that specifies both the argument list and the defining formula. You will get an error message if the key is undefined, or if the key was not defined by a @kbd{Z F} command.@refill The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has been defined by a formula uses a variant of the @code{calc-edit} command to edit the defining formula. Press @kbd{M-# M-#} to finish editing and store the new formula back in the definition, or @kbd{M-# x} to cancel the edit. (The argument list and other properties of the definition are unchanged; to adjust the argument list, you can use @kbd{Z G} to grab the function onto the stack, edit with @kbd{`}, and then re-execute the @kbd{Z F} command.) As usual, the @kbd{Z P} command records your definition permanently. In this case it will permanently record all three of the relevant definitions: the key, the command, and the function. You may find it useful to turn off the default simplifications with @kbd{m O} (@code{calc-no-simplify-mode}) when entering a formula to be used as a function definition. For example, the formula @samp{deriv(a^2,v)} which might be used to define a new function @samp{dsqr(a,v)} will be ``simplified'' to 0 immediately upon entry since @code{deriv} considers @cite{a} to be constant with respect to @cite{v}. Turning off default simplifications cures this problem: The definition will be stored in symbolic form without ever activating the @code{deriv} function. Press @kbd{m D} to turn the default simplifications back on afterwards. @node Lisp Definitions, , Algebraic Definitions, Programming @section Programming with Lisp @noindent The Calculator can be programmed quite extensively in Lisp. All you do is write a normal Lisp function definition, but with @code{defmath} in place of @code{defun}. This has the same form as @code{defun}, but it automagically replaces calls to standard Lisp functions like @code{+} and @code{zerop} with calls to the corresponding functions in Calc's own library. Thus you can write natural-looking Lisp code which operates on all of the standard Calculator data types. You can then use @kbd{Z D} if you wish to bind your new command to a @kbd{z}-prefix key sequence. The @kbd{Z E} command will not edit a Lisp-based definition. Emacs Lisp is described in the GNU Emacs Lisp Reference Manual. This section assumes a familiarity with Lisp programming concepts; if you do not know Lisp, you may find keyboard macros or rewrite rules to be an easier way to program the Calculator. This section first discusses ways to write commands, functions, or small programs to be executed inside of Calc. Then it discusses how your own separate programs are able to call Calc from the outside. Finally, there is a list of internal Calc functions and data structures for the true Lisp enthusiast. @menu * Defining Functions:: * Defining Simple Commands:: * Defining Stack Commands:: * Argument Qualifiers:: * Example Definitions:: * Calling Calc from Your Programs:: * Internals:: @end menu @node Defining Functions, Defining Simple Commands, Lisp Definitions, Lisp Definitions @subsection Defining New Functions @noindent @findex defmath The @code{defmath} function (actually a Lisp macro) is like @code{defun} except that code in the body of the definition can make use of the full range of Calculator data types. The prefix @samp{calcFunc-} is added to the specified name to get the actual Lisp function name. As a simple example, @example (defmath myfact (n) (if (> n 0) (* n (myfact (1- n))) 1)) @end example @noindent This actually expands to the code, @example (defun calcFunc-myfact (n) (if (math-posp n) (math-mul n (calcFunc-myfact (math-add n -1))) 1)) @end example @noindent This function can be used in algebraic expressions, e.g., @samp{myfact(5)}. The @samp{myfact} function as it is defined above has the bug that an expression @samp{myfact(a+b)} will be simplified to 1 because the formula @samp{a+b} is not considered to be @code{posp}. A robust factorial function would be written along the following lines: @smallexample (defmath myfact (n) (if (> n 0) (* n (myfact (1- n))) (if (= n 0) 1 nil))) ; this could be simplified as: (and (= n 0) 1) @end smallexample If a function returns @code{nil}, it is left unsimplified by the Calculator (except that its arguments will be simplified). Thus, @samp{myfact(a+1+2)} will be simplified to @samp{myfact(a+3)} but no further. Beware that every time the Calculator reexamines this formula it will attempt to resimplify it, so your function ought to detect the returning-@code{nil} case as efficiently as possible. The following standard Lisp functions are treated by @code{defmath}: @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^} or @code{expt}, @code{=}, @code{<}, @code{>}, @code{<=}, @code{>=}, @code{/=}, @code{1+}, @code{1-}, @code{logand}, @code{logior}, @code{logxor}, @code{logandc2}, @code{lognot}. Also, @code{~=} is an abbreviation for @code{math-nearly-equal}, which is useful in implementing Taylor series.@refill For other functions @var{func}, if a function by the name @samp{calcFunc-@var{func}} exists it is used, otherwise if a function by the name @samp{math-@var{func}} exists it is used, otherwise if @var{func} itself is defined as a function it is used, otherwise @samp{calcFunc-@var{func}} is used on the assumption that this is a to-be-defined math function. Also, if the function name is quoted as in @samp{('integerp a)} the function name is always used exactly as written (but not quoted).@refill Variable names have @samp{var-} prepended to them unless they appear in the function's argument list or in an enclosing @code{let}, @code{let*}, @code{for}, or @code{foreach} form, or their names already contain a @samp{-} character. Thus a reference to @samp{foo} is the same as a reference to @samp{var-foo}.@refill A few other Lisp extensions are available in @code{defmath} definitions: @itemize @bullet @item The @code{elt} function accepts any number of index variables. Note that Calc vectors are stored as Lisp lists whose first element is the symbol @code{vec}; thus, @samp{(elt v 2)} yields the second element of vector @code{v}, and @samp{(elt m i j)} yields one element of a Calc matrix. @item The @code{setq} function has been extended to act like the Common Lisp @code{setf} function. (The name @code{setf} is recognized as a synonym of @code{setq}.) Specifically, the first argument of @code{setq} can be an @code{nth}, @code{elt}, @code{car}, or @code{cdr} form, in which case the effect is to store into the specified element of a list. Thus, @samp{(setq (elt m i j) x)} stores @cite{x} into one element of a matrix. @item A @code{for} looping construct is available. For example, @samp{(for ((i 0 10)) body)} executes @code{body} once for each binding of @cite{i} from zero to 10. This is like a @code{let} form in that @cite{i} is temporarily bound to the loop count without disturbing its value outside the @code{for} construct. Nested loops, as in @samp{(for ((i 0 10) (j 0 (1- i) 2)) body)}, are also available. For each value of @cite{i} from zero to 10, @cite{j} counts from 0 to @cite{i-1} in steps of two. Note that @code{for} has the same general outline as @code{let*}, except that each element of the header is a list of three or four things, not just two. @item The @code{foreach} construct loops over elements of a list. For example, @samp{(foreach ((x (cdr v))) body)} executes @code{body} with @cite{x} bound to each element of Calc vector @cite{v} in turn. The purpose of @code{cdr} here is to skip over the initial @code{vec} symbol in the vector. @item The @code{break} function breaks out of the innermost enclosing @code{while}, @code{for}, or @code{foreach} loop. If given a value, as in @samp{(break x)}, this value is returned by the loop. (Lisp loops otherwise always return @code{nil}.) @item The @code{return} function prematurely returns from the enclosing function. For example, @samp{(return (+ x y))} returns @cite{x+y} as the value of a function. You can use @code{return} anywhere inside the body of the function. @end itemize Non-integer numbers (and extremely large integers) cannot be included directly into a @code{defmath} definition. This is because the Lisp reader will fail to parse them long before @code{defmath} ever gets control. Instead, use the notation, @samp{:"3.1415"}. In fact, any algebraic formula can go between the quotes. For example, @smallexample (defmath sqexp (x) ; sqexp(x) == sqrt(exp(x)) == exp(x*0.5) (and (numberp x) (exp :"x * 0.5"))) @end smallexample expands to @smallexample (defun calcFunc-sqexp (x) (and (math-numberp x) (calcFunc-exp (math-mul x '(float 5 -1))))) @end smallexample Note the use of @code{numberp} as a guard to ensure that the argument is a number first, returning @code{nil} if not. The exponential function could itself have been included in the expression, if we had preferred: @samp{:"exp(x * 0.5)"}. As another example, the multiplication-and-recursion step of @code{myfact} could have been written @example :"n * myfact(n-1)" @end example If a file named @file{.emacs} exists in your home directory, Emacs reads and executes the Lisp forms in this file as it starts up. While it may seem like a good idea to put your favorite @code{defmath} commands here, this has the unfortunate side-effect that parts of the Calculator must be loaded in to process the @code{defmath} commands whether or not you will actually use the Calculator! A better effect can be had by writing @example (put 'calc-define 'thing '(progn (defmath ... ) (defmath ... ) )) @end example @noindent @vindex calc-define The @code{put} function adds a @dfn{property} to a symbol. Each Lisp symbol has a list of properties associated with it. Here we add a property with a name of @code{thing} and a @samp{(progn ...)} form as its value. When Calc starts up, and at the start of every Calc command, the property list for the symbol @code{calc-define} is checked and the values of any properties found are evaluated as Lisp forms. The properties are removed as they are evaluated. The property names (like @code{thing}) are not used; you should choose something like the name of your project so as not to conflict with other properties. The net effect is that you can put the above code in your @file{.emacs} file and it will not be executed until Calc is loaded. Or, you can put that same code in another file which you load by hand either before or after Calc itself is loaded. The properties of @code{calc-define} are evaluated in the same order that they were added. They can assume that the Calc modules @file{calc.el}, @file{calc-ext.el}, and @file{calc-macs.el} have been fully loaded, and that the @samp{*Calculator*} buffer will be the current buffer. If your @code{calc-define} property only defines algebraic functions, you can be sure that it will have been evaluated before Calc tries to call your function, even if the file defining the property is loaded after Calc is loaded. But if the property defines commands or key sequences, it may not be evaluated soon enough. (Suppose it defines the new command @code{tweak-calc}; the user can load your file, then type @kbd{M-x tweak-calc} before Calc has had chance to do anything.) To protect against this situation, you can put @example (run-hooks 'calc-check-defines) @end example @findex calc-check-defines @noindent at the end of your file. The @code{calc-check-defines} function is what looks for and evaluates properties on @code{calc-define}; @code{run-hooks} has the advantage that it is quietly ignored if @code{calc-check-defines} is not yet defined because Calc has not yet been loaded. Examples of things that ought to be enclosed in a @code{calc-define} property are @code{defmath} calls, @code{define-key} calls that modify the Calc key map, and any calls that redefine things defined inside Calc. Ordinary @code{defun}s need not be enclosed with @code{calc-define}. @node Defining Simple Commands, Defining Stack Commands, Defining Functions, Lisp Definitions @subsection Defining New Simple Commands @noindent @findex interactive If a @code{defmath} form contains an @code{interactive} clause, it defines a Calculator command. Actually such a @code{defmath} results in @emph{two} function definitions: One, a @samp{calcFunc-} function as was just described, with the @code{interactive} clause removed. Two, a @samp{calc-} function with a suitable @code{interactive} clause and some sort of wrapper to make the command work in the Calc environment. In the simple case, the @code{interactive} clause has the same form as for normal Emacs Lisp commands: @smallexample (defmath increase-precision (delta) "Increase precision by DELTA." ; This is the "documentation string" (interactive "p") ; Register this as a M-x-able command (setq calc-internal-prec (+ calc-internal-prec delta))) @end smallexample This expands to the pair of definitions, @smallexample (defun calc-increase-precision (delta) "Increase precision by DELTA." (interactive "p") (calc-wrapper (setq calc-internal-prec (math-add calc-internal-prec delta)))) (defun calcFunc-increase-precision (delta) "Increase precision by DELTA." (setq calc-internal-prec (math-add calc-internal-prec delta))) @end smallexample @noindent where in this case the latter function would never really be used! Note that since the Calculator stores small integers as plain Lisp integers, the @code{math-add} function will work just as well as the native @code{+} even when the intent is to operate on native Lisp integers. @findex calc-wrapper The @samp{calc-wrapper} call invokes a macro which surrounds the body of the function with code that looks roughly like this: @smallexample (let ((calc-command-flags nil)) (unwind-protect (save-excursion (calc-select-buffer) @emph{body of function} @emph{renumber stack} @emph{clear} Working @emph{message}) @emph{realign cursor and window} @emph{clear Inverse, Hyperbolic, and Keep Args flags} @emph{update Emacs mode line})) @end smallexample @findex calc-select-buffer The @code{calc-select-buffer} function selects the @samp{*Calculator*} buffer if necessary, say, because the command was invoked from inside the @samp{*Calc Trail*} window. @findex calc-set-command-flag You can call, for example, @code{(calc-set-command-flag 'no-align)} to set the above-mentioned command flags. The following command flags are recognized by Calc routines: @table @code @item renum-stack Stack line numbers @samp{1:}, @samp{2:}, and so on must be renumbered after this command completes. This is set by routines like @code{calc-push}. @item clear-message Calc should call @samp{(message "")} if this command completes normally (to clear a ``Working@dots{}'' message out of the echo area). @item no-align Do not move the cursor back to the @samp{.} top-of-stack marker. @item position-point Use the variables @code{calc-position-point-line} and @code{calc-position-point-column} to position the cursor after this command finishes. @item keep-flags Do not clear @code{calc-inverse-flag}, @code{calc-hyperbolic-flag}, and @code{calc-keep-args-flag} at the end of this command. @item do-edit Switch to buffer @samp{*Calc Edit*} after this command. @item hold-trail Do not move trail pointer to end of trail when something is recorded there. @end table @kindex Y @kindex Y ? @vindex calc-Y-help-msgs Calc reserves a special prefix key, shift-@kbd{Y}, for user-written extensions to Calc. There are no built-in commands that work with this prefix key; you must call @code{define-key} from Lisp (probably from inside a @code{calc-define} property) to add to it. Initially only @kbd{Y ?} is defined; it takes help messages from a list of strings (initially @code{nil}) in the variable @code{calc-Y-help-msgs}. All other undefined keys except for @kbd{Y} are reserved for use by future versions of Calc. If you are writing a Calc enhancement which you expect to give to others, it is best to minimize the number of @kbd{Y}-key sequences you use. In fact, if you have more than one key sequence you should consider defining three-key sequences with a @kbd{Y}, then a key that stands for your package, then a third key for the particular command within your package. Users may wish to install several Calc enhancements, and it is possible that several enhancements will choose to use the same key. In the example below, a variable @code{inc-prec-base-key} has been defined to contain the key that identifies the @code{inc-prec} package. Its value is initially @code{"P"}, but a user can change this variable if necessary without having to modify the file. Here is a complete file, @file{inc-prec.el}, which makes a @kbd{Y P I} command that increases the precision, and a @kbd{Y P D} command that decreases the precision. @smallexample ;;; Increase and decrease Calc precision. Dave Gillespie, 5/31/91. ;;; (Include copyright or copyleft stuff here.) (defvar inc-prec-base-key "P" "Base key for inc-prec.el commands.") (put 'calc-define 'inc-prec '(progn (define-key calc-mode-map (format "Y%sI" inc-prec-base-key) 'increase-precision) (define-key calc-mode-map (format "Y%sD" inc-prec-base-key) 'decrease-precision) (setq calc-Y-help-msgs (cons (format "%s + Inc-prec, Dec-prec" inc-prec-base-key) calc-Y-help-msgs)) (defmath increase-precision (delta) "Increase precision by DELTA." (interactive "p") (setq calc-internal-prec (+ calc-internal-prec delta))) (defmath decrease-precision (delta) "Decrease precision by DELTA." (interactive "p") (setq calc-internal-prec (- calc-internal-prec delta))) )) ; end of calc-define property (run-hooks 'calc-check-defines) @end smallexample @node Defining Stack Commands, Argument Qualifiers, Defining Simple Commands, Lisp Definitions @subsection Defining New Stack-Based Commands @noindent To define a new computational command which takes and/or leaves arguments on the stack, a special form of @code{interactive} clause is used. @example (interactive @var{num} @var{tag}) @end example @noindent where @var{num} is an integer, and @var{tag} is a string. The effect is to pop @var{num} values off the stack, resimplify them by calling @code{calc-normalize}, and hand them to your function according to the function's argument list. Your function may include @code{&optional} and @code{&rest} parameters, so long as calling the function with @var{num} parameters is legal. Your function must return either a number or a formula in a form acceptable to Calc, or a list of such numbers or formulas. These value(s) are pushed onto the stack when the function completes. They are also recorded in the Calc Trail buffer on a line beginning with @var{tag}, a string of (normally) four characters or less. If you omit @var{tag} or use @code{nil} as a tag, the result is not recorded in the trail. As an example, the definition @smallexample (defmath myfact (n) "Compute the factorial of the integer at the top of the stack." (interactive 1 "fact") (if (> n 0) (* n (myfact (1- n))) (and (= n 0) 1))) @end smallexample @noindent is a version of the factorial function shown previously which can be used as a command as well as an algebraic function. It expands to @smallexample (defun calc-myfact () "Compute the factorial of the integer at the top of the stack." (interactive) (calc-slow-wrapper (calc-enter-result 1 "fact" (cons 'calcFunc-myfact (calc-top-list-n 1))))) (defun calcFunc-myfact (n) "Compute the factorial of the integer at the top of the stack." (if (math-posp n) (math-mul n (calcFunc-myfact (math-add n -1))) (and (math-zerop n) 1))) @end smallexample @findex calc-slow-wrapper The @code{calc-slow-wrapper} function is a version of @code{calc-wrapper} that automatically puts up a @samp{Working...} message before the computation begins. (This message can be turned off by the user with an @kbd{m w} (@code{calc-working}) command.) @findex calc-top-list-n The @code{calc-top-list-n} function returns a list of the specified number of values from the top of the stack. It resimplifies each value by calling @code{calc-normalize}. If its argument is zero it returns an empty list. It does not actually remove these values from the stack. @findex calc-enter-result The @code{calc-enter-result} function takes an integer @var{num} and string @var{tag} as described above, plus a third argument which is either a Calculator data object or a list of such objects. These objects are resimplified and pushed onto the stack after popping the specified number of values from the stack. If @var{tag} is non-@code{nil}, the values being pushed are also recorded in the trail. Note that if @code{calcFunc-myfact} returns @code{nil} this represents ``leave the function in symbolic form.'' To return an actual empty list, in the sense that @code{calc-enter-result} will push zero elements back onto the stack, you should return the special value @samp{'(nil)}, a list containing the single symbol @code{nil}. The @code{interactive} declaration can actually contain a limited Emacs-style code string as well which comes just before @var{num} and @var{tag}. Currently the only Emacs code supported is @samp{"p"}, as in @example (defmath foo (a b &optional c) (interactive "p" 2 "foo") @var{body}) @end example In this example, the command @code{calc-foo} will evaluate the expression @samp{foo(a,b)} if executed with no argument, or @samp{foo(a,b,n)} if executed with a numeric prefix argument of @cite{n}. The other code string allowed is @samp{"m"} (unrelated to the usual @samp{"m"} code as used with @code{defun}). It uses the numeric prefix argument as the number of objects to remove from the stack and pass to the function. In this case, the integer @var{num} serves as a default number of arguments to be used when no prefix is supplied. @node Argument Qualifiers, Example Definitions, Defining Stack Commands, Lisp Definitions @subsection Argument Qualifiers @noindent Anywhere a parameter name can appear in the parameter list you can also use an @dfn{argument qualifier}. Thus the general form of a definition is: @example (defmath @var{name} (@var{param} @var{param...} &optional @var{param} @var{param...} &rest @var{param}) @var{body}) @end example @noindent where each @var{param} is either a symbol or a list of the form @example (@var{qual} @var{param}) @end example The following qualifiers are recognized: @table @samp @item complete @findex complete The argument must not be an incomplete vector, interval, or complex number. (This is rarely needed since the Calculator itself will never call your function with an incomplete argument. But there is nothing stopping your own Lisp code from calling your function with an incomplete argument.)@refill @item integer @findex integer The argument must be an integer. If it is an integer-valued float it will be accepted but converted to integer form. Non-integers and formulas are rejected. @item natnum @findex natnum Like @samp{integer}, but the argument must be non-negative. @item fixnum @findex fixnum Like @samp{integer}, but the argument must fit into a native Lisp integer, which on most systems means less than 2^23 in absolute value. The argument is converted into Lisp-integer form if necessary. @item float @findex float The argument is converted to floating-point format if it is a number or vector. If it is a formula it is left alone. (The argument is never actually rejected by this qualifier.) @item @var{pred} The argument must satisfy predicate @var{pred}, which is one of the standard Calculator predicates. @xref{Predicates}. @item not-@var{pred} The argument must @emph{not} satisfy predicate @var{pred}. @end table For example, @example (defmath foo (a (constp (not-matrixp b)) &optional (float c) &rest (integer d)) @var{body}) @end example @noindent expands to @example (defun calcFunc-foo (a b &optional c &rest d) (and (math-matrixp b) (math-reject-arg b 'not-matrixp)) (or (math-constp b) (math-reject-arg b 'constp)) (and c (setq c (math-check-float c))) (setq d (mapcar 'math-check-integer d)) @var{body}) @end example @noindent which performs the necessary checks and conversions before executing the body of the function. @node Example Definitions, Calling Calc from Your Programs, Argument Qualifiers, Lisp Definitions @subsection Example Definitions @noindent This section includes some Lisp programming examples on a larger scale. These programs make use of some of the Calculator's internal functions; @pxref{Internals}. @menu * Bit Counting Example:: * Sine Example:: @end menu @node Bit Counting Example, Sine Example, Example Definitions, Example Definitions @subsubsection Bit-Counting @noindent @c @starindex @tindex bcount Calc does not include a built-in function for counting the number of ``one'' bits in a binary integer. It's easy to invent one using @kbd{b u} to convert the integer to a set, and @kbd{V #} to count the elements of that set; let's write a function that counts the bits without having to create an intermediate set. @smallexample (defmath bcount ((natnum n)) (interactive 1 "bcnt") (let ((count 0)) (while (> n 0) (if (oddp n) (setq count (1+ count))) (setq n (lsh n -1))) count)) @end smallexample @noindent When this is expanded by @code{defmath}, it will become the following Emacs Lisp function: @smallexample (defun calcFunc-bcount (n) (setq n (math-check-natnum n)) (let ((count 0)) (while (math-posp n) (if (math-oddp n) (setq count (math-add count 1))) (setq n (calcFunc-lsh n -1))) count)) @end smallexample If the input numbers are large, this function involves a fair amount of arithmetic. A binary right shift is essentially a division by two; recall that Calc stores integers in decimal form so bit shifts must involve actual division. To gain a bit more efficiency, we could divide the integer into @i{n}-bit chunks, each of which can be handled quickly because they fit into Lisp integers. It turns out that Calc's arithmetic routines are especially fast when dividing by an integer less than 1000, so we can set @i{n = 9} bits and use repeated division by 512: @smallexample (defmath bcount ((natnum n)) (interactive 1 "bcnt") (let ((count 0)) (while (not (fixnump n)) (let ((qr (idivmod n 512))) (setq count (+ count (bcount-fixnum (cdr qr))) n (car qr)))) (+ count (bcount-fixnum n)))) (defun bcount-fixnum (n) (let ((count 0)) (while (> n 0) (setq count (+ count (logand n 1)) n (lsh n -1))) count)) @end smallexample @noindent Note that the second function uses @code{defun}, not @code{defmath}. Because this function deals only with native Lisp integers (``fixnums''), it can use the actual Emacs @code{+} and related functions rather than the slower but more general Calc equivalents which @code{defmath} uses. The @code{idivmod} function does an integer division, returning both the quotient and the remainder at once. Again, note that while it might seem that @samp{(logand n 511)} and @samp{(lsh n -9)} are more efficient ways to split off the bottom nine bits of @code{n}, actually they are less efficient because each operation is really a division by 512 in disguise; @code{idivmod} allows us to do the same thing with a single division by 512. @node Sine Example, , Bit Counting Example, Example Definitions @subsubsection The Sine Function @noindent @c @starindex @tindex mysin A somewhat limited sine function could be defined as follows, using the well-known Taylor series expansion for @c{$\sin x$} @samp{sin(x)}: @smallexample (defmath mysin ((float (anglep x))) (interactive 1 "mysn") (setq x (to-radians x)) ; Convert from current angular mode. (let ((sum x) ; Initial term of Taylor expansion of sin. newsum (nfact 1) ; "nfact" equals "n" factorial at all times. (xnegsqr :"-(x^2)")) ; "xnegsqr" equals -x^2. (for ((n 3 100 2)) ; Upper limit of 100 is a good precaution. (working "mysin" sum) ; Display "Working" message, if enabled. (setq nfact (* nfact (1- n) n) x (* x xnegsqr) newsum (+ sum (/ x nfact))) (if (~= newsum sum) ; If newsum is "nearly equal to" sum, (break)) ; then we are done. (setq sum newsum)) sum)) @end smallexample The actual @code{sin} function in Calc works by first reducing the problem to a sine or cosine of a nonnegative number less than @c{$\pi \over 4$} @cite{pi/4}. This ensures that the Taylor series will converge quickly. Also, the calculation is carried out with two extra digits of precision to guard against cumulative round-off in @samp{sum}. Finally, complex arguments are allowed and handled by a separate algorithm. @smallexample (defmath mysin ((float (scalarp x))) (interactive 1 "mysn") (setq x (to-radians x)) ; Convert from current angular mode. (with-extra-prec 2 ; Evaluate with extra precision. (cond ((complexp x) (mysin-complex x)) ((< x 0) (- (mysin-raw (- x))) ; Always call mysin-raw with x >= 0. (t (mysin-raw x)))))) (defmath mysin-raw (x) (cond ((>= x 7) (mysin-raw (% x (two-pi)))) ; Now x < 7. ((> x (pi-over-2)) (- (mysin-raw (- x (pi))))) ; Now -pi/2 <= x <= pi/2. ((> x (pi-over-4)) (mycos-raw (- x (pi-over-2)))) ; Now -pi/2 <= x <= pi/4. ((< x (- (pi-over-4))) (- (mycos-raw (+ x (pi-over-2))))) ; Now -pi/4 <= x <= pi/4, (t (mysin-series x)))) ; so the series will be efficient. @end smallexample @noindent where @code{mysin-complex} is an appropriate function to handle complex numbers, @code{mysin-series} is the routine to compute the sine Taylor series as before, and @code{mycos-raw} is a function analogous to @code{mysin-raw} for cosines. The strategy is to ensure that @cite{x} is nonnegative before calling @code{mysin-raw}. This function then recursively reduces its argument to a suitable range, namely, plus-or-minus @c{$\pi \over 4$} @cite{pi/4}. Note that each test, and particularly the first comparison against 7, is designed so that small roundoff errors cannnot produce an infinite loop. (Suppose we compared with @samp{(two-pi)} instead; if due to roundoff problems the modulo operator ever returned @samp{(two-pi)} exactly, an infinite recursion could result!) We use modulo only for arguments that will clearly get reduced, knowing that the next rule will catch any reductions that this rule misses. If a program is being written for general use, it is important to code it carefully as shown in this second example. For quick-and-dirty programs, when you know that your own use of the sine function will never encounter a large argument, a simpler program like the first one shown is fine. @node Calling Calc from Your Programs, Internals, Example Definitions, Lisp Definitions @subsection Calling Calc from Your Lisp Programs @noindent A later section (@pxref{Internals}) gives a full description of Calc's internal Lisp functions. It's not hard to call Calc from inside your programs, but the number of these functions can be daunting. So Calc provides one special ``programmer-friendly'' function called @code{calc-eval} that can be made to do just about everything you need. It's not as fast as the low-level Calc functions, but it's much simpler to use! It may seem that @code{calc-eval} itself has a daunting number of options, but they all stem from one simple operation. In its simplest manifestation, @samp{(calc-eval "1+2")} parses the string @code{"1+2"} as if it were a Calc algebraic entry and returns the result formatted as a string: @code{"3"}. Since @code{calc-eval} is on the list of recommended @code{autoload} functions, you don't need to make any special preparations to load Calc before calling @code{calc-eval} the first time. Calc will be loaded and initialized for you. All the Calc modes that are currently in effect will be used when evaluating the expression and formatting the result. @ifinfo @example @end example @end ifinfo @subsubsection Additional Arguments to @code{calc-eval} @noindent If the input string parses to a list of expressions, Calc returns the results separated by @code{", "}. You can specify a different separator by giving a second string argument to @code{calc-eval}: @samp{(calc-eval "1+2,3+4" ";")} returns @code{"3;7"}. The ``separator'' can also be any of several Lisp symbols which request other behaviors from @code{calc-eval}. These are discussed one by one below. You can give additional arguments to be substituted for @samp{$}, @samp{$$}, and so on in the main expression. For example, @samp{(calc-eval "$/$$" nil "7" "1+1")} evaluates the expression @code{"7/(1+1)"} to yield the result @code{"3.5"} (assuming Fraction mode is not in effect). Note the @code{nil} used as a placeholder for the item-separator argument. @ifinfo @example @end example @end ifinfo @subsubsection Error Handling @noindent If @code{calc-eval} encounters an error, it returns a list containing the character position of the error, plus a suitable message as a string. Note that @samp{1 / 0} is @emph{not} an error by Calc's standards; it simply returns the string @code{"1 / 0"} which is the division left in symbolic form. But @samp{(calc-eval "1/")} will return the list @samp{(2 "Expected a number")}. If you bind the variable @code{calc-eval-error} to @code{t} using a @code{let} form surrounding the call to @code{calc-eval}, errors instead call the Emacs @code{error} function which aborts to the Emacs command loop with a beep and an error message. If you bind this variable to the symbol @code{string}, error messages are returned as strings instead of lists. The character position is ignored. As a courtesy to other Lisp code which may be using Calc, be sure to bind @code{calc-eval-error} using @code{let} rather than changing it permanently with @code{setq}. @ifinfo @example @end example @end ifinfo @subsubsection Numbers Only @noindent Sometimes it is preferable to treat @samp{1 / 0} as an error rather than returning a symbolic result. If you pass the symbol @code{num} as the second argument to @code{calc-eval}, results that are not constants are treated as errors. The error message reported is the first @code{calc-why} message if there is one, or otherwise ``Number expected.'' A result is ``constant'' if it is a number, vector, or other object that does not include variables or function calls. If it is a vector, the components must themselves be constants. @ifinfo @example @end example @end ifinfo @subsubsection Default Modes @noindent If the first argument to @code{calc-eval} is a list whose first element is a formula string, then @code{calc-eval} sets all the various Calc modes to their default values while the formula is evaluated and formatted. For example, the precision is set to 12 digits, digit grouping is turned off, and the normal language mode is used. This same principle applies to the other options discussed below. If the first argument would normally be @var{x}, then it can also be the list @samp{(@var{x})} to use the default mode settings. If there are other elements in the list, they are taken as variable-name/value pairs which override the default mode settings. Look at the documentation at the front of the @file{calc.el} file to find the names of the Lisp variables for the various modes. The mode settings are restored to their original values when @code{calc-eval} is done. For example, @samp{(calc-eval '("$+$$" calc-internal-prec 8) 'num a b)} computes the sum of two numbers, requiring a numeric result, and using default mode settings except that the precision is 8 instead of the default of 12. It's usually best to use this form of @code{calc-eval} unless your program actually considers the interaction with Calc's mode settings to be a feature. This will avoid all sorts of potential ``gotchas''; consider what happens with @samp{(calc-eval "sqrt(2)" 'num)} when the user has left Calc in symbolic mode or no-simplify mode. As another example, @samp{(equal (calc-eval '("$<$$") nil a b) "1")} checks if the number in string @cite{a} is less than the one in string @cite{b}. Without using a list, the integer 1 might come out in a variety of formats which would be hard to test for conveniently: @code{"1"}, @code{"8#1"}, @code{"00001"}. (But see ``Predicates'' mode, below.) @ifinfo @example @end example @end ifinfo @subsubsection Raw Numbers @noindent Normally all input and output for @code{calc-eval} is done with strings. You can do arithmetic with, say, @samp{(calc-eval "$+$$" nil a b)} in place of @samp{(+ a b)}, but this is very inefficient since the numbers must be converted to and from string format as they are passed from one @code{calc-eval} to the next. If the separator is the symbol @code{raw}, the result will be returned as a raw Calc data structure rather than a string. You can read about how these objects look in the following sections, but usually you can treat them as ``black box'' objects with no important internal structure. There is also a @code{rawnum} symbol, which is a combination of @code{raw} (returning a raw Calc object) and @code{num} (signalling an error if that object is not a constant). You can pass a raw Calc object to @code{calc-eval} in place of a string, either as the formula itself or as one of the @samp{$} arguments. Thus @samp{(calc-eval "$+$$" 'raw a b)} is an addition function that operates on raw Calc objects. Of course in this case it would be easier to call the low-level @code{math-add} function in Calc, if you can remember its name. In particular, note that a plain Lisp integer is acceptable to Calc as a raw object. (All Lisp integers are accepted on input, but integers of more than six decimal digits are converted to ``big-integer'' form for output. @xref{Data Type Formats}.) When it comes time to display the object, just use @samp{(calc-eval a)} to format it as a string. It is an error if the input expression evaluates to a list of values. The separator symbol @code{list} is like @code{raw} except that it returns a list of one or more raw Calc objects. Note that a Lisp string is not a valid Calc object, nor is a list containing a string. Thus you can still safely distinguish all the various kinds of error returns discussed above. @ifinfo @example @end example @end ifinfo @subsubsection Predicates @noindent If the separator symbol is @code{pred}, the result of the formula is treated as a true/false value; @code{calc-eval} returns @code{t} or @code{nil}, respectively. A value is considered ``true'' if it is a non-zero number, or false if it is zero or if it is not a number. For example, @samp{(calc-eval "$<$$" 'pred a b)} tests whether one value is less than another. As usual, it is also possible for @code{calc-eval} to return one of the error indicators described above. Lisp will interpret such an indicator as ``true'' if you don't check for it explicitly. If you wish to have an error register as ``false'', use something like @samp{(eq (calc-eval ...) t)}. @ifinfo @example @end example @end ifinfo @subsubsection Variable Values @noindent Variables in the formula passed to @code{calc-eval} are not normally replaced by their values. If you wish this, you can use the @code{evalv} function (@pxref{Algebraic Manipulation}). For example, if 4 is stored in Calc variable @code{a} (i.e., in Lisp variable @code{var-a}), then @samp{(calc-eval "a+pi")} will return the formula @code{"a + pi"}, but @samp{(calc-eval "evalv(a+pi)")} will return @code{"7.14159265359"}. To store in a Calc variable, just use @code{setq} to store in the corresponding Lisp variable. (This is obtained by prepending @samp{var-} to the Calc variable name.) Calc routines will understand either string or raw form values stored in variables, although raw data objects are much more efficient. For example, to increment the Calc variable @code{a}: @example (setq var-a (calc-eval "evalv(a+1)" 'raw)) @end example @ifinfo @example @end example @end ifinfo @subsubsection Stack Access @noindent If the separator symbol is @code{push}, the formula argument is evaluated (with possible @samp{$} expansions, as usual). The result is pushed onto the Calc stack. The return value is @code{nil} (unless there is an error from evaluating the formula, in which case the return value depends on @code{calc-eval-error} in the usual way). If the separator symbol is @code{pop}, the first argument to @code{calc-eval} must be an integer instead of a string. That many values are popped from the stack and thrown away. A negative argument deletes the entry at that stack level. The return value is the number of elements remaining in the stack after popping; @samp{(calc-eval 0 'pop)} is a good way to measure the size of the stack. If the separator symbol is @code{top}, the first argument to @code{calc-eval} must again be an integer. The value at that stack level is formatted as a string and returned. Thus @samp{(calc-eval 1 'top)} returns the top-of-stack value. If the integer is out of range, @code{nil} is returned. The separator symbol @code{rawtop} is just like @code{top} except that the stack entry is returned as a raw Calc object instead of as a string. In all of these cases the first argument can be made a list in order to force the default mode settings, as described above. Thus @samp{(calc-eval '(2 calc-number-radix 16) 'top)} returns the second-to-top stack entry, formatted as a string using the default instead of current display modes, except that the radix is hexadecimal instead of decimal. It is, of course, polite to put the Calc stack back the way you found it when you are done, unless the user of your program is actually expecting it to affect the stack. Note that you do not actually have to switch into the @samp{*Calculator*} buffer in order to use @code{calc-eval}; it temporarily switches into the stack buffer if necessary. @ifinfo @example @end example @end ifinfo @subsubsection Keyboard Macros @noindent If the separator symbol is @code{macro}, the first argument must be a string of characters which Calc can execute as a sequence of keystrokes. This switches into the Calc buffer for the duration of the macro. For example, @samp{(calc-eval "vx5\rVR+" 'macro)} pushes the vector @samp{[1,2,3,4,5]} on the stack and then replaces it with the sum of those numbers. Note that @samp{\r} is the Lisp notation for the carriage-return, @key{RET}, character. If your keyboard macro wishes to pop the stack, @samp{\C-d} is safer than @samp{\177} (the @key{DEL} character) because some installations may have switched the meanings of @key{DEL} and @kbd{C-h}. Calc always interprets @kbd{C-d} as a synonym for ``pop-stack'' regardless of key mapping. If you provide a third argument to @code{calc-eval}, evaluation of the keyboard macro will leave a record in the Trail using that argument as a tag string. Normally the Trail is unaffected. The return value in this case is always @code{nil}. @ifinfo @example @end example @end ifinfo @subsubsection Lisp Evaluation @noindent Finally, if the separator symbol is @code{eval}, then the Lisp @code{eval} function is called on the first argument, which must be a Lisp expression rather than a Calc formula. Remember to quote the expression so that it is not evaluated until inside @code{calc-eval}. The difference from plain @code{eval} is that @code{calc-eval} switches to the Calc buffer before evaluating the expression. For example, @samp{(calc-eval '(setq calc-internal-prec 17) 'eval)} will correctly affect the buffer-local Calc precision variable. An alternative would be @samp{(calc-eval '(calc-precision 17) 'eval)}. This is evaluating a call to the function that is normally invoked by the @kbd{p} key, giving it 17 as its ``numeric prefix argument.'' Note that this function will leave a message in the echo area as a side effect. Also, all Calc functions switch to the Calc buffer automatically if not invoked from there, so the above call is also equivalent to @samp{(calc-precision 17)} by itself. In all cases, Calc uses @code{save-excursion} to switch back to your original buffer when it is done. As usual the first argument can be a list that begins with a Lisp expression to use default instead of current mode settings. The result of @code{calc-eval} in this usage is just the result returned by the evaluated Lisp expression. @ifinfo @example @end example @end ifinfo @subsubsection Example @noindent @findex convert-temp Here is a sample Emacs command that uses @code{calc-eval}. Suppose you have a document with lots of references to temperatures on the Fahrenheit scale, say ``98.6 F'', and you wish to convert these references to Centigrade. The following command does this conversion. Place the Emacs cursor right after the letter ``F'' and invoke the command to change ``98.6 F'' to ``37 C''. Or, if the temperature is already in Centigrade form, the command changes it back to Fahrenheit. @example (defun convert-temp () (interactive) (save-excursion (re-search-backward "[^-.0-9]\\([-.0-9]+\\) *\\([FC]\\)") (let* ((top1 (match-beginning 1)) (bot1 (match-end 1)) (number (buffer-substring top1 bot1)) (top2 (match-beginning 2)) (bot2 (match-end 2)) (type (buffer-substring top2 bot2))) (if (equal type "F") (setq type "C" number (calc-eval "($ - 32)*5/9" nil number)) (setq type "F" number (calc-eval "$*9/5 + 32" nil number))) (goto-char top2) (delete-region top2 bot2) (insert-before-markers type) (goto-char top1) (delete-region top1 bot1) (if (string-match "\\.$" number) ; change "37." to "37" (setq number (substring number 0 -1))) (insert number)))) @end example Note the use of @code{insert-before-markers} when changing between ``F'' and ``C'', so that the character winds up before the cursor instead of after it. @node Internals, , Calling Calc from Your Programs, Lisp Definitions @subsection Calculator Internals @noindent This section describes the Lisp functions defined by the Calculator that may be of use to user-written Calculator programs (as described in the rest of this chapter). These functions are shown by their names as they conventionally appear in @code{defmath}. Their full Lisp names are generally gotten by prepending @samp{calcFunc-} or @samp{math-} to their apparent names. (Names that begin with @samp{calc-} are already in their full Lisp form.) You can use the actual full names instead if you prefer them, or if you are calling these functions from regular Lisp. The functions described here are scattered throughout the various Calc component files. Note that @file{calc.el} includes @code{autoload}s for only a few component files; when Calc wants to call an advanced function it calls @samp{(calc-extensions)} first; this function autoloads @file{calc-ext.el}, which in turn autoloads all the functions in the remaining component files. Because @code{defmath} itself uses the extensions, user-written code generally always executes with the extensions already loaded, so normally you can use any Calc function and be confident that it will be autoloaded for you when necessary. If you are doing something special, check carefully to make sure each function you are using is from @file{calc.el} or its components, and call @samp{(calc-extensions)} before using any function based in @file{calc-ext.el} if you can't prove this file will already be loaded. @menu * Data Type Formats:: * Interactive Lisp Functions:: * Stack Lisp Functions:: * Predicates:: * Computational Lisp Functions:: * Vector Lisp Functions:: * Symbolic Lisp Functions:: * Formatting Lisp Functions:: * Hooks:: @end menu @node Data Type Formats, Interactive Lisp Functions, Internals, Internals @subsubsection Data Type Formats @noindent Integers are stored in either of two ways, depending on their magnitude. Integers less than one million in absolute value are stored as standard Lisp integers. This is the only storage format for Calc data objects which is not a Lisp list. Large integers are stored as lists of the form @samp{(bigpos @var{d0} @var{d1} @var{d2} @dots{})} for positive integers 1000000 or more, or @samp{(bigneg @var{d0} @var{d1} @var{d2} @dots{})} for negative integers @i{-1000000} or less. Each @var{d} is a base-1000 ``digit,'' a Lisp integer from 0 to 999. The least significant digit is @var{d0}; the last digit, @var{dn}, which is always nonzero, is the most significant digit. For example, the integer @i{-12345678} is stored as @samp{(bigneg 678 345 12)}. The distinction between small and large integers is entirely hidden from the user. In @code{defmath} definitions, the Lisp predicate @code{integerp} returns true for either kind of integer, and in general both big and small integers are accepted anywhere the word ``integer'' is used in this manual. If the distinction must be made, native Lisp integers are called @dfn{fixnums} and large integers are called @dfn{bignums}. Fractions are stored as a list of the form, @samp{(frac @var{n} @var{d})} where @var{n} is an integer (big or small) numerator, @var{d} is an integer denominator greater than one, and @var{n} and @var{d} are relatively prime. Note that fractions where @var{d} is one are automatically converted to plain integers by all math routines; fractions where @var{d} is negative are normalized by negating the numerator and denominator. Floating-point numbers are stored in the form, @samp{(float @var{mant} @var{exp})}, where @var{mant} (the ``mantissa'') is an integer less than @samp{10^@var{p}} in absolute value (@var{p} represents the current precision), and @var{exp} (the ``exponent'') is a fixnum. The value of the float is @samp{@var{mant} * 10^@var{exp}}. For example, the number @i{-3.14} is stored as @samp{(float -314 -2) = -314*10^-2}. Other constraints are that the number 0.0 is always stored as @samp{(float 0 0)}, and, except for the 0.0 case, the rightmost base-10 digit of @var{mant} is always nonzero. (If the rightmost digit is zero, the number is rearranged by dividing @var{mant} by ten and incrementing @var{exp}.)@refill Rectangular complex numbers are stored in the form @samp{(cplx @var{re} @var{im})}, where @var{re} and @var{im} are each real numbers, either integers, fractions, or floats. The value is @samp{@var{re} + @var{im}i}. The @var{im} part is nonzero; complex numbers with zero imaginary components are converted to real numbers automatically.@refill Polar complex numbers are stored in the form @samp{(polar @var{r} @var{theta})}, where @var{r} is a positive real value and @var{theta} is a real value or HMS form representing an angle. This angle is usually normalized to lie in the interval @samp{(-180 ..@: 180)} degrees, or @samp{(-pi ..@: pi)} radians, according to the current angular mode. If the angle is 0 the value is converted to a real number automatically. (If the angle is 180 degrees, the value is usually also converted to a negative real number.)@refill Hours-minutes-seconds forms are stored as @samp{(hms @var{h} @var{m} @var{s})}, where @var{h} is an integer or an integer-valued float (i.e., a float with @samp{@var{exp} >= 0}), @var{m} is an integer or integer-valued float in the range @w{@samp{[0 ..@: 60)}}, and @var{s} is any real number in the range @samp{[0 ..@: 60)}.@refill Date forms are stored as @samp{(date @var{n})}, where @var{n} is a real number that counts days since midnight on the morning of January 1, 1 AD. If @var{n} is an integer, this is a pure date form. If @var{n} is a fraction or float, this is a date/time form. Modulo forms are stored as @samp{(mod @var{n} @var{m})}, where @var{m} is a positive real number or HMS form, and @var{n} is a real number or HMS form in the range @samp{[0 ..@: @var{m})}. Error forms are stored as @samp{(sdev @var{x} @var{sigma})}, where @var{x} is the mean value and @var{sigma} is the standard deviation. Each component is either a number, an HMS form, or a symbolic object (a variable or function call). If @var{sigma} is zero, the value is converted to a plain real number. If @var{sigma} is negative or complex, it is automatically normalized to be a positive real. Interval forms are stored as @samp{(intv @var{mask} @var{lo} @var{hi})}, where @var{mask} is one of the integers 0, 1, 2, or 3, and @var{lo} and @var{hi} are real numbers, HMS forms, or symbolic objects. The @var{mask} is a binary integer where 1 represents the fact that the interval is closed on the high end, and 2 represents the fact that it is closed on the low end. (Thus 3 represents a fully closed interval.) The interval @w{@samp{(intv 3 @var{x} @var{x})}} is converted to the plain number @var{x}; intervals @samp{(intv @var{mask} @var{x} @var{x})} for any other @var{mask} represent empty intervals. If @var{hi} is less than @var{lo}, the interval is converted to a standard empty interval by replacing @var{hi} with @var{lo}. Vectors are stored as @samp{(vec @var{v1} @var{v2} @dots{})}, where @var{v1} is the first element of the vector, @var{v2} is the second, and so on. An empty vector is stored as @samp{(vec)}. A matrix is simply a vector where all @var{v}'s are themselves vectors of equal lengths. Note that Calc vectors are unrelated to the Emacs Lisp ``vector'' type, which is generally unused by Calc data structures. Variables are stored as @samp{(var @var{name} @var{sym})}, where @var{name} is a Lisp symbol whose print name is used as the visible name of the variable, and @var{sym} is a Lisp symbol in which the variable's value is actually stored. Thus, @samp{(var pi var-pi)} represents the special constant @samp{pi}. Almost always, the form is @samp{(var @var{v} var-@var{v})}. If the variable name was entered with @code{#} signs (which are converted to hyphens internally), the form is @samp{(var @var{u} @var{v})}, where @var{u} is a symbol whose name contains @code{#} characters, and @var{v} is a symbol that contains @code{-} characters instead. The value of a variable is the Calc object stored in its @var{sym} symbol's value cell. If the symbol's value cell is void or if it contains @code{nil}, the variable has no value. Special constants have the form @samp{(special-const @var{value})} stored in their value cell, where @var{value} is a formula which is evaluated when the constant's value is requested. Variables which represent units are not stored in any special way; they are units only because their names appear in the units table. If the value cell contains a string, it is parsed to get the variable's value when the variable is used.@refill A Lisp list with any other symbol as the first element is a function call. The symbols @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^}, and @code{|} represent special binary operators; these lists are always of the form @samp{(@var{op} @var{lhs} @var{rhs})} where @var{lhs} is the sub-formula on the lefthand side and @var{rhs} is the sub-formula on the right. The symbol @code{neg} represents unary negation; this list is always of the form @samp{(neg @var{arg})}. Any other symbol @var{func} represents a function that would be displayed in function-call notation; the symbol @var{func} is in general always of the form @samp{calcFunc-@var{name}}. The function cell of the symbol @var{func} should contain a Lisp function for evaluating a call to @var{func}. This function is passed the remaining elements of the list (themselves already evaluated) as arguments; such functions should return @code{nil} or call @code{reject-arg} to signify that they should be left in symbolic form, or they should return a Calc object which represents their value, or a list of such objects if they wish to return multiple values. (The latter case is allowed only for functions which are the outer-level call in an expression whose value is about to be pushed on the stack; this feature is considered obsolete and is not used by any built-in Calc functions.)@refill @node Interactive Lisp Functions, Stack Lisp Functions, Data Type Formats, Internals @subsubsection Interactive Functions @noindent The functions described here are used in implementing interactive Calc commands. Note that this list is not exhaustive! If there is an existing command that behaves similarly to the one you want to define, you may find helpful tricks by checking the source code for that command. @defun calc-set-command-flag flag Set the command flag @var{flag}. This is generally a Lisp symbol, but may in fact be anything. The effect is to add @var{flag} to the list stored in the variable @code{calc-command-flags}, unless it is already there. @xref{Defining Simple Commands}. @end defun @defun calc-clear-command-flag flag If @var{flag} appears among the list of currently-set command flags, remove it from that list. @end defun @defun calc-record-undo rec Add the ``undo record'' @var{rec} to the list of steps to take if the current operation should need to be undone. Stack push and pop functions automatically call @code{calc-record-undo}, so the kinds of undo records you might need to create take the form @samp{(set @var{sym} @var{value})}, which says that the Lisp variable @var{sym} was changed and had previously contained @var{value}; @samp{(store @var{var} @var{value})} which says that the Calc variable @var{var} (a string which is the name of the symbol that contains the variable's value) was stored and its previous value was @var{value} (either a Calc data object, or @code{nil} if the variable was previously void); or @samp{(eval @var{undo} @var{redo} @var{args} @dots{})}, which means that to undo requires calling the function @samp{(@var{undo} @var{args} @dots{})} and, if the undo is later redone, calling @samp{(@var{redo} @var{args} @dots{})}.@refill @end defun @defun calc-record-why msg args Record the error or warning message @var{msg}, which is normally a string. This message will be replayed if the user types @kbd{w} (@code{calc-why}); if the message string begins with a @samp{*}, it is considered important enough to display even if the user doesn't type @kbd{w}. If one or more @var{args} are present, the displayed message will be of the form, @samp{@var{msg}: @var{arg1}, @var{arg2}, @dots{}}, where the arguments are formatted on the assumption that they are either strings or Calc objects of some sort. If @var{msg} is a symbol, it is the name of a Calc predicate (such as @code{integerp} or @code{numvecp}) which the arguments did not satisfy; it is expanded to a suitable string such as ``Expected an integer.'' The @code{reject-arg} function calls @code{calc-record-why} automatically; @pxref{Predicates}.@refill @end defun @defun calc-is-inverse This predicate returns true if the current command is inverse, i.e., if the Inverse (@kbd{I} key) flag was set. @end defun @defun calc-is-hyperbolic This predicate is the analogous function for the @kbd{H} key. @end defun @node Stack Lisp Functions, Predicates, Interactive Lisp Functions, Internals @subsubsection Stack-Oriented Functions @noindent The functions described here perform various operations on the Calc stack and trail. They are to be used in interactive Calc commands. @defun calc-push-list vals n Push the Calc objects in list @var{vals} onto the stack at stack level @var{n}. If @var{n} is omitted it defaults to 1, so that the elements are pushed at the top of the stack. If @var{n} is greater than 1, the elements will be inserted into the stack so that the last element will end up at level @var{n}, the next-to-last at level @var{n}+1, etc. The elements of @var{vals} are assumed to be valid Calc objects, and are not evaluated, rounded, or renormalized in any way. If @var{vals} is an empty list, nothing happens.@refill The stack elements are pushed without any sub-formula selections. You can give an optional third argument to this function, which must be a list the same size as @var{vals} of selections. Each selection must be @code{eq} to some sub-formula of the corresponding formula in @var{vals}, or @code{nil} if that formula should have no selection. @end defun @defun calc-top-list n m Return a list of the @var{n} objects starting at level @var{m} of the stack. If @var{m} is omitted it defaults to 1, so that the elements are taken from the top of the stack. If @var{n} is omitted, it also defaults to 1, so that the top stack element (in the form of a one-element list) is returned. If @var{m} is greater than 1, the @var{m}th stack element will be at the end of the list, the @var{m}+1st element will be next-to-last, etc. If @var{n} or @var{m} are out of range, the command is aborted with a suitable error message. If @var{n} is zero, the function returns an empty list. The stack elements are not evaluated, rounded, or renormalized.@refill If any stack elements contain selections, and selections have not been disabled by the @kbd{j e} (@code{calc-enable-selections}) command, this function returns the selected portions rather than the entire stack elements. It can be given a third ``selection-mode'' argument which selects other behaviors. If it is the symbol @code{t}, then a selection in any of the requested stack elements produces an ``illegal operation on selections'' error. If it is the symbol @code{full}, the whole stack entry is always returned regardless of selections. If it is the symbol @code{sel}, the selected portion is always returned, or @code{nil} if there is no selection. (This mode ignores the @kbd{j e} command.) If the symbol is @code{entry}, the complete stack entry in list form is returned; the first element of this list will be the whole formula, and the third element will be the selection (or @code{nil}). @end defun @defun calc-pop-stack n m Remove the specified elements from the stack. The parameters @var{n} and @var{m} are defined the same as for @code{calc-top-list}. The return value of @code{calc-pop-stack} is uninteresting. If there are any selected sub-formulas among the popped elements, and @kbd{j e} has not been used to disable selections, this produces an error without changing the stack. If you supply an optional third argument of @code{t}, the stack elements are popped even if they contain selections. @end defun @defun calc-record-list vals tag This function records one or more results in the trail. The @var{vals} are a list of strings or Calc objects. The @var{tag} is the four-character tag string to identify the values. If @var{tag} is omitted, a blank tag will be used. @end defun @defun calc-normalize n This function takes a Calc object and ``normalizes'' it. At the very least this involves re-rounding floating-point values according to the current precision and other similar jobs. Also, unless the user has selected no-simplify mode (@pxref{Simplification Modes}), this involves actually evaluating a formula object by executing the function calls it contains, and possibly also doing algebraic simplification, etc. @end defun @defun calc-top-list-n n m This function is identical to @code{calc-top-list}, except that it calls @code{calc-normalize} on the values that it takes from the stack. They are also passed through @code{check-complete}, so that incomplete objects will be rejected with an error message. All computational commands should use this in preference to @code{calc-top-list}; the only standard Calc commands that operate on the stack without normalizing are stack management commands like @code{calc-enter} and @code{calc-roll-up}. This function accepts the same optional selection-mode argument as @code{calc-top-list}. @end defun @defun calc-top-n m This function is a convenient form of @code{calc-top-list-n} in which only a single element of the stack is taken and returned, rather than a list of elements. This also accepts an optional selection-mode argument. @end defun @defun calc-enter-result n tag vals This function is a convenient interface to most of the above functions. The @var{vals} argument should be either a single Calc object, or a list of Calc objects; the object or objects are normalized, and the top @var{n} stack entries are replaced by the normalized objects. If @var{tag} is non-@code{nil}, the normalized objects are also recorded in the trail. A typical stack-based computational command would take the form, @smallexample (calc-enter-result @var{n} @var{tag} (cons 'calcFunc-@var{func} (calc-top-list-n @var{n}))) @end smallexample If any of the @var{n} stack elements replaced contain sub-formula selections, and selections have not been disabled by @kbd{j e}, this function takes one of two courses of action. If @var{n} is equal to the number of elements in @var{vals}, then each element of @var{vals} is spliced into the corresponding selection; this is what happens when you use the @key{TAB} key, or when you use a unary arithmetic operation like @code{sqrt}. If @var{vals} has only one element but @var{n} is greater than one, there must be only one selection among the top @var{n} stack elements; the element from @var{vals} is spliced into that selection. This is what happens when you use a binary arithmetic operation like @kbd{+}. Any other combination of @var{n} and @var{vals} is an error when selections are present. @end defun @defun calc-unary-op tag func arg This function implements a unary operator that allows a numeric prefix argument to apply the operator over many stack entries. If the prefix argument @var{arg} is @code{nil}, this uses @code{calc-enter-result} as outlined above. Otherwise, it maps the function over several stack elements; @pxref{Prefix Arguments}. For example,@refill @smallexample (defun calc-zeta (arg) (interactive "P") (calc-unary-op "zeta" 'calcFunc-zeta arg)) @end smallexample @end defun @defun calc-binary-op tag func arg ident unary This function implements a binary operator, analogously to @code{calc-unary-op}. The optional @var{ident} and @var{unary} arguments specify the behavior when the prefix argument is zero or one, respectively. If the prefix is zero, the value @var{ident} is pushed onto the stack, if specified, otherwise an error message is displayed. If the prefix is one, the unary function @var{unary} is applied to the top stack element, or, if @var{unary} is not specified, nothing happens. When the argument is two or more, the binary function @var{func} is reduced across the top @var{arg} stack elements; when the argument is negative, the function is mapped between the next-to-top @i{-@var{arg}} stack elements and the top element.@refill @end defun @defun calc-stack-size Return the number of elements on the stack as an integer. This count does not include elements that have been temporarily hidden by stack truncation; @pxref{Truncating the Stack}. @end defun @defun calc-cursor-stack-index n Move the point to the @var{n}th stack entry. If @var{n} is zero, this will be the @samp{.} line. If @var{n} is from 1 to the current stack size, this will be the beginning of the first line of that stack entry's display. If line numbers are enabled, this will move to the first character of the line number, not the stack entry itself.@refill @end defun @defun calc-substack-height n Return the number of lines between the beginning of the @var{n}th stack entry and the bottom of the buffer. If @var{n} is zero, this will be one (assuming no stack truncation). If all stack entries are one line long (i.e., no matrices are displayed), the return value will be equal @var{n}+1 as long as @var{n} is in range. (Note that in Big mode, the return value includes the blank lines that separate stack entries.)@refill @end defun @defun calc-refresh Erase the @code{*Calculator*} buffer and reformat its contents from memory. This must be called after changing any parameter, such as the current display radix, which might change the appearance of existing stack entries. (During a keyboard macro invoked by the @kbd{X} key, refreshing is suppressed, but a flag is set so that the entire stack will be refreshed rather than just the top few elements when the macro finishes.)@refill @end defun @node Predicates, Computational Lisp Functions, Stack Lisp Functions, Internals @subsubsection Predicates @noindent The functions described here are predicates, that is, they return a true/false value where @code{nil} means false and anything else means true. These predicates are expanded by @code{defmath}, for example, from @code{zerop} to @code{math-zerop}. In many cases they correspond to native Lisp functions by the same name, but are extended to cover the full range of Calc data types. @defun zerop x Returns true if @var{x} is numerically zero, in any of the Calc data types. (Note that for some types, such as error forms and intervals, it never makes sense to return true.) In @code{defmath}, the expression @samp{(= x 0)} will automatically be converted to @samp{(math-zerop x)}, and @samp{(/= x 0)} will be converted to @samp{(not (math-zerop x))}. @end defun @defun negp x Returns true if @var{x} is negative. This accepts negative real numbers of various types, negative HMS and date forms, and intervals in which all included values are negative. In @code{defmath}, the expression @samp{(< x 0)} will automatically be converted to @samp{(math-negp x)}, and @samp{(>= x 0)} will be converted to @samp{(not (math-negp x))}. @end defun @defun posp x Returns true if @var{x} is positive (and non-zero). For complex numbers, none of these three predicates will return true. @end defun @defun looks-negp x Returns true if @var{x} is ``negative-looking.'' This returns true if @var{x} is a negative number, or a formula with a leading minus sign such as @samp{-a/b}. In other words, this is an object which can be made simpler by calling @code{(- @var{x})}. @end defun @defun integerp x Returns true if @var{x} is an integer of any size. @end defun @defun fixnump x Returns true if @var{x} is a native Lisp integer. @end defun @defun natnump x Returns true if @var{x} is a nonnegative integer of any size. @end defun @defun fixnatnump x Returns true if @var{x} is a nonnegative Lisp integer. @end defun @defun num-integerp x Returns true if @var{x} is numerically an integer, i.e., either a true integer or a float with no significant digits to the right of the decimal point. @end defun @defun messy-integerp x Returns true if @var{x} is numerically, but not literally, an integer. A value is @code{num-integerp} if it is @code{integerp} or @code{messy-integerp} (but it is never both at once). @end defun @defun num-natnump x Returns true if @var{x} is numerically a nonnegative integer. @end defun @defun evenp x Returns true if @var{x} is an even integer. @end defun @defun looks-evenp x Returns true if @var{x} is an even integer, or a formula with a leading multiplicative coefficient which is an even integer. @end defun @defun oddp x Returns true if @var{x} is an odd integer. @end defun @defun ratp x Returns true if @var{x} is a rational number, i.e., an integer or a fraction. @end defun @defun realp x Returns true if @var{x} is a real number, i.e., an integer, fraction, or floating-point number. @end defun @defun anglep x Returns true if @var{x} is a real number or HMS form. @end defun @defun floatp x Returns true if @var{x} is a float, or a complex number, error form, interval, date form, or modulo form in which at least one component is a float. @end defun @defun complexp x Returns true if @var{x} is a rectangular or polar complex number (but not a real number). @end defun @defun rect-complexp x Returns true if @var{x} is a rectangular complex number. @end defun @defun polar-complexp x Returns true if @var{x} is a polar complex number. @end defun @defun numberp x Returns true if @var{x} is a real number or a complex number. @end defun @defun scalarp x Returns true if @var{x} is a real or complex number or an HMS form. @end defun @defun vectorp x Returns true if @var{x} is a vector (this simply checks if its argument is a list whose first element is the symbol @code{vec}). @end defun @defun numvecp x Returns true if @var{x} is a number or vector. @end defun @defun matrixp x Returns true if @var{x} is a matrix, i.e., a vector of one or more vectors, all of the same size. @end defun @defun square-matrixp x Returns true if @var{x} is a square matrix. @end defun @defun objectp x Returns true if @var{x} is any numeric Calc object, including real and complex numbers, HMS forms, date forms, error forms, intervals, and modulo forms. (Note that error forms and intervals may include formulas as their components; see @code{constp} below.) @end defun @defun objvecp x Returns true if @var{x} is an object or a vector. This also accepts incomplete objects, but it rejects variables and formulas (except as mentioned above for @code{objectp}). @end defun @defun primp x Returns true if @var{x} is a ``primitive'' or ``atomic'' Calc object, i.e., one whose components cannot be regarded as sub-formulas. This includes variables, and all @code{objectp} types except error forms and intervals. @end defun @defun constp x Returns true if @var{x} is constant, i.e., a real or complex number, HMS form, date form, or error form, interval, or vector all of whose components are @code{constp}. @end defun @defun lessp x y Returns true if @var{x} is numerically less than @var{y}. Returns false if @var{x} is greater than or equal to @var{y}, or if the order is undefined or cannot be determined. Generally speaking, this works by checking whether @samp{@var{x} - @var{y}} is @code{negp}. In @code{defmath}, the expression @samp{(< x y)} will automatically be converted to @samp{(lessp x y)}; expressions involving @code{>}, @code{<=}, and @code{>=} are similarly converted in terms of @code{lessp}.@refill @end defun @defun beforep x y Returns true if @var{x} comes before @var{y} in a canonical ordering of Calc objects. If @var{x} and @var{y} are both real numbers, this will be the same as @code{lessp}. But whereas @code{lessp} considers other types of objects to be unordered, @code{beforep} puts any two objects into a definite, consistent order. The @code{beforep} function is used by the @kbd{V S} vector-sorting command, and also by @kbd{a s} to put the terms of a product into canonical order: This allows @samp{x y + y x} to be simplified easily to @samp{2 x y}. @end defun @defun equal x y This is the standard Lisp @code{equal} predicate; it returns true if @var{x} and @var{y} are structurally identical. This is the usual way to compare numbers for equality, but note that @code{equal} will treat 0 and 0.0 as different. @end defun @defun math-equal x y Returns true if @var{x} and @var{y} are numerically equal, either because they are @code{equal}, or because their difference is @code{zerop}. In @code{defmath}, the expression @samp{(= x y)} will automatically be converted to @samp{(math-equal x y)}. @end defun @defun equal-int x n Returns true if @var{x} and @var{n} are numerically equal, where @var{n} is a fixnum which is not a multiple of 10. This will automatically be used by @code{defmath} in place of the more general @code{math-equal} whenever possible.@refill @end defun @defun nearly-equal x y Returns true if @var{x} and @var{y}, as floating-point numbers, are equal except possibly in the last decimal place. For example, 314.159 and 314.166 are considered nearly equal if the current precision is 6 (since they differ by 7 units), but not if the current precision is 7 (since they differ by 70 units). Most functions which use series expansions use @code{with-extra-prec} to evaluate the series with 2 extra digits of precision, then use @code{nearly-equal} to decide when the series has converged; this guards against cumulative error in the series evaluation without doing extra work which would be lost when the result is rounded back down to the current precision. In @code{defmath}, this can be written @samp{(~= @var{x} @var{y})}. The @var{x} and @var{y} can be numbers of any kind, including complex. @end defun @defun nearly-zerop x y Returns true if @var{x} is nearly zero, compared to @var{y}. This checks whether @var{x} plus @var{y} would by be @code{nearly-equal} to @var{y} itself, to within the current precision, in other words, if adding @var{x} to @var{y} would have a negligible effect on @var{y} due to roundoff error. @var{X} may be a real or complex number, but @var{y} must be real. @end defun @defun is-true x Return true if the formula @var{x} represents a true value in Calc, not Lisp, terms. It tests if @var{x} is a non-zero number or a provably non-zero formula. @end defun @defun reject-arg val pred Abort the current function evaluation due to unacceptable argument values. This calls @samp{(calc-record-why @var{pred} @var{val})}, then signals a Lisp error which @code{normalize} will trap. The net effect is that the function call which led here will be left in symbolic form.@refill @end defun @defun inexact-value If Symbolic Mode is enabled, this will signal an error that causes @code{normalize} to leave the formula in symbolic form, with the message ``Inexact result.'' (This function has no effect when not in Symbolic Mode.) Note that if your function calls @samp{(sin 5)} in Symbolic Mode, the @code{sin} function will call @code{inexact-value}, which will cause your function to be left unsimplified. You may instead wish to call @samp{(normalize (list 'calcFunc-sin 5))}, which in Symbolic Mode will return the formula @samp{sin(5)} to your function.@refill @end defun @defun overflow This signals an error that will be reported as a floating-point overflow. @end defun @defun underflow This signals a floating-point underflow. @end defun @node Computational Lisp Functions, Vector Lisp Functions, Predicates, Internals @subsubsection Computational Functions @noindent The functions described here do the actual computational work of the Calculator. In addition to these, note that any function described in the main body of this manual may be called from Lisp; for example, if the documentation refers to the @code{calc-sqrt} [@code{sqrt}] command, this means @code{calc-sqrt} is an interactive stack-based square-root command and @code{sqrt} (which @code{defmath} expands to @code{calcFunc-sqrt}) is the actual Lisp function for taking square roots.@refill The functions @code{math-add}, @code{math-sub}, @code{math-mul}, @code{math-div}, @code{math-mod}, and @code{math-neg} are not included in this list, since @code{defmath} allows you to write native Lisp @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, and unary @code{-}, respectively, instead.@refill @defun normalize val (Full form: @code{math-normalize}.) Reduce the value @var{val} to standard form. For example, if @var{val} is a fixnum, it will be converted to a bignum if it is too large, and if @var{val} is a bignum it will be normalized by clipping off trailing (i.e., most-significant) zero digits and converting to a fixnum if it is small. All the various data types are similarly converted to their standard forms. Variables are left alone, but function calls are actually evaluated in formulas. For example, normalizing @samp{(+ 2 (calcFunc-abs -4))} will return 6.@refill If a function call fails, because the function is void or has the wrong number of parameters, or because it returns @code{nil} or calls @code{reject-arg} or @code{inexact-result}, @code{normalize} returns the formula still in symbolic form.@refill If the current Simplification Mode is ``none'' or ``numeric arguments only,'' @code{normalize} will act appropriately. However, the more powerful simplification modes (like algebraic simplification) are not handled by @code{normalize}. They are handled by @code{calc-normalize}, which calls @code{normalize} and possibly some other routines, such as @code{simplify} or @code{simplify-units}. Programs generally will never call @code{calc-normalize} except when popping or pushing values on the stack.@refill @end defun @defun evaluate-expr expr Replace all variables in @var{expr} that have values with their values, then use @code{normalize} to simplify the result. This is what happens when you press the @kbd{=} key interactively.@refill @end defun @defmac with-extra-prec n body Evaluate the Lisp forms in @var{body} with precision increased by @var{n} digits. This is a macro which expands to @smallexample (math-normalize (let ((calc-internal-prec (+ calc-internal-prec @var{n}))) @var{body})) @end smallexample The surrounding call to @code{math-normalize} causes a floating-point result to be rounded down to the original precision afterwards. This is important because some arithmetic operations assume a number's mantissa contains no more digits than the current precision allows. @end defmac @defun make-frac n d Build a fraction @samp{@var{n}:@var{d}}. This is equivalent to calling @samp{(normalize (list 'frac @var{n} @var{d}))}, but more efficient. @end defun @defun make-float mant exp Build a floating-point value out of @var{mant} and @var{exp}, both of which are arbitrary integers. This function will return a properly normalized float value, or signal an overflow or underflow if @var{exp} is out of range. @end defun @defun make-sdev x sigma Build an error form out of @var{x} and the absolute value of @var{sigma}. If @var{sigma} is zero, the result is the number @var{x} directly. If @var{sigma} is negative or complex, its absolute value is used. If @var{x} or @var{sigma} is not a valid type of object for use in error forms, this calls @code{reject-arg}. @end defun @defun make-intv mask lo hi Build an interval form out of @var{mask} (which is assumed to be an integer from 0 to 3), and the limits @var{lo} and @var{hi}. If @var{lo} is greater than @var{hi}, an empty interval form is returned. This calls @code{reject-arg} if @var{lo} or @var{hi} is unsuitable. @end defun @defun sort-intv mask lo hi Build an interval form, similar to @code{make-intv}, except that if @var{lo} is less than @var{hi} they are simply exchanged, and the bits of @var{mask} are swapped accordingly. @end defun @defun make-mod n m Build a modulo form out of @var{n} and the modulus @var{m}. Since modulo forms do not allow formulas as their components, if @var{n} or @var{m} is not a real number or HMS form the result will be a formula which is a call to @code{makemod}, the algebraic version of this function. @end defun @defun float x Convert @var{x} to floating-point form. Integers and fractions are converted to numerically equivalent floats; components of complex numbers, vectors, HMS forms, date forms, error forms, intervals, and modulo forms are recursively floated. If the argument is a variable or formula, this calls @code{reject-arg}. @end defun @defun compare x y Compare the numbers @var{x} and @var{y}, and return @i{-1} if @samp{(lessp @var{x} @var{y})}, 1 if @samp{(lessp @var{y} @var{x})}, 0 if @samp{(math-equal @var{x} @var{y})}, or 2 if the order is undefined or cannot be determined.@refill @end defun @defun numdigs n Return the number of digits of integer @var{n}, effectively @samp{ceil(log10(@var{n}))}, but much more efficient. Zero is considered to have zero digits. @end defun @defun scale-int x n Shift integer @var{x} left @var{n} decimal digits, or right @i{-@var{n}} digits with truncation toward zero. @end defun @defun scale-rounding x n Like @code{scale-int}, except that a right shift rounds to the nearest integer rather than truncating. @end defun @defun fixnum n Return the integer @var{n} as a fixnum, i.e., a native Lisp integer. If @var{n} is outside the permissible range for Lisp integers (usually 24 binary bits) the result is undefined. @end defun @defun sqr x Compute the square of @var{x}; short for @samp{(* @var{x} @var{x})}. @end defun @defun quotient x y Divide integer @var{x} by integer @var{y}; return an integer quotient and discard the remainder. If @var{x} or @var{y} is negative, the direction of rounding is undefined. @end defun @defun idiv x y Perform an integer division; if @var{x} and @var{y} are both nonnegative integers, this uses the @code{quotient} function, otherwise it computes @samp{floor(@var{x}/@var{y})}. Thus the result is well-defined but slower than for @code{quotient}. @end defun @defun imod x y Divide integer @var{x} by integer @var{y}; return the integer remainder and discard the quotient. Like @code{quotient}, this works only for integer arguments and is not well-defined for negative arguments. For a more well-defined result, use @samp{(% @var{x} @var{y})}. @end defun @defun idivmod x y Divide integer @var{x} by integer @var{y}; return a cons cell whose @code{car} is @samp{(quotient @var{x} @var{y})} and whose @code{cdr} is @samp{(imod @var{x} @var{y})}.@refill @end defun @defun pow x y Compute @var{x} to the power @var{y}. In @code{defmath} code, this can also be written @samp{(^ @var{x} @var{y})} or @w{@samp{(expt @var{x} @var{y})}}.@refill @end defun @defun abs-approx x Compute a fast approximation to the absolute value of @var{x}. For example, for a rectangular complex number the result is the sum of the absolute values of the components. @end defun @findex two-pi @findex pi-over-2 @findex pi-over-4 @findex pi-over-180 @findex sqrt-two-pi @findex sqrt-e @findex e @findex ln-2 @findex ln-10 @defun pi The function @samp{(pi)} computes @samp{pi} to the current precision. Other related constant-generating functions are @code{two-pi}, @code{pi-over-2}, @code{pi-over-4}, @code{pi-over-180}, @code{sqrt-two-pi}, @code{e}, @code{sqrt-e}, @code{ln-2}, and @code{ln-10}. Each function returns a floating-point value in the current precision, and each uses caching so that all calls after the first are essentially free.@refill @end defun @defmac math-defcache @var{func} @var{initial} @var{form} This macro, usually used as a top-level call like @code{defun} or @code{defvar}, defines a new cached constant analogous to @code{pi}, etc. It defines a function @code{func} which returns the requested value; if @var{initial} is non-@code{nil} it must be a @samp{(float @dots{})} form which serves as an initial value for the cache. If @var{func} is called when the cache is empty or does not have enough digits to satisfy the current precision, the Lisp expression @var{form} is evaluated with the current precision increased by four, and the result minus its two least significant digits is stored in the cache. For example, calling @samp{(pi)} with a precision of 30 computes @samp{pi} to 34 digits, rounds it down to 32 digits for future use, then rounds it again to 30 digits for use in the present request.@refill @end defmac @findex half-circle @findex quarter-circle @defun full-circle symb If the current angular mode is Degrees or HMS, this function returns the integer 360. In Radians mode, this function returns either the corresponding value in radians to the current precision, or the formula @samp{2*pi}, depending on the Symbolic Mode. There are also similar function @code{half-circle} and @code{quarter-circle}. @end defun @defun power-of-2 n Compute two to the integer power @var{n}, as a (potentially very large) integer. Powers of two are cached, so only the first call for a particular @var{n} is expensive. @end defun @defun integer-log2 n Compute the base-2 logarithm of @var{n}, which must be an integer which is a power of two. If @var{n} is not a power of two, this function will return @code{nil}. @end defun @defun div-mod a b m Divide @var{a} by @var{b}, modulo @var{m}. This returns @code{nil} if there is no solution, or if any of the arguments are not integers.@refill @end defun @defun pow-mod a b m Compute @var{a} to the power @var{b}, modulo @var{m}. If @var{a}, @var{b}, and @var{m} are integers, this uses an especially efficient algorithm. Otherwise, it simply computes @samp{(% (^ a b) m)}. @end defun @defun isqrt n Compute the integer square root of @var{n}. This is the square root of @var{n} rounded down toward zero, i.e., @samp{floor(sqrt(@var{n}))}. If @var{n} is itself an integer, the computation is especially efficient. @end defun @defun to-hms a ang Convert the argument @var{a} into an HMS form. If @var{ang} is specified, it is the angular mode in which to interpret @var{a}, either @code{deg} or @code{rad}. Otherwise, the current angular mode is used. If @var{a} is already an HMS form it is returned as-is. @end defun @defun from-hms a ang Convert the HMS form @var{a} into a real number. If @var{ang} is specified, it is the angular mode in which to express the result, otherwise the current angular mode is used. If @var{a} is already a real number, it is returned as-is. @end defun @defun to-radians a Convert the number or HMS form @var{a} to radians from the current angular mode. @end defun @defun from-radians a Convert the number @var{a} from radians to the current angular mode. If @var{a} is a formula, this returns the formula @samp{deg(@var{a})}. @end defun @defun to-radians-2 a Like @code{to-radians}, except that in Symbolic Mode a degrees to radians conversion yields a formula like @samp{@var{a}*pi/180}. @end defun @defun from-radians-2 a Like @code{from-radians}, except that in Symbolic Mode a radians to degrees conversion yields a formula like @samp{@var{a}*180/pi}. @end defun @defun random-digit Produce a random base-1000 digit in the range 0 to 999. @end defun @defun random-digits n Produce a random @var{n}-digit integer; this will be an integer in the interval @samp{[0, 10^@var{n})}. @end defun @defun random-float Produce a random float in the interval @samp{[0, 1)}. @end defun @defun prime-test n iters Determine whether the integer @var{n} is prime. Return a list which has one of these forms: @samp{(nil @var{f})} means the number is non-prime because it was found to be divisible by @var{f}; @samp{(nil)} means it was found to be non-prime by table look-up (so no factors are known); @samp{(nil unknown)} means it is definitely non-prime but no factors are known because @var{n} was large enough that Fermat's probabilistic test had to be used; @samp{(t)} means the number is definitely prime; and @samp{(maybe @var{i} @var{p})} means that Fermat's test, after @var{i} iterations, is @var{p} percent sure that the number is prime. The @var{iters} parameter is the number of Fermat iterations to use, in the case that this is necessary. If @code{prime-test} returns ``maybe,'' you can call it again with the same @var{n} to get a greater certainty; @code{prime-test} remembers where it left off.@refill @end defun @defun to-simple-fraction f If @var{f} is a floating-point number which can be represented exactly as a small rational number. return that number, else return @var{f}. For example, 0.75 would be converted to 3:4. This function is very fast. @end defun @defun to-fraction f tol Find a rational approximation to floating-point number @var{f} to within a specified tolerance @var{tol}; this corresponds to the algebraic function @code{frac}, and can be rather slow. @end defun @defun quarter-integer n If @var{n} is an integer or integer-valued float, this function returns zero. If @var{n} is a half-integer (i.e., an integer plus @i{1:2} or 0.5), it returns 2. If @var{n} is a quarter-integer, it returns 1 or 3. If @var{n} is anything else, this function returns @code{nil}. @end defun @node Vector Lisp Functions, Symbolic Lisp Functions, Computational Lisp Functions, Internals @subsubsection Vector Functions @noindent The functions described here perform various operations on vectors and matrices. @defun math-concat x y Do a vector concatenation; this operation is written @samp{@var{x} | @var{y}} in a symbolic formula. @xref{Building Vectors}. @end defun @defun vec-length v Return the length of vector @var{v}. If @var{v} is not a vector, the result is zero. If @var{v} is a matrix, this returns the number of rows in the matrix. @end defun @defun mat-dimens m Determine the dimensions of vector or matrix @var{m}. If @var{m} is not a vector, the result is an empty list. If @var{m} is a plain vector but not a matrix, the result is a one-element list containing the length of the vector. If @var{m} is a matrix with @var{r} rows and @var{c} columns, the result is the list @samp{(@var{r} @var{c})}. Higher-order tensors produce lists of more than two dimensions. Note that the object @samp{[[1, 2, 3], [4, 5]]} is a vector of vectors not all the same size, and is treated by this and other Calc routines as a plain vector of two elements.@refill @end defun @defun dimension-error Abort the current function with a message of ``Dimension error.'' The Calculator will leave the function being evaluated in symbolic form; this is really just a special case of @code{reject-arg}. @end defun @defun build-vector args Return a Calc vector with the zero-or-more @var{args} as elements. For example, @samp{(build-vector 1 2 3)} returns the Calc vector @samp{[1, 2, 3]}, stored internally as the list @samp{(vec 1 2 3)}. @end defun @defun make-vec obj dims Return a Calc vector or matrix all of whose elements are equal to @var{obj}. For example, @samp{(make-vec 27 3 4)} returns a 3x4 matrix filled with 27's. @end defun @defun row-matrix v If @var{v} is a plain vector, convert it into a row matrix, i.e., a matrix whose single row is @var{v}. If @var{v} is already a matrix, leave it alone. @end defun @defun col-matrix v If @var{v} is a plain vector, convert it into a column matrix, i.e., a matrix with each element of @var{v} as a separate row. If @var{v} is already a matrix, leave it alone. @end defun @defun map-vec f v Map the Lisp function @var{f} over the Calc vector @var{v}. For example, @samp{(map-vec 'math-floor v)} returns a vector of the floored components of vector @var{v}. @end defun @defun map-vec-2 f a b Map the Lisp function @var{f} over the two vectors @var{a} and @var{b}. If @var{a} and @var{b} are vectors of equal length, the result is a vector of the results of calling @samp{(@var{f} @var{ai} @var{bi})} for each pair of elements @var{ai} and @var{bi}. If either @var{a} or @var{b} is a scalar, it is matched with each value of the other vector. For example, @samp{(map-vec-2 'math-add v 1)} returns the vector @var{v} with each element increased by one. Note that using @samp{'+} would not work here, since @code{defmath} does not expand function names everywhere, just where they are in the function position of a Lisp expression.@refill @end defun @defun reduce-vec f v Reduce the function @var{f} over the vector @var{v}. For example, if @var{v} is @samp{[10, 20, 30, 40]}, this calls @samp{(f (f (f 10 20) 30) 40)}. If @var{v} is a matrix, this reduces over the rows of @var{v}. @end defun @defun reduce-cols f m Reduce the function @var{f} over the columns of matrix @var{m}. For example, if @var{m} is @samp{[[1, 2], [3, 4], [5, 6]]}, the result is a vector of the two elements @samp{(f (f 1 3) 5)} and @samp{(f (f 2 4) 6)}. @end defun @defun mat-row m n Return the @var{n}th row of matrix @var{m}. This is equivalent to @samp{(elt m n)}. For a slower but safer version, use @code{mrow}. (@xref{Extracting Elements}.) @end defun @defun mat-col m n Return the @var{n}th column of matrix @var{m}, in the form of a vector. The arguments are not checked for correctness. @end defun @defun mat-less-row m n Return a copy of matrix @var{m} with its @var{n}th row deleted. The number @var{n} must be in range from 1 to the number of rows in @var{m}. @end defun @defun mat-less-col m n Return a copy of matrix @var{m} with its @var{n}th column deleted. @end defun @defun transpose m Return the transpose of matrix @var{m}. @end defun @defun flatten-vector v Flatten nested vector @var{v} into a vector of scalars. For example, if @var{v} is @samp{[[1, 2, 3], [4, 5]]} the result is @samp{[1, 2, 3, 4, 5]}. @end defun @defun copy-matrix m If @var{m} is a matrix, return a copy of @var{m}. This maps @code{copy-sequence} over the rows of @var{m}; in Lisp terms, each element of the result matrix will be @code{eq} to the corresponding element of @var{m}, but none of the @code{cons} cells that make up the structure of the matrix will be @code{eq}. If @var{m} is a plain vector, this is the same as @code{copy-sequence}.@refill @end defun @defun swap-rows m r1 r2 Exchange rows @var{r1} and @var{r2} of matrix @var{m} in-place. In other words, unlike most of the other functions described here, this function changes @var{m} itself rather than building up a new result matrix. The return value is @var{m}, i.e., @samp{(eq (swap-rows m 1 2) m)} is true, with the side effect of exchanging the first two rows of @var{m}.@refill @end defun @node Symbolic Lisp Functions, Formatting Lisp Functions, Vector Lisp Functions, Internals @subsubsection Symbolic Functions @noindent The functions described here operate on symbolic formulas in the Calculator. @defun calc-prepare-selection num Prepare a stack entry for selection operations. If @var{num} is omitted, the stack entry containing the cursor is used; otherwise, it is the number of the stack entry to use. This function stores useful information about the current stack entry into a set of variables. @code{calc-selection-cache-num} contains the number of the stack entry involved (equal to @var{num} if you specified it); @code{calc-selection-cache-entry} contains the stack entry as a list (such as @code{calc-top-list} would return with @code{entry} as the selection mode); and @code{calc-selection-cache-comp} contains a special ``tagged'' composition (@pxref{Formatting Lisp Functions}) which allows Calc to relate cursor positions in the buffer with their corresponding sub-formulas. A slight complication arises in the selection mechanism because formulas may contain small integers. For example, in the vector @samp{[1, 2, 1]} the first and last elements are @code{eq} to each other; selections are recorded as the actual Lisp object that appears somewhere in the tree of the whole formula, but storing @code{1} would falsely select both @code{1}'s in the vector. So @code{calc-prepare-selection} also checks the stack entry and replaces any plain integers with ``complex number'' lists of the form @samp{(cplx @var{n} 0)}. This list will be displayed the same as a plain @var{n} and the change will be completely invisible to the user, but it will guarantee that no two sub-formulas of the stack entry will be @code{eq} to each other. Next time the stack entry is involved in a computation, @code{calc-normalize} will replace these lists with plain numbers again, again invisibly to the user. @end defun @defun calc-encase-atoms x This modifies the formula @var{x} to ensure that each part of the formula is a unique atom, using the @samp{(cplx @var{n} 0)} trick described above. This function may use @code{setcar} to modify the formula in-place. @end defun @defun calc-find-selected-part Find the smallest sub-formula of the current formula that contains the cursor. This assumes @code{calc-prepare-selection} has been called already. If the cursor is not actually on any part of the formula, this returns @code{nil}. @end defun @defun calc-change-current-selection selection Change the currently prepared stack element's selection to @var{selection}, which should be @code{eq} to some sub-formula of the stack element, or @code{nil} to unselect the formula. The stack element's appearance in the Calc buffer is adjusted to reflect the new selection. @end defun @defun calc-find-nth-part expr n Return the @var{n}th sub-formula of @var{expr}. This function is used by the selection commands, and (unless @kbd{j b} has been used) treats sums and products as flat many-element formulas. Thus if @var{expr} is @samp{((a + b) - c) + d}, calling @code{calc-find-nth-part} with @var{n} equal to four will return @samp{d}. @end defun @defun calc-find-parent-formula expr part Return the sub-formula of @var{expr} which immediately contains @var{part}. If @var{expr} is @samp{a*b + (c+1)*d} and @var{part} is @code{eq} to the @samp{c+1} term of @var{expr}, then this function will return @samp{(c+1)*d}. If @var{part} turns out not to be a sub-formula of @var{expr}, the function returns @code{nil}. If @var{part} is @code{eq} to @var{expr}, the function returns @code{t}. This function does not take associativity into account. @end defun @defun calc-find-assoc-parent-formula expr part This is the same as @code{calc-find-parent-formula}, except that (unless @kbd{j b} has been used) it continues widening the selection to contain a complete level of the formula. Given @samp{a} from @samp{((a + b) - c) + d}, @code{calc-find-parent-formula} will return @samp{a + b} but @code{calc-find-assoc-parent-formula} will return the whole expression. @end defun @defun calc-grow-assoc-formula expr part This expands sub-formula @var{part} of @var{expr} to encompass a complete level of the formula. If @var{part} and its immediate parent are not compatible associative operators, or if @kbd{j b} has been used, this simply returns @var{part}. @end defun @defun calc-find-sub-formula expr part This finds the immediate sub-formula of @var{expr} which contains @var{part}. It returns an index @var{n} such that @samp{(calc-find-nth-part @var{expr} @var{n})} would return @var{part}. If @var{part} is not a sub-formula of @var{expr}, it returns @code{nil}. If @var{part} is @code{eq} to @var{expr}, it returns @code{t}. This function does not take associativity into account. @end defun @defun calc-replace-sub-formula expr old new This function returns a copy of formula @var{expr}, with the sub-formula that is @code{eq} to @var{old} replaced by @var{new}. @end defun @defun simplify expr Simplify the expression @var{expr} by applying various algebraic rules. This is what the @w{@kbd{a s}} (@code{calc-simplify}) command uses. This always returns a copy of the expression; the structure @var{expr} points to remains unchanged in memory. More precisely, here is what @code{simplify} does: The expression is first normalized and evaluated by calling @code{normalize}. If any @code{AlgSimpRules} have been defined, they are then applied. Then the expression is traversed in a depth-first, bottom-up fashion; at each level, any simplifications that can be made are made until no further changes are possible. Once the entire formula has been traversed in this way, it is compared with the original formula (from before the call to @code{normalize}) and, if it has changed, the entire procedure is repeated (starting with @code{normalize}) until no further changes occur. Usually only two iterations are needed:@: one to simplify the formula, and another to verify that no further simplifications were possible. @end defun @defun simplify-extended expr Simplify the expression @var{expr}, with additional rules enabled that help do a more thorough job, while not being entirely ``safe'' in all circumstances. (For example, this mode will simplify @samp{sqrt(x^2)} to @samp{x}, which is only valid when @var{x} is positive.) This is implemented by temporarily binding the variable @code{math-living-dangerously} to @code{t} (using a @code{let} form) and calling @code{simplify}. Dangerous simplification rules are written to check this variable before taking any action.@refill @end defun @defun simplify-units expr Simplify the expression @var{expr}, treating variable names as units whenever possible. This works by binding the variable @code{math-simplifying-units} to @code{t} while calling @code{simplify}. @end defun @defmac math-defsimplify funcs body Register a new simplification rule; this is normally called as a top-level form, like @code{defun} or @code{defmath}. If @var{funcs} is a symbol (like @code{+} or @code{calcFunc-sqrt}), this simplification rule is applied to the formulas which are calls to the specified function. Or, @var{funcs} can be a list of such symbols; the rule applies to all functions on the list. The @var{body} is written like the body of a function with a single argument called @code{expr}. The body will be executed with @code{expr} bound to a formula which is a call to one of the functions @var{funcs}. If the function body returns @code{nil}, or if it returns a result @code{equal} to the original @code{expr}, it is ignored and Calc goes on to try the next simplification rule that applies. If the function body returns something different, that new formula is substituted for @var{expr} in the original formula.@refill At each point in the formula, rules are tried in the order of the original calls to @code{math-defsimplify}; the search stops after the first rule that makes a change. Thus later rules for that same function will not have a chance to trigger until the next iteration of the main @code{simplify} loop. Note that, since @code{defmath} is not being used here, @var{body} must be written in true Lisp code without the conveniences that @code{defmath} provides. If you prefer, you can have @var{body} simply call another function (defined with @code{defmath}) which does the real work. The arguments of a function call will already have been simplified before any rules for the call itself are invoked. Since a new argument list is consed up when this happens, this means that the rule's body is allowed to rearrange the function's arguments destructively if that is convenient. Here is a typical example of a simplification rule: @smallexample (math-defsimplify calcFunc-arcsinh (or (and (math-looks-negp (nth 1 expr)) (math-neg (list 'calcFunc-arcsinh (math-neg (nth 1 expr))))) (and (eq (car-safe (nth 1 expr)) 'calcFunc-sinh) (or math-living-dangerously (math-known-realp (nth 1 (nth 1 expr)))) (nth 1 (nth 1 expr))))) @end smallexample This is really a pair of rules written with one @code{math-defsimplify} for convenience; the first replaces @samp{arcsinh(-x)} with @samp{-arcsinh(x)}, and the second, which is safe only for real @samp{x}, replaces @samp{arcsinh(sinh(x))} with @samp{x}.@refill @end defmac @defun common-constant-factor expr Check @var{expr} to see if it is a sum of terms all multiplied by the same rational value. If so, return this value. If not, return @code{nil}. For example, if called on @samp{6x + 9y + 12z}, it would return 3, since 3 is a common factor of all the terms. @end defun @defun cancel-common-factor expr factor Assuming @var{expr} is a sum with @var{factor} as a common factor, divide each term of the sum by @var{factor}. This is done by destructively modifying parts of @var{expr}, on the assumption that it is being used by a simplification rule (where such things are allowed; see above). For example, consider this built-in rule for square roots: @smallexample (math-defsimplify calcFunc-sqrt (let ((fac (math-common-constant-factor (nth 1 expr)))) (and fac (not (eq fac 1)) (math-mul (math-normalize (list 'calcFunc-sqrt fac)) (math-normalize (list 'calcFunc-sqrt (math-cancel-common-factor (nth 1 expr) fac))))))) @end smallexample @end defun @defun frac-gcd a b Compute a ``rational GCD'' of @var{a} and @var{b}, which must both be rational numbers. This is the fraction composed of the GCD of the numerators of @var{a} and @var{b}, over the GCD of the denominators. It is used by @code{common-constant-factor}. Note that the standard @code{gcd} function uses the LCM to combine the denominators.@refill @end defun @defun map-tree func expr many Try applying Lisp function @var{func} to various sub-expressions of @var{expr}. Initially, call @var{func} with @var{expr} itself as an argument. If this returns an expression which is not @code{equal} to @var{expr}, apply @var{func} again until eventually it does return @var{expr} with no changes. Then, if @var{expr} is a function call, recursively apply @var{func} to each of the arguments. This keeps going until no changes occur anywhere in the expression; this final expression is returned by @code{map-tree}. Note that, unlike simplification rules, @var{func} functions may @emph{not} make destructive changes to @var{expr}. If a third argument @var{many} is provided, it is an integer which says how many times @var{func} may be applied; the default, as described above, is infinitely many times.@refill @end defun @defun compile-rewrites rules Compile the rewrite rule set specified by @var{rules}, which should be a formula that is either a vector or a variable name. If the latter, the compiled rules are saved so that later @code{compile-rules} calls for that same variable can return immediately. If there are problems with the rules, this function calls @code{error} with a suitable message. @end defun @defun apply-rewrites expr crules heads Apply the compiled rewrite rule set @var{crules} to the expression @var{expr}. This will make only one rewrite and only checks at the top level of the expression. The result @code{nil} if no rules matched, or if the only rules that matched did not actually change the expression. The @var{heads} argument is optional; if is given, it should be a list of all function names that (may) appear in @var{expr}. The rewrite compiler tags each rule with the rarest-looking function name in the rule; if you specify @var{heads}, @code{apply-rewrites} can use this information to narrow its search down to just a few rules in the rule set. @end defun @defun rewrite-heads expr Compute a @var{heads} list for @var{expr} suitable for use with @code{apply-rewrites}, as discussed above. @end defun @defun rewrite expr rules many This is an all-in-one rewrite function. It compiles the rule set specified by @var{rules}, then uses @code{map-tree} to apply the rules throughout @var{expr} up to @var{many} (default infinity) times. @end defun @defun match-patterns pat vec not-flag Given a Calc vector @var{vec} and an uncompiled pattern set or pattern set variable @var{pat}, this function returns a new vector of all elements of @var{vec} which do (or don't, if @var{not-flag} is non-@code{nil}) match any of the patterns in @var{pat}. @end defun @defun deriv expr var value symb Compute the derivative of @var{expr} with respect to variable @var{var} (which may actually be any sub-expression). If @var{value} is specified, the derivative is evaluated at the value of @var{var}; otherwise, the derivative is left in terms of @var{var}. If the expression contains functions for which no derivative formula is known, new derivative functions are invented by adding primes to the names; @pxref{Calculus}. However, if @var{symb} is non-@code{nil}, the presence of undifferentiable functions in @var{expr} instead cancels the whole differentiation, and @code{deriv} returns @code{nil} instead. Derivatives of an @var{n}-argument function can be defined by adding a @code{math-derivative-@var{n}} property to the property list of the symbol for the function's derivative, which will be the function name followed by an apostrophe. The value of the property should be a Lisp function; it is called with the same arguments as the original function call that is being differentiated. It should return a formula for the derivative. For example, the derivative of @code{ln} is defined by @smallexample (put 'calcFunc-ln\' 'math-derivative-1 (function (lambda (u) (math-div 1 u)))) @end smallexample The two-argument @code{log} function has two derivatives, @smallexample (put 'calcFunc-log\' 'math-derivative-2 ; d(log(x,b)) / dx (function (lambda (x b) ... ))) (put 'calcFunc-log\'2 'math-derivative-2 ; d(log(x,b)) / db (function (lambda (x b) ... ))) @end smallexample @end defun @defun tderiv expr var value symb Compute the total derivative of @var{expr}. This is the same as @code{deriv}, except that variables other than @var{var} are not assumed to be constant with respect to @var{var}. @end defun @defun integ expr var low high Compute the integral of @var{expr} with respect to @var{var}. @xref{Calculus}, for further details. @end defun @defmac math-defintegral funcs body Define a rule for integrating a function or functions of one argument; this macro is very similar in format to @code{math-defsimplify}. The main difference is that here @var{body} is the body of a function with a single argument @code{u} which is bound to the argument to the function being integrated, not the function call itself. Also, the variable of integration is available as @code{math-integ-var}. If evaluation of the integral requires doing further integrals, the body should call @samp{(math-integral @var{x})} to find the integral of @var{x} with respect to @code{math-integ-var}; this function returns @code{nil} if the integral could not be done. Some examples: @smallexample (math-defintegral calcFunc-conj (let ((int (math-integral u))) (and int (list 'calcFunc-conj int)))) (math-defintegral calcFunc-cos (and (equal u math-integ-var) (math-from-radians-2 (list 'calcFunc-sin u)))) @end smallexample In the @code{cos} example, we define only the integral of @samp{cos(x) dx}, relying on the general integration-by-substitution facility to handle cosines of more complicated arguments. An integration rule should return @code{nil} if it can't do the integral; if several rules are defined for the same function, they are tried in order until one returns a non-@code{nil} result.@refill @end defmac @defmac math-defintegral-2 funcs body Define a rule for integrating a function or functions of two arguments. This is exactly analogous to @code{math-defintegral}, except that @var{body} is written as the body of a function with two arguments, @var{u} and @var{v}.@refill @end defmac @defun solve-for lhs rhs var full Attempt to solve the equation @samp{@var{lhs} = @var{rhs}} by isolating the variable @var{var} on the lefthand side; return the resulting righthand side, or @code{nil} if the equation cannot be solved. The variable @var{var} must appear at least once in @var{lhs} or @var{rhs}. Note that the return value is a formula which does not contain @var{var}; this is different from the user-level @code{solve} and @code{finv} functions, which return a rearranged equation or a functional inverse, respectively. If @var{full} is non-@code{nil}, a full solution including dummy signs and dummy integers will be produced. User-defined inverses are provided as properties in a manner similar to derivatives:@refill @smallexample (put 'calcFunc-ln 'math-inverse (function (lambda (x) (list 'calcFunc-exp x)))) @end smallexample This function can call @samp{(math-solve-get-sign @var{x})} to create a new arbitrary sign variable, returning @var{x} times that sign, and @samp{(math-solve-get-int @var{x})} to create a new arbitrary integer variable multiplied by @var{x}. These functions simply return @var{x} if the caller requested a non-``full'' solution. @end defun @defun solve-eqn expr var full This version of @code{solve-for} takes an expression which will typically be an equation or inequality. (If it is not, it will be interpreted as the equation @samp{@var{expr} = 0}.) It returns an equation or inequality, or @code{nil} if no solution could be found. @end defun @defun solve-system exprs vars full This function solves a system of equations. Generally, @var{exprs} and @var{vars} will be vectors of equal length. @xref{Solving Systems of Equations}, for other options. @end defun @defun expr-contains expr var Returns a non-@code{nil} value if @var{var} occurs as a subexpression of @var{expr}. This function might seem at first to be identical to @code{calc-find-sub-formula}. The key difference is that @code{expr-contains} uses @code{equal} to test for matches, whereas @code{calc-find-sub-formula} uses @code{eq}. In the formula @samp{f(a, a)}, the two @samp{a}s will be @code{equal} but not @code{eq} to each other.@refill @end defun @defun expr-contains-count expr var Returns the number of occurrences of @var{var} as a subexpression of @var{expr}, or @code{nil} if there are no occurrences.@refill @end defun @defun expr-depends expr var Returns true if @var{expr} refers to any variable the occurs in @var{var}. In other words, it checks if @var{expr} and @var{var} have any variables in common. @end defun @defun expr-contains-vars expr Return true if @var{expr} contains any variables, or @code{nil} if @var{expr} contains only constants and functions with constant arguments. @end defun @defun expr-subst expr old new Returns a copy of @var{expr}, with all occurrences of @var{old} replaced by @var{new}. This treats @code{lambda} forms specially with respect to the dummy argument variables, so that the effect is always to return @var{expr} evaluated at @var{old} = @var{new}.@refill @end defun @defun multi-subst expr old new This is like @code{expr-subst}, except that @var{old} and @var{new} are lists of expressions to be substituted simultaneously. If one list is shorter than the other, trailing elements of the longer list are ignored. @end defun @defun expr-weight expr Returns the ``weight'' of @var{expr}, basically a count of the total number of objects and function calls that appear in @var{expr}. For ``primitive'' objects, this will be one. @end defun @defun expr-height expr Returns the ``height'' of @var{expr}, which is the deepest level to which function calls are nested. (Note that @samp{@var{a} + @var{b}} counts as a function call.) For primitive objects, this returns zero.@refill @end defun @defun polynomial-p expr var Check if @var{expr} is a polynomial in variable (or sub-expression) @var{var}. If so, return the degree of the polynomial, that is, the highest power of @var{var} that appears in @var{expr}. For example, for @samp{(x^2 + 3)^3 + 4} this would return 6. This function returns @code{nil} unless @var{expr}, when expanded out by @kbd{a x} (@code{calc-expand}), would consist of a sum of terms in which @var{var} appears only raised to nonnegative integer powers. Note that if @var{var} does not occur in @var{expr}, then @var{expr} is considered a polynomial of degree 0.@refill @end defun @defun is-polynomial expr var degree loose Check if @var{expr} is a polynomial in variable or sub-expression @var{var}, and, if so, return a list representation of the polynomial where the elements of the list are coefficients of successive powers of @var{var}: @samp{@var{a} + @var{b} x + @var{c} x^3} would produce the list @samp{(@var{a} @var{b} 0 @var{c})}, and @samp{(x + 1)^2} would produce the list @samp{(1 2 1)}. The highest element of the list will be non-zero, with the special exception that if @var{expr} is the constant zero, the returned value will be @samp{(0)}. Return @code{nil} if @var{expr} is not a polynomial in @var{var}. If @var{degree} is specified, this will not consider polynomials of degree higher than that value. This is a good precaution because otherwise an input of @samp{(x+1)^1000} will cause a huge coefficient list to be built. If @var{loose} is non-@code{nil}, then a looser definition of a polynomial is used in which coefficients are no longer required not to depend on @var{var}, but are only required not to take the form of polynomials themselves. For example, @samp{sin(x) x^2 + cos(x)} is a loose polynomial with coefficients @samp{((calcFunc-cos x) 0 (calcFunc-sin x))}. The result will never be @code{nil} in loose mode, since any expression can be interpreted as a ``constant'' loose polynomial.@refill @end defun @defun polynomial-base expr pred Check if @var{expr} is a polynomial in any variable that occurs in it; if so, return that variable. (If @var{expr} is a multivariate polynomial, this chooses one variable arbitrarily.) If @var{pred} is specified, it should be a Lisp function which is called as @samp{(@var{pred} @var{subexpr})}, and which should return true if @code{mpb-top-expr} (a global name for the original @var{expr}) is a suitable polynomial in @var{subexpr}. The default predicate uses @samp{(polynomial-p mpb-top-expr @var{subexpr})}; you can use @var{pred} to specify additional conditions. Or, you could have @var{pred} build up a list of every suitable @var{subexpr} that is found.@refill @end defun @defun poly-simplify poly Simplify polynomial coefficient list @var{poly} by (destructively) clipping off trailing zeros. @end defun @defun poly-mix a ac b bc Mix two polynomial lists @var{a} and @var{b} (in the form returned by @code{is-polynomial}) in a linear combination with coefficient expressions @var{ac} and @var{bc}. The result is a (not necessarily simplified) polynomial list representing @samp{@var{ac} @var{a} + @var{bc} @var{b}}.@refill @end defun @defun poly-mul a b Multiply two polynomial coefficient lists @var{a} and @var{b}. The result will be in simplified form if the inputs were simplified. @end defun @defun build-polynomial-expr poly var Construct a Calc formula which represents the polynomial coefficient list @var{poly} applied to variable @var{var}. The @kbd{a c} (@code{calc-collect}) command uses @code{is-polynomial} to turn an expression into a coefficient list, then @code{build-polynomial-expr} to turn the list back into an expression in regular form.@refill @end defun @defun check-unit-name var Check if @var{var} is a variable which can be interpreted as a unit name. If so, return the units table entry for that unit. This will be a list whose first element is the unit name (not counting prefix characters) as a symbol and whose second element is the Calc expression which defines the unit. (Refer to the Calc sources for details on the remaining elements of this list.) If @var{var} is not a variable or is not a unit name, return @code{nil}. @end defun @defun units-in-expr-p expr sub-exprs Return true if @var{expr} contains any variables which can be interpreted as units. If @var{sub-exprs} is @code{t}, the entire expression is searched. If @var{sub-exprs} is @code{nil}, this checks whether @var{expr} is directly a units expression.@refill @end defun @defun single-units-in-expr-p expr Check whether @var{expr} contains exactly one units variable. If so, return the units table entry for the variable. If @var{expr} does not contain any units, return @code{nil}. If @var{expr} contains two or more units, return the symbol @code{wrong}. @end defun @defun to-standard-units expr which Convert units expression @var{expr} to base units. If @var{which} is @code{nil}, use Calc's native base units. Otherwise, @var{which} can specify a units system, which is a list of two-element lists, where the first element is a Calc base symbol name and the second is an expression to substitute for it.@refill @end defun @defun remove-units expr Return a copy of @var{expr} with all units variables replaced by ones. This expression is generally normalized before use. @end defun @defun extract-units expr Return a copy of @var{expr} with everything but units variables replaced by ones. @end defun @node Formatting Lisp Functions, Hooks, Symbolic Lisp Functions, Internals @subsubsection I/O and Formatting Functions @noindent The functions described here are responsible for parsing and formatting Calc numbers and formulas. @defun calc-eval str sep arg1 arg2 @dots{} This is the simplest interface to the Calculator from another Lisp program. @xref{Calling Calc from Your Programs}. @end defun @defun read-number str If string @var{str} contains a valid Calc number, either integer, fraction, float, or HMS form, this function parses and returns that number. Otherwise, it returns @code{nil}. @end defun @defun read-expr str Read an algebraic expression from string @var{str}. If @var{str} does not have the form of a valid expression, return a list of the form @samp{(error @var{pos} @var{msg})} where @var{pos} is an integer index into @var{str} of the general location of the error, and @var{msg} is a string describing the problem.@refill @end defun @defun read-exprs str Read a list of expressions separated by commas, and return it as a Lisp list. If an error occurs in any expressions, an error list as shown above is returned instead. @end defun @defun calc-do-alg-entry initial prompt no-norm Read an algebraic formula or formulas using the minibuffer. All conventions of regular algebraic entry are observed. The return value is a list of Calc formulas; there will be more than one if the user entered a list of values separated by commas. The result is @code{nil} if the user presses Return with a blank line. If @var{initial} is given, it is a string which the minibuffer will initially contain. If @var{prompt} is given, it is the prompt string to use; the default is ``Algebraic:''. If @var{no-norm} is @code{t}, the formulas will be returned exactly as parsed; otherwise, they will be passed through @code{calc-normalize} first.@refill To support the use of @kbd{$} characters in the algebraic entry, use @code{let} to bind @code{calc-dollar-values} to a list of the values to be substituted for @kbd{$}, @kbd{$$}, and so on, and bind @code{calc-dollar-used} to 0. Upon return, @code{calc-dollar-used} will have been changed to the highest number of consecutive @kbd{$}s that actually appeared in the input.@refill @end defun @defun format-number a Convert the real or complex number or HMS form @var{a} to string form. @end defun @defun format-flat-expr a prec Convert the arbitrary Calc number or formula @var{a} to string form, in the style used by the trail buffer and the @code{calc-edit} command. This is a simple format designed mostly to guarantee the string is of a form that can be re-parsed by @code{read-expr}. Most formatting modes, such as digit grouping, complex number format, and point character, are ignored to ensure the result will be re-readable. The @var{prec} parameter is normally 0; if you pass a large integer like 1000 instead, the expression will be surrounded by parentheses unless it is a plain number or variable name.@refill @end defun @defun format-nice-expr a width This is like @code{format-flat-expr} (with @var{prec} equal to 0), except that newlines will be inserted to keep lines down to the specified @var{width}, and vectors that look like matrices or rewrite rules are written in a pseudo-matrix format. The @code{calc-edit} command uses this when only one stack entry is being edited. @end defun @defun format-value a width Convert the Calc number or formula @var{a} to string form, using the format seen in the stack buffer. Beware the the string returned may not be re-readable by @code{read-expr}, for example, because of digit grouping. Multi-line objects like matrices produce strings that contain newline characters to separate the lines. The @var{w} parameter, if given, is the target window size for which to format the expressions. If @var{w} is omitted, the width of the Calculator window is used.@refill @end defun @defun compose-expr a prec Format the Calc number or formula @var{a} according to the current language mode, returning a ``composition.'' To learn about the structure of compositions, see the comments in the Calc source code. You can specify the format of a given type of function call by putting a @code{math-compose-@var{lang}} property on the function's symbol, whose value is a Lisp function that takes @var{a} and @var{prec} as arguments and returns a composition. Here @var{lang} is a language mode name, one of @code{normal}, @code{big}, @code{c}, @code{pascal}, @code{fortran}, @code{tex}, @code{eqn}, @code{math}, or @code{maple}. In Big mode, Calc actually tries @code{math-compose-big} first, then tries @code{math-compose-normal}. If this property does not exist, or if the function returns @code{nil}, the function is written in the normal function-call notation for that language. @end defun @defun composition-to-string c w Convert a composition structure returned by @code{compose-expr} into a string. Multi-line compositions convert to strings containing newline characters. The target window size is given by @var{w}. The @code{format-value} function basically calls @code{compose-expr} followed by @code{composition-to-string}. @end defun @defun comp-width c Compute the width in characters of composition @var{c}. @end defun @defun comp-height c Compute the height in lines of composition @var{c}. @end defun @defun comp-ascent c Compute the portion of the height of composition @var{c} which is on or above the baseline. For a one-line composition, this will be one. @end defun @defun comp-descent c Compute the portion of the height of composition @var{c} which is below the baseline. For a one-line composition, this will be zero. @end defun @defun comp-first-char c If composition @var{c} is a ``flat'' composition, return the first (leftmost) character of the composition as an integer. Otherwise, return @code{nil}.@refill @end defun @defun comp-last-char c If composition @var{c} is a ``flat'' composition, return the last (rightmost) character, otherwise return @code{nil}. @end defun @comment @node Lisp Variables, Hooks, Formatting Lisp Functions, Internals @comment @subsubsection Lisp Variables @comment @comment @noindent @comment (This section is currently unfinished.) @node Hooks, , Formatting Lisp Functions, Internals @subsubsection Hooks @noindent Hooks are variables which contain Lisp functions (or lists of functions) which are called at various times. Calc defines a number of hooks that help you to customize it in various ways. Calc uses the Lisp function @code{run-hooks} to invoke the hooks shown below. Several other customization-related variables are also described here. @defvar calc-load-hook This hook is called at the end of @file{calc.el}, after the file has been loaded, before any functions in it have been called, but after @code{calc-mode-map} and similar variables have been set up. @end defvar @defvar calc-ext-load-hook This hook is called at the end of @file{calc-ext.el}. @end defvar @defvar calc-start-hook This hook is called as the last step in a @kbd{M-x calc} command. At this point, the Calc buffer has been created and initialized if necessary, the Calc window and trail window have been created, and the ``Welcome to Calc'' message has been displayed. @end defvar @defvar calc-mode-hook This hook is called when the Calc buffer is being created. Usually this will only happen once per Emacs session. The hook is called after Emacs has switched to the new buffer, the mode-settings file has been read if necessary, and all other buffer-local variables have been set up. After this hook returns, Calc will perform a @code{calc-refresh} operation, set up the mode line display, then evaluate any deferred @code{calc-define} properties that have not been evaluated yet. @end defvar @defvar calc-trail-mode-hook This hook is called when the Calc Trail buffer is being created. It is called as the very last step of setting up the Trail buffer. Like @code{calc-mode-hook}, this will normally happen only once per Emacs session. @end defvar @defvar calc-end-hook This hook is called by @code{calc-quit}, generally because the user presses @kbd{q} or @kbd{M-# c} while in Calc. The Calc buffer will be the current buffer. The hook is called as the very first step, before the Calc window is destroyed. @end defvar @defvar calc-window-hook If this hook exists, it is called to create the Calc window. Upon return, this new Calc window should be the current window. (The Calc buffer will already be the current buffer when the hook is called.) If the hook is not defined, Calc will generally use @code{split-window}, @code{set-window-buffer}, and @code{select-window} to create the Calc window. @end defvar @defvar calc-trail-window-hook If this hook exists, it is called to create the Calc Trail window. The variable @code{calc-trail-buffer} will contain the buffer which the window should use. Unlike @code{calc-window-hook}, this hook must @emph{not} switch into the new window. @end defvar @defvar calc-edit-mode-hook This hook is called by @code{calc-edit} (and the other ``edit'' commands) when the temporary editing buffer is being created. The buffer will have been selected and set up to be in @code{calc-edit-mode}, but will not yet have been filled with text. (In fact it may still have leftover text from a previous @code{calc-edit} command.) @end defvar @defvar calc-mode-save-hook This hook is called by the @code{calc-save-modes} command, after Calc's own mode features have been inserted into the @file{.emacs} buffer and just before the ``End of mode settings'' message is inserted. @end defvar @defvar calc-reset-hook This hook is called after @kbd{M-# 0} (@code{calc-reset}) has reset all modes. The Calc buffer will be the current buffer. @end defvar @defvar calc-other-modes This variable contains a list of strings. The strings are concatenated at the end of the modes portion of the Calc mode line (after standard modes such as ``Deg'', ``Inv'' and ``Hyp''). Each string should be a short, single word followed by a space. The variable is @code{nil} by default. @end defvar @defvar calc-mode-map This is the keymap that is used by Calc mode. The best time to adjust it is probably in a @code{calc-mode-hook}. If the Calc extensions package (@file{calc-ext.el}) has not yet been loaded, many of these keys will be bound to @code{calc-missing-key}, which is a command that loads the extensions package and ``retypes'' the key. If your @code{calc-mode-hook} rebinds one of these keys, it will probably be overridden when the extensions are loaded. @end defvar @defvar calc-digit-map This is the keymap that is used during numeric entry. Numeric entry uses the minibuffer, but this map binds every non-numeric key to @code{calcDigit-nondigit} which generally calls @code{exit-minibuffer} and ``retypes'' the key. @end defvar @defvar calc-alg-ent-map This is the keymap that is used during algebraic entry. This is mostly a copy of @code{minibuffer-local-map}. @end defvar @defvar calc-store-var-map This is the keymap that is used during entry of variable names for commands like @code{calc-store} and @code{calc-recall}. This is mostly a copy of @code{minibuffer-local-completion-map}. @end defvar @defvar calc-edit-mode-map This is the (sparse) keymap used by @code{calc-edit} and other temporary editing commands. It binds @key{RET}, @key{LFD}, and @kbd{C-c C-c} to @code{calc-edit-finish}. @end defvar @defvar calc-mode-var-list This is a list of variables which are saved by @code{calc-save-modes}. Each entry is a list of two items, the variable (as a Lisp symbol) and its default value. When modes are being saved, each variable is compared with its default value (using @code{equal}) and any non-default variables are written out. @end defvar @defvar calc-local-var-list This is a list of variables which should be buffer-local to the Calc buffer. Each entry is a variable name (as a Lisp symbol). These variables also have their default values manipulated by the @code{calc} and @code{calc-quit} commands; @pxref{Multiple Calculators}. Since @code{calc-mode-hook} is called after this list has been used the first time, your hook should add a variable to the list and also call @code{make-local-variable} itself. @end defvar @node Installation, Reporting Bugs, Programming, Top @appendix Installation @noindent Calc 2.02 comes as a set of GNU Emacs Lisp files, with names like @file{calc.el} and @file{calc-ext.el}, and also as a @file{calc.texinfo} file which can be used to generate both on-line and printed documentation.@refill To install Calc, just follow these simple steps. If you want more information, each step is discussed at length in the sections below. @enumerate @item Change (@samp{cd}) to the Calc ``home'' directory. This directory was created when you unbundled the Calc @file{.tar} or @file{.shar} file. @item Type @samp{make} to install Calc privately for your own use, or type @samp{make install} to install Calc system-wide. This will compile all the Calc component files, modify your @file{.emacs} or the system-wide @file{lisp/default} file to install Calc as appropriate, and format the on-line Calc manual. @noindent Both variants are shorthand for the following three steps: @itemize @bullet @item @pindex calc-compile @samp{make compile} to run the byte-compiler. @item @samp{make private} or @samp{make public}, corresponding to @samp{make} and @samp{make install}, respectively. (If @samp{make public} fails because your system doesn't already have a @file{default} or @file{default.el} file, use Emacs or the Unix @code{touch} command to create a zero-sized one first.) @item @samp{make info} to format the on-line Calc manual. This first tries to use the @file{makeinfo} program; if that program is not present, it uses the Emacs @code{texinfo-format-buffer} command instead. @end itemize @noindent The Unix @code{make} utility looks in the file @file{Makefile} in the current directory to see what Unix commands correspond to the various ``targets'' like @code{install} or @code{public}. If your system doesn't have @code{make}, you will have to examine the @file{Makefile} and type in the corresponding commands by hand. @item If you ever move Calc to a new home directory, just give the @samp{make private} or @samp{make public} command again in the new directory. @item Test your installation as described at the end of these instructions. @item (Optional.) To print a hardcopy of the Calc manual (over 500 pages) or just the Calc Summary (about 20 pages), follow the instructions under ``Printed Documentation'' below. @end enumerate @noindent Calc is now installed and ready to go! @example @end example @iftex @node Installation 2, foo, bar, spam @end iftex @appendixsec Upgrading from Calc 1.07 @noindent If you have Calc version 1.07 or earlier, you will find that Calc 2.00 is organized quite differently. For one, Calc 2.00 is now distributed already split into many parts; formerly this was done as part of the installation procedure. Also, some new functions must be autoloaded and the @kbd{M-#} key must be bound to @code{calc-dispatch} instead of to @code{calc}. The easiest way to upgrade is to delete your old Calc files and then install Calc 2.00 from scratch using the above instructions. You should then go into your @file{.emacs} or @file{default} file and remove the old @code{autoload} and @code{global-set-key} commands for Calc, since @samp{make public}/@samp{make private} has added new, better ones. See the @file{README} and @file{README.prev} files in the Calc distribution for more information about what has changed since version 1.07. (@file{README.prev} describes changes before 2.00, and is present only in the FTP and tape versions of the distribution.) @ifinfo @example @end example @end ifinfo @appendixsec The @samp{make public} Command @noindent If you are not the regular Emacs administrator on your system, your account may not be allowed to execute the @samp{make public} command, since the system-wide @file{default} file may be write-protected. If this is the case, you will have to ask your Emacs installer to execute this command. (Just @code{cd} to the Calc home directory and type @samp{make public}.) The @samp{make private} command adds exactly the same set of commands to your @file{.emacs} file as @samp{make public} adds to @file{default}. If your Emacs installer is concerned about typing this command out of the blue, you can ask her/him instead to copy the necessary text from your @file{.emacs} file. (It will be marked by a comment that says ``Commands added by @code{calc-private-autoloads} on (date and time).'') @ifinfo @example @end example @end ifinfo @appendixsec Compilation @noindent Calc is written in a way that maximizes performance when its code has been byte-compiled; a side effect is that performance is seriously degraded if it @emph{isn't} compiled. Thus, it is essential to compile the Calculator before trying to use it. The function @samp{calc-compile} in the file @file{calc-maint.el} runs the Emacs byte-compiler on all the Calc source files. (Specifically, it runs @kbd{M-x byte-compile-file} on all files in the current directory with names of the form @file{calc*.el}, and also on the file @file{macedit.el}.) If @code{calc-compile} finds that certain files have already been compiled and have not been changed since, then it will not bother to recompile those files. The @code{calc-compile} command also pre-builds certain tables, such as the units table (@pxref{The Units Table}) and the built-in rewrite rules (@pxref{Rearranging with Selections}) which Calc would otherwise need to rebuild every time those features were used. The @samp{make compile} shell command is simply a convenient way to start an Emacs and give it a @code{calc-compile} command. @ifinfo @example @end example @end ifinfo @appendixsec Auto-loading @noindent To teach Emacs how to load in Calc when you type @kbd{M-#} for the first time, add these lines to your @file{.emacs} file (if you are installing Calc just for your own use), or the system's @file{lisp/default} file (if you are installing Calc publicly). The @samp{make private} and @samp{make public} commands, respectively, take care of this. (Note that @samp{make} runs @samp{make private}, and @samp{make install} runs @samp{make public}.) @smallexample (autoload 'calc-dispatch "calc" "Calculator Options" t) (autoload 'full-calc "calc" "Full-screen Calculator" t) (autoload 'full-calc-keypad "calc" "Full-screen X Calculator" t) (autoload 'calc-eval "calc" "Use Calculator from Lisp") (autoload 'defmath "calc" nil t t) (autoload 'calc "calc" "Calculator Mode" t) (autoload 'quick-calc "calc" "Quick Calculator" t) (autoload 'calc-keypad "calc" "X windows Calculator" t) (autoload 'calc-embedded "calc" "Use Calc from any buffer" t) (autoload 'calc-embedded-activate "calc" "Activate =>'s in buffer" t) (autoload 'calc-grab-region "calc" "Grab region of Calc data" t) (autoload 'calc-grab-rectangle "calc" "Grab rectangle of data" t) @end smallexample @vindex load-path Unless you have installed the Calc files in Emacs' main @file{lisp/} directory, you will also have to add a command that looks like the following to tell Emacs where to find them. In this example, we have put the files in directory @file{/usr/gnu/src/calc-2.00}. @smallexample (setq load-path (append load-path (list "/usr/gnu/src/calc-2.00"))) @end smallexample @noindent The @samp{make public} and @samp{make private} commands also do this (they use the then-current directory as the name to add to the path). If you move Calc to a new location, just repeat the @samp{make public} or @samp{make private} command to have this new location added to the @code{load-path}.@refill The @code{autoload} command for @code{calc-dispatch} is what loads @file{calc.elc} when you type @kbd{M-#}. It is the only @code{autoload} that is absolutely necessary for Calc to work. The others are for commands and features that you may wish to use before typing @kbd{M-#} for the first time. In particular, @code{full-calc} and @code{full-calc-keypad} are autoloaded to support ``standalone'' operation (@pxref{Standalone Operation}), @code{calc-eval} and @code{defmath} are autoloaded to allow other Emacs Lisp programs to use Calc facilities (@pxref{Calling Calc from Your Programs}), and @code{calc-embedded-activate} is autoloaded because some Embedded Mode files may call it as soon as they are read into Emacs (@pxref{Assignments in Embedded Mode}). @ifinfo @example @end example @end ifinfo @appendixsec Finding Component Files @noindent There is no need to write @code{autoload} commands that point to all the various Calc component files like @file{calc-misc.elc} and @file{calc-alg.elc}. The main file, @file{calc.elc}, contains all the necessary @code{autoload} commands for these files. (Actually, to conserve space @file{calc.elc} only autoloads a few of the component files, plus @file{calc-ext.elc}, which in turn autoloads the rest of the components. This allows Calc to load a little faster in the beginning, but the net effect is the same.) This autoloading mechanism assumes that all the component files can be found on the @code{load-path}. The @samp{make public} and @samp{make private} commands take care of this, but Calc has a few other strategies in case you have installed it in an unusual way. If, when Calc is loaded, it is unable to find its components on the @code{load-path} it is given, it checks the file name in the original @code{autoload} command for @code{calc-dispatch}. If that name included directory information, Calc adds that directory to the @code{load-path}: @example (autoload 'calc-dispatch "calc-2.00/calc" "Calculator" t) @end example @noindent Suppose the directory @file{/usr/gnu/src/emacs/lisp} is on the path, and the above @code{autoload} allows Emacs to find Calc under the name @file{/usr/gnu/src/emacs/lisp/calc-2.00/calc.elc}. Then when Calc starts up it will add @file{/usr/gnu/src/emacs/lisp/calc-2.00} to the path so that it will later be able to find its component files. @vindex calc-autoload-directory If the above strategy does not locate the component files, Calc examines the variable @code{calc-autoload-directory}. This is initially @code{nil}, but you can store the name of Calc's home directory in it as a sure-fire way of getting Calc to find its components. @ifinfo @example @end example @end ifinfo @appendixsec Merging Source Files @noindent If the @code{autoload} mechanism is not managing to load each part of Calc when it is needed, you can concatenate all the @file{.el} files into one big file. The order should be @file{calc.el}, then @file{calc-ext.el}, then all the other files in any order. Byte-compile the resulting big file. This merged Calculator ought to work just like Calc normally does, though it will be @emph{substantially} slower to load.@refill @ifinfo @example @end example @end ifinfo @appendixsec Key Bindings @noindent Calc is normally bound to the @kbd{M-#} key. To set up this key binding, include the following command in your @file{.emacs} or @file{lisp/default} file. (This is done automatically by @samp{make private} or @samp{make public}, respectively.) @smallexample (global-set-key "\e#" 'calc-dispatch) @end smallexample Note that @code{calc-dispatch} actually works as a prefix for various two-key sequences. If you have a convenient unused function key on your keyboard, you may wish to bind @code{calc-dispatch} to that as well. You may even wish to bind other specific Calc functions like @code{calc} or @code{quick-calc} to other handy function keys. Even if you bind @code{calc-dispatch} to other keys, it is best to bind it to @kbd{M-#} as well if you possibly can: There are references to @kbd{M-#} all throughout the Calc manual which would confuse novice users if they didn't work as advertised. @vindex calc-scan-for-dels Another key binding issue is the @key{DEL} key. Some installations use a different key (such as backspace) for this purpose. Calc normally scans the entire keymap and maps all keys defined like @key{DEL} to the @code{calc-pop} command. However, this may be slow. You can set the variable @code{calc-scan-for-dels} to @code{nil} to cause only the actual @key{DEL} key to be mapped to @code{calc-pop}; this will speed loading of Calc. @ifinfo @example @end example @end ifinfo @appendixsec The @file{macedit} Package @noindent The file @file{macedit.el} contains another useful Emacs extension called @code{edit-kbd-macro}. It allows you to edit a keyboard macro in human-readable form. The @kbd{Z E} command in Calc knows how to use it to edit user commands that have been defined by keyboard macros. To autoload it, you will want to include the commands, @smallexample (autoload 'edit-kbd-macro "macedit" "Edit Keyboard Macro" t) (autoload 'edit-last-kbd-macro "macedit" "Edit Keyboard Macro" t) (autoload 'read-kbd-macro "macedit" "Read Keyboard Macro" t) @end smallexample @noindent The @samp{make public} and @samp{make private} commands do this. @ifinfo @example @end example @end ifinfo @appendixsec The GNUPLOT Program @noindent Calc's graphing commands use the GNUPLOT program. If you have GNUPLOT but you must type some command other than @file{gnuplot} to get it, you should add a command to set the Lisp variable @code{calc-gnuplot-name} to the appropriate file name. You may also need to change the variables @code{calc-gnuplot-plot-command} and @code{calc-gnuplot-print-command} in order to get correct displays and hardcopies, respectively, of your plots.@refill @ifinfo @example @end example @end ifinfo @appendixsec On-Line Documentation @noindent The documentation for Calc (this manual) comes in a file called @file{calc.texinfo}. To format this for use as an on-line manual, type @samp{make info} (to use the @code{makeinfo} program), or @samp{make texinfo} (to use the @code{texinfmt.el} program which runs inside of Emacs). The former command is recommended if it works on your system; it is faster and produces nicer-looking output. The @code{makeinfo} program will report inconsistencies involving the nodes ``Copying'' and ``Interactive Tutorial''; these messages should be ignored. The result will be a collection of files whose names begin with @file{calc.info}. You may wish to add a reference to the first of these, @file{calc.info} itself, to your Info system's @file{dir} file. (This is optional since the @kbd{M-# i} command can access @file{calc.info} whether or not it appears in the @file{dir} file.) @vindex calc-info-filename There is a Lisp variable called @code{calc-info-filename} which holds the name of the Info file containing Calc's on-line documentation. Its default value is @code{"calc.info"}, which will work correctly if the Info files are stored in Emacs' main @file{info/} directory, or if they are in any of the directories listed in the @code{load-path}. If you keep them elsewhere, you will want to put a command of the form, @smallexample (setq calc-info-filename ".../calc.info") @end smallexample @noindent in your @file{.emacs} or @file{lisp/default} file, where @file{...} represents the directory containing the Info files. This will not be necessary if you follow the normal installation procedures. The @samp{make info} and @samp{make texinfo} commands compare the dates on the files @file{calc.texinfo} and @file{calc.info}, and run the appropriate program only if the latter file is older or does not exist. @ifinfo @example @end example @end ifinfo @appendixsec Printed Documentation @noindent Because the Calc manual is so large, you should only make a printed copy if you really need it. To print the manual, you will need the @TeX{} typesetting program (this is a free program by Donald Knuth at Stanford University) as well as the @file{texindex} program and @file{texinfo.tex} file, both of which can be obtained from the FSF as part of the @code{texinfo2} package.@refill To print the Calc manual in one huge 550 page tome, type @samp{make tex}. This will take care of running the manual through @TeX{} twice so that references to later parts of the manual will have correct page numbers. (Don't worry if you get some ``overfull box'' warnings.) The result will be a device-independent output file called @file{calc.dvi}, which you must print in whatever way is right for your system. On many systems, the command is @example lpr -d calc.dvi @end example @cindex Marginal notes, adjusting Marginal notes for each function and key sequence normally alternate between the left and right sides of the page, which is correct if the manual is going to be bound as double-sided pages. Near the top of the file @file{calc.texinfo} you will find alternate definitions of the @code{\bumpoddpages} macro that put the marginal notes always on the same side, best if you plan to be binding single-sided pages. @pindex calc-split-manual Some people find the Calc manual to be too large to handle easily. In fact, some versions of @TeX{} have too little memory to print it. So Calc includes a @code{calc-split-manual} command that splits @file{calc.texinfo} into two volumes, the Calc Tutorial and the Calc Reference. The easiest way to use it is to type @samp{make tex2} instead of @samp{make tex}. The result will be two smaller files, @file{calctut.dvi} and @file{calcref.dvi}. The former contains the tutorial part of the manual; the latter contains the reference part. Both volumes include copies of the ``Getting Started'' chapter and licensing information. To save disk space, you may wish to delete @file{calctut.*} and @file{calcref.*} after you're done. Don't delete @file{calc.texinfo}, because you will need it to install future patches to Calc. The @samp{make tex2} command takes care of all of this for you. The @samp{make textut} command formats only the Calc Tutorial volume, producing @file{calctut.dvi} but not @file{calcref.dvi}. Likewise, @samp{make texref} formats only the Calc Reference volume. @pindex calc-split-summary Finally, there is a @code{calc-split-summary} command that splits off just the Calc Summary appendix suitable for printing by itself. Type @samp{make summary} instead of @samp{make tex}. The resulting @file{calcsum.dvi} file will print in less than 20 pages. If the Key Index file @file{calc.ky} is present, left over from a previous @samp{make tex} command, then @samp{make summary} will insert a column of page numbers into the summary using that information. The @samp{make isummary} command is like @samp{make summary}, but it prints a summary that is designed to be substituted into the regular manual. (The two summaries will be identical except for the additional column of page numbers.) To make a complete manual, run @samp{make tex} and @samp{make isummary}, print the two resulting @file{.dvi} files, then discard the Summary pages that came from @file{calc.dvi} and insert the ones from @file{calcsum.dvi} in their place. Also, remember that the table of contents prints at the end of the manual but should generally be moved to the front (after the title and copyright pages). If you don't have @TeX{}, you can print the summary as a plain text file by going to the ``Summary'' node in Calc's Info file, then typing @kbd{M-x print-buffer} (@pxref{Summary}). @ifinfo @example @end example @end ifinfo @appendixsec Settings File @noindent @vindex calc-settings-file Another variable you might want to set is @code{calc-settings-file}, which holds the file name in which commands like @kbd{m m} and @kbd{Z P} store ``permanent'' definitions. The default value for this variable is @code{"~/.emacs"}. If @code{calc-settings-file} does not contain @code{".emacs"} as a substring, and if the variable @code{calc-loaded-settings-file} is @code{nil}, then Calc will automatically load your settings file (if it exists) the first time Calc is invoked.@refill @ifinfo @example @end example @end ifinfo @appendixsec Testing the Installation @noindent To test your installation of Calc, start a new Emacs and type @kbd{M-# c} to make sure the autoloads and key bindings work. Type @kbd{M-# i} to make sure Calc can find its Info documentation. Press @kbd{q} to exit the Info system and @kbd{M-# c} to re-enter the Calculator. Type @kbd{20 S} to compute the sine of 20 degrees; this will test the autoloading of the extensions modules. The result should be 0.342020143326. Finally, press @kbd{M-# c} again to make sure the Calculator can exit. You may also wish to test the GNUPLOT interface; to plot a sine wave, type @kbd{' [0 ..@: 360], sin(x) RET g f}. Type @kbd{g q} when you are done viewing the plot. Calc is now ready to use. If you wish to go through the Calc Tutorial, press @kbd{M-# t} to begin. @example @end example @noindent (The above text is included in both the Calc documentation and the file INSTALL in the Calc distribution directory.) @node Reporting Bugs, Summary, Installation, Top @appendix Reporting Bugs @noindent If you find a bug in Calc, send e-mail to Dave Gillespie, @example daveg@@synaptics.com @r{or} daveg@@csvax.cs.caltech.edu @end example @noindent While I cannot guarantee that I will have time to work on your bug, I do try to fix bugs quickly whenever I can. You can obtain a current version of Calc from anonymous FTP on @samp{csvax.cs.caltech.edu} in @samp{pub/calc-@var{version}.tar.Z}. Calc is also available on the GNU machine, @samp{prep.ai.mit.edu}. Patches are posted to the @samp{comp.sources.misc} Usenet group, and are also available on @code{csvax}. There is an automatic @kbd{M-x report-calc-bug} command which helps you to report bugs. This command prompts you for a brief subject line, then leaves you in a mail editing buffer. Type @kbd{C-c C-c} to send your mail. Make sure your subject line indicates that you are reporting a Calc bug; this command sends mail to my regular mailbox. If you have suggestions for additional features for Calc, I would love to hear them. Some have dared to suggest that Calc is already top-heavy with features; I really don't see what they're talking about, so, if you have ideas, send them right in. (I may even have time to implement them!) At the front of the source file, @file{calc.el}, is a list of ideas for future work which I have not had time to do. If any enthusiastic souls wish to take it upon themselves to work on these, I would be delighted. Please let me know if you plan to contribute to Calc so I can coordinate your efforts with mine and those of others. I will do my best to help you in whatever way I can. @c [summary] @node Summary, Key Index, Reporting Bugs, Top @appendix Calc Summary @noindent This section includes a complete list of Calc 2.02 keystroke commands. Each line lists the stack entries used by the command (top-of-stack last), the keystrokes themselves, the prompts asked by the command, and the result of the command (also with top-of-stack last). The result is expressed using the equivalent algebraic function. Commands which put no results on the stack show the full @kbd{M-x} command name in that position. Numbers preceding the result or command name refer to notes at the end. Algebraic functions and @kbd{M-x} commands that don't have corresponding keystrokes are not listed in this summary. @xref{Command Index}. @xref{Function Index}. @iftex @begingroup @tex \vskip-2\baselineskip \null \gdef\sumrow#1{\sumrowx#1\relax}% \gdef\sumrowx#1\:#2\:#3\:#4\:#5\:#6\relax{% \leavevmode% \hbox to5em{\indsl\hss#1}% \hbox to5em{\ninett#2\hss}% \hbox to4em{\indsl#3\hss}% \hbox to5em{\indrm\hss#4}% \thinspace% {\ninett#5}% {\indsl#6}% }% \gdef\sumlpar{{\indrm(}}% \gdef\sumrpar{{\indrm)}}% \gdef\sumcomma{{\indrm,\thinspace}}% \gdef\sumexcl{{\indrm!}}% \gdef\sumbreak{\vskip-2.5\baselineskip\goodbreak}% \gdef\minus#1{{\tt-}}% @end tex @let@:=@sumsep @let@r=@sumrow @catcode`@(=@active @let(=@sumlpar @catcode`@)=@active @let)=@sumrpar @catcode`@,=@active @let,=@sumcomma @catcode`@!=@active @let!=@sumexcl @end iftex @format @iftex @advance@baselineskip-2.5pt @let@tt@ninett @let@c@sumbreak @end iftex @r{ @: M-# a @: @: 33 @:calc-embedded-activate@:} @r{ @: M-# b @: @: @:calc-big-or-small@:} @r{ @: M-# c @: @: @:calc@:} @r{ @: M-# d @: @: @:calc-embedded-duplicate@:} @r{ @: M-# e @: @: 34 @:calc-embedded@:} @r{ @: M-# f @:formula @: @:calc-embedded-new-formula@:} @r{ @: M-# g @: @: 35 @:calc-grab-region@:} @r{ @: M-# i @: @: @:calc-info@:} @r{ @: M-# j @: @: @:calc-embedded-select@:} @r{ @: M-# k @: @: @:calc-keypad@:} @r{ @: M-# l @: @: @:calc-load-everything@:} @r{ @: M-# m @: @: @:read-kbd-macro@:} @r{ @: M-# n @: @: 4 @:calc-embedded-next@:} @r{ @: M-# o @: @: @:calc-other-window@:} @r{ @: M-# p @: @: 4 @:calc-embedded-previous@:} @r{ @: M-# q @:formula @: @:quick-calc@:} @r{ @: M-# r @: @: 36 @:calc-grab-rectangle@:} @r{ @: M-# s @: @: @:calc-info-summary@:} @r{ @: M-# t @: @: @:calc-tutorial@:} @r{ @: M-# u @: @: @:calc-embedded-update@:} @r{ @: M-# w @: @: @:calc-embedded-word@:} @r{ @: M-# x @: @: @:calc-quit@:} @r{ @: M-# y @: @:1,28,49 @:calc-copy-to-buffer@:} @r{ @: M-# z @: @: @:calc-user-invocation@:} @r{ @: M-# : @: @: 36 @:calc-grab-sum-down@:} @r{ @: M-# _ @: @: 36 @:calc-grab-sum-across@:} @r{ @: M-# ` @:editing @: 30 @:calc-embedded-edit@:} @r{ @: M-# 0 @:(zero) @: @:calc-reset@:} @c @r{ @: 0-9 @:number @: @:@:number} @r{ @: . @:number @: @:@:0.number} @r{ @: _ @:number @: @:-@:number} @r{ @: e @:number @: @:@:1e number} @r{ @: # @:number @: @:@:current-radix@t{#}number} @r{ @: P @:(in number) @: @:+/-@:} @r{ @: M @:(in number) @: @:mod@:} @r{ @: @@ ' " @: (in number)@: @:@:HMS form} @r{ @: h m s @: (in number)@: @:@:HMS form} @c @r{ @: ' @:formula @: 37,46 @:@:formula} @r{ @: $ @:formula @: 37,46 @:$@:formula} @r{ @: " @:string @: 37,46 @:@:string} @c @r{ a b@: + @: @: 2 @:add@:(a,b) a+b} @r{ a b@: - @: @: 2 @:sub@:(a,b) a@minus{}b} @r{ a b@: * @: @: 2 @:mul@:(a,b) a b, a*b} @r{ a b@: / @: @: 2 @:div@:(a,b) a/b} @r{ a b@: ^ @: @: 2 @:pow@:(a,b) a^b} @r{ a b@: I ^ @: @: 2 @:nroot@:(a,b) a^(1/b)} @r{ a b@: % @: @: 2 @:mod@:(a,b) a%b} @r{ a b@: \ @: @: 2 @:idiv@:(a,b) a\b} @r{ a b@: : @: @: 2 @:fdiv@:(a,b)} @r{ a b@: | @: @: 2 @:vconcat@:(a,b) a|b} @r{ a b@: I | @: @: @:vconcat@:(b,a) b|a} @r{ a b@: H | @: @: 2 @:append@:(a,b)} @r{ a b@: I H | @: @: @:append@:(b,a)} @r{ a@: & @: @: 1 @:inv@:(a) 1/a} @r{ a@: ! @: @: 1 @:fact@:(a) a!} @r{ a@: = @: @: 1 @:evalv@:(a)} @r{ a@: M-% @: @: @:percent@:(a) a%} @c @r{ ... a@: RET @: @: 1 @:@:... a a} @r{ ... a@: SPC @: @: 1 @:@:... a a} @r{... a b@: TAB @: @: 3 @:@:... b a} @r{. a b c@: M-TAB @: @: 3 @:@:... b c a} @r{... a b@: LFD @: @: 1 @:@:... a b a} @r{ ... a@: DEL @: @: 1 @:@:...} @r{... a b@: M-DEL @: @: 1 @:@:... b} @r{ @: M-RET @: @: 4 @:calc-last-args@:} @r{ a@: ` @:editing @: 1,30 @:calc-edit@:} @c @r{ ... a@: C-d @: @: 1 @:@:...} @r{ @: C-k @: @: 27 @:calc-kill@:} @r{ @: C-w @: @: 27 @:calc-kill-region@:} @r{ @: C-y @: @: @:calc-yank@:} @r{ @: C-_ @: @: 4 @:calc-undo@:} @r{ @: M-k @: @: 27 @:calc-copy-as-kill@:} @r{ @: M-w @: @: 27 @:calc-copy-region-as-kill@:} @c @r{ @: [ @: @: @:@:[...} @r{[.. a b@: ] @: @: @:@:[a,b]} @r{ @: ( @: @: @:@:(...} @r{(.. a b@: ) @: @: @:@:(a,b)} @r{ @: , @: @: @:@:vector or rect complex} @r{ @: ; @: @: @:@:matrix or polar complex} @r{ @: .. @: @: @:@:interval} @c @r{ @: ~ @: @: @:calc-num-prefix@:} @r{ @: < @: @: 4 @:calc-scroll-left@:} @r{ @: > @: @: 4 @:calc-scroll-right@:} @r{ @: @{ @: @: 4 @:calc-scroll-down@:} @r{ @: @} @: @: 4 @:calc-scroll-up@:} @r{ @: ? @: @: @:calc-help@:} @c @r{ a@: n @: @: 1 @:neg@:(a) @minus{}a} @r{ @: o @: @: 4 @:calc-realign@:} @r{ @: p @:precision @: 31 @:calc-precision@:} @r{ @: q @: @: @:calc-quit@:} @r{ @: w @: @: @:calc-why@:} @r{ @: x @:command @: @:M-x calc-@:command} @r{ a@: y @: @:1,28,49 @:calc-copy-to-buffer@:} @c @r{ a@: A @: @: 1 @:abs@:(a)} @r{ a b@: B @: @: 2 @:log@:(a,b)} @r{ a b@: I B @: @: 2 @:alog@:(a,b) b^a} @r{ a@: C @: @: 1 @:cos@:(a)} @r{ a@: I C @: @: 1 @:arccos@:(a)} @r{ a@: H C @: @: 1 @:cosh@:(a)} @r{ a@: I H C @: @: 1 @:arccosh@:(a)} @r{ @: D @: @: 4 @:calc-redo@:} @r{ a@: E @: @: 1 @:exp@:(a)} @r{ a@: H E @: @: 1 @:exp10@:(a) 10.^a} @r{ a@: F @: @: 1,11 @:floor@:(a,d)} @r{ a@: I F @: @: 1,11 @:ceil@:(a,d)} @r{ a@: H F @: @: 1,11 @:ffloor@:(a,d)} @r{ a@: I H F @: @: 1,11 @:fceil@:(a,d)} @r{ a@: G @: @: 1 @:arg@:(a)} @r{ @: H @:command @: 32 @:@:Hyperbolic} @r{ @: I @:command @: 32 @:@:Inverse} @r{ a@: J @: @: 1 @:conj@:(a)} @r{ @: K @:command @: 32 @:@:Keep-args} @r{ a@: L @: @: 1 @:ln@:(a)} @r{ a@: H L @: @: 1 @:log10@:(a)} @r{ @: M @: @: @:calc-more-recursion-depth@:} @r{ @: I M @: @: @:calc-less-recursion-depth@:} @r{ a@: N @: @: 5 @:evalvn@:(a)} @r{ @: P @: @: @:@:pi} @r{ @: I P @: @: @:@:gamma} @r{ @: H P @: @: @:@:e} @r{ @: I H P @: @: @:@:phi} @r{ a@: Q @: @: 1 @:sqrt@:(a)} @r{ a@: I Q @: @: 1 @:sqr@:(a) a^2} @r{ a@: R @: @: 1,11 @:round@:(a,d)} @r{ a@: I R @: @: 1,11 @:trunc@:(a,d)} @r{ a@: H R @: @: 1,11 @:fround@:(a,d)} @r{ a@: I H R @: @: 1,11 @:ftrunc@:(a,d)} @r{ a@: S @: @: 1 @:sin@:(a)} @r{ a@: I S @: @: 1 @:arcsin@:(a)} @r{ a@: H S @: @: 1 @:sinh@:(a)} @r{ a@: I H S @: @: 1 @:arcsinh@:(a)} @r{ a@: T @: @: 1 @:tan@:(a)} @r{ a@: I T @: @: 1 @:arctan@:(a)} @r{ a@: H T @: @: 1 @:tanh@:(a)} @r{ a@: I H T @: @: 1 @:arctanh@:(a)} @r{ @: U @: @: 4 @:calc-undo@:} @r{ @: X @: @: 4 @:calc-call-last-kbd-macro@:} @c @r{ a b@: a = @: @: 2 @:eq@:(a,b) a=b} @r{ a b@: a # @: @: 2 @:neq@:(a,b) a!=b} @r{ a b@: a < @: @: 2 @:lt@:(a,b) a @: @: 2 @:gt@:(a,b) a>b} @r{ a b@: a [ @: @: 2 @:leq@:(a,b) a<=b} @r{ a b@: a ] @: @: 2 @:geq@:(a,b) a>=b} @r{ a b@: a @{ @: @: 2 @:in@:(a,b)} @r{ a b@: a & @: @: 2,45 @:land@:(a,b) a&&b} @r{ a b@: a | @: @: 2,45 @:lor@:(a,b) a||b} @r{ a@: a ! @: @: 1,45 @:lnot@:(a) !a} @r{ a b c@: a : @: @: 45 @:if@:(a,b,c) a?b:c} @r{ a@: a . @: @: 1 @:rmeq@:(a)} @r{ a@: a " @: @: 7,8 @:calc-expand-formula@:} @c @r{ a@: a + @:i, l, h @: 6,38 @:sum@:(a,i,l,h)} @r{ a@: a - @:i, l, h @: 6,38 @:asum@:(a,i,l,h)} @r{ a@: a * @:i, l, h @: 6,38 @:prod@:(a,i,l,h)} @r{ a b@: a _ @: @: 2 @:subscr@:(a,b) a_b} @c @r{ a b@: a \ @: @: 2 @:pdiv@:(a,b)} @r{ a b@: a % @: @: 2 @:prem@:(a,b)} @r{ a b@: a / @: @: 2 @:pdivrem@:(a,b) [q,r]} @r{ a b@: H a / @: @: 2 @:pdivide@:(a,b) q+r/b} @c @r{ a@: a a @: @: 1 @:apart@:(a)} @r{ a@: a b @:old, new @: 38 @:subst@:(a,old,new)} @r{ a@: a c @:v @: 38 @:collect@:(a,v)} @r{ a@: a d @:v @: 4,38 @:deriv@:(a,v)} @r{ a@: H a d @:v @: 4,38 @:tderiv@:(a,v)} @r{ a@: a e @: @: @:esimplify@:(a)} @r{ a@: a f @: @: 1 @:factor@:(a)} @r{ a@: H a f @: @: 1 @:factors@:(a)} @r{ a b@: a g @: @: 2 @:pgcd@:(a,b)} @r{ a@: a i @:v @: 38 @:integ@:(a,v)} @r{ a@: a m @:pats @: 38 @:match@:(a,pats)} @r{ a@: I a m @:pats @: 38 @:matchnot@:(a,pats)} @r{ data x@: a p @: @: 28 @:polint@:(data,x)} @r{ data x@: H a p @: @: 28 @:ratint@:(data,x)} @r{ a@: a n @: @: 1 @:nrat@:(a)} @r{ a@: a r @:rules @:4,8,38 @:rewrite@:(a,rules,n)} @r{ a@: a s @: @: @:simplify@:(a)} @r{ a@: a t @:v, n @: 31,39 @:taylor@:(a,v,n)} @r{ a@: a v @: @: 7,8 @:calc-alg-evaluate@:} @r{ a@: a x @: @: 4,8 @:expand@:(a)} @c @r{ data@: a F @:model, vars @: 48 @:fit@:(m,iv,pv,data)} @r{ data@: I a F @:model, vars @: 48 @:xfit@:(m,iv,pv,data)} @r{ data@: H a F @:model, vars @: 48 @:efit@:(m,iv,pv,data)} @r{ a@: a I @:v, l, h @: 38 @:ninteg@:(a,v,l,h)} @r{ a b@: a M @:op @: 22 @:mapeq@:(op,a,b)} @r{ a b@: I a M @:op @: 22 @:mapeqr@:(op,a,b)} @r{ a b@: H a M @:op @: 22 @:mapeqp@:(op,a,b)} @r{ a g@: a N @:v @: 38 @:minimize@:(a,v,g)} @r{ a g@: H a N @:v @: 38 @:wminimize@:(a,v,g)} @r{ a@: a P @:v @: 38 @:roots@:(a,v)} @r{ a g@: a R @:v @: 38 @:root@:(a,v,g)} @r{ a g@: H a R @:v @: 38 @:wroot@:(a,v,g)} @r{ a@: a S @:v @: 38 @:solve@:(a,v)} @r{ a@: I a S @:v @: 38 @:finv@:(a,v)} @r{ a@: H a S @:v @: 38 @:fsolve@:(a,v)} @r{ a@: I H a S @:v @: 38 @:ffinv@:(a,v)} @r{ a@: a T @:i, l, h @: 6,38 @:table@:(a,i,l,h)} @r{ a g@: a X @:v @: 38 @:maximize@:(a,v,g)} @r{ a g@: H a X @:v @: 38 @:wmaximize@:(a,v,g)} @c @r{ a b@: b a @: @: 9 @:and@:(a,b,w)} @r{ a@: b c @: @: 9 @:clip@:(a,w)} @r{ a b@: b d @: @: 9 @:diff@:(a,b,w)} @r{ a@: b l @: @: 10 @:lsh@:(a,n,w)} @r{ a n@: H b l @: @: 9 @:lsh@:(a,n,w)} @r{ a@: b n @: @: 9 @:not@:(a,w)} @r{ a b@: b o @: @: 9 @:or@:(a,b,w)} @r{ v@: b p @: @: 1 @:vpack@:(v)} @r{ a@: b r @: @: 10 @:rsh@:(a,n,w)} @r{ a n@: H b r @: @: 9 @:rsh@:(a,n,w)} @r{ a@: b t @: @: 10 @:rot@:(a,n,w)} @r{ a n@: H b t @: @: 9 @:rot@:(a,n,w)} @r{ a@: b u @: @: 1 @:vunpack@:(a)} @r{ @: b w @:w @: 9,50 @:calc-word-size@:} @r{ a b@: b x @: @: 9 @:xor@:(a,b,w)} @c @r{c s l p@: b D @: @: @:ddb@:(c,s,l,p)} @r{ r n p@: b F @: @: @:fv@:(r,n,p)} @r{ r n p@: I b F @: @: @:fvb@:(r,n,p)} @r{ r n p@: H b F @: @: @:fvl@:(r,n,p)} @r{ v@: b I @: @: 19 @:irr@:(v)} @r{ v@: I b I @: @: 19 @:irrb@:(v)} @r{ a@: b L @: @: 10 @:ash@:(a,n,w)} @r{ a n@: H b L @: @: 9 @:ash@:(a,n,w)} @r{ r n a@: b M @: @: @:pmt@:(r,n,a)} @r{ r n a@: I b M @: @: @:pmtb@:(r,n,a)} @r{ r n a@: H b M @: @: @:pmtl@:(r,n,a)} @r{ r v@: b N @: @: 19 @:npv@:(r,v)} @r{ r v@: I b N @: @: 19 @:npvb@:(r,v)} @r{ r n p@: b P @: @: @:pv@:(r,n,p)} @r{ r n p@: I b P @: @: @:pvb@:(r,n,p)} @r{ r n p@: H b P @: @: @:pvl@:(r,n,p)} @r{ a@: b R @: @: 10 @:rash@:(a,n,w)} @r{ a n@: H b R @: @: 9 @:rash@:(a,n,w)} @r{ c s l@: b S @: @: @:sln@:(c,s,l)} @r{ n p a@: b T @: @: @:rate@:(n,p,a)} @r{ n p a@: I b T @: @: @:rateb@:(n,p,a)} @r{ n p a@: H b T @: @: @:ratel@:(n,p,a)} @r{c s l p@: b Y @: @: @:syd@:(c,s,l,p)} @r{ r p a@: b # @: @: @:nper@:(r,p,a)} @r{ r p a@: I b # @: @: @:nperb@:(r,p,a)} @r{ r p a@: H b # @: @: @:nperl@:(r,p,a)} @r{ a b@: b % @: @: @:relch@:(a,b)} @c @r{ a@: c c @: @: 5 @:pclean@:(a,p)} @r{ a@: c 0-9 @: @: @:pclean@:(a,p)} @r{ a@: H c c @: @: 5 @:clean@:(a,p)} @r{ a@: H c 0-9 @: @: @:clean@:(a,p)} @r{ a@: c d @: @: 1 @:deg@:(a)} @r{ a@: c f @: @: 1 @:pfloat@:(a)} @r{ a@: H c f @: @: 1 @:float@:(a)} @r{ a@: c h @: @: 1 @:hms@:(a)} @r{ a@: c p @: @: @:polar@:(a)} @r{ a@: I c p @: @: @:rect@:(a)} @r{ a@: c r @: @: 1 @:rad@:(a)} @c @r{ a@: c F @: @: 5 @:pfrac@:(a,p)} @r{ a@: H c F @: @: 5 @:frac@:(a,p)} @c @r{ a@: c % @: @: @:percent@:(a*100)} @c @r{ @: d . @:char @: 50 @:calc-point-char@:} @r{ @: d , @:char @: 50 @:calc-group-char@:} @r{ @: d < @: @: 13,50 @:calc-left-justify@:} @r{ @: d = @: @: 13,50 @:calc-center-justify@:} @r{ @: d > @: @: 13,50 @:calc-right-justify@:} @r{ @: d @{ @:label @: 50 @:calc-left-label@:} @r{ @: d @} @:label @: 50 @:calc-right-label@:} @r{ @: d [ @: @: 4 @:calc-truncate-up@:} @r{ @: d ] @: @: 4 @:calc-truncate-down@:} @r{ @: d " @: @: 12,50 @:calc-display-strings@:} @r{ @: d SPC @: @: @:calc-refresh@:} @r{ @: d RET @: @: 1 @:calc-refresh-top@:} @c @r{ @: d 0 @: @: 50 @:calc-decimal-radix@:} @r{ @: d 2 @: @: 50 @:calc-binary-radix@:} @r{ @: d 6 @: @: 50 @:calc-hex-radix@:} @r{ @: d 8 @: @: 50 @:calc-octal-radix@:} @c @r{ @: d b @: @:12,13,50 @:calc-line-breaking@:} @r{ @: d c @: @: 50 @:calc-complex-notation@:} @r{ @: d d @:format @: 50 @:calc-date-notation@:} @r{ @: d e @: @: 5,50 @:calc-eng-notation@:} @r{ @: d f @:num @: 31,50 @:calc-fix-notation@:} @r{ @: d g @: @:12,13,50 @:calc-group-digits@:} @r{ @: d h @:format @: 50 @:calc-hms-notation@:} @r{ @: d i @: @: 50 @:calc-i-notation@:} @r{ @: d j @: @: 50 @:calc-j-notation@:} @r{ @: d l @: @: 12,50 @:calc-line-numbering@:} @r{ @: d n @: @: 5,50 @:calc-normal-notation@:} @r{ @: d o @:format @: 50 @:calc-over-notation@:} @r{ @: d p @: @: 12,50 @:calc-show-plain@:} @r{ @: d r @:radix @: 31,50 @:calc-radix@:} @r{ @: d s @: @: 5,50 @:calc-sci-notation@:} @r{ @: d t @: @: 27 @:calc-truncate-stack@:} @r{ @: d w @: @: 12,13 @:calc-auto-why@:} @r{ @: d z @: @: 12,50 @:calc-leading-zeros@:} @c @r{ @: d B @: @: 50 @:calc-big-language@:} @r{ @: d C @: @: 50 @:calc-c-language@:} @r{ @: d E @: @: 50 @:calc-eqn-language@:} @r{ @: d F @: @: 50 @:calc-fortran-language@:} @r{ @: d M @: @: 50 @:calc-mathematica-language@:} @r{ @: d N @: @: 50 @:calc-normal-language@:} @r{ @: d O @: @: 50 @:calc-flat-language@:} @r{ @: d P @: @: 50 @:calc-pascal-language@:} @r{ @: d T @: @: 50 @:calc-tex-language@:} @r{ @: d U @: @: 50 @:calc-unformatted-language@:} @r{ @: d W @: @: 50 @:calc-maple-language@:} @c @r{ a@: f [ @: @: 4 @:decr@:(a,n)} @r{ a@: f ] @: @: 4 @:incr@:(a,n)} @c @r{ a b@: f b @: @: 2 @:beta@:(a,b)} @r{ a@: f e @: @: 1 @:erf@:(a)} @r{ a@: I f e @: @: 1 @:erfc@:(a)} @r{ a@: f g @: @: 1 @:gamma@:(a)} @r{ a b@: f h @: @: 2 @:hypot@:(a,b)} @r{ a@: f i @: @: 1 @:im@:(a)} @r{ n a@: f j @: @: 2 @:besJ@:(n,a)} @r{ a b@: f n @: @: 2 @:min@:(a,b)} @r{ a@: f r @: @: 1 @:re@:(a)} @r{ a@: f s @: @: 1 @:sign@:(a)} @r{ a b@: f x @: @: 2 @:max@:(a,b)} @r{ n a@: f y @: @: 2 @:besY@:(n,a)} @c @r{ a@: f A @: @: 1 @:abssqr@:(a)} @r{ x a b@: f B @: @: @:betaI@:(x,a,b)} @r{ x a b@: H f B @: @: @:betaB@:(x,a,b)} @r{ a@: f E @: @: 1 @:expm1@:(a)} @r{ a x@: f G @: @: 2 @:gammaP@:(a,x)} @r{ a x@: I f G @: @: 2 @:gammaQ@:(a,x)} @r{ a x@: H f G @: @: 2 @:gammag@:(a,x)} @r{ a x@: I H f G @: @: 2 @:gammaG@:(a,x)} @r{ a b@: f I @: @: 2 @:ilog@:(a,b)} @r{ a b@: I f I @: @: 2 @:alog@:(a,b) b^a} @r{ a@: f L @: @: 1 @:lnp1@:(a)} @r{ a@: f M @: @: 1 @:mant@:(a)} @r{ a@: f Q @: @: 1 @:isqrt@:(a)} @r{ a@: I f Q @: @: 1 @:sqr@:(a) a^2} @r{ a n@: f S @: @: 2 @:scf@:(a,n)} @r{ y x@: f T @: @: @:arctan2@:(y,x)} @r{ a@: f X @: @: 1 @:xpon@:(a)} @c @r{ x y@: g a @: @: 28,40 @:calc-graph-add@:} @r{ @: g b @: @: 12 @:calc-graph-border@:} @r{ @: g c @: @: @:calc-graph-clear@:} @r{ @: g d @: @: 41 @:calc-graph-delete@:} @r{ x y@: g f @: @: 28,40 @:calc-graph-fast@:} @r{ @: g g @: @: 12 @:calc-graph-grid@:} @r{ @: g h @:title @: @:calc-graph-header@:} @r{ @: g j @: @: 4 @:calc-graph-juggle@:} @r{ @: g k @: @: 12 @:calc-graph-key@:} @r{ @: g l @: @: 12 @:calc-graph-log-x@:} @r{ @: g n @:name @: @:calc-graph-name@:} @r{ @: g p @: @: 42 @:calc-graph-plot@:} @r{ @: g q @: @: @:calc-graph-quit@:} @r{ @: g r @:range @: @:calc-graph-range-x@:} @r{ @: g s @: @: 12,13 @:calc-graph-line-style@:} @r{ @: g t @:title @: @:calc-graph-title-x@:} @r{ @: g v @: @: @:calc-graph-view-commands@:} @r{ @: g x @:display @: @:calc-graph-display@:} @r{ @: g z @: @: 12 @:calc-graph-zero-x@:} @c @r{ x y z@: g A @: @: 28,40 @:calc-graph-add-3d@:} @r{ @: g C @:command @: @:calc-graph-command@:} @r{ @: g D @:device @: 43,44 @:calc-graph-device@:} @r{ x y z@: g F @: @: 28,40 @:calc-graph-fast-3d@:} @r{ @: g H @: @: 12 @:calc-graph-hide@:} @r{ @: g K @: @: @:calc-graph-kill@:} @r{ @: g L @: @: 12 @:calc-graph-log-y@:} @r{ @: g N @:number @: 43,51 @:calc-graph-num-points@:} @r{ @: g O @:filename @: 43,44 @:calc-graph-output@:} @r{ @: g P @: @: 42 @:calc-graph-print@:} @r{ @: g R @:range @: @:calc-graph-range-y@:} @r{ @: g S @: @: 12,13 @:calc-graph-point-style@:} @r{ @: g T @:title @: @:calc-graph-title-y@:} @r{ @: g V @: @: @:calc-graph-view-trail@:} @r{ @: g X @:format @: @:calc-graph-geometry@:} @r{ @: g Z @: @: 12 @:calc-graph-zero-y@:} @c @r{ @: g C-l @: @: 12 @:calc-graph-log-z@:} @r{ @: g C-r @:range @: @:calc-graph-range-z@:} @r{ @: g C-t @:title @: @:calc-graph-title-z@:} @c @r{ @: h b @: @: @:calc-describe-bindings@:} @r{ @: h c @:key @: @:calc-describe-key-briefly@:} @r{ @: h f @:function @: @:calc-describe-function@:} @r{ @: h h @: @: @:calc-full-help@:} @r{ @: h i @: @: @:calc-info@:} @r{ @: h k @:key @: @:calc-describe-key@:} @r{ @: h n @: @: @:calc-view-news@:} @r{ @: h s @: @: @:calc-info-summary@:} @r{ @: h t @: @: @:calc-tutorial@:} @r{ @: h v @:var @: @:calc-describe-variable@:} @c @r{ @: j 1-9 @: @: @:calc-select-part@:} @r{ @: j RET @: @: 27 @:calc-copy-selection@:} @r{ @: j DEL @: @: 27 @:calc-del-selection@:} @r{ @: j ' @:formula @: 27 @:calc-enter-selection@:} @r{ @: j ` @:editing @: 27,30 @:calc-edit-selection@:} @r{ @: j " @: @: 7,27 @:calc-sel-expand-formula@:} @c @r{ @: j + @:formula @: 27 @:calc-sel-add-both-sides@:} @r{ @: j - @:formula @: 27 @:calc-sel-sub-both-sides@:} @r{ @: j * @:formula @: 27 @:calc-sel-mul-both-sides@:} @r{ @: j / @:formula @: 27 @:calc-sel-div-both-sides@:} @r{ @: j & @: @: 27 @:calc-sel-invert@:} @c @r{ @: j a @: @: 27 @:calc-select-additional@:} @r{ @: j b @: @: 12 @:calc-break-selections@:} @r{ @: j c @: @: @:calc-clear-selections@:} @r{ @: j d @: @: 12,50 @:calc-show-selections@:} @r{ @: j e @: @: 12 @:calc-enable-selections@:} @r{ @: j l @: @: 4,27 @:calc-select-less@:} @r{ @: j m @: @: 4,27 @:calc-select-more@:} @r{ @: j n @: @: 4 @:calc-select-next@:} @r{ @: j o @: @: 4,27 @:calc-select-once@:} @r{ @: j p @: @: 4 @:calc-select-previous@:} @r{ @: j r @:rules @:4,8,27 @:calc-rewrite-selection@:} @r{ @: j s @: @: 4,27 @:calc-select-here@:} @r{ @: j u @: @: 27 @:calc-unselect@:} @r{ @: j v @: @: 7,27 @:calc-sel-evaluate@:} @c @r{ @: j C @: @: 27 @:calc-sel-commute@:} @r{ @: j D @: @: 4,27 @:calc-sel-distribute@:} @r{ @: j E @: @: 27 @:calc-sel-jump-equals@:} @r{ @: j I @: @: 27 @:calc-sel-isolate@:} @r{ @: H j I @: @: 27 @:calc-sel-isolate@: (full)} @r{ @: j L @: @: 4,27 @:calc-commute-left@:} @r{ @: j M @: @: 27 @:calc-sel-merge@:} @r{ @: j N @: @: 27 @:calc-sel-negate@:} @r{ @: j O @: @: 4,27 @:calc-select-once-maybe@:} @r{ @: j R @: @: 4,27 @:calc-commute-right@:} @r{ @: j S @: @: 4,27 @:calc-select-here-maybe@:} @r{ @: j U @: @: 27 @:calc-sel-unpack@:} @c @r{ @: k a @: @: @:calc-random-again@:} @r{ n@: k b @: @: 1 @:bern@:(n)} @r{ n x@: H k b @: @: 2 @:bern@:(n,x)} @r{ n m@: k c @: @: 2 @:choose@:(n,m)} @r{ n m@: H k c @: @: 2 @:perm@:(n,m)} @r{ n@: k d @: @: 1 @:dfact@:(n) n!!} @r{ n@: k e @: @: 1 @:euler@:(n)} @r{ n x@: H k e @: @: 2 @:euler@:(n,x)} @r{ n@: k f @: @: 4 @:prfac@:(n)} @r{ n m@: k g @: @: 2 @:gcd@:(n,m)} @r{ m n@: k h @: @: 14 @:shuffle@:(n,m)} @r{ n m@: k l @: @: 2 @:lcm@:(n,m)} @r{ n@: k m @: @: 1 @:moebius@:(n)} @r{ n@: k n @: @: 4 @:nextprime@:(n)} @r{ n@: I k n @: @: 4 @:prevprime@:(n)} @r{ n@: k p @: @: 4,28 @:calc-prime-test@:} @r{ m@: k r @: @: 14 @:random@:(m)} @r{ n m@: k s @: @: 2 @:stir1@:(n,m)} @r{ n m@: H k s @: @: 2 @:stir2@:(n,m)} @r{ n@: k t @: @: 1 @:totient@:(n)} @c @r{ n p x@: k B @: @: @:utpb@:(x,n,p)} @r{ n p x@: I k B @: @: @:ltpb@:(x,n,p)} @r{ v x@: k C @: @: @:utpc@:(x,v)} @r{ v x@: I k C @: @: @:ltpc@:(x,v)} @r{ n m@: k E @: @: @:egcd@:(n,m)} @r{v1 v2 x@: k F @: @: @:utpf@:(x,v1,v2)} @r{v1 v2 x@: I k F @: @: @:ltpf@:(x,v1,v2)} @r{ m s x@: k N @: @: @:utpn@:(x,m,s)} @r{ m s x@: I k N @: @: @:ltpn@:(x,m,s)} @r{ m x@: k P @: @: @:utpp@:(x,m)} @r{ m x@: I k P @: @: @:ltpp@:(x,m)} @r{ v x@: k T @: @: @:utpt@:(x,v)} @r{ v x@: I k T @: @: @:ltpt@:(x,v)} @c @r{ @: m a @: @: 12,13 @:calc-algebraic-mode@:} @r{ @: m d @: @: @:calc-degrees-mode@:} @r{ @: m f @: @: 12 @:calc-frac-mode@:} @r{ @: m g @: @: 52 @:calc-get-modes@:} @r{ @: m h @: @: @:calc-hms-mode@:} @r{ @: m i @: @: 12,13 @:calc-infinite-mode@:} @r{ @: m m @: @: @:calc-save-modes@:} @r{ @: m p @: @: 12 @:calc-polar-mode@:} @r{ @: m r @: @: @:calc-radians-mode@:} @r{ @: m s @: @: 12 @:calc-symbolic-mode@:} @r{ @: m t @: @: 12 @:calc-total-algebraic-mode@:} @r{ @: m v @: @: 12,13 @:calc-matrix-mode@:} @r{ @: m w @: @: 13 @:calc-working@:} @r{ @: m x @: @: @:calc-always-load-extensions@:} @c @r{ @: m A @: @: 12 @:calc-alg-simplify-mode@:} @r{ @: m B @: @: 12 @:calc-bin-simplify-mode@:} @r{ @: m C @: @: 12 @:calc-auto-recompute@:} @r{ @: m D @: @: @:calc-default-simplify-mode@:} @r{ @: m E @: @: 12 @:calc-ext-simplify-mode@:} @r{ @: m F @:filename @: 13 @:calc-settings-file-name@:} @r{ @: m N @: @: 12 @:calc-num-simplify-mode@:} @r{ @: m O @: @: 12 @:calc-no-simplify-mode@:} @r{ @: m R @: @: 12,13 @:calc-mode-record-mode@:} @r{ @: m S @: @: 12 @:calc-shift-prefix@:} @r{ @: m U @: @: 12 @:calc-units-simplify-mode@:} @c @r{ @: s c @:var1, var2 @: 29 @:calc-copy-variable@:} @r{ @: s d @:var, decl @: @:calc-declare-variable@:} @r{ @: s e @:var, editing @: 29,30 @:calc-edit-variable@:} @r{ @: s i @:buffer @: @:calc-insert-variables@:} @r{ a b@: s l @:var @: 29 @:@:a (letting var=b)} @r{ a ...@: s m @:op, var @: 22,29 @:calc-store-map@:} @r{ @: s n @:var @: 29,47 @:calc-store-neg@: (v/-1)} @r{ @: s p @:var @: 29 @:calc-permanent-variable@:} @r{ @: s r @:var @: 29 @:@:v (recalled value)} @r{ @: r 0-9 @: @: @:calc-recall-quick@:} @r{ a@: s s @:var @: 28,29 @:calc-store@:} @r{ a@: s 0-9 @: @: @:calc-store-quick@:} @r{ a@: s t @:var @: 29 @:calc-store-into@:} @r{ a@: t 0-9 @: @: @:calc-store-into-quick@:} @r{ @: s u @:var @: 29 @:calc-unstore@:} @r{ a@: s x @:var @: 29 @:calc-store-exchange@:} @c @r{ @: s A @:editing @: 30 @:calc-edit-AlgSimpRules@:} @r{ @: s D @:editing @: 30 @:calc-edit-Decls@:} @r{ @: s E @:editing @: 30 @:calc-edit-EvalRules@:} @r{ @: s F @:editing @: 30 @:calc-edit-FitRules@:} @r{ @: s G @:editing @: 30 @:calc-edit-GenCount@:} @r{ @: s H @:editing @: 30 @:calc-edit-Holidays@:} @r{ @: s I @:editing @: 30 @:calc-edit-IntegLimit@:} @r{ @: s L @:editing @: 30 @:calc-edit-LineStyles@:} @r{ @: s P @:editing @: 30 @:calc-edit-PointStyles@:} @r{ @: s R @:editing @: 30 @:calc-edit-PlotRejects@:} @r{ @: s T @:editing @: 30 @:calc-edit-TimeZone@:} @r{ @: s U @:editing @: 30 @:calc-edit-Units@:} @r{ @: s X @:editing @: 30 @:calc-edit-ExtSimpRules@:} @c @r{ a@: s + @:var @: 29,47 @:calc-store-plus@: (v+a)} @r{ a@: s - @:var @: 29,47 @:calc-store-minus@: (v-a)} @r{ a@: s * @:var @: 29,47 @:calc-store-times@: (v*a)} @r{ a@: s / @:var @: 29,47 @:calc-store-div@: (v/a)} @r{ a@: s ^ @:var @: 29,47 @:calc-store-power@: (v^a)} @r{ a@: s | @:var @: 29,47 @:calc-store-concat@: (v|a)} @r{ @: s & @:var @: 29,47 @:calc-store-inv@: (v^-1)} @r{ @: s [ @:var @: 29,47 @:calc-store-decr@: (v-1)} @r{ @: s ] @:var @: 29,47 @:calc-store-incr@: (v-(-1))} @r{ a b@: s : @: @: 2 @:assign@:(a,b) a @t{:=} b} @r{ a@: s = @: @: 1 @:evalto@:(a,b) a @t{=>}} @c @r{ @: t [ @: @: 4 @:calc-trail-first@:} @r{ @: t ] @: @: 4 @:calc-trail-last@:} @r{ @: t < @: @: 4 @:calc-trail-scroll-left@:} @r{ @: t > @: @: 4 @:calc-trail-scroll-right@:} @r{ @: t . @: @: 12 @:calc-full-trail-vectors@:} @c @r{ @: t b @: @: 4 @:calc-trail-backward@:} @r{ @: t d @: @: 12,50 @:calc-trail-display@:} @r{ @: t f @: @: 4 @:calc-trail-forward@:} @r{ @: t h @: @: @:calc-trail-here@:} @r{ @: t i @: @: @:calc-trail-in@:} @r{ @: t k @: @: 4 @:calc-trail-kill@:} @r{ @: t m @:string @: @:calc-trail-marker@:} @r{ @: t n @: @: 4 @:calc-trail-next@:} @r{ @: t o @: @: @:calc-trail-out@:} @r{ @: t p @: @: 4 @:calc-trail-previous@:} @r{ @: t r @:string @: @:calc-trail-isearch-backward@:} @r{ @: t s @:string @: @:calc-trail-isearch-forward@:} @r{ @: t y @: @: 4 @:calc-trail-yank@:} @c @r{ d@: t C @:oz, nz @: @:tzconv@:(d,oz,nz)} @r{d oz nz@: t C @:$ @: @:tzconv@:(d,oz,nz)} @r{ d@: t D @: @: 15 @:date@:(d)} @r{ d@: t I @: @: 4 @:incmonth@:(d,n)} @r{ d@: t J @: @: 16 @:julian@:(d,z)} @r{ d@: t M @: @: 17 @:newmonth@:(d,n)} @r{ @: t N @: @: 16 @:now@:(z)} @r{ d@: t P @:1 @: 31 @:year@:(d)} @r{ d@: t P @:2 @: 31 @:month@:(d)} @r{ d@: t P @:3 @: 31 @:day@:(d)} @r{ d@: t P @:4 @: 31 @:hour@:(d)} @r{ d@: t P @:5 @: 31 @:minute@:(d)} @r{ d@: t P @:6 @: 31 @:second@:(d)} @r{ d@: t P @:7 @: 31 @:weekday@:(d)} @r{ d@: t P @:8 @: 31 @:yearday@:(d)} @r{ d@: t P @:9 @: 31 @:time@:(d)} @r{ d@: t U @: @: 16 @:unixtime@:(d,z)} @r{ d@: t W @: @: 17 @:newweek@:(d,w)} @r{ d@: t Y @: @: 17 @:newyear@:(d,n)} @c @r{ a b@: t + @: @: 2 @:badd@:(a,b)} @r{ a b@: t - @: @: 2 @:bsub@:(a,b)} @c @r{ @: u a @: @: 12 @:calc-autorange-units@:} @r{ a@: u b @: @: @:calc-base-units@:} @r{ a@: u c @:units @: 18 @:calc-convert-units@:} @r{ defn@: u d @:unit, descr @: @:calc-define-unit@:} @r{ @: u e @: @: @:calc-explain-units@:} @r{ @: u g @:unit @: @:calc-get-unit-definition@:} @r{ @: u p @: @: @:calc-permanent-units@:} @r{ a@: u r @: @: @:calc-remove-units@:} @r{ a@: u s @: @: @:usimplify@:(a)} @r{ a@: u t @:units @: 18 @:calc-convert-temperature@:} @r{ @: u u @:unit @: @:calc-undefine-unit@:} @r{ @: u v @: @: @:calc-enter-units-table@:} @r{ a@: u x @: @: @:calc-extract-units@:} @r{ a@: u 0-9 @: @: @:calc-quick-units@:} @c @r{ v1 v2@: u C @: @: 20 @:vcov@:(v1,v2)} @r{ v1 v2@: I u C @: @: 20 @:vpcov@:(v1,v2)} @r{ v1 v2@: H u C @: @: 20 @:vcorr@:(v1,v2)} @r{ v@: u G @: @: 19 @:vgmean@:(v)} @r{ a b@: H u G @: @: 2 @:agmean@:(a,b)} @r{ v@: u M @: @: 19 @:vmean@:(v)} @r{ v@: I u M @: @: 19 @:vmeane@:(v)} @r{ v@: H u M @: @: 19 @:vmedian@:(v)} @r{ v@: I H u M @: @: 19 @:vhmean@:(v)} @r{ v@: u N @: @: 19 @:vmin@:(v)} @r{ v@: u S @: @: 19 @:vsdev@:(v)} @r{ v@: I u S @: @: 19 @:vpsdev@:(v)} @r{ v@: H u S @: @: 19 @:vvar@:(v)} @r{ v@: I H u S @: @: 19 @:vpvar@:(v)} @r{ @: u V @: @: @:calc-view-units-table@:} @r{ v@: u X @: @: 19 @:vmax@:(v)} @c @r{ v@: u + @: @: 19 @:vsum@:(v)} @r{ v@: u * @: @: 19 @:vprod@:(v)} @r{ v@: u # @: @: 19 @:vcount@:(v)} @c @r{ @: V ( @: @: 50 @:calc-vector-parens@:} @r{ @: V @{ @: @: 50 @:calc-vector-braces@:} @r{ @: V [ @: @: 50 @:calc-vector-brackets@:} @r{ @: V ] @:ROCP @: 50 @:calc-matrix-brackets@:} @r{ @: V , @: @: 50 @:calc-vector-commas@:} @r{ @: V < @: @: 50 @:calc-matrix-left-justify@:} @r{ @: V = @: @: 50 @:calc-matrix-center-justify@:} @r{ @: V > @: @: 50 @:calc-matrix-right-justify@:} @r{ @: V / @: @: 12,50 @:calc-break-vectors@:} @r{ @: V . @: @: 12,50 @:calc-full-vectors@:} @c @r{ s t@: V ^ @: @: 2 @:vint@:(s,t)} @r{ s t@: V - @: @: 2 @:vdiff@:(s,t)} @r{ s@: V ~ @: @: 1 @:vcompl@:(s)} @r{ s@: V # @: @: 1 @:vcard@:(s)} @r{ s@: V : @: @: 1 @:vspan@:(s)} @r{ s@: V + @: @: 1 @:rdup@:(s)} @c @r{ m@: V & @: @: 1 @:inv@:(m) 1/m} @c @r{ v@: v a @:n @: @:arrange@:(v,n)} @r{ a@: v b @:n @: @:cvec@:(a,n)} @r{ v@: v c @:n >0 @: 21,31 @:mcol@:(v,n)} @r{ v@: v c @:n <0 @: 31 @:mrcol@:(v,-n)} @r{ m@: v c @:0 @: 31 @:getdiag@:(m)} @r{ v@: v d @: @: 25 @:diag@:(v,n)} @r{ v m@: v e @: @: 2 @:vexp@:(v,m)} @r{ v m f@: H v e @: @: 2 @:vexp@:(v,m,f)} @r{ v a@: v f @: @: 26 @:find@:(v,a,n)} @r{ v@: v h @: @: 1 @:head@:(v)} @r{ v@: I v h @: @: 1 @:tail@:(v)} @r{ v@: H v h @: @: 1 @:rhead@:(v)} @r{ v@: I H v h @: @: 1 @:rtail@:(v)} @r{ @: v i @:n @: 31 @:idn@:(1,n)} @r{ @: v i @:0 @: 31 @:idn@:(1)} @r{ h t@: v k @: @: 2 @:cons@:(h,t)} @r{ h t@: H v k @: @: 2 @:rcons@:(h,t)} @r{ v@: v l @: @: 1 @:vlen@:(v)} @r{ v@: H v l @: @: 1 @:mdims@:(v)} @r{ v m@: v m @: @: 2 @:vmask@:(v,m)} @r{ v@: v n @: @: 1 @:rnorm@:(v)} @r{ a b c@: v p @: @: 24 @:calc-pack@:} @r{ v@: v r @:n >0 @: 21,31 @:mrow@:(v,n)} @r{ v@: v r @:n <0 @: 31 @:mrrow@:(v,-n)} @r{ m@: v r @:0 @: 31 @:getdiag@:(m)} @r{ v i j@: v s @: @: @:subvec@:(v,i,j)} @r{ v i j@: I v s @: @: @:rsubvec@:(v,i,j)} @r{ m@: v t @: @: 1 @:trn@:(m)} @r{ v@: v u @: @: 24 @:calc-unpack@:} @r{ v@: v v @: @: 1 @:rev@:(v)} @r{ @: v x @:n @: 31 @:index@:(n)} @r{ n s i@: C-u v x @: @: @:index@:(n,s,i)} @c @r{ v@: V A @:op @: 22 @:apply@:(op,v)} @r{ v1 v2@: V C @: @: 2 @:cross@:(v1,v2)} @r{ m@: V D @: @: 1 @:det@:(m)} @r{ s@: V E @: @: 1 @:venum@:(s)} @r{ s@: V F @: @: 1 @:vfloor@:(s)} @r{ v@: V G @: @: @:grade@:(v)} @r{ v@: I V G @: @: @:rgrade@:(v)} @r{ v@: V H @:n @: 31 @:histogram@:(v,n)} @r{ v w@: H V H @:n @: 31 @:histogram@:(v,w,n)} @r{ v1 v2@: V I @:mop aop @: 22 @:inner@:(mop,aop,v1,v2)} @r{ m@: V J @: @: 1 @:ctrn@:(m)} @r{ m@: V L @: @: 1 @:lud@:(m)} @r{ v@: V M @:op @: 22,23 @:map@:(op,v)} @r{ v@: V N @: @: 1 @:cnorm@:(v)} @r{ v1 v2@: V O @:op @: 22 @:outer@:(op,v1,v2)} @r{ v@: V R @:op @: 22,23 @:reduce@:(op,v)} @r{ v@: I V R @:op @: 22,23 @:rreduce@:(op,v)} @r{ a n@: H V R @:op @: 22 @:nest@:(op,a,n)} @r{ a@: I H V R @:op @: 22 @:fixp@:(op,a)} @r{ v@: V S @: @: @:sort@:(v)} @r{ v@: I V S @: @: @:rsort@:(v)} @r{ m@: V T @: @: 1 @:tr@:(m)} @r{ v@: V U @:op @: 22 @:accum@:(op,v)} @r{ v@: I V U @:op @: 22 @:raccum@:(op,v)} @r{ a n@: H V U @:op @: 22 @:anest@:(op,a,n)} @r{ a@: I H V U @:op @: 22 @:afixp@:(op,a)} @r{ s t@: V V @: @: 2 @:vunion@:(s,t)} @r{ s t@: V X @: @: 2 @:vxor@:(s,t)} @c @r{ @: Y @: @: @:@:user commands} @c @r{ @: z @: @: @:@:user commands} @c @r{ c@: Z [ @: @: 45 @:calc-kbd-if@:} @r{ c@: Z | @: @: 45 @:calc-kbd-else-if@:} @r{ @: Z : @: @: @:calc-kbd-else@:} @r{ @: Z ] @: @: @:calc-kbd-end-if@:} @c @r{ @: Z @{ @: @: 4 @:calc-kbd-loop@:} @r{ c@: Z / @: @: 45 @:calc-kbd-break@:} @r{ @: Z @} @: @: @:calc-kbd-end-loop@:} @r{ n@: Z < @: @: @:calc-kbd-repeat@:} @r{ @: Z > @: @: @:calc-kbd-end-repeat@:} @r{ n m@: Z ( @: @: @:calc-kbd-for@:} @r{ s@: Z ) @: @: @:calc-kbd-end-for@:} @c @r{ @: Z C-g @: @: @:@:cancel if/loop command} @c @r{ @: Z ` @: @: @:calc-kbd-push@:} @r{ @: Z ' @: @: @:calc-kbd-pop@:} @r{ a@: Z = @:message @: 28 @:calc-kbd-report@:} @r{ @: Z # @:prompt @: @:calc-kbd-query@:} @c @r{ comp@: Z C @:func, args @: 50 @:calc-user-define-composition@:} @r{ @: Z D @:key, command @: @:calc-user-define@:} @r{ @: Z E @:key, editing @: 30 @:calc-user-define-edit@:} @r{ defn@: Z F @:k, c, f, a, n@: 28 @:calc-user-define-formula@:} @r{ @: Z G @:key @: @:calc-get-user-defn@:} @r{ @: Z I @: @: @:calc-user-define-invocation@:} @r{ @: Z K @:key, command @: @:calc-user-define-kbd-macro@:} @r{ @: Z P @:key @: @:calc-user-define-permanent@:} @r{ @: Z S @: @: 30 @:calc-edit-user-syntax@:} @r{ @: Z T @: @: 12 @:calc-timing@:} @r{ @: Z U @:key @: @:calc-user-undefine@:} @end format @noindent NOTES @enumerate @c 1 @item Positive prefix arguments apply to @cite{n} stack entries. Negative prefix arguments apply to the @cite{-n}th stack entry. A prefix of zero applies to the entire stack. (For @key{LFD} and @kbd{M-DEL}, the meaning of the sign is reversed.) @c 2 @item Positive prefix arguments apply to @cite{n} stack entries. Negative prefix arguments apply to the top stack entry and the next @cite{-n} stack entries. @c 3 @item Positive prefix arguments rotate top @cite{n} stack entries by one. Negative prefix arguments rotate the entire stack by @cite{-n}. A prefix of zero reverses the entire stack. @c 4 @item Prefix argument specifies a repeat count or distance. @c 5 @item Positive prefix arguments specify a precision @cite{p}. Negative prefix arguments reduce the current precision by @cite{-p}. @c 6 @item A prefix argument is interpreted as an additional step-size parameter. A plain @kbd{C-u} prefix means to prompt for the step size. @c 7 @item A prefix argument specifies simplification level and depth. 1=Default, 2=like @kbd{a s}, 3=like @kbd{a e}. @c 8 @item A negative prefix operates only on the top level of the input formula. @c 9 @item Positive prefix arguments specify a word size of @cite{w} bits, unsigned. Negative prefix arguments specify a word size of @cite{w} bits, signed. @c 10 @item Prefix arguments specify the shift amount @cite{n}. The @cite{w} argument cannot be specified in the keyboard version of this command. @c 11 @item From the keyboard, @cite{d} is omitted and defaults to zero. @c 12 @item Mode is toggled; a positive prefix always sets the mode, and a negative prefix always clears the mode. @c 13 @item Some prefix argument values provide special variations of the mode. @c 14 @item A prefix argument, if any, is used for @cite{m} instead of taking @cite{m} from the stack. @cite{M} may take any of these values: @iftex {@advance@tableindent10pt @end iftex @table @asis @item Integer Random integer in the interval @cite{[0 .. m)}. @item Float Random floating-point number in the interval @cite{[0 .. m)}. @item 0.0 Gaussian with mean 1 and standard deviation 0. @item Error form Gaussian with specified mean and standard deviation. @item Interval Random integer or floating-point number in that interval. @item Vector Random element from the vector. @end table @iftex } @end iftex @c 15 @item A prefix argument from 1 to 6 specifies number of date components to remove from the stack. @xref{Date Conversions}. @c 16 @item A prefix argument specifies a time zone; @kbd{C-u} says to take the time zone number or name from the top of the stack. @xref{Time Zones}. @c 17 @item A prefix argument specifies a day number (0-6, 0-31, or 0-366). @c 18 @item If the input has no units, you will be prompted for both the old and the new units. @c 19 @item With a prefix argument, collect that many stack entries to form the input data set. Each entry may be a single value or a vector of values. @c 20 @item With a prefix argument of 1, take a single @c{$N\times2$} @asis{Nx2} matrix from the stack instead of two separate data vectors. @c 21 @item The row or column number @cite{n} may be given as a numeric prefix argument instead. A plain @kbd{C-u} prefix says to take @cite{n} from the top of the stack. If @cite{n} is a vector or interval, a subvector/submatrix of the input is created. @c 22 @item The @cite{op} prompt can be answered with the key sequence for the desired function, or with @kbd{x} or @kbd{z} followed by a function name, or with @kbd{$} to take a formula from the top of the stack, or with @kbd{'} and a typed formula. In the last two cases, the formula may be a nameless function like @samp{<#1+#2>} or @samp{}, or it may include @kbd{$}, @kbd{$$}, etc. (where @kbd{$} will correspond to the last argument of the created function), or otherwise you will be prompted for an argument list. The number of vectors popped from the stack by @kbd{V M} depends on the number of arguments of the function. @c 23 @item One of the mapping direction keys @kbd{_} (horizontal, i.e., map by rows or reduce across), @kbd{:} (vertical, i.e., map by columns or reduce down), or @kbd{=} (map or reduce by rows) may be used before entering @cite{op}; these modify the function name by adding the letter @code{r} for ``rows,'' @code{c} for ``columns,'' @code{a} for ``across,'' or @code{d} for ``down.'' @c 24 @item The prefix argument specifies a packing mode. A nonnegative mode is the number of items (for @kbd{v p}) or the number of levels (for @kbd{v u}). A negative mode is as described below. With no prefix argument, the mode is taken from the top of the stack and may be an integer or a vector of integers. @iftex {@advance@tableindent-20pt @end iftex @table @cite @item -1 @var{(2)} Rectangular complex number. @item -2 @var{(2)} Polar complex number. @item -3 @var{(3)} HMS form. @item -4 @var{(2)} Error form. @item -5 @var{(2)} Modulo form. @item -6 @var{(2)} Closed interval. @item -7 @var{(2)} Closed .. open interval. @item -8 @var{(2)} Open .. closed interval. @item -9 @var{(2)} Open interval. @item -10 @var{(2)} Fraction. @item -11 @var{(2)} Float with integer mantissa. @item -12 @var{(2)} Float with mantissa in @cite{[1 .. 10)}. @item -13 @var{(1)} Date form (using date numbers). @item -14 @var{(3)} Date form (using year, month, day). @item -15 @var{(6)} Date form (using year, month, day, hour, minute, second). @end table @iftex } @end iftex @c 25 @item A prefix argument specifies the size @cite{n} of the matrix. With no prefix argument, @cite{n} is omitted and the size is inferred from the input vector. @c 26 @item The prefix argument specifies the starting position @cite{n} (default 1). @c 27 @item Cursor position within stack buffer affects this command. @c 28 @item Arguments are not actually removed from the stack by this command. @c 29 @item Variable name may be a single digit or a full name. @c 30 @item Editing occurs in a separate buffer. Press @kbd{M-# M-#} (or @kbd{C-c C-c}, @key{LFD}, or in some cases @key{RET}) to finish the edit, or press @kbd{M-# x} to cancel the edit. The @key{LFD} key prevents evaluation of the result of the edit. @c 31 @item The number prompted for can also be provided as a prefix argument. @c 32 @item Press this key a second time to cancel the prefix. @c 33 @item With a negative prefix, deactivate all formulas. With a positive prefix, deactivate and then reactivate from scratch. @c 34 @item Default is to scan for nearest formula delimiter symbols. With a prefix of zero, formula is delimited by mark and point. With a non-zero prefix, formula is delimited by scanning forward or backward by that many lines. @c 35 @item Parse the region between point and mark as a vector. A nonzero prefix parses @var{n} lines before or after point as a vector. A zero prefix parses the current line as a vector. A @kbd{C-u} prefix parses the region between point and mark as a single formula. @c 36 @item Parse the rectangle defined by point and mark as a matrix. A positive prefix @var{n} divides the rectangle into columns of width @var{n}. A zero or @kbd{C-u} prefix parses each line as one formula. A negative prefix suppresses special treatment of bracketed portions of a line. @c 37 @item A numeric prefix causes the current language mode to be ignored. @c 38 @item Responding to a prompt with a blank line answers that and all later prompts by popping additional stack entries. @c 39 @item Answer for @cite{v} may also be of the form @cite{v = v_0} or @cite{v - v_0}. @c 40 @item With a positive prefix argument, stack contains many @cite{y}'s and one common @cite{x}. With a zero prefix, stack contains a vector of @cite{y}s and a common @cite{x}. With a negative prefix, stack contains many @cite{[x,y]} vectors. (For 3D plots, substitute @cite{z} for @cite{y} and @cite{x,y} for @cite{x}.) @c 41 @item With any prefix argument, all curves in the graph are deleted. @c 42 @item With a positive prefix, refines an existing plot with more data points. With a negative prefix, forces recomputation of the plot data. @c 43 @item With any prefix argument, set the default value instead of the value for this graph. @c 44 @item With a negative prefix argument, set the value for the printer. @c 45 @item Condition is considered ``true'' if it is a nonzero real or complex number, or a formula whose value is known to be nonzero; it is ``false'' otherwise. @c 46 @item Several formulas separated by commas are pushed as multiple stack entries. Trailing @kbd{)}, @kbd{]}, @kbd{@}}, @kbd{>}, and @kbd{"} delimiters may be omitted. The notation @kbd{$$$} refers to the value in stack level three, and causes the formula to replace the top three stack levels. The notation @kbd{$3} refers to stack level three without causing that value to be removed from the stack. Use @key{LFD} in place of @key{RET} to prevent evaluation; use @kbd{M-=} in place of @key{RET} to evaluate variables.@refill @c 47 @item The variable is replaced by the formula shown on the right. The Inverse flag reverses the order of the operands, e.g., @kbd{I s - x} assigns @c{$x \coloneq a-x$} @cite{x := a-x}. @c 48 @item Press @kbd{?} repeatedly to see how to choose a model. Answer the variables prompt with @cite{iv} or @cite{iv;pv} to specify independent and parameter variables. A positive prefix argument takes @i{N+1} vectors from the stack; a zero prefix takes a matrix and a vector from the stack. @c 49 @item With a plain @kbd{C-u} prefix, replace the current region of the destination buffer with the yanked text instead of inserting. @c 50 @item All stack entries are reformatted; the @kbd{H} prefix inhibits this. The @kbd{I} prefix sets the mode temporarily, redraws the top stack entry, then restores the original setting of the mode. @c 51 @item A negative prefix sets the default 3D resolution instead of the default 2D resolution. @c 52 @item This grabs a vector of the form [@var{prec}, @var{wsize}, @var{ssize}, @var{radix}, @var{flfmt}, @var{ang}, @var{frac}, @var{symb}, @var{polar}, @var{matrix}, @var{simp}, @var{inf}]. A prefix argument from 1 to 12 grabs the @var{n}th mode value only. @end enumerate @iftex (Space is provided below for you to keep your own written notes.) @page @endgroup @end iftex @c [end-summary] @node Key Index, Command Index, Summary, Top @unnumbered Index of Key Sequences @printindex ky @node Command Index, Function Index, Key Index, Top @unnumbered Index of Calculator Commands Since all Calculator commands begin with the prefix @samp{calc-}, the @kbd{x} key has been provided as a variant of @kbd{M-x} which automatically types @samp{calc-} for you. Thus, @kbd{x last-args} is short for @kbd{M-x calc-last-args}. @printindex pg @node Function Index, Concept Index, Command Index, Top @unnumbered Index of Algebraic Functions This is a list of built-in functions and operators usable in algebraic expressions. Their full Lisp names are derived by adding the prefix @samp{calcFunc-}, as in @code{calcFunc-sqrt}. @iftex All functions except those noted with ``*'' have corresponding Calc keystrokes and can also be found in the Calc Summary. @end iftex @printindex tp @node Concept Index, Variable Index, Function Index, Top @unnumbered Concept Index @printindex cp @node Variable Index, Lisp Function Index, Concept Index, Top @unnumbered Index of Variables The variables in this list that do not contain dashes are accessible as Calc variables. Add a @samp{var-} prefix to get the name of the corresponding Lisp variable. The remaining variables are Lisp variables suitable for @code{setq}ing in your @file{.emacs} file. @printindex vr @node Lisp Function Index, , Variable Index, Top @unnumbered Index of Lisp Math Functions The following functions are meant to be used with @code{defmath}, not @code{defun} definitions. For names that do not start with @samp{calc-}, the corresponding full Lisp name is derived by adding a prefix of @samp{math-}. @printindex fn @summarycontents @c [end] @contents @bye