code.delx.au - gnu-emacs/blob - lisp/calc/calc-help.el

   1 ;;; calc-help.el --- help display functions for Calc,
   2
   3 ;; Copyright (C) 1990, 1991, 1992, 1993, 2001, 2002, 2004
   4 ;;           Free Software Foundation, Inc.
   5
   6 ;; Author: David Gillespie <daveg@synaptics.com>
   7 ;; Maintainer: Jay Belanger <belanger@truman.edu>
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is distributed in the hope that it will be useful,
  12 ;; but WITHOUT ANY WARRANTY.  No author or distributor
  13 ;; accepts responsibility to anyone for the consequences of using it
  14 ;; or for whether it serves any particular purpose or works at all,
  15 ;; unless he says so in writing.  Refer to the GNU Emacs General Public
  16 ;; License for full details.
  17
  18 ;; Everyone is granted permission to copy, modify and redistribute
  19 ;; GNU Emacs, but only under the conditions described in the
  20 ;; GNU Emacs General Public License.   A copy of this license is
  21 ;; supposed to have been given to you along with GNU Emacs so you
  22 ;; can know your rights and responsibilities.  It should be in a
  23 ;; file named COPYING.  Among other things, the copyright notice
  24 ;; and this notice must be preserved on all copies.
  25
  26 ;;; Commentary:
  27
  28 ;;; Code:
  29
  30 ;; This file is autoloaded from calc-ext.el.
  31 (require 'calc-ext)
  32
  33 (require 'calc-macs)
  34
  35 (defun calc-Need-calc-help () nil)
  36
  37
  38 (defun calc-help-prefix (arg)
  39   "This key is the prefix for Calc help functions.  See calc-help-for-help."
  40   (interactive "P")
  41   (or calc-dispatch-help (sit-for echo-keystrokes))
  42   (let ((key (calc-read-key-sequence
  43               (if calc-dispatch-help
  44                   "Calc Help options: Help, Info, Tutorial, Summary; Key, Function; ?=more"
  45                 (format "%s  (Type ? for a list of Calc Help options)"
  46                         (key-description (this-command-keys))))
  47               calc-help-map)))
  48     (setq key (lookup-key calc-help-map key))
  49     (message "")
  50     (if key
  51         (call-interactively key)
  52       (beep))))
  53
  54 (defun calc-help-for-help (arg)
  55   "You have typed `h', the Calc help character.  Type a Help option:
  56
  57 B  calc-describe-bindings.  Display a table of all key bindings.
  58 H  calc-full-help.  Display all `?' key messages at once.
  59
  60 I  calc-info.  Read the Calc manual using the Info system.
  61 T  calc-tutorial.  Read the Calc tutorial using the Info system.
  62 S  calc-info-summary.  Read the Calc summary using the Info system.
  63
  64 C  calc-describe-key-briefly.  Look up the command name for a given key.
  65 K  calc-describe-key.  Look up a key's documentation in the manual.
  66 F  calc-describe-function.  Look up a function's documentation in the manual.
  67 V  calc-describe-variable.  Look up a variable's documentation in the manual.
  68
  69 N  calc-view-news.  Display Calc history of changes.
  70
  71 C-c  Describe conditions for copying Calc.
  72 C-d  Describe how you can get a new copy of Calc or report a bug.
  73 C-w  Describe how there is no warranty for Calc."
  74   (interactive "P")
  75   (if calc-dispatch-help
  76       (let (key)
  77         (save-window-excursion
  78           (describe-function 'calc-help-for-help)
  79           (select-window (get-buffer-window "*Help*"))
  80           (while (progn
  81                    (message "Calc Help options: Help, Info, ...  press SPC, DEL to scroll, C-g to cancel")
  82                    (memq (car (setq key (calc-read-key t)))
  83                          '(?  ?\C-h ?\C-? ?\C-v ?\M-v)))
  84             (condition-case err
  85                 (if (memq (car key) '(?  ?\C-v))
  86                     (scroll-up)
  87                   (scroll-down))
  88               (error (beep)))))
  89         (calc-unread-command (cdr key))
  90         (calc-help-prefix nil))
  91     (let ((calc-dispatch-help t))
  92       (calc-help-prefix arg))))
  93
  94 (defun calc-describe-copying ()
  95   (interactive)
  96   (calc-info-goto-node "Copying"))
  97
  98 (defun calc-describe-distribution ()
  99   (interactive)
 100   (calc-info-goto-node "Reporting Bugs"))
 101
 102 (defun calc-describe-no-warranty ()
 103   (interactive)
 104   (calc-info-goto-node "Copying")
 105   (let ((case-fold-search nil))
 106     (search-forward "     NO WARRANTY"))
 107   (beginning-of-line)
 108   (recenter 0))
 109
 110 (defun calc-describe-bindings ()
 111   (interactive)
 112   (describe-bindings)
 113   (save-excursion
 114     (set-buffer "*Help*")
 115     (let ((inhibit-read-only t))
 116       (goto-char (point-min))
 117       (when (search-forward "Major Mode Bindings:" nil t)
 118         (delete-region (point-min) (point))
 119         (insert "Calc Mode Bindings:"))
 120       (when (search-forward "Global bindings:" nil t)
 121         (forward-line -1)
 122         (delete-region (point) (point-max)))
 123       (goto-char (point-min))
 124       (while
 125           (re-search-forward
 126            "\n[a-z] [0-9]\\( .*\n\\)\\([a-z] [0-9]\\1\\)*[a-z] \\([0-9]\\)\\1"
 127            nil t)
 128         (let ((dig1 (char-after (1- (match-beginning 1))))
 129               (dig2 (char-after (match-beginning 3))))
 130           (delete-region (match-end 1) (match-end 0))
 131           (goto-char (match-beginning 1))
 132           (delete-backward-char 1)
 133           (delete-char 5)
 134           (insert (format "%c .. %c" (min dig1 dig2) (max dig1 dig2)))))
 135       (goto-char (point-min)))))
 136
 137 (defun calc-describe-key-briefly (key)
 138   (interactive "kDescribe key briefly: ")
 139   (calc-describe-key key t))
 140
 141 (defvar Info-history)
 142
 143 (defun calc-describe-key (key &optional briefly)
 144   (interactive "kDescribe key: ")
 145   (let ((defn (if (eq (key-binding key) 'calc-dispatch)
 146                   (let ((key2 (calc-read-key-sequence
 147                                (format "Describe key briefly: %s-"
 148                                        (key-description key))
 149                                calc-dispatch-map)))
 150                     (setq key (concat key key2))
 151                     (lookup-key calc-dispatch-map key2))
 152                 (if (eq (key-binding key) 'calc-help-prefix)
 153                     (let ((key2 (calc-read-key-sequence
 154                                  (format "Describe key briefly: %s-"
 155                                          (key-description key))
 156                                  calc-help-map)))
 157                       (setq key (concat key key2))
 158                       (lookup-key calc-help-map key2))
 159                   (key-binding key))))
 160         (inv nil)
 161         (hyp nil)
 162         calc-summary-indentation)
 163     (while (or (equal key "I") (equal key "H"))
 164       (if (equal key "I")
 165           (setq inv (not inv))
 166         (setq hyp (not hyp)))
 167       (setq key (read-key-sequence (format "Describe key%s:%s%s "
 168                                            (if briefly " briefly" "")
 169                                            (if inv " I" "")
 170                                            (if hyp " H" "")))
 171             defn (key-binding key)))
 172     (let ((desc (key-description key))
 173           target)
 174       (if (string-match "^ESC " desc)
 175           (setq desc (concat "M-" (substring desc 4))))
 176       (while (string-match "^M-# \\(ESC \\|C-\\)" desc)
 177         (setq desc (concat "M-# " (substring desc (match-end 0)))))
 178       (if briefly
 179           (let ((msg (save-excursion
 180                        (set-buffer (get-buffer-create "*Calc Summary*"))
 181                        (if (= (buffer-size) 0)
 182                            (progn
 183                              (message "Reading Calc summary from manual...")
 184                              (save-window-excursion
 185                                (save-excursion
 186                                  (calc-info-goto-node "Summary")
 187                                  (goto-char (point-min))
 188                                  (forward-line 1)
 189                                  (copy-to-buffer "*Calc Summary*"
 190                                                  (point) (point-max))
 191                                  (if Info-history
 192                                      (Info-last))))
 193                              (setq case-fold-search nil)
 194                              (re-search-forward "^\\(.*\\)\\[\\.\\. a b")
 195                              (setq calc-summary-indentation
 196                                    (- (match-end 1) (match-beginning 1)))))
 197                        (goto-char (point-min))
 198                        (setq target (if (and (string-match "[0-9]\\'" desc)
 199                                              (not (string-match "[d#]" desc)))
 200                                         (concat (substring desc 0 -1) "0-9")
 201                                       desc))
 202                        (if (re-search-forward
 203                             (format "\n%s%s%s%s[ a-zA-Z]"
 204                                     (make-string (+ calc-summary-indentation 9)
 205                                                  ?\.)
 206                                     (if (string-match "M-#" desc) "   "
 207                                       (if inv
 208                                           (if hyp "I H " "  I ")
 209                                         (if hyp "  H " "    ")))
 210                                     (regexp-quote target)
 211                                     (make-string (max (- 6 (length target)) 0)
 212                                                  ?\ ))
 213                             nil t)
 214                            (let (pt)
 215                              (beginning-of-line)
 216                              (forward-char calc-summary-indentation)
 217                              (setq pt (point))
 218                              (end-of-line)
 219                              (buffer-substring pt (point)))))))
 220             (if msg
 221                 (let ((args (substring msg 0 9))
 222                       (keys (substring msg 9 19))
 223                       (prompts (substring msg 19 38))
 224                       (notes "")
 225                       (cmd (substring msg 40))
 226                       msg)
 227                   (if (string-match "\\` +" args)
 228                       (setq args (substring args (match-end 0))))
 229                   (if (string-match " +\\'" args)
 230                       (setq args (substring args 0 (match-beginning 0))))
 231                   (if (string-match "\\` +" keys)
 232                       (setq keys (substring keys (match-end 0))))
 233                   (if (string-match " +\\'" keys)
 234                       (setq keys (substring keys 0 (match-beginning 0))))
 235                   (if (string-match " [0-9,]+\\'" prompts)
 236                       (setq notes (substring prompts (1+ (match-beginning 0)))
 237                             prompts (substring prompts 0 (match-beginning 0))))
 238                   (if (string-match " +\\'" prompts)
 239                       (setq prompts (substring prompts 0 (match-beginning 0))))
 240                   (if (string-match "\\` +" prompts)
 241                       (setq prompts (substring prompts (match-end 0))))
 242                   (setq msg (format
 243                              "%s:  %s%s`%s'%s%s %s%s"
 244                              (if (string-match
 245                                   "\\`\\(calc-[-a-zA-Z0-9]+\\) *\\(.*\\)\\'"
 246                                   cmd)
 247                                  (prog1 (math-match-substring cmd 1)
 248                                    (setq cmd (math-match-substring cmd 2)))
 249                                defn)
 250                              args (if (equal args "") "" " ")
 251                              keys
 252                              (if (equal prompts "") "" " ") prompts
 253                              (if (equal cmd "") "" " => ") cmd))
 254                   (message "%s%s%s runs %s%s"
 255                            (if inv "I " "") (if hyp "H " "") desc
 256                            msg
 257                            (if (equal notes "") ""
 258                              (format "  (?=notes %s)" notes)))
 259                   (let ((key (calc-read-key t)))
 260                     (if (eq (car key) ??)
 261                         (if (equal notes "")
 262                             (message "No notes for this command")
 263                           (while (string-match "," notes)
 264                             (aset notes (match-beginning 0) ? ))
 265                           (setq notes (sort (car (read-from-string
 266                                                   (format "(%s)" notes)))
 267                                             '<))
 268                           (with-output-to-temp-buffer "*Help*"
 269                             (princ (format "%s\n\n" msg))
 270                             (set-buffer "*Calc Summary*")
 271                             (re-search-forward "^ *NOTES")
 272                             (while notes
 273                               (re-search-forward
 274                                (format "^ *%d\\. " (car notes)))
 275                               (beginning-of-line)
 276                               (let ((pt (point)))
 277                                 (forward-line 1)
 278                                 (or (re-search-forward "^ ? ?[0-9]+\\. " nil t)
 279                                     (goto-char (point-max)))
 280                                 (beginning-of-line)
 281                                 (princ (buffer-substring pt (point))))
 282                               (setq notes (cdr notes)))
 283                             (print-help-return-message)))
 284                       (calc-unread-command (cdr key)))))
 285               (if (or (null defn) (integerp defn))
 286                   (message "%s is undefined" desc)
 287                 (message "%s runs the command %s"
 288                          desc
 289                          (if (symbolp defn) defn (prin1-to-string defn))))))
 290         (if inv (setq desc (concat "I " desc)))
 291         (if hyp (setq desc (concat "H " desc)))
 292         (calc-describe-thing desc "Key Index" nil
 293                              (string-match "[A-Z][A-Z][A-Z]" desc))))))
 294
 295 (defvar calc-help-function-list nil
 296   "List of functions provided by Calc.")
 297
 298 (defvar calc-help-variable-list nil
 299   "List of variables provided by Calc.")
 300
 301 (defun calc-help-index-entries (&rest indices)
 302   "Create a list of entries from the INDICES in the Calc info manual."
 303   (let ((entrylist '())
 304         entry)
 305     (require 'info nil t)
 306     (while indices
 307       (condition-case nil
 308           (with-temp-buffer
 309             (Info-mode)
 310             (Info-goto-node (concat "(Calc)" (car indices) " Index"))
 311             (goto-char (point-min))
 312             (while (re-search-forward "\n\\* \\(.*\\): " nil t)
 313               (setq entry (match-string 1))
 314               (if (and (not (string-match "<[1-9]+>" entry))
 315                        (not (string-match "(.*)" entry))
 316                        (not (string= entry "Menu")))
 317                   (unless (assoc entry entrylist)
 318                     (setq entrylist (cons entry entrylist))))))
 319         (error nil))
 320       (setq indices (cdr indices)))
 321     entrylist))
 322
 323 (defun calc-describe-function (&optional func)
 324   (interactive)
 325   (unless calc-help-function-list
 326     (setq calc-help-function-list
 327           (calc-help-index-entries "Function" "Command")))
 328   (or func
 329       (setq func (completing-read "Describe function: "
 330                                   calc-help-function-list
 331                                   nil t)))
 332   (if (string-match "\\`calc-." func)
 333       (calc-describe-thing func "Command Index")
 334     (calc-describe-thing func "Function Index")))
 335
 336 (defun calc-describe-variable (&optional var)
 337   (interactive)
 338   (unless calc-help-variable-list
 339     (setq calc-help-variable-list
 340           (calc-help-index-entries "Variable")))
 341   (or var
 342       (setq var (completing-read "Describe variable: "
 343                                  calc-help-variable-list
 344                                  nil t)))
 345   (calc-describe-thing var "Variable Index"))
 346
 347 (defun calc-describe-thing (thing where &optional target not-quoted)
 348   (message "Looking for `%s' in %s..." thing where)
 349   (let ((savewin (current-window-configuration)))
 350     (calc-info-goto-node where)
 351     (or (let ((case-fold-search nil))
 352           (re-search-forward (format "\n\\* +%s: \\(.*\\)\\."
 353                                      (regexp-quote thing))
 354                              nil t))
 355         (and (string-match "\\`\\([a-z ]*\\)[0-9]\\'" thing)
 356              (re-search-forward (format "\n\\* +%s[01]-9: \\(.*\\)\\."
 357                                         (substring thing 0 -1))
 358                                 nil t)
 359              (setq thing (format "%s9" (substring thing 0 -1))))
 360         (progn
 361           (if Info-history
 362               (Info-last))
 363           (set-window-configuration savewin)
 364           (error "Can't find `%s' in %s" thing where)))
 365     (let (Info-history)
 366       (Info-goto-node (buffer-substring (match-beginning 1) (match-end 1))))
 367     (or (let ((case-fold-search nil))
 368           (or (search-forward (format "\\[`%s'\\]\\|(`%s')\\|\\<The[ \n]`%s'"
 369                                       (or target thing)
 370                                       (or target thing)
 371                                       (or target thing)) nil t)
 372               (and not-quoted
 373                    (let ((case-fold-search t))
 374                      (search-forward (or target thing) nil t)))
 375               (search-forward (format "`%s'" (or target thing)) nil t)
 376               (search-forward (or target thing) nil t)))
 377         (let ((case-fold-search t))
 378           (or (search-forward (format "\\[`%s'\\]\\|(`%s')\\|\\<The[ \n]`%s'"
 379                                       (or target thing)
 380                                       (or target thing)
 381                                       (or target thing)) nil t)
 382               (search-forward (format "`%s'" (or target thing)) nil t)
 383               (search-forward (or target thing) nil t))))
 384     (beginning-of-line)
 385     (message "Found `%s' in %s" thing where)))
 386
 387 (defun calc-view-news ()
 388   (interactive)
 389   (let ((path load-path))
 390     (while (and path
 391                 (not (file-exists-p (expand-file-name "calc.el" (car path)))))
 392       (setq path (cdr path)))
 393     (or (and path
 394              (file-exists-p (expand-file-name "README" (car path))))
 395         (error "Can't locate Calc sources"))
 396     (calc-quit)
 397     (switch-to-buffer "*Help*")
 398     (erase-buffer)
 399     (insert-file-contents (expand-file-name "README" (car path)))
 400     (search-forward "Summary of changes")
 401     (forward-line -1)
 402     (delete-region (point-min) (point))
 403     (goto-char (point-min))))
 404
 405 (defvar calc-help-long-names '((?b . "binary/business")
 406                                (?g . "graphics")
 407                                (?j . "selection")
 408                                (?k . "combinatorics/statistics")
 409                                (?u . "units/statistics")))
 410
 411 (defun calc-full-help ()
 412   (interactive)
 413   (with-output-to-temp-buffer "*Help*"
 414     (princ (format "GNU Emacs Calculator version %s of %s.\n"
 415                    calc-version calc-version-date))
 416     (princ "  By Dave Gillespie, daveg@synaptics.com.\n")
 417     (princ "  Copyright (C) 1990, 1993 Free Software Foundation, Inc.\n\n")
 418     (princ "Type `h s' for a more detailed summary.\n")
 419     (princ "Or type `h i' to read the full Calc manual on-line.\n\n")
 420     (princ "Basic keys:\n")
 421     (let* ((calc-full-help-flag t))
 422       (mapcar (function (lambda (x) (princ (format "  %s\n" x))))
 423               (nreverse (cdr (reverse (cdr (calc-help))))))
 424       (mapcar (function (lambda (prefix)
 425                           (let ((msgs (condition-case err
 426                                           (funcall prefix)
 427                                         (error nil))))
 428                             (if (car msgs)
 429                                 (princ
 430                                  (if (eq (nth 2 msgs) ?v)
 431                                      "\n`v' or `V' prefix (vector/matrix) keys: \n"
 432                                    (if (nth 2 msgs)
 433                                        (format
 434                                         "\n`%c' prefix (%s) keys:\n"
 435                                         (nth 2 msgs)
 436                                         (or (cdr (assq (nth 2 msgs)
 437                                                        calc-help-long-names))
 438                                             (nth 1 msgs)))
 439                                      (format "\n%s-modified keys:\n"
 440                                              (capitalize (nth 1 msgs)))))))
 441                             (mapcar (function (lambda (x)
 442                                                 (princ (format "  %s\n" x))))
 443                                     (car msgs)))))
 444               '(calc-inverse-prefix-help
 445                 calc-hyperbolic-prefix-help
 446                 calc-inv-hyp-prefix-help
 447                 calc-a-prefix-help
 448                 calc-b-prefix-help
 449                 calc-c-prefix-help
 450                 calc-d-prefix-help
 451                 calc-f-prefix-help
 452                 calc-g-prefix-help
 453                 calc-h-prefix-help
 454                 calc-j-prefix-help
 455                 calc-k-prefix-help
 456                 calc-m-prefix-help
 457                 calc-r-prefix-help
 458                 calc-s-prefix-help
 459                 calc-t-prefix-help
 460                 calc-u-prefix-help
 461                 calc-v-prefix-help
 462                 calc-shift-Y-prefix-help
 463                 calc-shift-Z-prefix-help
 464                 calc-z-prefix-help)))
 465     (print-help-return-message)))
 466
 467 (defun calc-h-prefix-help ()
 468   (interactive)
 469   (calc-do-prefix-help
 470    '("Help; Bindings; Info, Tutorial, Summary; News"
 471      "describe: Key, C (briefly), Function, Variable")
 472    "help" ?h))
 473
 474 (defun calc-inverse-prefix-help ()
 475   (interactive)
 476   (calc-do-prefix-help
 477    '("I + S (arcsin), C (arccos), T (arctan); Q (square)"
 478      "I + E (ln), L (exp), B (alog: B^X); f E (lnp1), f L (expm1)"
 479      "I + F (ceiling), R (truncate); a S (invert func)"
 480      "I + a m (match-not); c h (from-hms); k n (prev prime)"
 481      "I + f G (gamma-Q); f e (erfc); k B (etc., lower-tail dists)"
 482      "I + V S (reverse sort); V G (reverse grade)"
 483      "I + v s (remove subvec); v h (tail)"
 484      "I + t + (alt sum), t M (mean with error)"
 485      "I + t S (pop std dev), t C (pop covar)")
 486    "inverse" nil))
 487
 488 (defun calc-hyperbolic-prefix-help ()
 489   (interactive)
 490   (calc-do-prefix-help
 491    '("H + S (sinh), C (cosh), T (tanh); E (exp10), L (log10)"
 492      "H + F (float floor), R (float round); P (constant \"e\")"
 493      "H + a d (total derivative); k c (permutations)"
 494      "H + k b (bern-poly), k e (euler-poly); k s (stirling-2)"
 495      "H + f G (gamma-g), f B (beta-B); v h (rhead), v k (rcons)"
 496      "H + v e (expand w/filler); V H (weighted histogram)"
 497      "H + a S (general solve eqn), j I (general isolate)"
 498      "H + a R (widen/root), a N (widen/min), a X (widen/max)"
 499      "H + t M (median), t S (variance), t C (correlation coef)"
 500      "H + c f/F/c (pervasive float/frac/clean)")
 501    "hyperbolic" nil))
 502
 503 (defun calc-inv-hyp-prefix-help ()
 504   (interactive)
 505   (calc-do-prefix-help
 506    '("I H + S (arcsinh), C (arccosh), T (arctanh)"
 507      "I H + E (log10), L (exp10); f G (gamma-G)"
 508      "I H + F (float ceiling), R (float truncate)"
 509      "I H + t S (pop variance)"
 510      "I H + a S (general invert func); v h (rtail)")
 511    "inverse-hyperbolic" nil))
 512
 513
 514 (defun calc-f-prefix-help ()
 515   (interactive)
 516   (calc-do-prefix-help
 517    '("miN, maX; Hypot; Im, Re; Sign; [, ] (incr/decr)"
 518      "Gamma, Beta, Erf, besselJ, besselY"
 519      "SHIFT + int-sQrt; Int-log, Exp(x)-1, Ln(x+1); arcTan2"
 520      "SHIFT + Abssqr; Mantissa, eXponent, Scale"
 521      "SHIFT + incomplete: Gamma-P, Beta-I")
 522    "functions" ?f))
 523
 524
 525 (defun calc-s-prefix-help ()
 526   (interactive)
 527   (calc-do-prefix-help
 528    '("Store, inTo, Xchg, Unstore; Recall, 0-9; : (:=); = (=>)"
 529      "Let; Copy; Declare; Insert, Perm; Edit"
 530      "Negate, +, -, *, /, ^, &, |, [, ]; Map"
 531      "SHIFT + Decls, GenCount, TimeZone, Holidays; IntegLimit"
 532      "SHIFT + LineStyles, PointStyles, plotRejects; Units"
 533      "SHIFT + Eval-, AlgSimp-, ExtSimp-, FitRules")
 534    "store" ?s))
 535
 536 (defun calc-r-prefix-help ()
 537   (interactive)
 538   (calc-do-prefix-help
 539    '("digits 0-9: recall, same as `s r 0-9'")
 540    "recall" ?r))
 541
 542
 543 (defun calc-j-prefix-help ()
 544   (interactive)
 545   (calc-do-prefix-help
 546    '("Select, Additional, Once; eVal, Formula; Rewrite"
 547      "More, Less, 1-9, Next, Previous"
 548      "Unselect, Clear; Display; Enable; Breakable"
 549      "' (replace), ` (edit), +, -, *, /, RET (grab), DEL"
 550      "SHIFT + swap: Left, Right; maybe: Select, Once"
 551      "SHIFT + Commute, Merge, Distrib, jump-Eqn, Isolate"
 552      "SHIFT + Negate, & (invert); Unpack")
 553    "select" ?j))
 554
 555
 556 (defun calc-a-prefix-help ()
 557   (interactive)
 558   (calc-do-prefix-help
 559    '("Simplify, Extended-simplify, eVal; \" (exp-formula)"
 560      "eXpand, Collect, Factor, Apart, Norm-rat"
 561      "GCD, /, \\, % (polys); Polint"
 562      "Derivative, Integral, Taylor; _ (subscr)"
 563      "suBstitute; Rewrite, Match"
 564      "SHIFT + Solve; Root, miN, maX; Poly-roots; Fit"
 565      "SHIFT + Map; Tabulate, + (sum), * (prod); num-Integ"
 566      "relations: =, # (not =), <, >, [ (< or =), ] (> or =)"
 567      "logical: & (and), | (or), ! (not); : (if)"
 568      "misc: { (in-set); . (rmeq)")
 569    "algebra" ?a))
 570
 571
 572 (defun calc-b-prefix-help ()
 573   (interactive)
 574   (calc-do-prefix-help
 575    '("And, Or, Xor, Diff, Not; Wordsize, Clip"
 576      "Lshift, Rshift, roTate; SHIFT + signed Lshift, Rshift"
 577      "SHIFT + business: Pv, Npv, Fv, pMt, #pmts, raTe, Irr"
 578      "SHIFT + business: Sln, sYd, Ddb; %ch")
 579    "binary/bus" ?b))
 580
 581
 582 (defun calc-c-prefix-help ()
 583   (interactive)
 584   (calc-do-prefix-help
 585    '("Deg, Rad, HMS; Float; Polar/rect; Clean, 0-9; %"
 586      "SHIFT + Fraction")
 587    "convert" ?c))
 588
 589
 590 (defun calc-d-prefix-help ()
 591   (interactive)
 592   (calc-do-prefix-help
 593    '("Group, \",\"; Normal, Fix, Sci, Eng, \".\"; Over"
 594      "Radix, Zeros, 2, 8, 0, 6; Hms; Date; Complex, I, J"
 595      "Why; Line-nums, line-Breaks; <, =, > (justify); Plain"
 596      "\" (strings); Truncate, [, ]; SPC (refresh), RET, @"
 597      "SHIFT + language: Normal, One-line, Big, Unformatted"
 598      "SHIFT + language: C, Pascal, Fortran; TeX, Eqn"
 599      "SHIFT + language: Mathematica, W=Maple")
 600    "display" ?d))
 601
 602
 603 (defun calc-g-prefix-help ()
 604   (interactive)
 605   (calc-do-prefix-help
 606    '("Fast; Add, Delete, Juggle; Plot, Clear; Quit"
 607      "Header, Name, Grid, Border, Key; View-commands, X-display"
 608      "x-axis: Range, Title, Log, Zero; lineStyle"
 609      "SHIFT + y-axis: Range, Title, Log, Zero; pointStyle"
 610      "SHIFT + Print; Device, Output-file; X-geometry"
 611      "SHIFT + Num-pts; Command, Kill, View-trail"
 612      "SHIFT + 3d: Fast, Add; CTRL + z-axis: Range, Title, Log")
 613    "graph" ?g))
 614
 615
 616 (defun calc-k-prefix-help ()
 617   (interactive)
 618   (calc-do-prefix-help
 619    '("GCD, LCM; Choose (binomial), Double-factorial"
 620      "Random, random-Again, sHuffle"
 621      "Factors, Prime-test, Next-prime, Totient, Moebius"
 622      "Bernoulli, Euler, Stirling"
 623      "SHIFT + Extended-gcd"
 624      "SHIFT + dists: Binomial, Chi-square, F, Normal"
 625      "SHIFT + dists: Poisson, student's-T")
 626    "combinatorics" ?k))
 627
 628
 629 (defun calc-m-prefix-help ()
 630   (interactive)
 631   (calc-do-prefix-help
 632    '("Deg, Rad, HMS; Frac; Polar; Inf; Alg, Total; Symb; Vec/mat"
 633      "Working; Xtensions; Mode-save"
 634      "SHIFT + Shifted-prefixes, mode-Filename; Record; reCompute"
 635      "SHIFT + simplify: Off, Num, Default, Bin, Alg, Ext, Units")
 636    "mode" ?m))
 637
 638
 639 (defun calc-t-prefix-help ()
 640   (interactive)
 641   (calc-do-prefix-help
 642    '("Display; Fwd, Back; Next, Prev, Here, [, ]; Yank"
 643      "Search, Rev; In, Out; <, >; Kill; Marker; . (abbrev)"
 644      "SHIFT + time: Now; Part; Date, Julian, Unix, Czone"
 645      "SHIFT + time: newWeek, newMonth, newYear; Incmonth"
 646      "SHIFT + time: +, - (business days)"
 647      "digits 0-9: store-to, same as `s t 0-9'")
 648    "trail/time" ?t))
 649
 650
 651 (defun calc-u-prefix-help ()
 652   (interactive)
 653   (calc-do-prefix-help
 654    '("Simplify, Convert, Temperature-convert, Base-units"
 655      "Autorange; Remove, eXtract; Explain; View-table; 0-9"
 656      "Define, Undefine, Get-defn, Permanent"
 657      "SHIFT + View-table-other-window"
 658      "SHIFT + stat: Mean, G-mean, Std-dev, Covar, maX, miN"
 659      "SHIFT + stat: + (sum), - (asum), * (prod), # (count)")
 660    "units/stat" ?u))
 661
 662
 663 (defun calc-v-prefix-help ()
 664   (interactive)
 665   (calc-do-prefix-help
 666    '("Pack, Unpack, Identity, Diagonal, indeX, Build"
 667      "Row, Column, Subvector; Length; Find; Mask, Expand"
 668      "Tranpose, Arrange, reVerse; Head, Kons; rNorm"
 669      "SHIFT + Det, & (inverse), LUD, Trace, conJtrn, Cross"
 670      "SHIFT + Sort, Grade, Histogram; cNorm"
 671      "SHIFT + Apply, Map, Reduce, accUm, Inner-, Outer-prod"
 672      "SHIFT + sets: V (union), ^ (intersection), - (diff)"
 673      "SHIFT + sets: Xor, ~ (complement), Floor, Enum"
 674      "SHIFT + sets: : (span), # (card), + (rdup)"
 675      "<, =, > (justification); , (commas); [, {, ( (brackets)"
 676      "} (matrix brackets); . (abbreviate); / (multi-lines)")
 677    "vec/mat" ?v))
 678
 679 ;; arch-tag: 2d347593-7591-449e-a64a-93dab5f2f686
 680 ;;; calc-help.el ends here