home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume13 / gmcalc / patch02 < prev    next >
Encoding:
Text File  |  1990-07-02  |  25.1 KB  |  679 lines
  1. Newsgroups: comp.sources.misc
  2. subject: v13i082: Patch for GNU Emacs Calc, version 1.02 -> 1.03
  3. from: daveg@csvax.caltech.edu (David Gillespie)
  4. Sender: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  5.  
  6. Posting-number: Volume 13, Issue 82
  7. Submitted-by: daveg@csvax.caltech.edu (David Gillespie)
  8. Archive-name: gmcalc/patch02
  9.  
  10. The following patches convert Calc version 1.02 into Calc
  11. version 1.03.  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 INSTALL file.
  16.  
  17. These patches do not cover the README and INSTALL files.  The
  18. INSTALL file is just a copy of the "Installation" chapter of
  19. calc.texinfo, which is updated by this patch.  Note that some
  20. patches will add to the list of "autoload" commands recommended
  21. in that chapter.
  22.  
  23. Patches and complete tar files are also available from anonymous FTP
  24. on csvax.caltech.edu, in the "pub" subdirectory.
  25.  
  26. Enjoy!
  27.                             -- Dave
  28.  
  29. Dave Gillespie
  30. 256-80 Caltech, Pasadena CA 91125
  31. daveg@csvax.caltech.edu, ...!cit-vax!daveg
  32.  
  33.  
  34.  
  35. *** calc.el    Tue Jun 26 16:33:01 1990
  36. --- ../dist/calc.el    Tue Jun 26 17:02:14 1990
  37. ***************
  38. *** 1,4 ****
  39. ! ;; Calculator for GNU Emacs version 1.02
  40.   ;; Copyright (C) 1990 Dave Gillespie
  41.   
  42.   ;; This file is part of GNU Emacs.
  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. ***************
  49. *** 23,39 ****
  50.   ;;; commands only.  Assuming the autoload commands shown below have been
  51.   ;;; done, the Calculator will autoload the remaining commands from calc-ext.elc
  52.   ;;; whenever one is first needed.  If you wish, you can concatenate calc-ext
  53. ! ;;; onto the end of calc (.el or .elc) to make one big file.
  54.   
  55.   ;;; Suggested usage:
  56.   ;;;
  57.   ;;;   (autoload 'calc ".../calc.elc" "Calculator Mode" t nil)
  58.   ;;;   (autoload 'quick-calc ".../calc.elc" "Quick Calculator" t nil)
  59.   ;;;   (autoload 'calc-grab-region ".../calc-ext.elc" nil t nil)
  60.   ;;;   (autoload 'defmath ".../calc-ext.elc" nil t t)
  61.   ;;;   (autoload 'calc-extensions ".../calc-ext.elc" nil nil nil)
  62.   ;;;   (global-set-key "\e#" 'calc)
  63. ! ;;;   M-x calc
  64.   ;;;
  65.   ;;; where ".../calc.elc" represents the full path for "calc.elc",
  66.   ;;; and ".../calc-ext.elc" is the path of the companion file containing
  67. --- 23,41 ----
  68.   ;;; commands only.  Assuming the autoload commands shown below have been
  69.   ;;; done, the Calculator will autoload the remaining commands from calc-ext.elc
  70.   ;;; whenever one is first needed.  If you wish, you can concatenate calc-ext
  71. ! ;;; onto the end of calc to make one big file (.el or .elc).
  72.   
  73.   ;;; Suggested usage:
  74.   ;;;
  75.   ;;;   (autoload 'calc ".../calc.elc" "Calculator Mode" t nil)
  76.   ;;;   (autoload 'quick-calc ".../calc.elc" "Quick Calculator" t nil)
  77. + ;;;   (autoload 'full-calc ".../calc.elc" "Full-screen Calculator" t nil)
  78. + ;;;   (autoload 'calc-eval ".../calc.elc" "Call Calculator" nil nil)
  79.   ;;;   (autoload 'calc-grab-region ".../calc-ext.elc" nil t nil)
  80.   ;;;   (autoload 'defmath ".../calc-ext.elc" nil t t)
  81.   ;;;   (autoload 'calc-extensions ".../calc-ext.elc" nil nil nil)
  82.   ;;;   (global-set-key "\e#" 'calc)
  83. ! ;;;   `M-x calc' or `M-#' to start.
  84.   ;;;
  85.   ;;; where ".../calc.elc" represents the full path for "calc.elc",
  86.   ;;; and ".../calc-ext.elc" is the path of the companion file containing
  87. ***************
  88. *** 45,58 ****
  89.   ;;;   daveg@csvax.caltech.edu, ...!cit-vax!daveg.
  90.   ;;;
  91.   ;;; This file and the manual, calc.texinfo, are available from anonymous FTP
  92. ! ;;; on csvax.caltech.edu [192.12.18.1]; look in ~ftp/pub/calc.
  93.   ;;;
  94.   ;;; Bug reports and suggestions are always welcome!
  95.   
  96.   
  97.   ;;; All functions, macros, and Lisp variables defined here begin with one
  98. ! ;;; of the prefixes "math", "Math", or "calc", with the exception of
  99. ! ;;; "another-calc".  User-accessible variables begin with "var-".
  100.   
  101.   
  102.   
  103. --- 47,61 ----
  104.   ;;;   daveg@csvax.caltech.edu, ...!cit-vax!daveg.
  105.   ;;;
  106.   ;;; This file and the manual, calc.texinfo, are available from anonymous FTP
  107. ! ;;; on csvax.caltech.edu [192.12.18.1]; look in ~ftp/pub/calc*.
  108.   ;;;
  109.   ;;; Bug reports and suggestions are always welcome!
  110.   
  111.   
  112.   ;;; All functions, macros, and Lisp variables defined here begin with one
  113. ! ;;; of the prefixes "math", "Math", or "calc", with the exceptions of
  114. ! ;;; "full-calc", "another-calc", "quick-calc", "report-calc-bug",
  115. ! ;;; and "defmath".  User-accessible variables begin with "var-".
  116.   
  117.   
  118.   
  119. ***************
  120. *** 60,66 ****
  121.   
  122.   (defmacro calc-record-compilation-date-macro ()
  123.     (` (setq calc-version (concat "Emacs Calc Mode"
  124. !                 " v1.02 by Dave Gillespie"
  125.                   ", installed "
  126.                   (, (current-time-string))
  127.                   " by "
  128. --- 63,69 ----
  129.   
  130.   (defmacro calc-record-compilation-date-macro ()
  131.     (` (setq calc-version (concat "Emacs Calc Mode"
  132. !                 " v1.03 by Dave Gillespie"
  133.                   ", installed "
  134.                   (, (current-time-string))
  135.                   " by "
  136. ***************
  137. *** 143,148 ****
  138. --- 146,152 ----
  139.   ;;;
  140.   ;;;   Tim suggests adding spreadsheet-like features.
  141.   ;;;   How about ultra-low-resolution plots?  (Probably too slow.)
  142. + ;;;   How about running gnuplot to generate high-res plots?
  143.   ;;;   Implement language modes for Lisp, Ada, ...?
  144.   ;;;
  145.   
  146. ***************
  147. *** 794,811 ****
  148.          (calc-dollar-values calc-quick-prev-results)
  149.          (calc-dollar-used 0)
  150.          (enable-recursive-minibuffers t)
  151. !        (alg-exp (calc-do-alg-entry "" "Quick calc: ")))
  152. !       (let ((buf ""))
  153. !     (setq calc-quick-prev-results alg-exp)
  154. !     (while alg-exp
  155.         (setq buf (concat buf
  156.                   (if calc-extensions-loaded
  157. !                 (math-format-value (car alg-exp) 1000)
  158. !                   (math-format-flat-expr (car alg-exp) 0))
  159. !                 " ")
  160. !         alg-exp (cdr alg-exp)))
  161. !     (calc-handle-whys)
  162. !     (message buf))))
  163.   )
  164.   
  165.   (defun calc-summary (&optional full)
  166. --- 798,841 ----
  167.          (calc-dollar-values calc-quick-prev-results)
  168.          (calc-dollar-used 0)
  169.          (enable-recursive-minibuffers t)
  170. !        (alg-exp (calc-do-alg-entry "" "Quick calc: "))
  171. !        buf)
  172. !       (setq calc-quick-prev-results alg-exp)
  173. !       (while alg-exp
  174. !     (setq buf (concat buf
  175. !               (and buf " ")
  176. !               (if calc-extensions-loaded
  177. !                   (math-format-value (car alg-exp) 1000)
  178. !                 (math-format-flat-expr (car alg-exp) 0)))
  179. !           alg-exp (cdr alg-exp)))
  180. !       (calc-handle-whys)
  181. !       (message buf)))
  182. ! )
  183. ! 
  184. ! (defun calc-eval (str &optional separator &rest args)
  185. !   "Do a quick calculation and return the result as a string.
  186. ! Return value will either be the formatted result in string form,
  187. ! or a list containing a character position and an error message in string form."
  188. !   (save-excursion
  189. !     (calc-create-buffer)
  190. !     (let* ((calc-command-flags nil)
  191. !        (calc-language (if (memq calc-language '(nil big))
  192. !                   'flat calc-language))
  193. !        (calc-dollar-values args)
  194. !        (calc-dollar-used 0)
  195. !        (res (math-read-exprs str))
  196. !        buf)
  197. !       (if (eq (car res) 'error)
  198. !       (cdr res)
  199. !     (setq res (mapcar 'calc-normalize res))
  200. !     (while res
  201.         (setq buf (concat buf
  202. +                 (and buf (or separator ", "))
  203.                   (if calc-extensions-loaded
  204. !                 (math-format-value (car res) 1000)
  205. !                   (math-format-flat-expr (car res) 0)))
  206. !         res (cdr res)))
  207. !     buf)))
  208.   )
  209.   
  210.   (defun calc-summary (&optional full)
  211. ***************
  212. *** 2598,2604 ****
  213.   
  214.   
  215.   ;;; Build a normalized fraction.  [R I I]
  216. ! ;;; (This could probably be implemented more efficiently than using the
  217.   ;;;  the plain gcd algorithm.)
  218.   (defun math-make-frac (num den)
  219.     (if (Math-integer-negp den)
  220. --- 2628,2634 ----
  221.   
  222.   
  223.   ;;; Build a normalized fraction.  [R I I]
  224. ! ;;; (This could probably be implemented more efficiently than using
  225.   ;;;  the plain gcd algorithm.)
  226.   (defun math-make-frac (num den)
  227.     (if (Math-integer-negp den)
  228. ***************
  229. *** 3802,3808 ****
  230.              exp-data (math-restore-dashes
  231.                    (math-match-substring exp-str 0))))
  232.           ((or (and (>= ch ?0) (<= ch ?9))
  233. !          (memq ch '(?\. ?_)))
  234.            (or (and (eq calc-language 'c)
  235.                 (string-match "0[xX][0-9a-fA-F]+" exp-str exp-pos))
  236.            (string-match "_?\\([0-9]+.?0*@ *\\)?\\([0-9]+.?0*' *\\)?\\([0-9]+\\(#\\|\\^\\^\\)[0-9a-zA-Z:]+\\|[0-9]+:[0-9:]+\\|[0-9.]+\\([eE][-+_]?[0-9]+\\)?\"?\\)?" exp-str exp-pos))
  237. --- 3832,3842 ----
  238.              exp-data (math-restore-dashes
  239.                    (math-match-substring exp-str 0))))
  240.           ((or (and (>= ch ?0) (<= ch ?9))
  241. !          (eq ch '?\.)
  242. !          (and (eq ch '?_)
  243. !               (or (not (eq calc-language 'tex))
  244. !               (eq exp-pos 0)
  245. !               (memq (elt exp-str (1- exp-pos)) '(32 ?\()))))
  246.            (or (and (eq calc-language 'c)
  247.                 (string-match "0[xX][0-9a-fA-F]+" exp-str exp-pos))
  248.            (string-match "_?\\([0-9]+.?0*@ *\\)?\\([0-9]+.?0*' *\\)?\\([0-9]+\\(#\\|\\^\\^\\)[0-9a-zA-Z:]+\\|[0-9]+:[0-9:]+\\|[0-9.]+\\([eE][-+_]?[0-9]+\\)?\"?\\)?" exp-str exp-pos))
  249. ***************
  250. *** 4072,4078 ****
  251.     (interactive "sBug Subject: ")
  252.     (mail nil calc-bug-address topic)
  253.     (goto-char (point-max))
  254. !   (insert "\nIn Calc 1.02, Emacs " (emacs-version) "\n\n")
  255.     (message (substitute-command-keys "Type \\[mail-send] to send bug report."))
  256.   )
  257.   
  258. --- 4106,4112 ----
  259.     (interactive "sBug Subject: ")
  260.     (mail nil calc-bug-address topic)
  261.     (goto-char (point-max))
  262. !   (insert "\nIn Calc 1.03, Emacs " (emacs-version) "\n\n")
  263.     (message (substitute-command-keys "Type \\[mail-send] to send bug report."))
  264.   )
  265.   
  266. *** calc-ext.el    Wed Jun 13 11:27:16 1990
  267. --- ../dist/calc-ext.el    Tue Jun 26 17:02:21 1990
  268. ***************
  269. *** 1,4 ****
  270. ! ;; Calculator for GNU Emacs, part II
  271.   ;; Copyright (C) 1990 Dave Gillespie
  272.   
  273.   ;; This file is part of GNU Emacs.
  274. --- 1,4 ----
  275. ! ;; Calculator for GNU Emacs version 1.03, part II
  276.   ;; Copyright (C) 1990 Dave Gillespie
  277.   
  278.   ;; This file is part of GNU Emacs.
  279. ***************
  280. *** 1454,1466 ****
  281.      (t s))
  282.   )
  283.   
  284. ! (defun calc-grab-region (top bot)
  285.     "Parse the region as a matrix of numbers and push it on the Calculator stack.
  286.   This is intended to be used in a non-Calculator buffer!
  287.   If the start and the end of the region are in column zero, the contained lines
  288.   are parsed into rows of the matrix.  Otherwise, point and mark define a
  289. ! rectangle which is parsed into a matrix."
  290. !   (interactive "r")
  291.     (and (memq major-mode '(calc-mode calc-trail-mode))
  292.          (error "This command works only in a regular text buffer."))
  293.     (let* ((col1 (save-excursion (goto-char top) (current-column)))
  294. --- 1454,1480 ----
  295.      (t s))
  296.   )
  297.   
  298. ! (defun calc-grab-region (top bot arg)
  299.     "Parse the region as a matrix of numbers and push it on the Calculator stack.
  300.   This is intended to be used in a non-Calculator buffer!
  301.   If the start and the end of the region are in column zero, the contained lines
  302.   are parsed into rows of the matrix.  Otherwise, point and mark define a
  303. ! rectangle which is parsed into a matrix.
  304. ! 
  305. ! With a positive numeric prefix N, each line is divided into columns of
  306. ! width N which become the elements of that row of the matrix.  With a
  307. ! prefix of zero, each line is interpreted in its entirety as a formula
  308. ! which becomes a row of the (one-column) matrix.
  309. ! 
  310. ! Otherwise, if a line contains a portion delimited by square brackets
  311. ! or curly braces (possibly surrounded by other ignored text), that portion
  312. ! is interpreted as a vector which becomes a row of the matrix.  This can be
  313. ! suppressed by giving a negative numeric prefix argument.
  314. ! 
  315. ! Otherwise, the entire contents of the line are parsed as if surrounded by
  316. ! brackets.  If a stack-style line number (as in \"23: \") is present it is
  317. ! first removed."
  318. !   (interactive "r\nP")
  319.     (and (memq major-mode '(calc-mode calc-trail-mode))
  320.          (error "This command works only in a regular text buffer."))
  321.     (let* ((col1 (save-excursion (goto-char top) (current-column)))
  322. ***************
  323. *** 1481,1505 ****
  324.       (calc)
  325.       (setq mat (list 'vec)
  326.         lnum 0)
  327.       (while data
  328. !       (if (string-match "[[{][^][{}]*[]}]" (car data))
  329. !       (setq pos (match-beginning 0)
  330. !         vals (math-read-expr (math-match-substring (car data) 0)))
  331. !     (if (string-match "\\`\\([0-9]+:[ \t]\\)?\\(.*[^, \t]\\)[, \t]*\\'" (car data))
  332.           (setq pos -1
  333. !           vals (math-read-expr (concat "["
  334. !                            (math-match-substring
  335. !                         (car data) 2)
  336. !                            "]")))
  337. !       (setq pos -1
  338. !         vals (math-read-expr (concat "[" (car data) "]")))))
  339.         (if (eq (car-safe vals) 'error)
  340.         (progn
  341.           (calc-quit)
  342.           (switch-to-buffer from-buffer)
  343.           (goto-char top)
  344. !         (next-line lnum)
  345. !         (forward-char (+ (nth 1 vals) pos))
  346.           (error (nth 2 vals))))
  347.         (setq mat (cons vals mat)
  348.           data (cdr data)
  349. --- 1495,1540 ----
  350.       (calc)
  351.       (setq mat (list 'vec)
  352.         lnum 0)
  353. +     (and arg
  354. +      (setq arg (prefix-numeric-value arg)))
  355.       (while data
  356. !       (if (natnump arg)
  357. !       (progn
  358. !         (if (= arg 0)
  359. !         (setq arg 1000000))
  360. !         (setq pos 0
  361. !           vals (list 'vec))
  362. !         (let ((w (length (car data)))
  363. !           j v)
  364. !           (while (< pos w)
  365. !         (setq j (+ pos arg)
  366. !               v (if (>= j w)
  367. !                 (math-read-expr (substring (car data) pos))
  368. !               (math-read-expr (substring (car data) pos j))))
  369. !         (if (eq (car-safe v) 'error)
  370. !             (setq vals v w 0)
  371. !           (setq vals (nconc vals (list v))
  372. !             pos j)))))
  373. !     (if (and (null arg)
  374. !          (string-match "[[{][^][{}]*[]}]" (car data)))
  375. !         (setq pos (match-beginning 0)
  376. !           vals (math-read-expr (math-match-substring (car data) 0)))
  377. !       (if (string-match "\\`\\([0-9]+:[ \t]\\)?\\(.*[^, \t]\\)[, \t]*\\'"
  378. !                 (car data))
  379. !           (setq pos -1
  380. !             vals (math-read-expr (concat "["
  381. !                          (math-match-substring
  382. !                           (car data) 2)
  383. !                          "]")))
  384.           (setq pos -1
  385. !           vals (math-read-expr (concat "[" (car data) "]"))))))
  386.         (if (eq (car-safe vals) 'error)
  387.         (progn
  388.           (calc-quit)
  389.           (switch-to-buffer from-buffer)
  390.           (goto-char top)
  391. !         (forward-line lnum)
  392. !         (forward-char (+ (nth 1 vals) (min col1 col2) pos))
  393.           (error (nth 2 vals))))
  394.         (setq mat (cons vals mat)
  395.           data (cdr data)
  396. ***************
  397. *** 2860,2865 ****
  398. --- 2895,2901 ----
  399.        ( \\tan       . calcFunc-tan )
  400.        ( \\sin       . calcFunc-sin )
  401.        ( \\sinh       . calcFunc-sinh )
  402. +      ( \\sqrt       . calcFunc-sqrt )
  403.        ( \\tanh       . calcFunc-tanh )
  404.        ( \\phi       . calcFunc-totient )
  405.        ( \\mu       . calcFunc-moebius )
  406. ***************
  407. *** 9917,9923 ****
  408.   
  409.   (defun math-choose (n m)   ; [I I I] [F F F] [Public]
  410.     (cond ((and (integerp n) (integerp m) (<= m n) (>= m 0))
  411. !      (math-choose-iter m n 1 1))
  412.       ((not (math-realp n))
  413.        (math-reject-arg n 'realp))
  414.       ((not (math-realp m))
  415. --- 9953,9961 ----
  416.   
  417.   (defun math-choose (n m)   ; [I I I] [F F F] [Public]
  418.     (cond ((and (integerp n) (integerp m) (<= m n) (>= m 0))
  419. !      (if (> m (/ n 2))
  420. !          (math-choose-iter (- n m) n 1 1)
  421. !        (math-choose-iter m n 1 1)))
  422.       ((not (math-realp n))
  423.        (math-reject-arg n 'realp))
  424.       ((not (math-realp m))
  425. ***************
  426. *** 10564,10570 ****
  427.   (fset 'calcFunc-rsh (symbol-function 'math-rshift-binary))
  428.   
  429.   (defun math-shift-binary (a &optional n w)   ; [I I] [Public]
  430. !   (if (not (Math-negp n))
  431.         (math-lshift-binary a n w)
  432.       (setq a (math-trunc a)
  433.         n (if n (math-trunc n) 1))
  434. --- 10602,10609 ----
  435.   (fset 'calcFunc-rsh (symbol-function 'math-rshift-binary))
  436.   
  437.   (defun math-shift-binary (a &optional n w)   ; [I I] [Public]
  438. !   (if (or (null n)
  439. !       (not (Math-negp n)))
  440.         (math-lshift-binary a n w)
  441.       (setq a (math-trunc a)
  442.         n (if n (math-trunc n) 1))
  443. *** calc.texinfo    Tue Jun 26 16:34:50 1990
  444. --- ../dist/calc.texinfo    Tue Jun 26 17:02:30 1990
  445. ***************
  446. *** 1,7 ****
  447.   \input texinfo                  @c -*-texinfo-*-
  448.   @comment %**start of header (This is for running Texinfo on a region.)
  449.   @setfilename calc-info
  450. ! @settitle GNU Emacs Calc 1.02 Manual
  451.   @setchapternewpage odd
  452.   @comment %**end of header (This is for running Texinfo on a region.)
  453.   
  454. --- 1,7 ----
  455.   \input texinfo                  @c -*-texinfo-*-
  456.   @comment %**start of header (This is for running Texinfo on a region.)
  457.   @setfilename calc-info
  458. ! @settitle GNU Emacs Calc 1.03 Manual
  459.   @setchapternewpage odd
  460.   @comment %**end of header (This is for running Texinfo on a region.)
  461.   
  462. ***************
  463. *** 38,44 ****
  464.   @sp 6
  465.   @center @titlefont{Calc Manual}
  466.   @sp 4
  467. ! @center GNU Emacs Calc Version 1.02
  468.   @sp 1
  469.   @center June 1990
  470.   @sp 5
  471. --- 38,44 ----
  472.   @sp 6
  473.   @center @titlefont{Calc Manual}
  474.   @sp 4
  475. ! @center GNU Emacs Calc Version 1.03
  476.   @sp 1
  477.   @center June 1990
  478.   @sp 5
  479. ***************
  480. *** 1450,1456 ****
  481.       .          1:  10000.         .
  482.                      .
  483.   
  484. !   2. RET           1e4 RET        ^
  485.   @end example
  486.   @end group
  487.   
  488. --- 1450,1456 ----
  489.       .          1:  10000.         .
  490.                      .
  491.   
  492. !   2.0 RET          1e4 RET        ^
  493.   @end example
  494.   @end group
  495.   
  496. ***************
  497. *** 1497,1504 ****
  498.   notation}.  You get them by pressing @kbd{d n}, @kbd{d f},
  499.   @kbd{d s}, and @kbd{d e}, respectively.  In each case, you can
  500.   supply a numeric prefix argument which says how many digits
  501. ! should be displayed.  As an example, put the following numbers
  502. ! onto the stack, then try some different display modes.  First,
  503.   use @kbd{M-0 DEL} to clear the stack, then enter the four
  504.   numbers shown here:
  505.   
  506. --- 1497,1504 ----
  507.   notation}.  You get them by pressing @kbd{d n}, @kbd{d f},
  508.   @kbd{d s}, and @kbd{d e}, respectively.  In each case, you can
  509.   supply a numeric prefix argument which says how many digits
  510. ! should be displayed.  As an example, let's put a few numbers
  511. ! onto the stack and try some different display modes.  First,
  512.   use @kbd{M-0 DEL} to clear the stack, then enter the four
  513.   numbers shown here:
  514.   
  515. ***************
  516. *** 2767,2773 ****
  517.   
  518.   @group
  519.   @example
  520. ! 1:  8 +/- 0.2    2:  8 +/- 0.2    1:  0.266 +/- 0.011   1:  14.9 +/- 0.594
  521.       .            1:  30 +/- 1         .                     .
  522.                        .
  523.   
  524. --- 2767,2773 ----
  525.   
  526.   @group
  527.   @example
  528. ! 1:  8 +/- 0.2    2:  8 +/- 0.2    1:  0.266 +/- 0.011   1:  14.93 +/- 0.594
  529.       .            1:  30 +/- 1         .                     .
  530.                        .
  531.   
  532. ***************
  533. *** 8086,8109 ****
  534.   The @kbd{M-#} key with a negative prefix argument (@kbd{M-- M-#}) is
  535.   equivalent to @code{calc-grab-region}.
  536.   
  537. ! Each line of the grabbed area must contain one or more numbers,
  538. ! separated by spaces and/or commas.  Leading and trailing square
  539. ! brackets, curly braces and commas on the line are ignored.  Leading
  540. ! line numbers (as found in the Calc stack) are also ignored.  Thus, this
  541. ! command can generally read anything from a column of numbers in a
  542. ! spreadsheet to a matrix in one of Calc's own display formats.  The
  543. ! grabbed values may actually be any Calc formulas, except that spaces
  544. ! not enclosed in parentheses will be interpreted as separating two
  545. ! separate formulas.@refill
  546.   
  547.   If a different language has been specified (@pxref{Language Modes}),
  548.   the grabbed text will be interpreted according to the that language.
  549.   
  550. ! Each line becomes a row of the matrix.  The result will actually be a
  551. ! vector of vectors, which Calc will treat as a matrix only if every row
  552. ! contains the same number of values.  @xref{Matrix Functions}, to see how
  553. ! to pull the matrix apart into its constituent rows and columns.  (If it
  554. ! is a 1x1 matrix, just hit @kbd{v u} (@code{calc-unpack}) twice.)
  555.   
  556.   For example, suppose we have a column of numbers in a file which we
  557.   wish to sum.  Go to one corner of the column and press @kbd{C-@@} to
  558. --- 8086,8127 ----
  559.   The @kbd{M-#} key with a negative prefix argument (@kbd{M-- M-#}) is
  560.   equivalent to @code{calc-grab-region}.
  561.   
  562. ! Each line of the grabbed area becomes a row of the matrix.  The result
  563. ! will actually be a vector of vectors, which Calc will treat as a matrix
  564. ! only if every row contains the same number of values.
  565.   
  566. + If a line contains a portion surrounded by square brackets (or curly
  567. + braces), that portion is interpreted as a vector which becomes a row
  568. + of the matrix.  Any text surrounding the bracketed portion on the line
  569. + is ignored.
  570. + 
  571. + Otherwise, the entire line is interpreted as a row vector as if it
  572. + were surrounded by square brackets.  Leading line numbers (in the
  573. + format used in the Calc stack buffer) are ignored.  If you wish to
  574. + force this interpretation (even if the line contains bracketed
  575. + portions), give a negative numeric prefix argument to the
  576. + @code{calc-grab-region} command.
  577. + 
  578. + If you give a numeric prefix argument of zero, each line is instead
  579. + interpreted as a single formula which is converted into a one-element
  580. + vector.  Thus the result of @code{calc-grab-region} will be a one-column
  581. + matrix.  For example, suppose one line of the data is the expression
  582. + @samp{2 a}.  A plain @code{calc-grab-region} will interpret this as
  583. + @samp{[2 a]}, which in turn is read as a two-element vector.  But
  584. + with a zero prefix argument, it will be interpreted as @samp{[2*a]}.
  585. + 
  586. + If you give a positive numeric prefix argument @var{n}, then each line
  587. + will be split up into columns of width @var{n}; each column is parsed
  588. + separately as a matrix element.  If a line contained @samp{2 +/- 3 4 +/- 5},
  589. + then grabbing with a prefix argument of 8 would correctly split the
  590. + line into two error forms.
  591. + 
  592.   If a different language has been specified (@pxref{Language Modes}),
  593.   the grabbed text will be interpreted according to the that language.
  594.   
  595. ! @xref{Matrix Functions}, to see how to pull the matrix apart into its
  596. ! constituent rows and columns.  (If it is a 1x1 matrix, just hit @kbd{v u}
  597. ! (@code{calc-unpack}) twice.)
  598.   
  599.   For example, suppose we have a column of numbers in a file which we
  600.   wish to sum.  Go to one corner of the column and press @kbd{C-@@} to
  601. ***************
  602. *** 10739,10744 ****
  603. --- 10757,10779 ----
  604.   The functions described here are responsible for parsing and formatting
  605.   Calc numbers and formulas.
  606.   
  607. + @defun calc-eval str sep arg1 arg2 @dots{}
  608. + This is the simplest interface to the Calculator from another Lisp program.
  609. + The algebraic expression(s) in @var{str} are parsed and evaluated; the
  610. + results are formatted as a string and returned.  If @var{str} contains
  611. + several expressions the results are separated by string @var{sep}, or
  612. + by the string @samp{", "} if @var{sep} is omitted.  If any additional
  613. + arguments are given, they are values (in Calc's internal format) to be
  614. + used for @kbd{$}, @kbd{$$}, and so on in the string.
  615. + 
  616. + If the string @var{str} contains an error, the return value is instead
  617. + a list of two items:  An integer index into @var{str} to show the
  618. + approximate position of the error, and an explanatory message string.
  619. + 
  620. + This function uses the mode settings in the @code{*Calculator*} buffer.
  621. + If no such buffer exists, it will be created as a side-effect.
  622. + @end defun
  623. + 
  624.   @defun read-number str
  625.   If string @var{str} contains a valid Calc number, either integer,
  626.   fraction, float, or HMS form, this function parses and returns that
  627. ***************
  628. *** 10895,10900 ****
  629. --- 10930,10937 ----
  630.   (autoload 'calc             ".../calc.elc"     "Calculator Mode" t nil)
  631.   (autoload 'calc-extensions  ".../calc-ext.elc" nil nil nil)
  632.   (autoload 'quick-calc       ".../calc.elc"     "Quick Calculator" t nil)
  633. + (autoload 'full-calc        ".../calc.elc"     "Full-screen Calculator" t nil)
  634. + (autoload 'calc-eval        ".../calc.elc"     "Call Calculator" nil nil)
  635.   (autoload 'calc-grab-region ".../calc-ext.elc" nil t nil)
  636.   (autoload 'defmath          ".../calc-ext.elc" nil t t)
  637.   @end example
  638. ***************
  639. *** 10909,10915 ****
  640.   brings in the extensions module; Calc takes care to call the
  641.   @code{calc-extensions} function (which doesn't actually do anything)
  642.   before any operation that requires the extensions to be present.
  643. ! The other three @code{autoload} commands are for functions which might
  644.   reasonably be used before the user has typed @kbd{M-x calc} for the
  645.   first time.
  646.   
  647. --- 10946,10952 ----
  648.   brings in the extensions module; Calc takes care to call the
  649.   @code{calc-extensions} function (which doesn't actually do anything)
  650.   before any operation that requires the extensions to be present.
  651. ! The other five @code{autoload} commands are for functions which might
  652.   reasonably be used before the user has typed @kbd{M-x calc} for the
  653.   first time.
  654.   
  655. ***************
  656. *** 10978,10987 ****
  657.   To test your installation of Calc, start a fresh Emacs and type @kbd{M-#}
  658.   to make sure the autoload commands and key bindings work.  Now, type
  659.   @kbd{i} to make sure Calc can find its Info documentation.  Press @kbd{q}
  660. ! to exit the Info system.  Type @kbd{20 S} to compute the sine of
  661. ! 20 degrees; this will test the autoloading of the extensions module.
  662. ! The result should be 0.342020143326.  Finally, press @kbd{M-#} again to
  663. ! make sure the Calculator can exit.
  664.   
  665.   (The above text is included in both the Calc documentation and the
  666.   file INSTALL in the Calc distribution directory.)
  667. --- 11015,11024 ----
  668.   To test your installation of Calc, start a fresh Emacs and type @kbd{M-#}
  669.   to make sure the autoload commands and key bindings work.  Now, type
  670.   @kbd{i} to make sure Calc can find its Info documentation.  Press @kbd{q}
  671. ! to exit the Info system and @kbd{M-#} to re-enter the Calculator.
  672. ! Type @kbd{20 S} to compute the sine of 20 degrees; this will test the
  673. ! autoloading of the extensions module.  The result should be 0.342020143326.
  674. ! Finally, press @kbd{M-#} again to make sure the Calculator can exit.
  675.   
  676.   (The above text is included in both the Calc documentation and the
  677.   file INSTALL in the Calc distribution directory.)
  678.  
  679.