home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume14 / gmcalc / patch03 next >
Encoding:
Text File  |  1990-08-09  |  53.9 KB  |  1,430 lines
  1. Newsgroups: comp.sources.misc
  2. subject: v14i050: Patch for GNU Emacs Calc, version 1.03 -> 1.04, part 1/2
  3. from: daveg@csvax.cs.caltech.edu (David Gillespie)
  4. Sender: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  5.  
  6. Posting-number: Volume 14, Issue 50
  7. Submitted-by: daveg@csvax.cs.caltech.edu (David Gillespie)
  8. Archive-name: gmcalc/patch03
  9.  
  10. The following patches convert Calc version 1.03 into Calc
  11. version 1.04.  To apply them automatically with Patch v2.0,
  12. first cd into your Calc distribution directory, then execute
  13. "patch -p0 <calc.patch", where "calc.patch" is the name of this file.
  14. You will want to re-byte-compile both parts, and re-format the
  15. manual, as explained in the calc-INSTALL file.
  16.  
  17. This is part 1 of 2 patches.  You must apply both in order to
  18. complete the upgrade to version 1.04.
  19.  
  20. These patches do not cover the README file, but the interesting
  21. part of that file (the revision history) is now present near the
  22. top of calc.el.  The INSTALL file is now being included in the
  23. patches under the name calc-INSTALL.
  24.  
  25. Note that some patches will add to the list of "autoload" commands
  26. recommended in the calc-INSTALL file.
  27.  
  28. Patches and complete tar files are also available from anonymous FTP
  29. on csvax.cs.caltech.edu [131.215.131.131], in the "pub" subdirectory.
  30.  
  31. Enjoy!
  32.                             -- Dave
  33.  
  34. Dave Gillespie
  35. 256-80 Caltech, Pasadena CA 91125
  36. daveg@csvax.cs.caltech.edu, ...!cit-vax!daveg
  37.  
  38.  
  39.  
  40. *** calc.el    Tue Jun 26 20:53:26 1990
  41. --- ../dist/calc.el    Mon Aug  6 14:54:39 1990
  42. ***************
  43. *** 1,4 ****
  44. ! ;; Calculator for GNU Emacs version 1.03
  45.   ;; Copyright (C) 1990 Dave Gillespie
  46.   
  47.   ;; This file is part of GNU Emacs.
  48. --- 1,4 ----
  49. ! ;; Calculator for GNU Emacs version 1.04
  50.   ;; Copyright (C) 1990 Dave Gillespie
  51.   
  52.   ;; This file is part of GNU Emacs.
  53. ***************
  54. *** 44,53 ****
  55.   
  56.   ;;; Author's address:
  57.   ;;;   Dave Gillespie, 256-80 Caltech, Pasadena CA 91125.
  58. ! ;;;   daveg@csvax.caltech.edu, ...!cit-vax!daveg.
  59.   ;;;
  60.   ;;; This file and the manual, calc.texinfo, are available from anonymous FTP
  61. ! ;;; on csvax.caltech.edu [192.12.18.1]; look in ~ftp/pub/calc*.
  62.   ;;;
  63.   ;;; Bug reports and suggestions are always welcome!
  64.   
  65. --- 44,56 ----
  66.   
  67.   ;;; Author's address:
  68.   ;;;   Dave Gillespie, 256-80 Caltech, Pasadena CA 91125.
  69. ! ;;;   daveg@csvax.cs.caltech.edu, ...!cit-vax!daveg.
  70.   ;;;
  71. + ;;; Note that csvax's name has changed slightly.  The old name,
  72. + ;;; csvax.caltech.edu, will also still work for a while.
  73. + ;;;
  74.   ;;; This file and the manual, calc.texinfo, are available from anonymous FTP
  75. ! ;;; on csvax.cs.caltech.edu [131.215.131.131]; look in ~ftp/pub/calc*.
  76.   ;;;
  77.   ;;; Bug reports and suggestions are always welcome!
  78.   
  79. ***************
  80. *** 58,69 ****
  81.   ;;; and "defmath".  User-accessible variables begin with "var-".
  82.   
  83.   
  84.   
  85.   (provide 'calc)
  86.   
  87.   (defmacro calc-record-compilation-date-macro ()
  88.     (` (setq calc-version (concat "Emacs Calc Mode"
  89. !                 " v1.03 by Dave Gillespie"
  90.                   ", installed "
  91.                   (, (current-time-string))
  92.                   " by "
  93. --- 61,124 ----
  94.   ;;; and "defmath".  User-accessible variables begin with "var-".
  95.   
  96.   
  97. + ;;; Version 1.04:
  98. + ;;;  * Included a copy of revision history (from README) in calc.el.
  99. + ;;;  * Added the "calc-split" feature to split calc-ext.el into smaller bits.
  100. + ;;;  * Changed calc-unpack to unpack floats and fractions, too.
  101. + ;;;  * Added "mant", "xpon", and "scf" functions for decomposing floats.
  102. + ;;;  * Fixed a bug in the "y" command with positive prefix arguments.
  103. + ;;;  * Rearranged binary shift/rotate command keys to be a bit more convenient.
  104. + ;;;  * Fixed a bug in which simplifying "(0/0) * 2" crashed with a Lisp error.
  105. + ;;;  * Made `H F' [ffloor] and friends faster for very large arguments.
  106. + ;;;  * Made calc-define-del more robust.
  107. + ;;;  * Handled pasting of data into the Calculator using the mouse under X.
  108. + ;;;  * Made overlay-arrow variables buffer-local to avoid interference.
  109. + ;;;  * Fixed a problem in which Calc Trail buffer got stuck after a C-x C-w.
  110. + ;;; 
  111. + ;;; Version 1.03:
  112. + ;;;  * Changed math-choose to compute n-choose-m faster when m is large.
  113. + ;;;  * Fixed some problems with TeX mode.
  114. + ;;;  * Fixed a bug that prevented `b s' from working without a prefix argument.
  115. + ;;;  * Added "calc-eval" function.
  116. + ;;;  * Improved calc-grab-region.
  117. + ;;; 
  118. + ;;; Version 1.02:
  119. + ;;;  * Fixed a bug in Tutorial: telephone pole height/distance were switched!
  120. + ;;;  * Fixed a few other things in the manual.
  121. + ;;;  * Added "full-calc" command.
  122. + ;;;  * Added "calc-insert-variables" (`Z I') command.
  123. + ;;;  * Quick Calc now works even if you are already in the minibuffer.
  124. + ;;;  * Fixed a bug in math-mul-bignum-digit which affected math-and, etc.
  125. + ;;;  * Definition of "Hectares" was wrong in units table.
  126. + ;;;  * Fixed a bug in calc-execute-kbd-macro concerning undo and refresh.
  127. + ;;;  * Bound "calc-undo" to `C-x u' as well as `C-_' and `U'.
  128. + ;;; 
  129. + ;;; Version 1.01:
  130. + ;;;  * Added a tutorial section to the manual.
  131. + ;;;  * Next and Prev for node Strings in the manual were reversed; fixed.
  132. + ;;;  * Changed "'bignum" in calc-isqrt-bignum-iter to "'bigpos".
  133. + ;;;  * Fixed a bug that prevented "$" from working during algebraic entry.
  134. + ;;;  * Fixed a bug caused by an X (last-X) command following a K (macro) cmd.
  135. + ;;;  * Fixed a bug in which K command incorrectly formatted stack in Big mode.
  136. + ;;;  * Added space between unary operators and non-flat compositions.
  137. + ;;;    (Otherwise, "-(a/b)" in Big mode blended the minus sign into the rule!)
  138. + ;;;  * Fixed formatting of (-1)^n in Big mode.
  139. + ;;;  * Fixed some problems relating to "not" operator in Pascal language mode.
  140. + ;;;  * Fixed several bugs relating to V M ' and V M $ sequences.
  141. + ;;;  * Fixed matrix-vector multiplication to produce a vector.
  142. + ;;;  * Introduced Z ` ... Z ' commands; renamed old Z ' to Z #.
  143. + ;;;  * Fixed various other bugs.
  144. + ;;;  * Added calc-settings-file variable suggested by C. Witty.
  145. + ;;; 
  146. + ;;; Version 1.00:
  147. + ;;;  * First official release of Calc.
  148. + 
  149.   
  150.   (provide 'calc)
  151.   
  152.   (defmacro calc-record-compilation-date-macro ()
  153.     (` (setq calc-version (concat "Emacs Calc Mode"
  154. !                 " v1.04 by Dave Gillespie"
  155.                   ", installed "
  156.                   (, (current-time-string))
  157.                   " by "
  158. ***************
  159. *** 85,93 ****
  160.   
  161.   ;;; IDEAS:
  162.   ;;;
  163. - ;;;   Consider breaking calc-ext.el into several extension modules:
  164. - ;;;      Base extensions, algebra/units, scientific, programming
  165. - ;;;
  166.   ;;;   How about putting cursor on an operator or functor in stack window
  167.   ;;;      to indicate the subterm to which a command should apply?
  168.   ;;;   Make math-simplify faster!
  169. --- 140,145 ----
  170. ***************
  171. *** 119,124 ****
  172. --- 171,177 ----
  173.   ;;;   Consider implementing some other special functions.
  174.   ;;;   May as well make continued-fractions stuff available to the user.
  175.   ;;;   Provide date arithmetic a la HP 48.
  176. + ;;;   Consider providing infinities and indeterminate values as a data type.
  177.   ;;;
  178.   ;;;   Implement some more built-in statistical functions:
  179.   ;;;      mean, median, variance, std dev of a list.
  180. ***************
  181. *** 141,146 ****
  182. --- 194,200 ----
  183.   ;;;   Provide more examples in the tutorial section of the manual.
  184.   ;;;   Cover in the tutorial:  language modes, simplification modes,
  185.   ;;;       bitwise stuff, rewrite rules.
  186. + ;;;   Add some exercises to the tutorial.
  187.   ;;;   Provide more Lisp programming examples in the manual.
  188.   ;;;   Finish the Internals section of the manual.
  189.   ;;;
  190. ***************
  191. *** 147,153 ****
  192.   ;;;   Tim suggests adding spreadsheet-like features.
  193.   ;;;   How about ultra-low-resolution plots?  (Probably too slow.)
  194.   ;;;   How about running gnuplot to generate high-res plots?
  195. ! ;;;   Implement language modes for Lisp, Ada, ...?
  196.   ;;;
  197.   
  198.   
  199. --- 201,207 ----
  200.   ;;;   Tim suggests adding spreadsheet-like features.
  201.   ;;;   How about ultra-low-resolution plots?  (Probably too slow.)
  202.   ;;;   How about running gnuplot to generate high-res plots?
  203. ! ;;;   Implement language modes for Eqn, Gnuplot, Lisp, Ada, ...?
  204.   ;;;
  205.   
  206.   
  207. ***************
  208. *** 416,421 ****
  209. --- 470,478 ----
  210.   (defvar calc-executing-macro nil)
  211.   
  212.   
  213. + (defvar calc-trail-buffer nil)
  214. + 
  215. + 
  216.   (defvar calc-other-modes nil
  217.     "List of used-defined strings to append to Calculator mode line.")
  218.   
  219. ***************
  220. *** 450,456 ****
  221.   
  222.   (defun calc-define-del (map func)
  223.     (define-key map "\C-d" func)
  224. !   (mapcar (function (lambda (x) (define-key map x func)))
  225.         (append (where-is-internal 'delete-backward-char global-map)
  226.             (where-is-internal 'backward-delete-char global-map)))
  227.   )
  228. --- 507,515 ----
  229.   
  230.   (defun calc-define-del (map func)
  231.     (define-key map "\C-d" func)
  232. !   (mapcar (function (lambda (x) (condition-case err
  233. !                     (define-key map x func)
  234. !                   (error nil))))
  235.         (append (where-is-internal 'delete-backward-char global-map)
  236.             (where-is-internal 'backward-delete-char global-map)))
  237.   )
  238. ***************
  239. *** 646,651 ****
  240. --- 705,715 ----
  241.         (progn
  242.       (setq calc-loaded-settings-file t)
  243.       (load calc-settings-file t)))   ; t = missing-ok
  244. +   (if (eq window-system 'x)
  245. +       (progn
  246. +     (or (boundp 'calc-old-x-paste-text)
  247. +         (setq calc-old-x-paste-text (symbol-function 'x-paste-text)))
  248. +     (define-key mouse-map x-button-middle 'calc-x-paste-text)))
  249.     (run-hooks 'calc-mode-hook)
  250.     (calc-refresh t)
  251.     (calc-set-mode-line)
  252. ***************
  253. *** 667,672 ****
  254. --- 731,738 ----
  255.     (setq mode-name "Calc Trail")
  256.     (setq truncate-lines nil)
  257.     (setq buffer-read-only t)
  258. +   (make-local-variable 'overlay-arrow-position)
  259. +   (make-local-variable 'overlay-arrow-string)
  260.     (if buf
  261.         (progn
  262.       (make-local-variable 'calc-main-buffer)
  263. ***************
  264. *** 731,742 ****
  265.                 (select-window w))
  266.             (pop-to-buffer (current-buffer)))))))
  267.       (save-excursion
  268. !       (let ((buf (current-buffer)))
  269. !         (set-buffer (get-buffer-create "*Calc Trail*"))
  270. !         (calc-trail-mode buf)
  271. !         (and calc-display-trail
  272. !          (= (window-width) (screen-width))
  273. !          (calc-trail-display 1 t))))
  274.       (calc-summary full-display)
  275.       (and calc-said-hello
  276.            (interactive-p)
  277. --- 797,806 ----
  278.                 (select-window w))
  279.             (pop-to-buffer (current-buffer)))))))
  280.       (save-excursion
  281. !       (set-buffer (calc-trail-buffer))
  282. !       (and calc-display-trail
  283. !            (= (window-width) (screen-width))
  284. !            (calc-trail-display 1 t)))
  285.       (calc-summary full-display)
  286.       (and calc-said-hello
  287.            (interactive-p)
  288. ***************
  289. *** 776,790 ****
  290.     (mapcar (function
  291.          (lambda (v) (set-default v (symbol-value v)))) calc-local-var-list)
  292.     (let ((buf (current-buffer))
  293. -     (tbuf (get-buffer-create "*Calc Trail*"))
  294.       (win (get-buffer-window (current-buffer))))
  295.       (if (and win
  296.            (< (window-height win) (1- (screen-height))))
  297.       (setq calc-window-height (- (window-height win) 2)))
  298.       (delete-windows-on buf)
  299. !     (delete-windows-on tbuf)
  300.       (bury-buffer buf)
  301. !     (bury-buffer tbuf))
  302.   )
  303.   
  304.   (defun quick-calc ()
  305. --- 840,853 ----
  306.     (mapcar (function
  307.          (lambda (v) (set-default v (symbol-value v)))) calc-local-var-list)
  308.     (let ((buf (current-buffer))
  309.       (win (get-buffer-window (current-buffer))))
  310.       (if (and win
  311.            (< (window-height win) (1- (screen-height))))
  312.       (setq calc-window-height (- (window-height win) 2)))
  313.       (delete-windows-on buf)
  314. !     (delete-windows-on calc-trail-buffer)
  315.       (bury-buffer buf)
  316. !     (bury-buffer calc-trail-buffer))
  317.   )
  318.   
  319.   (defun quick-calc ()
  320. ***************
  321. *** 1347,1354 ****
  322. --- 1410,1433 ----
  323.     (calc-wrapper)
  324.   )
  325.   
  326. + (defun calc-x-paste-text (arg)
  327. +   "Move point to mouse position and insert window system cut buffer contents.
  328. + If mouse is pressed in Calc window, push cut buffer contents onto the stack."
  329. +   (x-mouse-select arg)
  330. +   (if (memq major-mode '(calc-mode calc-trail-mode))
  331. +       (progn
  332. +     (calc-wrapper
  333. +      (calc-extensions)
  334. +      (let ((val (math-read-exprs (calc-clean-newlines
  335. +                       (x-get-cut-buffer)))))
  336. +        (if (eq (car-safe val) 'error)
  337. +            (error "%s in yanked data" (nth 2 val))
  338. +          (calc-enter-result 0 "Xynk" val)))))
  339. +     (funcall calc-old-x-paste-text arg))
  340. + )
  341.   
  342.   
  343. + 
  344.   ;;;; The Calc Trail buffer.
  345.   
  346.   (defun calc-check-trail-aligned ()
  347. ***************
  348. *** 1366,1375 ****
  349.       body)
  350.   )
  351.   
  352.   (defun calc-record (val &optional prefix)
  353.     (or calc-executing-macro
  354.         (let* ((mainbuf (current-buffer))
  355. !          (buf (get-buffer-create "*Calc Trail*"))
  356.            (calc-display-raw (eq calc-display-raw t))
  357.            (fval (if val
  358.                  (if (stringp val)
  359. --- 1445,1466 ----
  360.       body)
  361.   )
  362.   
  363. + (defun calc-trail-buffer ()
  364. +   (and (or (null calc-trail-buffer)
  365. +        (null (buffer-name calc-trail-buffer)))
  366. +        (save-excursion
  367. +      (setq calc-trail-buffer (get-buffer-create "*Calc Trail*"))
  368. +      (let ((buf (current-buffer)))
  369. +        (set-buffer calc-trail-buffer)
  370. +        (or (eq major-mode 'calc-trail-mode)
  371. +            (calc-trail-mode (current-buffer))))))
  372. +   calc-trail-buffer
  373. + )
  374. + 
  375.   (defun calc-record (val &optional prefix)
  376.     (or calc-executing-macro
  377.         (let* ((mainbuf (current-buffer))
  378. !          (buf (calc-trail-buffer))
  379.            (calc-display-raw (eq calc-display-raw t))
  380.            (fval (if val
  381.                  (if (stringp val)
  382. ***************
  383. *** 1379,1386 ****
  384.                "")))
  385.       (save-excursion
  386.         (set-buffer buf)
  387. -       (if (not (eq major-mode 'calc-trail-mode))
  388. -           (calc-trail-mode mainbuf))
  389.         (let ((aligned (calc-check-trail-aligned))
  390.           (buffer-read-only nil))
  391.           (goto-char (point-max))
  392. --- 1470,1475 ----
  393. ***************
  394. *** 1409,1416 ****
  395.     "Turn the Trail display on or off.
  396.   With prefix argument 1, turn it on; with argument 0, turn it off."
  397.     (interactive "P")
  398. !   (let* ((trail (get-buffer-create "*Calc Trail*"))
  399. !      (win (get-buffer-window trail)))
  400.       (if (setq calc-display-trail
  401.             (not (if flag (memq flag '(nil 0)) win)))
  402.       (if (null win)
  403. --- 1498,1504 ----
  404.     "Turn the Trail display on or off.
  405.   With prefix argument 1, turn it on; with argument 0, turn it off."
  406.     (interactive "P")
  407. !   (let ((win (get-buffer-window (calc-trail-buffer))))
  408.       (if (setq calc-display-trail
  409.             (not (if flag (memq flag '(nil 0)) win)))
  410.       (if (null win)
  411. ***************
  412. *** 1418,1424 ****
  413.             (if (and (boundp 'calc-trail-window-hook) calc-trail-window-hook)
  414.             (run-hooks 'calc-trail-window-hook)
  415.           (let ((w (split-window nil (/ (* (window-width) 2) 3) t)))
  416. !           (set-window-buffer w trail)))
  417.             (calc-wrapper
  418.              (or no-refresh
  419.              (calc-refresh)))))
  420. --- 1506,1512 ----
  421.             (if (and (boundp 'calc-trail-window-hook) calc-trail-window-hook)
  422.             (run-hooks 'calc-trail-window-hook)
  423.           (let ((w (split-window nil (/ (* (window-width) 2) 3) t)))
  424. !           (set-window-buffer w calc-trail-buffer)))
  425.             (calc-wrapper
  426.              (or no-refresh
  427.              (calc-refresh)))))
  428. ***************
  429. *** 1430,1437 ****
  430.            (calc-refresh)))))
  431.         (if (and (boundp 'overlay-arrow-position)
  432.              (eq overlay-arrow-position calc-trail-pointer))
  433. !       (setq overlay-arrow-position nil)))
  434. !     trail)
  435.   )
  436.   
  437.   (defun calc-trail-here ()
  438. --- 1518,1525 ----
  439.            (calc-refresh)))))
  440.         (if (and (boundp 'overlay-arrow-position)
  441.              (eq overlay-arrow-position calc-trail-pointer))
  442. !       (setq overlay-arrow-position nil))))
  443. !   calc-trail-buffer
  444.   )
  445.   
  446.   (defun calc-trail-here ()
  447. ***************
  448. *** 4106,4112 ****
  449.     (interactive "sBug Subject: ")
  450.     (mail nil calc-bug-address topic)
  451.     (goto-char (point-max))
  452. !   (insert "\nIn Calc 1.03, Emacs " (emacs-version) "\n\n")
  453.     (message (substitute-command-keys "Type \\[mail-send] to send bug report."))
  454.   )
  455.   
  456. --- 4194,4200 ----
  457.     (interactive "sBug Subject: ")
  458.     (mail nil calc-bug-address topic)
  459.     (goto-char (point-max))
  460. !   (insert "\nIn Calc 1.04, Emacs " (emacs-version) "\n\n")
  461.     (message (substitute-command-keys "Type \\[mail-send] to send bug report."))
  462.   )
  463.   
  464. *** calc-INSTALL    Mon Aug  6 15:07:44 1990
  465. --- ../dist/calc-INSTALL    Mon Aug  6 15:04:40 1990
  466. ***************
  467. *** 0 ****
  468. --- 1,185 ----
  469. + 
  470. + Installation
  471. + ************
  472. + 
  473. + Calc 1.04 comes as a pair of Emacs Lisp files, generally called
  474. + `calc.el' and `calc-ext.el'.  The first contains the basic foundations
  475. + of the Calculator, and is as small as possible to promote quick loading.
  476. + The second contains all the more advanced commands and functions.  Calc
  477. + is usually installed so that the `M-x calc' or `M-#' command auto-loads
  478. + only the first part, and the second part is auto-loaded whenever the
  479. + first advanced feature is used.
  480. + 
  481. + 
  482. + Compilation
  483. + ===========
  484. + 
  485. + Calc is written in a way that maximizes performance when its code has been
  486. + byte-compiled; a side effect is that performance is seriously degraded if
  487. + it *isn't* compiled.  Thus, it is essential to compile the Calculator
  488. + before trying to use it.  The Emacs command `M-x byte-compile-file'
  489. + is used to compile an Emacs Lisp file.  Compile each of `calc.el' and
  490. + `calc-ext.el' to obtain byte-code files `calc.elc' and
  491. + `calc-ext.elc'.  You may find you need to do `M-x load-file
  492. + calc.elc' before compiling `calc-ext.el' will work.
  493. + 
  494. + For your convenience, the FTP distribution of Calc, obtainable from
  495. + anonymous FTP on `csvax.cs.caltech.edu', includes already-compiled
  496. + versions of both of these files.
  497. + 
  498. + 
  499. + Auto-loading
  500. + ============
  501. + 
  502. + To teach Emacs how to load in Calc when you type `M-x calc' for the
  503. + first time, include these lines in your `.emacs' file (if you are
  504. + installing Calc just for your own use), or the system's `lisp/default'
  505. + file (if you are installing Calc publicly).
  506. + 
  507. +      (autoload 'calc             ".../calc.elc"     "Calculator Mode" t nil)
  508. +      (autoload 'calc-extensions  ".../calc-ext.elc" nil nil nil)
  509. +      (autoload 'quick-calc       ".../calc.elc"     "Quick Calculator" t nil)
  510. +      (autoload 'full-calc        ".../calc.elc"     "Full-screen Calculator" t nil)
  511. +      (autoload 'calc-eval        ".../calc.elc"     "Call Calculator" nil nil)
  512. +      (autoload 'calc-grab-region ".../calc-ext.elc" nil t nil)
  513. +      (autoload 'defmath          ".../calc-ext.elc" nil t t)
  514. + 
  515. + where `.../calc.elc' represents the full path to the `calc.elc'
  516. + file, and similarly for `.../calc-ext.elc'.  If you have installed
  517. + these files in Emacs' main `lisp/' directory, you can just write
  518. + `"calc.elc"' and `"calc-ext.elc"'.
  519. + 
  520. + The `autoload' command for `calc' is what loads `calc.elc'
  521. + when you type `M-x calc'.  The `autoload' for `calc-extensions'
  522. + brings in the extensions module; Calc takes care to call the
  523. + `calc-extensions' function (which doesn't actually do anything)
  524. + before any operation that requires the extensions to be present.
  525. + The other five `autoload' commands are for functions which might
  526. + reasonably be used before the user has typed `M-x calc' for the
  527. + first time.
  528. + 
  529. + 
  530. + Merging `calc' and `calc-ext'
  531. + =============================
  532. + 
  533. + If you don't want to bother with a split Calculator, you can simply
  534. + concatenate `calc-ext.elc' onto the end of `calc.elc', rewrite
  535. + the above `autoload' commands all to point to the combined file,
  536. + and treat Calc as one big program.  You may need to do this if
  537. + the `autoload' mechanism is giving you problems.
  538. + 
  539. + 
  540. + Splitting `calc-ext'
  541. + ====================
  542. + 
  543. + On the other hand, you may find that `calc-ext.el' is too big to load
  544. + quickly.  You can split the Calculator into still more parts using the
  545. + `calc-split' command.  This command splits the file `calc-ext.el' into
  546. + about 20 small files with names like `calc-cplx.el' and `calc-mode.el'
  547. + in the same directory as `calc-ext.el'.  First, load the file
  548. + `calc-ext.el' with `C-x C-f'.  Move to the end of the buffer and type
  549. + `C-x C-e' at the indicated position.  Now type `M-x calc-split'.  This
  550. + moves most of the text out of `calc-ext.el' and into other files.  All
  551. + necessary `autoload' commands are inserted into `calc-ext.el'.
  552. + 
  553. + The `calc-split' command prompts for a directory name; the new files are
  554. + placed in this directory, and the `autoload' commands are written to
  555. + refer to the directory explicitly.  If you wish you can backspace over
  556. + the default directory name and enter a blank name, in which case the
  557. + `autoload' commands will be written without directory names on the
  558. + assumption that Emacs can find the Calc files in one of the default
  559. + places.  Some people prefer to put the Calc files in a subdirectory by
  560. + themselves.
  561. + 
  562. + The `calc-split' command also offers to byte-compile all Calc files
  563. + automatically.  Note that `calc.el' must have been byte-compiled and
  564. + loaded already, just as if you were compiling `calc-ext' whole.  If you
  565. + choose to compile by hand, you will need to compile `calc.el' first,
  566. + load it, compile the new `calc-ext.el' and load it, then compile each of
  567. + the new component files.  Also, note that the `autoload' commands shown
  568. + above are still correct for use in your startup file.
  569. + 
  570. + If you do decide to use `calc-split', note that when patches are made
  571. + available for new versions of Calc, they will refer to the old, unsplit
  572. + version of the file `calc-ext.el'.  The `calc-split' command makes a
  573. + copy of this under the name `calc-old.el'; be sure to keep it around so
  574. + you can rename it back to `calc-ext.el' before installing new patches.
  575. + You can then use `calc-split' again to re-split your updated version of
  576. + Calc.
  577. + 
  578. + 
  579. + Key Bindings
  580. + ============
  581. + 
  582. + You may wish to bind the `calc' command to a key.  The
  583. + recommended keystroke is `M-#' (i.e., Meta-Shift-3).  To set up
  584. + this key binding, include this command in your `.emacs' or
  585. + `lisp/default' file:
  586. + 
  587. +      (global-set-key "\e#" 'calc)
  588. + 
  589. + There are no standard key assignments for `quick-calc' and
  590. + `calc-grab-region', but you may wish to define some.
  591. + 
  592. + 
  593. + The `macedit' Package
  594. + =====================
  595. + 
  596. + The file `macedit.el' contains another useful Emacs extension
  597. + called `edit-kbd-macro'.  It allows you to edit a keyboard macro
  598. + in human-readable form.  The `Z E' command in Calc knows how to
  599. + use it to edit user commands that have been defined by keyboard macros.
  600. + To autoload it, you will want to include the commands,
  601. + 
  602. +      (autoload 'edit-kbd-macro      ".../macedit.elc" "Edit Keyboard Macro" t nil)
  603. +      (autoload 'edit-last-kbd-macro ".../macedit.elc" "Edit Keyboard Macro" t nil)
  604. + 
  605. + 
  606. + Documentation
  607. + =============
  608. + 
  609. + The documentation for Calc (i.e., this manual) comes in a file
  610. + `calc.texinfo'.  To format this for use as an on-line manual,
  611. + open this file for editing in Emacs and give the command
  612. + `M-x texinfo-format-buffer'.  When this finishes, type `C-x C-s'
  613. + to save.  The result will be a collection of files whose names begin
  614. + with `calc-info'.  You can also format this into a printable
  615. + document using TeX, but beware, the manual is about 170 printed pages!
  616. + 
  617. + There is a Lisp variable called `calc-info-filename' which holds
  618. + the name of the Info file containing Calc's on-line documentation.
  619. + Its default value is `calc-info', which will work correctly if
  620. + the Info files are stored in Emacs' main `info/' directory.  If
  621. + you keep them elsewhere, you will want to put a command of the form,
  622. + 
  623. +      (setq calc-info-filename ".../calc-info")
  624. + 
  625. + in your `.emacs' or `lisp/default' file, where again `...'
  626. + represents the directory containing the Info files.
  627. + 
  628. + 
  629. + Settings File
  630. + =============
  631. + 
  632. + Another variable you might want to set is `calc-settings-file', which
  633. + holds the file name in which commands like `m m' and `Z P' store
  634. + "permanent" definitions.  The default value for this variable is
  635. + `"~/.emacs"'.  If `calc-settings-file' does not contain `".emacs"' as a
  636. + substring, and if the variable `calc-loaded-settings-file' is `nil',
  637. + then Calc will automatically load your settings file (if it exists) the
  638. + first time Calc is invoked.
  639. + 
  640. + 
  641. + Testing the Installation
  642. + ========================
  643. + 
  644. + To test your installation of Calc, start a fresh Emacs and type `M-#'
  645. + to make sure the autoload commands and key bindings work.  Now, type
  646. + `i' to make sure Calc can find its Info documentation.  Press `q'
  647. + to exit the Info system and `M-#' to re-enter the Calculator.
  648. + Type `20 S' to compute the sine of 20 degrees; this will test the
  649. + autoloading of the extensions module.  The result should be 0.342020143326.
  650. + Finally, press `M-#' again to make sure the Calculator can exit.
  651. + 
  652. + (The above text is included in both the Calc documentation and the
  653. + file INSTALL in the Calc distribution directory.)
  654. *** calc.texinfo    Tue Jun 26 20:53:34 1990
  655. --- ../dist/calc.texinfo    Mon Aug  6 15:03:10 1990
  656. ***************
  657. *** 1,7 ****
  658.   \input texinfo                  @c -*-texinfo-*-
  659.   @comment %**start of header (This is for running Texinfo on a region.)
  660.   @setfilename calc-info
  661. ! @settitle GNU Emacs Calc 1.03 Manual
  662.   @setchapternewpage odd
  663.   @comment %**end of header (This is for running Texinfo on a region.)
  664.   
  665. --- 1,7 ----
  666.   \input texinfo                  @c -*-texinfo-*-
  667.   @comment %**start of header (This is for running Texinfo on a region.)
  668.   @setfilename calc-info
  669. ! @settitle GNU Emacs Calc 1.04 Manual
  670.   @setchapternewpage odd
  671.   @comment %**end of header (This is for running Texinfo on a region.)
  672.   
  673. ***************
  674. *** 38,46 ****
  675.   @sp 6
  676.   @center @titlefont{Calc Manual}
  677.   @sp 4
  678. ! @center GNU Emacs Calc Version 1.03
  679.   @sp 1
  680. ! @center June 1990
  681.   @sp 5
  682.   @center Dave Gillespie
  683.   @page
  684. --- 38,46 ----
  685.   @sp 6
  686.   @center @titlefont{Calc Manual}
  687.   @sp 4
  688. ! @center GNU Emacs Calc Version 1.04
  689.   @sp 1
  690. ! @center July 1990
  691.   @sp 5
  692.   @center Dave Gillespie
  693.   @page
  694. ***************
  695. *** 512,518 ****
  696.   Type @kbd{M-x calc} or @kbd{M-#} to start the Calculator; type @kbd{q} to quit.
  697.   Type @kbd{M-x quick-calc} to do one quick calculation in the minibuffer.
  698.   
  699. ! Calc normally uses RPN notation.  @xref{Stack Basics}, for a discussion
  700.   of RPN for the beginner.  The @kbd{RET} or @kbd{SPC} key enters a number
  701.   or duplicates the top number on the stack, @kbd{DEL} removes the top
  702.   number from the stack, and @kbd{TAB} swaps the top two numbers.@refill
  703. --- 512,518 ----
  704.   Type @kbd{M-x calc} or @kbd{M-#} to start the Calculator; type @kbd{q} to quit.
  705.   Type @kbd{M-x quick-calc} to do one quick calculation in the minibuffer.
  706.   
  707. ! Calc normally uses RPN notation.  @xref{RPN Tutorial}, for a discussion
  708.   of RPN for the beginner.  The @kbd{RET} or @kbd{SPC} key enters a number
  709.   or duplicates the top number on the stack, @kbd{DEL} removes the top
  710.   number from the stack, and @kbd{TAB} swaps the top two numbers.@refill
  711. ***************
  712. *** 714,725 ****
  713.   number of operands from the stack and pushes back the result.
  714.   
  715.   Thus we could add the numbers 2 and 3 in an RPN calculator by typing the
  716. ! keys: @kbd{1 @key{RET} 2 @key{RET} +}.  (@key{RET} corresponds to the
  717.   @key{ENTER} key on traditional RPN calculators.)  The first four
  718.   keystrokes ``push'' the numbers 2 and 3 onto the stack.  The @kbd{+} key
  719.   ``pops'' the top two numbers from the stack, adds them, and pushes the
  720.   result (5) back onto the stack.  Here's how the stack will look at
  721. ! various points throughout the calculation:
  722.   
  723.   @group
  724.   @example
  725. --- 714,725 ----
  726.   number of operands from the stack and pushes back the result.
  727.   
  728.   Thus we could add the numbers 2 and 3 in an RPN calculator by typing the
  729. ! keys: @kbd{2 @key{RET} 3 @key{RET} +}.  (@key{RET} corresponds to the
  730.   @key{ENTER} key on traditional RPN calculators.)  The first four
  731.   keystrokes ``push'' the numbers 2 and 3 onto the stack.  The @kbd{+} key
  732.   ``pops'' the top two numbers from the stack, adds them, and pushes the
  733.   result (5) back onto the stack.  Here's how the stack will look at
  734. ! various points throughout the calculation:@refill
  735.   
  736.   @group
  737.   @example
  738. ***************
  739. *** 742,748 ****
  740.   as large as you like, so it uses numbers instead of letters.  Some
  741.   stack-manipulation commands accept a numeric argument which says
  742.   which stack level to work on.  Normal commands like @kbd{+} always
  743. ! work on the top few levels of the stack.
  744.   
  745.   The Stack buffer is just an Emacs buffer, and you can move around in
  746.   it using the regular Emacs motion commands.  But no matter where the
  747. --- 742,748 ----
  748.   as large as you like, so it uses numbers instead of letters.  Some
  749.   stack-manipulation commands accept a numeric argument which says
  750.   which stack level to work on.  Normal commands like @kbd{+} always
  751. ! work on the top few levels of the stack.@refill
  752.   
  753.   The Stack buffer is just an Emacs buffer, and you can move around in
  754.   it using the regular Emacs motion commands.  But no matter where the
  755. ***************
  756. *** 932,938 ****
  757.   
  758.   @group
  759.   @example
  760. ! 1:  ( ...      2:  ( ...      1:  ( 2, ...   1:  ( 2, ...   1:  (2, 3)
  761.       .          1:  2              .              3              .
  762.                                                    .
  763.   
  764. --- 932,938 ----
  765.   
  766.   @group
  767.   @example
  768. ! 1:  ( ...      2:  ( ...      1:  (2, ...    1:  (2, ...    1:  (2, 3)
  769.       .          1:  2              .              3              .
  770.                                                    .
  771.   
  772. ***************
  773. *** 1217,1223 ****
  774.   calls are not evaluated.  In the second call, the logarithm is
  775.   undefined for that value of the argument; in the third, there are
  776.   too many arguments.  In the fourth case, there is no function
  777. ! called @code{foo}.
  778.   
  779.   We will encounter formulas involving variables and functions again
  780.   when we discuss the algebra and calculus features of the Calculator.
  781. --- 1217,1226 ----
  782.   calls are not evaluated.  In the second call, the logarithm is
  783.   undefined for that value of the argument; in the third, there are
  784.   too many arguments.  In the fourth case, there is no function
  785. ! called @code{foo}.  You can press the @kbd{w} key (``why'') to
  786. ! see an explanation of why a function call was left unevaluated.
  787. ! Pressing @kbd{w} the first time will report the too-many-arguments
  788. ! problem; pressing it again will report the logarithm-of-zero problem.
  789.   
  790.   We will encounter formulas involving variables and functions again
  791.   when we discuss the algebra and calculus features of the Calculator.
  792. ***************
  793. *** 1393,1399 ****
  794.   Calc has to stop somewhere.
  795.   
  796.   Of course, calculations are slower the more digits you request.
  797. ! Press @kbd{p 12} to set the precision back down to the default.
  798.   
  799.   Calculations always use the current precision.  For example, even
  800.   though we have a 30-digit value for @samp{1/7} on the stack, if
  801. --- 1396,1402 ----
  802.   Calc has to stop somewhere.
  803.   
  804.   Of course, calculations are slower the more digits you request.
  805. ! Press @kbd{p 12} now to set the precision back down to the default.
  806.   
  807.   Calculations always use the current precision.  For example, even
  808.   though we have a 30-digit value for @samp{1/7} on the stack, if
  809. ***************
  810. *** 1605,1611 ****
  811.   
  812.   You can enter non-decimal numbers using the @kbd{#} symbol, too.
  813.   Let's see what the hexadecimal number @samp{5FE} looks like in
  814. ! binary.  Type @kbd{16#5FE} (the F's can be in upper or lower case).
  815.   It will also help to turn grouping on with @kbd{d g}:
  816.   
  817.   @example
  818. --- 1608,1614 ----
  819.   
  820.   You can enter non-decimal numbers using the @kbd{#} symbol, too.
  821.   Let's see what the hexadecimal number @samp{5FE} looks like in
  822. ! binary.  Type @kbd{16#5FE} (the letters can be in upper or lower case).
  823.   It will also help to turn grouping on with @kbd{d g}:
  824.   
  825.   @example
  826. ***************
  827. *** 1649,1655 ****
  828.   The shift-@kbd{S} command computes the sine of an angle.  The sine
  829.   of 45 degrees is @samp{sqrt(2)/2}; squaring this yields @samp{2/4 = 0.5}.
  830.   However, there has been a slight roundoff error because the
  831. ! resentation of @samp{sqrt(2)/2} wasn't exact.  The @kbd{c 1}
  832.   command is a handy way to clean up numbers in this case; it
  833.   temporarily reduces the precision by one digit while it
  834.   re-rounds the number on the top of the stack.
  835. --- 1652,1658 ----
  836.   The shift-@kbd{S} command computes the sine of an angle.  The sine
  837.   of 45 degrees is @samp{sqrt(2)/2}; squaring this yields @samp{2/4 = 0.5}.
  838.   However, there has been a slight roundoff error because the
  839. ! representation of @samp{sqrt(2)/2} wasn't exact.  The @kbd{c 1}
  840.   command is a handy way to clean up numbers in this case; it
  841.   temporarily reduces the precision by one digit while it
  842.   re-rounds the number on the top of the stack.
  843. ***************
  844. *** 1713,1719 ****
  845.   @end group
  846.   
  847.   In the first case, we get an approximate floating-point result.
  848. ! In the second case, we get an exact fractional result.
  849.   
  850.   You can enter a fraction at any time using @kbd{:} notation.
  851.   (Calc uses @kbd{:} instead of @kbd{/} as the fraction separator
  852. --- 1716,1723 ----
  853.   @end group
  854.   
  855.   In the first case, we get an approximate floating-point result.
  856. ! In the second case, we get an exact fractional result
  857. ! (four-thirds).
  858.   
  859.   You can enter a fraction at any time using @kbd{:} notation.
  860.   (Calc uses @kbd{:} instead of @kbd{/} as the fraction separator
  861. ***************
  862. *** 1794,1804 ****
  863.   @end example
  864.   @end group
  865.   
  866. ! Since dividing-and-flooring is such a common operation, Calc
  867. ! provides a special command for that purpose, the backslash @kbd{\}.
  868. ! Another common arithmetic operator is @kbd{%}, which computes the
  869. ! remainder that would arise from a @kbd{\} operation, i.e., the
  870. ! ``modulo'' of two numbers.  For example,
  871.   
  872.   @group
  873.   @example
  874. --- 1798,1808 ----
  875.   @end example
  876.   @end group
  877.   
  878. ! Since dividing-and-flooring (i.e., ``integer quotient'') is such a
  879. ! common operation, Calc provides a special command for that purpose, the
  880. ! backslash @kbd{\}.  Another common arithmetic operator is @kbd{%}, which
  881. ! computes the remainder that would arise from a @kbd{\} operation, i.e.,
  882. ! the ``modulo'' of two numbers.  For example,
  883.   
  884.   @group
  885.   @example
  886. ***************
  887. *** 2079,2085 ****
  888.   
  889.   Note that we can separate the vector elements with either commas or
  890.   spaces.  This is true whether we are using incomplete vectors or
  891. ! algebraic entry.
  892.   
  893.   If you multiply two vectors, the result is the sum of the products
  894.   of the elements taken pairwise.  This is called the @dfn{dot product}
  895. --- 2083,2090 ----
  896.   
  897.   Note that we can separate the vector elements with either commas or
  898.   spaces.  This is true whether we are using incomplete vectors or
  899. ! algebraic entry.  The @kbd{s 1} and @kbd{s 2} commands save these
  900. ! vectors so we can easily reuse them later.
  901.   
  902.   If you multiply two vectors, the result is the sum of the products
  903.   of the elements taken pairwise.  This is called the @dfn{dot product}
  904. ***************
  905. *** 2335,2341 ****
  906.   @end example
  907.   @end group
  908.   
  909. ! Dividing by a square matrix is equivalent to multiplying by the
  910.   inverse.
  911.   
  912.   Let's verify this solution:
  913. --- 2340,2346 ----
  914.   @end example
  915.   @end group
  916.   
  917. ! Dividing by a square matrix is equivalent to multiplying by its
  918.   inverse.
  919.   
  920.   Let's verify this solution:
  921. ***************
  922. *** 2369,2376 ****
  923.   @end example
  924.   @end group
  925.   
  926. ! You can also build vectors out of consecutive integers, or many
  927. ! copies of a given value:
  928.   
  929.   @group
  930.   @example
  931. --- 2374,2381 ----
  932.   @end example
  933.   @end group
  934.   
  935. ! You can also build vectors out of consecutive integers, or out
  936. ! of many copies of a given value:
  937.   
  938.   @group
  939.   @example
  940. ***************
  941. *** 2767,2777 ****
  942.   
  943.   @group
  944.   @example
  945. ! 1:  8 +/- 0.2    2:  8 +/- 0.2    1:  0.266 +/- 0.011   1:  14.93 +/- 0.594
  946. !     .            1:  30 +/- 1         .                     .
  947.                        .
  948.   
  949. !     8 p .2           30 p 1           /                     I T
  950.   @end example
  951.   @end group
  952.   
  953. --- 2772,2782 ----
  954.   
  955.   @group
  956.   @example
  957. ! 1:  8 +/- 0.2    2:  8 +/- 0.2   1:  0.266 +/- 0.011   1:  14.93 +/- 0.594
  958. !     .            1:  30 +/- 1        .                     .
  959.                        .
  960.   
  961. !     8 p .2           30 p 1          /                     I T
  962.   @end example
  963.   @end group
  964.   
  965. ***************
  966. *** 3177,3183 ****
  967.   1:  [1, 2, ... ]    1:  [10, 11, ... ]    1:  [1, 1.1, ... ]
  968.       .                   .                     .
  969.   
  970. !     v x 10 RET          9 +                   10 /
  971.   @end example
  972.   @end group
  973.   
  974. --- 3182,3188 ----
  975.   1:  [1, 2, ... ]    1:  [10, 11, ... ]    1:  [1, 1.1, ... ]
  976.       .                   .                     .
  977.   
  978. !     v x 10 RET          9 +                   0.1 *
  979.   @end example
  980.   @end group
  981.   
  982. ***************
  983. *** 3461,3467 ****
  984.   
  985.   @group
  986.   @example
  987. ! 3:  []             1:  [0.10132, 0.03079, 0.02340, 0.33197, ...]
  988.   2:  2                  .
  989.   1:  30
  990.       .
  991. --- 3466,3472 ----
  992.   
  993.   @group
  994.   @example
  995. ! 3:  []             1:  [0.10132, 0.03079, 0.02340, 0.033197, ...]
  996.   2:  2                  .
  997.   1:  30
  998.       .
  999. ***************
  1000. *** 3508,3514 ****
  1001.   Let's edit in a new definition, for computing harmonic numbers.
  1002.   First, erase the three lines of the old definition.  Then, type
  1003.   in the new definition (or use Emacs @kbd{M-w} and @kbd{C-y} commands
  1004. ! to copy it from the Info file).
  1005.   
  1006.   @example
  1007.   calc-kbd-push         # Save local values (Z `)
  1008. --- 3513,3519 ----
  1009.   Let's edit in a new definition, for computing harmonic numbers.
  1010.   First, erase the three lines of the old definition.  Then, type
  1011.   in the new definition (or use Emacs @kbd{M-w} and @kbd{C-y} commands
  1012. ! to copy it from this page of the Info file).
  1013.   
  1014.   @example
  1015.   calc-kbd-push         # Save local values (Z `)
  1016. ***************
  1017. *** 4288,4297 ****
  1018.   An @dfn{interval} is a subset of consecutive real numbers.  For example,
  1019.   the interval @samp{[2 .. 4]} represents all the numbers from 2 to 4,
  1020.   inclusive.  If you multiply it by the interval @samp{[0.5 .. 2]} you
  1021. ! obtain @samp{[1 .. 6]}.  This calculation represents the fact that if
  1022.   you multiply some number in the range @samp{[2 .. 4]} by some other
  1023.   number in the range @samp{[0.5 .. 2]}, your result will lie in the range
  1024. ! from 1 to 6.  Interval arithmetic is used to get a worst-case estimate
  1025.   of the possible range of values a computation will produce, given the
  1026.   set of possible values of the input.
  1027.   
  1028. --- 4293,4302 ----
  1029.   An @dfn{interval} is a subset of consecutive real numbers.  For example,
  1030.   the interval @samp{[2 .. 4]} represents all the numbers from 2 to 4,
  1031.   inclusive.  If you multiply it by the interval @samp{[0.5 .. 2]} you
  1032. ! obtain @samp{[1 .. 8]}.  This calculation represents the fact that if
  1033.   you multiply some number in the range @samp{[2 .. 4]} by some other
  1034.   number in the range @samp{[0.5 .. 2]}, your result will lie in the range
  1035. ! from 1 to 8.  Interval arithmetic is used to get a worst-case estimate
  1036.   of the possible range of values a computation will produce, given the
  1037.   set of possible values of the input.
  1038.   
  1039. ***************
  1040. *** 5693,5699 ****
  1041.   The @kbd{\} (@code{calc-idiv}) command divides two numbers on the stack
  1042.   to produce an integer result.  It is equivalent to dividing with
  1043.   @key{/}, then rounding down with @kbd{F} (@code{calc-floor}), only a bit
  1044. ! more convenient and efficient.
  1045.   
  1046.   @kindex :
  1047.   @pindex calc-fdiv
  1048. --- 5698,5706 ----
  1049.   The @kbd{\} (@code{calc-idiv}) command divides two numbers on the stack
  1050.   to produce an integer result.  It is equivalent to dividing with
  1051.   @key{/}, then rounding down with @kbd{F} (@code{calc-floor}), only a bit
  1052. ! more convenient and efficient.  Also, since it is an all-integer
  1053. ! operation when the arguments are integers, it avoids problems that
  1054. ! @kbd{/ F} would have with floating-point roundoff.
  1055.   
  1056.   @kindex :
  1057.   @pindex calc-fdiv
  1058. ***************
  1059. *** 5730,5736 ****
  1060.   The @code{calc-abssqr} [@code{abssqr}] command computes the absolute
  1061.   value squared of a number, vector or matrix, or error form.
  1062.   
  1063. - @pindex calc-sign
  1064.   @tindex sign
  1065.   The @code{sign} algebraic function returns 1 if its argument is positive,
  1066.   -1 if its argument is negative, or 0 if its argument is zero.
  1067. --- 5737,5742 ----
  1068. ***************
  1069. *** 5766,5771 ****
  1070. --- 5772,5801 ----
  1071.   take any number of arguments and return the maximum or minimum among all
  1072.   the arguments.)@refill
  1073.   
  1074. + @pindex calc-mant-part
  1075. + @tindex mant
  1076. + @pindex calc-xpon-part
  1077. + @tindex xpon
  1078. + The @code{calc-mant-part} [@code{mant}] function extracts the ``mantissa''
  1079. + part @var{m} of its floating-point argument; @code{calc-xpon-part}
  1080. + [@code{xpon}] extracts the ``exponent'' part @var{e}.  The original
  1081. + number is equal to @samp{@var{m} * 10^@var{e}}, where @var{m} is in
  1082. + the interval @samp{[1.0 .. 10.0)} except that @samp{@var{m}=@var{e}=0}
  1083. + if the original number is zero.  For integers and fractions,
  1084. + @code{mant} returns the number unchanged and @code{xpon} returns zero.
  1085. + The @kbd{v u} (@code{calc-unpack}) command can also be used to ``unpack''
  1086. + a floating-point number; this produces an integer mantissa and exponent,
  1087. + with the constraint that the mantissa is either zero or a non-multiple
  1088. + of ten.@refill
  1089. + 
  1090. + @pindex calc-scale-float
  1091. + @tindex scf
  1092. + The @code{calc-scale-float} [@code{scf}] function scales a number by
  1093. + a given power of ten.  Thus, @samp{scf(mant(x), xpon(x)) = x} for any
  1094. + real @var{x}.  The second argument must be an integer, but the first
  1095. + may actually be any numeric value.  For example, @samp{scf(5,-2) = 0.05}
  1096. + or @samp{1:20} depending on the current Fraction Mode.@refill
  1097. + 
  1098.   @node Integer Truncation, Complex Number Functions, Basic Arithmetic, Arithmetic
  1099.   @section Integer Truncation
  1100.   
  1101. ***************
  1102. *** 6491,6512 ****
  1103.   number right by one bit, or by the number of bits specified in the numeric
  1104.   prefix argument:  @samp{rsh(a,n) = lsh(a,-n)}.
  1105.   
  1106. ! @kindex b s
  1107. ! @pindex calc-shift-binary
  1108.   @tindex ash
  1109. ! The @kbd{b s} (@code{calc-shift-binary}) [@code{ash}] command shifts a
  1110. ! number left in the same way as @code{lsh}.  However, if shifting right,
  1111. ! it performs an ``arithmetic'' shift, in which the leftmost bit (according
  1112. ! to the current word size) is duplicated rather than shifting in zeros.
  1113. ! This corresponds to dividing by two where the input is interpreted as a
  1114. ! signed, twos-complement number.  (The distinction between the @samp{lsh}
  1115. ! and @samp{ash} operations is totally independent from whether the word
  1116. ! size is positive or negative.)
  1117.   
  1118.   @kindex b R
  1119.   @pindex calc-rotate-binary
  1120.   @tindex rot
  1121. ! The @kbd{b R} (@code{calc-rotate-binary}) [@code{rot}] command rotates a
  1122.   number one bit to the left.  The leftmost bit (according to the current
  1123.   word size) is dropped off the left and shifted in on the right.  With a
  1124.   numeric prefix argument, the number is rotated the specified number of
  1125. --- 6521,6550 ----
  1126.   number right by one bit, or by the number of bits specified in the numeric
  1127.   prefix argument:  @samp{rsh(a,n) = lsh(a,-n)}.
  1128.   
  1129. ! @kindex b L
  1130. ! @pindex calc-lshift-arith
  1131.   @tindex ash
  1132. ! The @kbd{b L} (@code{calc-lshift-arith}) [@code{ash}] command shifts a
  1133. ! number left.  It is analogous to @code{lsh}, except that if the shift
  1134. ! is rightward (the prefix argument is negative), an arithmetic shift
  1135. ! is performed as described below.
  1136.   
  1137.   @kindex b R
  1138. + @pindex calc-rshift-arith
  1139. + @tindex rash
  1140. + The @kbd{b R} (@code{calc-rshift-arith}) [@code{rash}] command performs
  1141. + an ``arithmetic'' shift to the right, in which the leftmost bit (according
  1142. + to the current word size) is duplicated rather than shifting in zeros.
  1143. + This corresponds to dividing by a power of two where the input is interpreted
  1144. + as a signed, twos-complement number.  (The distinction between the @samp{rsh}
  1145. + and @samp{rash} operations is totally independent from whether the word
  1146. + size is positive or negative.)  With a negative prefix argument, this
  1147. + performs a standard left shift.
  1148. + 
  1149. + @kindex b t
  1150.   @pindex calc-rotate-binary
  1151.   @tindex rot
  1152. ! The @kbd{b t} (@code{calc-rotate-binary}) [@code{rot}] command rotates a
  1153.   number one bit to the left.  The leftmost bit (according to the current
  1154.   word size) is dropped off the left and shifted in on the right.  With a
  1155.   numeric prefix argument, the number is rotated the specified number of
  1156. ***************
  1157. *** 7195,7206 ****
  1158.   
  1159.   The @code{calc-substitute} command normally prompts for two formulas,
  1160.   the old one and the new one.  If you enter a blank line for the first
  1161. ! prompt, all three arguments are taken from the stack (old, then new,
  1162.   then target expression).  If you type an old formula but then enter a
  1163.   blank line for the new one, the new formula is taken from top-of-stack
  1164.   and the target from second-to-top.  If you answer both prompts, the
  1165.   target is taken from top-of-stack as usual.
  1166.   
  1167.   @node Rewrite Rules, Logical Operations, Algebraic Manipulation, Algebra
  1168.   @section Rewrite Rules
  1169.   
  1170. --- 7233,7252 ----
  1171.   
  1172.   The @code{calc-substitute} command normally prompts for two formulas,
  1173.   the old one and the new one.  If you enter a blank line for the first
  1174. ! prompt, all three arguments are taken from the stack (new, then old,
  1175.   then target expression).  If you type an old formula but then enter a
  1176.   blank line for the new one, the new formula is taken from top-of-stack
  1177.   and the target from second-to-top.  If you answer both prompts, the
  1178.   target is taken from top-of-stack as usual.
  1179.   
  1180. + Note that @code{calc-substitute} has no understanding of commutativity
  1181. + or associativity.  The pattern @samp{x+y} will not match the formula
  1182. + @samp{y+x}.  Also, @samp{y+z} will not match inside the formula @samp{x+y+z}
  1183. + because the @samp{+} operator is left-associative, so the ``deep
  1184. + structure'' of that formula is @samp{(x+y) + z}.  Use @kbd{d U}
  1185. + (@code{calc-unformatted-language}) mode to see the true structure of
  1186. + a formula.
  1187. + 
  1188.   @node Rewrite Rules, Logical Operations, Algebraic Manipulation, Algebra
  1189.   @section Rewrite Rules
  1190.   
  1191. ***************
  1192. *** 7254,7260 ****
  1193.   Pattern-matching is completely structural, not taking the algebraic
  1194.   properties of formulas into account.  Thus @samp{f(x+1)} matches
  1195.   the formula @samp{f(a+1)} but not @samp{f(a)}, @samp{f(a+2)}, or
  1196. ! @samp{f(1+a)}.@refill
  1197.   
  1198.   If the @samp{old} pattern is found to match a given formula, that
  1199.   formula is replaced by @samp{new}, where any occurrences in @samp{new}
  1200. --- 7300,7307 ----
  1201.   Pattern-matching is completely structural, not taking the algebraic
  1202.   properties of formulas into account.  Thus @samp{f(x+1)} matches
  1203.   the formula @samp{f(a+1)} but not @samp{f(a)}, @samp{f(a+2)}, or
  1204. ! @samp{f(1+a)}.  For other examples @pxref{Algebraic Manipulation},
  1205. ! under the discussion of @code{calc-substitute}.@refill
  1206.   
  1207.   If the @samp{old} pattern is found to match a given formula, that
  1208.   formula is replaced by @samp{new}, where any occurrences in @samp{new}
  1209. ***************
  1210. *** 8771,8777 ****
  1211.   @example
  1212.   (defmath myfact (n)
  1213.     (if (> n 0)
  1214. !       (* (myfact (1- n)))
  1215.       (if (= n 0)
  1216.           1
  1217.         nil)))    ; this could be simplified as: (and (= n 0) 1)
  1218. --- 8818,8824 ----
  1219.   @example
  1220.   (defmath myfact (n)
  1221.     (if (> n 0)
  1222. !       (* n (myfact (1- n)))
  1223.       (if (= n 0)
  1224.           1
  1225.         nil)))    ; this could be simplified as: (and (= n 0) 1)
  1226. ***************
  1227. *** 9023,9029 ****
  1228.     "Compute the factorial of the integer at the top of the stack."
  1229.     (interactive 1 "fact")
  1230.     (if (> n 0)
  1231. !       (* (myfact (1- n)))
  1232.       (and (= n 0) 1)))
  1233.   @end example
  1234.   
  1235. --- 9070,9076 ----
  1236.     "Compute the factorial of the integer at the top of the stack."
  1237.     (interactive 1 "fact")
  1238.     (if (> n 0)
  1239. !       (* n (myfact (1- n)))
  1240.       (and (= n 0) 1)))
  1241.   @end example
  1242.   
  1243. ***************
  1244. *** 10900,10906 ****
  1245.   @node Installation, Reporting Bugs, Programming, Top
  1246.   @chapter Installation
  1247.   
  1248. ! Calc comes as a pair of Emacs Lisp files, generally called
  1249.   @file{calc.el} and @file{calc-ext.el}.  The first contains the basic
  1250.   foundations of the Calculator, and is as small as possible to promote
  1251.   quick loading.  The second contains all the more advanced commands and
  1252. --- 10947,10953 ----
  1253.   @node Installation, Reporting Bugs, Programming, Top
  1254.   @chapter Installation
  1255.   
  1256. ! Calc 1.04 comes as a pair of Emacs Lisp files, generally called
  1257.   @file{calc.el} and @file{calc-ext.el}.  The first contains the basic
  1258.   foundations of the Calculator, and is as small as possible to promote
  1259.   quick loading.  The second contains all the more advanced commands and
  1260. ***************
  1261. *** 10908,10913 ****
  1262. --- 10955,10962 ----
  1263.   @kbd{M-#} command auto-loads only the first part, and the second part is
  1264.   auto-loaded whenever the first advanced feature is used.@refill
  1265.   
  1266. + @section Compilation
  1267. + 
  1268.   Calc is written in a way that maximizes performance when its code has been
  1269.   byte-compiled; a side effect is that performance is seriously degraded if
  1270.   it @emph{isn't} compiled.  Thus, it is essential to compile the Calculator
  1271. ***************
  1272. *** 10918,10926 ****
  1273.   calc.elc} before compiling @file{calc-ext.el} will work.
  1274.   
  1275.   For your convenience, the FTP distribution of Calc, obtainable from
  1276. ! anonymous FTP on @samp{csvax.caltech.edu}, includes already-compiled
  1277.   versions of both of these files.
  1278.   
  1279.   To teach Emacs how to load in Calc when you type @kbd{M-x calc} for the
  1280.   first time, include these lines in your @file{.emacs} file (if you are
  1281.   installing Calc just for your own use), or the system's @file{lisp/default}
  1282. --- 10967,10977 ----
  1283.   calc.elc} before compiling @file{calc-ext.el} will work.
  1284.   
  1285.   For your convenience, the FTP distribution of Calc, obtainable from
  1286. ! anonymous FTP on @samp{csvax.cs.caltech.edu}, includes already-compiled
  1287.   versions of both of these files.
  1288.   
  1289. + @section Auto-loading
  1290. + 
  1291.   To teach Emacs how to load in Calc when you type @kbd{M-x calc} for the
  1292.   first time, include these lines in your @file{.emacs} file (if you are
  1293.   installing Calc just for your own use), or the system's @file{lisp/default}
  1294. ***************
  1295. *** 10950,10962 ****
  1296.   reasonably be used before the user has typed @kbd{M-x calc} for the
  1297.   first time.
  1298.   
  1299.   If you don't want to bother with a split Calculator, you can simply
  1300.   concatenate @code{calc-ext.elc} onto the end of @code{calc.elc}, rewrite
  1301.   the above @code{autoload} commands all to point to the combined file,
  1302.   and treat Calc as one big program.  You may need to do this if
  1303. ! @code{autoload} is giving you problems.
  1304.   
  1305. ! You may also wish to bind the @code{calc} command to a key.  The
  1306.   recommended keystroke is @kbd{M-#} (i.e., Meta-Shift-3).  To set up
  1307.   this key binding, include this command in your @file{.emacs} or
  1308.   @file{lisp/default} file:
  1309. --- 11001,11058 ----
  1310.   reasonably be used before the user has typed @kbd{M-x calc} for the
  1311.   first time.
  1312.   
  1313. + @section Merging @file{calc} and @file{calc-ext}
  1314. + 
  1315.   If you don't want to bother with a split Calculator, you can simply
  1316.   concatenate @code{calc-ext.elc} onto the end of @code{calc.elc}, rewrite
  1317.   the above @code{autoload} commands all to point to the combined file,
  1318.   and treat Calc as one big program.  You may need to do this if
  1319. ! the @code{autoload} mechanism is giving you problems.
  1320. ! 
  1321. ! @section Splitting @file{calc-ext}
  1322. ! 
  1323. ! On the other hand, you may find that @file{calc-ext.el} is too big to load
  1324. ! quickly.  You can split the Calculator into still more parts using the
  1325. ! @code{calc-split} command.  This command splits the file
  1326. ! @file{calc-ext.el} into about 20 small files with names like
  1327. ! @file{calc-cplx.el} and @file{calc-mode.el} in the same directory
  1328. ! as @file{calc-ext.el}.  First, load the file @file{calc-ext.el} with
  1329. ! @kbd{C-x C-f}.  Move to the end of the buffer and type @kbd{C-x C-e}
  1330. ! at the indicated position.  Now type @kbd{M-x calc-split}.
  1331. ! This moves most of the text out of @file{calc-ext.el} and into
  1332. ! other files.  All necessary @code{autoload} commands are inserted
  1333. ! into @file{calc-ext.el}.@refill
  1334. ! 
  1335. ! The @code{calc-split} command prompts for a directory name; the new
  1336. ! files are placed in this directory, and the @code{autoload} commands are
  1337. ! written to refer to the directory explicitly.  If you wish you can
  1338. ! backspace over the default directory name and enter a blank name, in
  1339. ! which case the @code{autoload} commands will be written without
  1340. ! directory names on the assumption that Emacs can find the Calc files in
  1341. ! one of the default places.  Some people prefer to put the Calc files in
  1342. ! a subdirectory by themselves.@refill
  1343. ! 
  1344. ! The @code{calc-split} command also offers to byte-compile all Calc files
  1345. ! automatically.  Note that @file{calc.el} must have been byte-compiled
  1346. ! and loaded already, just as if you were compiling @file{calc-ext} whole.
  1347. ! If you choose to compile by hand, you will need to compile @file{calc.el}
  1348. ! first, load it, compile the new @file{calc-ext.el} and load it, then
  1349. ! compile each of the new component files.  Also, note that the
  1350. ! @code{autoload} commands shown above are still correct for use in
  1351. ! your startup file.@refill
  1352. ! 
  1353. ! If you do decide to use @code{calc-split}, note that when patches
  1354. ! are made available for new versions of Calc, they will refer to
  1355. ! the old, unsplit version of the file @file{calc-ext.el}.  The
  1356. ! @code{calc-split} command makes a copy of this under the name
  1357. ! @file{calc-old.el}; be sure to keep it around so you can rename
  1358. ! it back to @file{calc-ext.el} before installing new patches.
  1359. ! You can then use @code{calc-split} again to re-split your updated
  1360. ! version of Calc.@refill
  1361. ! 
  1362. ! @section Key Bindings
  1363.   
  1364. ! You may wish to bind the @code{calc} command to a key.  The
  1365.   recommended keystroke is @kbd{M-#} (i.e., Meta-Shift-3).  To set up
  1366.   this key binding, include this command in your @file{.emacs} or
  1367.   @file{lisp/default} file:
  1368. ***************
  1369. *** 10968,10973 ****
  1370. --- 11064,11071 ----
  1371.   There are no standard key assignments for @code{quick-calc} and
  1372.   @code{calc-grab-region}, but you may wish to define some.
  1373.   
  1374. + @section The @file{macedit} Package
  1375. + 
  1376.   The file @file{macedit.el} contains another useful Emacs extension
  1377.   called @code{edit-kbd-macro}.  It allows you to edit a keyboard macro
  1378.   in human-readable form.  The @kbd{Z E} command in Calc knows how to
  1379. ***************
  1380. *** 10979,10984 ****
  1381. --- 11077,11084 ----
  1382.   (autoload 'edit-last-kbd-macro ".../macedit.elc" "Edit Keyboard Macro" t nil)
  1383.   @end example
  1384.   
  1385. + @section Documentation
  1386. + 
  1387.   The documentation for Calc (i.e., this manual) comes in a file
  1388.   @file{calc.texinfo}.  To format this for use as an on-line manual,
  1389.   open this file for editing in Emacs and give the command
  1390. ***************
  1391. *** 11002,11007 ****
  1392. --- 11102,11109 ----
  1393.   in your @file{.emacs} or @file{lisp/default} file, where again @file{...}
  1394.   represents the directory containing the Info files.
  1395.   
  1396. + @section Settings File
  1397. + 
  1398.   @vindex calc-settings-file
  1399.   Another variable you might want to set is @code{calc-settings-file},
  1400.   which holds the file name in which commands like @kbd{m m} and @kbd{Z P}
  1401. ***************
  1402. *** 11012,11017 ****
  1403. --- 11114,11121 ----
  1404.   automatically load your settings file (if it exists) the first time
  1405.   Calc is invoked.@refill
  1406.   
  1407. + @section Testing the Installation
  1408. + 
  1409.   To test your installation of Calc, start a fresh Emacs and type @kbd{M-#}
  1410.   to make sure the autoload commands and key bindings work.  Now, type
  1411.   @kbd{i} to make sure Calc can find its Info documentation.  Press @kbd{q}
  1412. ***************
  1413. *** 11027,11033 ****
  1414.   @chapter Reporting Bugs
  1415.   
  1416.   If you find a bug in Calc, send e-mail to Dave Gillespie,
  1417. ! @samp{daveg@@csvax.caltech.edu}.  While I cannot guarantee that I
  1418.   will have time to work on your bug, I do try to fix bugs quickly
  1419.   whenever I can.
  1420.   
  1421. --- 11131,11137 ----
  1422.   @chapter Reporting Bugs
  1423.   
  1424.   If you find a bug in Calc, send e-mail to Dave Gillespie,
  1425. ! @samp{daveg@@csvax.cs.caltech.edu}.  While I cannot guarantee that I
  1426.   will have time to work on your bug, I do try to fix bugs quickly
  1427.   whenever I can.
  1428.   
  1429.  
  1430.