lisp/calc/calc-help.el

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