lisp/calc/calc.el

   1 ;;; calc.el --- the GNU Emacs calculator
   2
   3 ;; Copyright (C) 1990-1993, 2001-2011  Free Software Foundation, Inc.
   4
   5 ;; Author: David Gillespie <daveg@synaptics.com>
   6 ;; Maintainer: Jay Belanger <jay.p.belanger@gmail.com>
   7 ;; Keywords: convenience, extensions
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software: you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation, either version 3 of the License, or
  14 ;; (at your option) any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 ;;; Commentary:
  25
  26 ;; Calc is split into many files.  This file is the main entry point.
  27 ;; This file includes autoload commands for various other basic Calc
  28 ;; facilities.  The more advanced features are based in calc-ext, which
  29 ;; in turn contains autoloads for the rest of the Calc files.  This
  30 ;; odd set of interactions is designed to make Calc's loading time
  31 ;; be as short as possible when only simple calculations are needed.
  32
  33 ;; Original author's address:
  34 ;;  Dave Gillespie, daveg@synaptics.com, uunet!synaptx!daveg.
  35 ;;  Synaptics, Inc., 2698 Orchard Parkway, San Jose, CA 95134.
  36 ;;
  37 ;; The old address daveg@csvax.cs.caltech.edu will continue to
  38 ;; work for the foreseeable future.
  39 ;;
  40 ;; Bug reports and suggestions are always welcome!  (Type M-x
  41 ;; report-calc-bug to send them).
  42
  43 ;; All functions, macros, and Lisp variables defined here begin with one
  44 ;; of the prefixes "math", "Math", or "calc", with the exceptions of
  45 ;; "full-calc", "full-calc-keypad", "another-calc", "quick-calc",
  46 ;; "report-calc-bug", and "defmath".  User-accessible variables begin
  47 ;; with "var-".
  48
  49 ;;; TODO:
  50
  51 ;;   Fix rewrite mechanism to do less gratuitous rearrangement of terms.
  52 ;;   Implement a pattern-based "refers" predicate.
  53 ;;
  54 ;;   Make it possible to Undo a selection command.
  55 ;;   Figure out how to allow selecting rows of matrices.
  56 ;;   If cursor was in selection before, move it after j n, j p, j L, etc.
  57 ;;   Consider reimplementing calc-delete-selection using rewrites.
  58 ;;
  59 ;;   Implement line-breaking in non-flat compositions (is this desirable?).
  60 ;;   Implement matrix formatting with multi-line components.
  61 ;;
  62 ;;   Have "Z R" define a user command based on a set of rewrite rules.
  63 ;;   Support "incf" and "decf" in defmath definitions.
  64 ;;   Have defmath generate calls to calc-binary-op or calc-unary-op.
  65 ;;   Make some way to define algebraic functions using keyboard macros.
  66 ;;
  67 ;;   Allow calc-word-size=0 => Common Lisp-style signed bitwise arithmetic.
  68 ;;   Consider digamma function (and thus arb. prec. Euler's gamma constant).
  69 ;;   May as well make continued-fractions stuff available to the user.
  70 ;;
  71 ;;   How about matrix eigenvalues, SVD, pseudo-inverse, etc.?
  72 ;;   Should cache matrix inverses as well as decompositions.
  73 ;;   If dividing by a non-square matrix, use least-squares automatically.
  74 ;;   Consider supporting matrix exponentials.
  75 ;;
  76 ;;   Have ninteg detect and work around singularities at the endpoints.
  77 ;;   Use an adaptive subdivision algorithm for ninteg.
  78 ;;   Provide nsum and nprod to go along with ninteg.
  79 ;;
  80 ;;   Handle TeX-mode parsing of \matrix{ ... } where ... contains braces.
  81 ;;   Support AmS-TeX's \{d,t,}frac, \{d,t,}binom notations.
  82 ;;   Format and parse sums and products in Eqn and Math modes.
  83 ;;
  84 ;;   Get math-read-big-expr to read sums, products, etc.
  85 ;;   Change calc-grab-region to use math-read-big-expr.
  86 ;;   Have a way to define functions using := in Embedded Mode.
  87 ;;
  88 ;;   Support polar plotting with GNUPLOT.
  89 ;;   Make a calc-graph-histogram function.
  90 ;;
  91 ;;   Replace hokey formulas for complex functions with formulas designed
  92 ;;      to minimize roundoff while maintaining the proper branch cuts.
  93 ;;   Test accuracy of advanced math functions over whole complex plane.
  94 ;;   Extend Bessel functions to provide arbitrary precision.
  95 ;;   Extend advanced math functions to handle error forms and intervals.
  96 ;;   Provide a better implementation for math-sin-cos-raw.
  97 ;;   Provide a better implementation for math-hypot.
  98 ;;   Provide a better implementation for math-make-frac.
  99 ;;   Provide a better implementation for calcFunc-prfac.
 100 ;;   Provide a better implementation for calcFunc-factor.
 101 ;;
 102 ;;   Provide more examples in the tutorial section of the manual.
 103 ;;   Cover in the tutorial:  simplification modes, declarations,
 104 ;;       bitwise stuff, selections, matrix mapping, financial functions.
 105 ;;   Provide more Lisp programming examples in the manual.
 106 ;;   Finish the Internals section of the manual (and bring it up to date).
 107 ;;
 108 ;;   Tim suggests adding spreadsheet-like features.
 109 ;;   Implement language modes for Gnuplot, Lisp, Ada, APL, ...?
 110 ;;
 111 ;; For atan series, if x > tan(pi/12) (about 0.268) reduce using the identity
 112 ;;   atan(x) = atan((x * sqrt(3) - 1) / (sqrt(3) + x)) + pi/6.
 113 ;;
 114 ;; A better integration algorithm:
 115 ;;   Use breadth-first instead of depth-first search, as follows:
 116 ;;      The integral cache allows unfinished integrals in symbolic notation
 117 ;;      on the righthand side.  An entry with no unfinished integrals on the
 118 ;;      RHS is "complete"; references to it elsewhere are replaced by the
 119 ;;      integrated value.  More than one cache entry for the same integral
 120 ;;      may exist, though if one becomes complete, the others may be deleted.
 121 ;;      The integrator works by using every applicable rule (such as
 122 ;;      substitution, parts, linearity, etc.) to generate possible righthand
 123 ;;      sides, all of which are entered into the cache.  Now, as long as the
 124 ;;      target integral is not complete (and the time limit has not run out)
 125 ;;      choose an incomplete integral from the cache and, for every integral
 126 ;;      appearing in its RHS's, add those integrals to the cache using the
 127 ;;      same substitition, parts, etc. rules.  The cache should be organized
 128 ;;      as a priority queue, choosing the "simplest" incomplete integral at
 129 ;;      each step, or choosing randomly among equally simple integrals.
 130 ;;      Simplicity equals small size, and few steps removed from the original
 131 ;;      target integral.  Note that when the integrator finishes, incomplete
 132 ;;      integrals can be left in the cache, so the algorithm can start where
 133 ;;      it left off if another similar integral is later requested.
 134 ;;   Breadth-first search would avoid the nagging problem of, e.g., whether
 135 ;;   to use parts or substitution first, and which decomposition is best.
 136 ;;   All are tried, and any path that diverges will quickly be put on the
 137 ;;   back burner by the priority queue.
 138 ;;   Note: Probably a good idea to call math-simplify-extended before
 139 ;;   measuring a formula's simplicity.
 140
 141 ;;; Code:
 142
 143 (require 'calc-macs)
 144
 145 ;; Declare functions which are defined elsewhere.
 146 (declare-function calc-set-language "calc-lang" (lang &optional option no-refresh))
 147 (declare-function calc-edit-finish "calc-yank" (&optional keep))
 148 (declare-function calc-edit-cancel "calc-yank" ())
 149 (declare-function calc-do-quick-calc "calc-aent" ())
 150 (declare-function calc-do-calc-eval "calc-aent" (str separator args))
 151 (declare-function calc-do-keypad "calc-keypd" (&optional full-display interactive))
 152 (declare-function calcFunc-unixtime "calc-forms" (date &optional zone))
 153 (declare-function math-parse-date "calc-forms" (math-pd-str))
 154 (declare-function math-lessp "calc-ext" (a b))
 155 (declare-function math-compare "calc-ext" (a b))
 156 (declare-function calc-embedded-finish-command "calc-embed" ())
 157 (declare-function calc-embedded-select-buffer "calc-embed" ())
 158 (declare-function calc-embedded-mode-line-change "calc-embed" ())
 159 (declare-function calc-push-list-in-macro "calc-prog" (vals m sels))
 160 (declare-function calc-replace-selections "calc-sel" (n vals m))
 161 (declare-function calc-record-list "calc-misc" (vals &optional prefix))
 162 (declare-function calc-normalize-fancy "calc-ext" (val))
 163 (declare-function calc-do-handle-whys "calc-misc" ())
 164 (declare-function calc-top-selected "calc-sel" (&optional n m))
 165 (declare-function calc-sel-error "calc-sel" ())
 166 (declare-function calc-pop-stack-in-macro "calc-prog" (n mm))
 167 (declare-function calc-embedded-stack-change "calc-embed" ())
 168 (declare-function calc-refresh-evaltos "calc-ext" (&optional which-var))
 169 (declare-function calc-do-refresh "calc-misc" ())
 170 (declare-function calc-binary-op-fancy "calc-ext" (name func arg ident unary))
 171 (declare-function calc-unary-op-fancy "calc-ext" (name func arg))
 172 (declare-function calc-delete-selection "calc-sel" (n))
 173 (declare-function calc-alg-digit-entry "calc-aent" ())
 174 (declare-function calc-alg-entry "calc-aent" (&optional initial prompt))
 175 (declare-function calc-dots "calc-incom" ())
 176 (declare-function calc-temp-minibuffer-message "calc-misc" (m))
 177 (declare-function math-read-radix-digit "calc-misc" (dig))
 178 (declare-function calc-digit-dots "calc-incom" ())
 179 (declare-function math-normalize-fancy "calc-ext" (a))
 180 (declare-function math-normalize-nonstandard "calc-ext" ())
 181 (declare-function math-recompile-eval-rules "calc-alg" ())
 182 (declare-function math-apply-rewrites "calc-rewr" (expr rules &optional heads math-apply-rw-ruleset))
 183 (declare-function calc-record-why "calc-misc" (&rest stuff))
 184 (declare-function math-dimension-error "calc-vec" ())
 185 (declare-function calc-incomplete-error "calc-incom" (a))
 186 (declare-function math-float-fancy "calc-arith" (a))
 187 (declare-function math-neg-fancy "calc-arith" (a))
 188 (declare-function calc-add-fractions "calc-frac" (a b))
 189 (declare-function math-add-objects-fancy "calc-arith" (a b))
 190 (declare-function math-add-symb-fancy "calc-arith" (a b))
 191 (declare-function math-mul-zero "calc-arith" (a b))
 192 (declare-function calc-mul-fractions "calc-frac" (a b))
 193 (declare-function math-mul-objects-fancy "calc-arith" (a b))
 194 (declare-function math-mul-symb-fancy "calc-arith" (a b))
 195 (declare-function math-reject-arg "calc-misc" (&optional a p option))
 196 (declare-function math-div-by-zero "calc-arith" (a b))
 197 (declare-function math-div-zero "calc-arith" (a b))
 198 (declare-function math-make-frac "calc-frac" (num den))
 199 (declare-function calc-div-fractions "calc-frac" (a b))
 200 (declare-function math-div-objects-fancy "calc-arith" (a b))
 201 (declare-function math-div-symb-fancy "calc-arith" (a b))
 202 (declare-function math-compose-expr "calccomp" (a prec))
 203 (declare-function math-comp-width "calccomp" (c))
 204 (declare-function math-composition-to-string "calccomp" (c &optional width))
 205 (declare-function math-stack-value-offset-fancy "calccomp" ())
 206 (declare-function math-format-flat-expr-fancy "calc-ext" (a prec))
 207 (declare-function math-adjust-fraction "calc-ext" (a))
 208 (declare-function math-format-binary "calc-bin" (a))
 209 (declare-function math-format-radix "calc-bin" (a))
 210 (declare-function math-format-twos-complement "calc-bin" (a))
 211 (declare-function math-group-float "calc-ext" (str))
 212 (declare-function math-mod "calc-misc" (a b))
 213 (declare-function math-format-number-fancy "calc-ext" (a prec))
 214 (declare-function math-format-bignum-fancy "calc-ext" (a))
 215 (declare-function math-read-number-fancy "calc-ext" (s))
 216 (declare-function calc-do-grab-region "calc-yank" (top bot arg))
 217 (declare-function calc-do-grab-rectangle "calc-yank" (top bot arg &optional reduce))
 218 (declare-function calc-do-embedded "calc-embed" (calc-embed-arg end obeg oend))
 219 (declare-function calc-do-embedded-activate "calc-embed" (calc-embed-arg cbuf))
 220 (declare-function math-do-defmath "calc-prog" (func args body))
 221 (declare-function calc-load-everything "calc-ext" ())
 222
 223
 224 (defgroup calc nil
 225   "GNU Calc."
 226   :prefix "calc-"
 227   :tag    "Calc"
 228   :group  'applications)
 229
 230 ;; Do not autoload, so it is evaluated at run-time rather than at dump time.
 231 ;; ;;;###autoload
 232 (defcustom calc-settings-file
 233   (locate-user-emacs-file "calc.el" ".calc.el")
 234   "File in which to record permanent settings."
 235   :group 'calc
 236   :type '(file))
 237
 238 (defcustom calc-language-alist
 239   '((latex-mode . latex)
 240     (tex-mode   . tex)
 241     (plain-tex-mode . tex)
 242     (context-mode . tex)
 243     (nroff-mode . eqn)
 244     (pascal-mode . pascal)
 245     (c-mode . c)
 246     (c++-mode . c)
 247     (fortran-mode . fortran)
 248     (f90-mode . fortran)
 249     (texinfo-mode . calc-normal-language))
 250   "Alist of major modes with appropriate Calc languages."
 251   :group 'calc
 252   :type '(alist :key-type (symbol :tag "Major mode")
 253                 :value-type (symbol :tag "Calc language")))
 254
 255 (defcustom calc-embedded-announce-formula
 256   "%Embed\n\\(% .*\n\\)*"
 257   "A regular expression which is sure to be followed by a calc-embedded formula."
 258   :group 'calc
 259   :type '(regexp))
 260
 261 (defcustom calc-embedded-announce-formula-alist
 262   '((c++-mode     . "//Embed\n\\(// .*\n\\)*")
 263     (c-mode       . "/\\*Embed\\*/\n\\(/\\* .*\\*/\n\\)*")
 264     (f90-mode     . "!Embed\n\\(! .*\n\\)*")
 265     (fortran-mode . "C Embed\n\\(C .*\n\\)*")
 266     (html-helper-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
 267     (html-mode    . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
 268     (nroff-mode   . "\\\\\"Embed\n\\(\\\\\" .*\n\\)*")
 269     (pascal-mode  . "{Embed}\n\\({.*}\n\\)*")
 270     (sgml-mode    . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
 271     (xml-mode     . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
 272     (texinfo-mode . "@c Embed\n\\(@c .*\n\\)*"))
 273   "Alist of major modes with appropriate values for `calc-embedded-announce-formula'."
 274   :group 'calc
 275   :type '(alist :key-type (symbol :tag "Major mode")
 276                 :value-type (regexp :tag "Regexp to announce formula")))
 277
 278 (defcustom calc-embedded-open-formula
 279   "\\`\\|^\n\\|\\$\\$?\\|\\\\\\[\\|^\\\\begin[^{].*\n\\|^\\\\begin{.*[^x]}.*\n\\|^@.*\n\\|^\\.EQ.*\n\\|\\\\(\\|^%\n\\|^\\.\\\\\"\n"
 280   "A regular expression for the opening delimiter of a formula used by calc-embedded."
 281   :group 'calc
 282   :type '(regexp))
 283
 284 (defcustom calc-embedded-close-formula
 285   "\\'\\|\n$\\|\\$\\$?\\|\\\\]\\|^\\\\end[^{].*\n\\|^\\\\end{.*[^x]}.*\n\\|^@.*\n\\|^\\.EN.*\n\\|\\\\)\\|\n%\n\\|^\\.\\\\\"\n"
 286   "A regular expression for the closing delimiter of a formula used by calc-embedded."
 287   :group 'calc
 288   :type '(regexp))
 289
 290 (defcustom calc-embedded-open-close-formula-alist
 291   nil
 292   "Alist of major modes with pairs of formula delimiters used by calc-embedded."
 293   :group 'calc
 294   :type '(alist :key-type (symbol :tag "Major mode")
 295                 :value-type (list (regexp :tag "Opening formula delimiter")
 296                                   (regexp :tag "Closing formula delimiter"))))
 297
 298 (defcustom calc-embedded-word-regexp
 299   "[-+]?[0-9]+\\(\\.[0-9]+\\)?\\([eE][-+]?[0-9]+\\)?"
 300   "A regular expression determining a word for calc-embedded-word."
 301   :group 'calc
 302   :type '(regexp))
 303
 304 (defcustom calc-embedded-word-regexp-alist
 305   nil
 306   "Alist of major modes with word regexps used by calc-embedded-word."
 307   :group 'calc
 308   :type '(alist :key-type (symbol :tag "Major mode")
 309                 :value-type (regexp :tag "Regexp for word")))
 310
 311 (defcustom calc-embedded-open-plain
 312   "%%% "
 313   "A string which is the opening delimiter for a \"plain\" formula.
 314 If calc-show-plain mode is enabled, this is inserted at the front of
 315 each formula."
 316   :group 'calc
 317   :type '(string))
 318
 319 (defcustom calc-embedded-close-plain
 320   " %%%\n"
 321   "A string which is the closing delimiter for a \"plain\" formula.
 322 See calc-embedded-open-plain."
 323   :group 'calc
 324   :type '(string))
 325
 326 (defcustom calc-embedded-open-close-plain-alist
 327   '((c++-mode     "// %% "   " %%\n")
 328     (c-mode       "/* %% "   " %% */\n")
 329     (f90-mode     "! %% "    " %%\n")
 330     (fortran-mode "C %% "    " %%\n")
 331     (html-helper-mode "<!-- %% " " %% -->\n")
 332     (html-mode "<!-- %% " " %% -->\n")
 333     (nroff-mode   "\\\" %% " " %%\n")
 334     (pascal-mode  "{%% "    " %%}\n")
 335     (sgml-mode     "<!-- %% " " %% -->\n")
 336     (xml-mode     "<!-- %% " " %% -->\n")
 337     (texinfo-mode "@c %% "   " %%\n"))
 338   "Alist of major modes with pairs of delimiters for \"plain\" formulas."
 339   :group 'calc
 340   :type '(alist :key-type (symbol :tag "Major mode")
 341                 :value-type (list (string :tag "Opening \"plain\" delimiter")
 342                                   (string :tag "Closing \"plain\" delimiter"))))
 343
 344 (defcustom calc-embedded-open-new-formula
 345   "\n\n"
 346   "A string which is inserted at front of formula by calc-embedded-new-formula."
 347   :group 'calc
 348   :type '(string))
 349
 350 (defcustom calc-embedded-close-new-formula
 351   "\n\n"
 352   "A string which is inserted at end of formula by calc-embedded-new-formula."
 353   :group 'calc
 354   :type '(string))
 355
 356 (defcustom calc-embedded-open-close-new-formula-alist
 357   nil
 358   "Alist of major modes with pairs of new formula delimiters used by calc-embedded."
 359   :group 'calc
 360   :type '(alist :key-type (symbol :tag "Major mode")
 361                 :value-type (list (string :tag "Opening new formula delimiter")
 362                                   (string :tag "Closing new formula delimiter"))))
 363
 364 (defcustom calc-embedded-open-mode
 365   "% "
 366   "A string which should precede calc-embedded mode annotations.
 367 This is not required to be present for user-written mode annotations."
 368   :group 'calc
 369   :type '(string))
 370
 371 (defcustom calc-embedded-close-mode
 372   "\n"
 373   "A string which should follow calc-embedded mode annotations.
 374 This is not required to be present for user-written mode annotations."
 375   :group 'calc
 376   :type '(string))
 377
 378 (defcustom calc-embedded-open-close-mode-alist
 379   '((c++-mode     "// "   "\n")
 380     (c-mode       "/* "   " */\n")
 381     (f90-mode     "! "    "\n")
 382     (fortran-mode "C "    "\n")
 383     (html-helper-mode "<!-- " " -->\n")
 384     (html-mode    "<!-- " " -->\n")
 385     (nroff-mode   "\\\" " "\n")
 386     (pascal-mode  "{ "    " }\n")
 387     (sgml-mode    "<!-- " " -->\n")
 388     (xml-mode     "<!-- " " -->\n")
 389     (texinfo-mode "@c "   "\n"))
 390   "Alist of major modes with pairs of strings to delimit annotations."
 391   :group 'calc
 392   :type '(alist :key-type (symbol :tag "Major mode")
 393                 :value-type (list (string :tag "Opening annotation delimiter")
 394                                   (string :tag "Closing annotation delimiter"))))
 395
 396 (defcustom calc-gnuplot-name
 397   (if (eq system-type 'windows-nt) "pgnuplot" "gnuplot")
 398   "Name of GNUPLOT program, for calc-graph features."
 399   :group 'calc
 400   :type '(string))
 401
 402 (defcustom calc-gnuplot-plot-command
 403   nil
 404   "Name of command for displaying GNUPLOT output; %s = file name to print."
 405   :group 'calc
 406   :type '(choice (string) (sexp)))
 407
 408 (defcustom calc-gnuplot-print-command
 409   "lp %s"
 410   "Name of command for printing GNUPLOT output; %s = file name to print."
 411   :group 'calc
 412   :type '(choice (string) (sexp)))
 413
 414 (defcustom calc-multiplication-has-precedence
 415   t
 416   "If non-nil, multiplication has precedence over division
 417 in normal mode."
 418   :group 'calc
 419   :type 'boolean)
 420
 421 (defcustom calc-undo-length
 422   100
 423   "The number of undo steps that will be preserved when Calc is quit."
 424   :group 'calc
 425   :type 'integer)
 426
 427 (defcustom calc-highlight-selections-with-faces
 428   nil
 429   "If non-nil, use a separate face to indicate selected sub-formulas.
 430 If `calc-show-selections' is non-nil, then selected sub-formulas are shown
 431 by displaying the rest of the formula in `calc-nonselected-face'.
 432 If `calc-show-selections' is nil, then selected sub-formulas are shown
 433 by displaying the sub-formula in `calc-selected-face'."
 434   :group 'calc
 435   :type 'boolean)
 436
 437 (defcustom calc-lu-field-reference
 438   "20 uPa"
 439   "The default reference level for logarithmic units (field)."
 440   :group 'calc
 441   :type '(string))
 442
 443 (defcustom calc-lu-power-reference
 444   "mW"
 445   "The default reference level for logarithmic units (power)."
 446   :group 'calc
 447   :type '(string))
 448
 449 (defcustom calc-note-threshold "1"
 450   "The number of cents that a frequency should be near a note
 451 to be identified as that note."
 452   :type 'string
 453   :group 'calc)
 454
 455 (defface calc-nonselected-face
 456   '((t :inherit shadow
 457        :slant italic))
 458   "Face used to show the non-selected portion of a formula."
 459   :group 'calc)
 460
 461 (defface calc-selected-face
 462   '((t :weight bold))
 463   "Face used to show the selected portion of a formula."
 464   :group 'calc)
 465
 466 (defvar calc-bug-address "jay.p.belanger@gmail.com"
 467   "Address of the maintainer of Calc, for use by `report-calc-bug'.")
 468
 469 (defvar calc-scan-for-dels t
 470   "If t, scan keymaps to find all DEL-like keys.
 471 if nil, only DEL itself is mapped to calc-pop.")
 472
 473 (defvar calc-stack '((top-of-stack 1 nil))
 474   "Calculator stack.
 475 Entries are 3-lists:  Formula, Height (in lines), Selection (or nil).")
 476
 477 (defvar calc-stack-top 1
 478   "Index into `calc-stack' of \"top\" of stack.
 479 This is 1 unless `calc-truncate-stack' has been used.")
 480
 481 (defvar calc-display-sci-high 0
 482   "Floating-point numbers with this positive exponent or higher above the
 483 current precision are displayed in scientific notation in calc-mode.")
 484
 485 (defvar calc-display-sci-low -3
 486   "Floating-point numbers with this negative exponent or lower are displayed
 487 scientific notation in calc-mode.")
 488
 489 (defvar calc-other-modes nil
 490   "List of used-defined strings to append to Calculator mode line.")
 491
 492 (defvar calc-Y-help-msgs nil
 493   "List of strings for Y prefix help.")
 494
 495 (defvar calc-loaded-settings-file nil
 496   "t if `calc-settings-file' has been loaded yet.")
 497
 498
 499 (defvar calc-mode-var-list '()
 500   "List of variables used in customizing GNU Calc.")
 501
 502 (defmacro defcalcmodevar (var defval &optional doc)
 503   "Declare VAR as a Calc variable, with default value DEFVAL
 504 and doc-string DOC.
 505 The variable VAR will be added to `calc-mode-var-list'."
 506   `(progn
 507      (defvar ,var ,defval ,doc)
 508      (add-to-list 'calc-mode-var-list (list (quote ,var) ,defval))))
 509
 510 (defun calc-mode-var-list-restore-default-values ()
 511   "Restore the default values of the variables in `calc-mode-var-list'."
 512   (mapcar (function (lambda (v) (set (car v) (nth 1 v))))
 513           calc-mode-var-list))
 514
 515 (defun calc-mode-var-list-restore-saved-values ()
 516   "Restore the user-saved values of the variables in `calc-mode-var-list'."
 517   (let ((newvarlist '()))
 518     (save-excursion
 519       (let (pos
 520             (file (substitute-in-file-name calc-settings-file)))
 521         (when (and
 522                (file-regular-p file)
 523                (set-buffer (find-file-noselect file))
 524                (goto-char (point-min))
 525                (search-forward ";;; Mode settings stored by Calc" nil t)
 526                (progn
 527                  (forward-line 1)
 528                  (setq pos (point))
 529                  (search-forward "\n;;; End of mode settings" nil t)))
 530           (beginning-of-line)
 531           (calc-mode-var-list-restore-default-values)
 532           (eval-region pos (point))
 533           (let ((varlist calc-mode-var-list))
 534             (while varlist
 535               (let ((var (car varlist)))
 536                 (setq newvarlist
 537                       (cons (list (car var) (symbol-value (car var)))
 538                             newvarlist)))
 539               (setq varlist (cdr varlist)))))))
 540     (if newvarlist
 541         (mapcar (function (lambda (v) (set (car v) (nth 1 v))))
 542                 newvarlist)
 543       (calc-mode-var-list-restore-default-values))))
 544
 545 (defcalcmodevar calc-always-load-extensions nil
 546   "If non-nil, load the calc-ext module automatically when Calc is loaded.")
 547
 548 (defcalcmodevar  calc-line-numbering t
 549   "If non-nil, display line numbers in Calculator stack.")
 550
 551 (defcalcmodevar calc-line-breaking t
 552   "If non-nil, break long values across multiple lines in Calculator stack.")
 553
 554 (defcalcmodevar calc-display-just nil
 555   "If nil, stack display is left-justified.
 556 If `right', stack display is right-justified.
 557 If `center', stack display is centered.")
 558
 559 (defcalcmodevar calc-display-origin nil
 560   "Horizontal origin of displayed stack entries.
 561 In left-justified mode, this is effectively indentation.  (Default 0).
 562 In right-justified mode, this is effectively window width.
 563 In centered mode, center of stack entry is placed here.")
 564
 565 (defcalcmodevar calc-number-radix 10
 566   "Radix for entry and display of numbers in calc-mode, 2-36.")
 567
 568 (defcalcmodevar calc-leading-zeros nil
 569   "If non-nil, leading zeros are provided to pad integers to calc-word-size.")
 570
 571 (defcalcmodevar calc-group-digits nil
 572   "If non-nil, group digits in large displayed integers by inserting spaces.
 573 If an integer, group that many digits at a time.
 574 If t, use 4 for binary and hex, 3 otherwise.")
 575
 576 (defcalcmodevar calc-group-char ","
 577   "The character (in the form of a string) to be used for grouping digits.
 578 This is used only when calc-group-digits mode is on.")
 579
 580 (defcalcmodevar calc-point-char "."
 581   "The character (in the form of a string) to be used as a decimal point.")
 582
 583 (defcalcmodevar calc-frac-format '(":" nil)
 584   "Format of displayed fractions; a string of one or two of \":\" or \"/\".")
 585
 586 (defcalcmodevar calc-prefer-frac nil
 587   "If non-nil, prefer fractional over floating-point results.")
 588
 589 (defcalcmodevar calc-hms-format "%s@ %s' %s\""
 590   "Format of displayed hours-minutes-seconds angles, a format string.
 591 String must contain three %s marks for hours, minutes, seconds respectively.")
 592
 593 (defcalcmodevar calc-date-format '((H ":" mm C SS pp " ")
 594                                   Www " " Mmm " " D ", " YYYY)
 595   "Format of displayed date forms.")
 596
 597 (defcalcmodevar calc-float-format '(float 0)
 598   "Format to use for display of floating-point numbers in calc-mode.
 599 Must be a list of one of the following forms:
 600  (float 0)      Floating point format, display full precision.
 601  (float N)      N > 0: Floating point format, at most N significant figures.
 602  (float -N)     -N < 0: Floating point format, calc-internal-prec - N figs.
 603  (fix N)        N >= 0: Fixed point format, N places after decimal point.
 604  (sci 0)        Scientific notation, full precision.
 605  (sci N)        N > 0: Scientific notation, N significant figures.
 606  (sci -N)       -N < 0: Scientific notation, calc-internal-prec - N figs.
 607  (eng 0)        Engineering notation, full precision.
 608  (eng N)        N > 0: Engineering notation, N significant figures.
 609  (eng -N)       -N < 0: Engineering notation, calc-internal-prec - N figs.")
 610
 611 (defcalcmodevar calc-full-float-format '(float 0)
 612   "Format to use when full precision must be displayed.")
 613
 614 (defcalcmodevar calc-complex-format nil
 615   "Format to use for display of complex numbers in calc-mode.  Must be one of:
 616   nil            Use (x, y) form.
 617   i              Use x + yi form.
 618   j              Use x + yj form.")
 619
 620 (defcalcmodevar calc-complex-mode 'cplx
 621   "Preferred form, either `cplx' or `polar', for complex numbers.")
 622
 623 (defcalcmodevar calc-infinite-mode nil
 624   "If nil, 1 / 0 is left unsimplified.
 625 If 0, 1 / 0 is changed to inf (zeros are considered positive).
 626 Otherwise, 1 / 0 is changed to uinf (undirected infinity).")
 627
 628 (defcalcmodevar calc-display-strings nil
 629   "If non-nil, display vectors of byte-sized integers as strings.")
 630
 631 (defcalcmodevar calc-matrix-just 'center
 632   "If nil, vector elements are left-justified.
 633 If `right', vector elements are right-justified.
 634 If `center', vector elements are centered.")
 635
 636 (defcalcmodevar calc-break-vectors nil
 637   "If non-nil, display vectors one element per line.")
 638
 639 (defcalcmodevar calc-full-vectors t
 640   "If non-nil, display long vectors in full.  If nil, use abbreviated form.")
 641
 642 (defcalcmodevar calc-full-trail-vectors t
 643   "If non-nil, display long vectors in full in the trail.")
 644
 645 (defcalcmodevar calc-vector-commas ","
 646   "If non-nil, separate elements of displayed vectors with this string.")
 647
 648 (defcalcmodevar calc-vector-brackets "[]"
 649   "If non-nil, surround displayed vectors with these characters.")
 650
 651 (defcalcmodevar calc-matrix-brackets '(R O)
 652   "A list of code-letter symbols that control \"big\" matrix display.
 653 If `R' is present, display inner brackets for matrices.
 654 If `O' is present, display outer brackets for matrices (above/below).
 655 If `C' is present, display outer brackets for matrices (centered).")
 656
 657 (defcalcmodevar calc-language nil
 658   "Language or format for entry and display of stack values.  Must be one of:
 659   nil           Use standard Calc notation.
 660   flat          Use standard Calc notation, one-line format.
 661   big           Display formulas in 2-d notation (enter w/std notation).
 662   unform        Use unformatted display: add(a, mul(b,c)).
 663   c             Use C language notation.
 664   pascal        Use Pascal language notation.
 665   fortran       Use Fortran language notation.
 666   tex           Use TeX notation.
 667   latex         Use LaTeX notation.
 668   eqn           Use eqn notation.
 669   yacas         Use Yacas notation.
 670   maxima        Use Maxima notation.
 671   giac          Use Giac notation.
 672   math          Use Mathematica(tm) notation.
 673   maple         Use Maple notation.")
 674
 675 (defcalcmodevar calc-language-option nil
 676   "Numeric prefix argument for the command that set `calc-language'.")
 677
 678 (defcalcmodevar calc-left-label ""
 679   "Label to display at left of formula.")
 680
 681 (defcalcmodevar calc-right-label ""
 682   "Label to display at right of formula.")
 683
 684 (defcalcmodevar calc-word-size 32
 685   "Minimum number of bits per word, if any, for binary operations in calc-mode.")
 686
 687 (defcalcmodevar calc-previous-modulo nil
 688   "Most recently used value of M in a modulo form.")
 689
 690 (defcalcmodevar calc-simplify-mode nil
 691   "Type of simplification applied to results.
 692 If `none', results are not simplified when pushed on the stack.
 693 If `num', functions are simplified only when args are constant.
 694 If nil, only fast simplifications are applied.
 695 If `binary', `math-clip' is applied if appropriate.
 696 If `alg', `math-simplify' is applied.
 697 If `ext', `math-simplify-extended' is applied.
 698 If `units', `math-simplify-units' is applied.")
 699
 700 (defcalcmodevar calc-auto-recompute t
 701   "If non-nil, recompute evalto's automatically when necessary.")
 702
 703 (defcalcmodevar calc-display-raw nil
 704   "If non-nil, display shows unformatted Lisp exprs. (For debugging)")
 705
 706 (defcalcmodevar calc-internal-prec 12
 707   "Number of digits of internal precision for calc-mode calculations.")
 708
 709 (defcalcmodevar calc-angle-mode 'deg
 710   "If deg, angles are in degrees; if rad, angles are in radians.
 711 If hms, angles are in degrees-minutes-seconds.")
 712
 713 (defcalcmodevar calc-algebraic-mode nil
 714   "If non-nil, numeric entry accepts whole algebraic expressions.
 715 If nil, algebraic expressions must be preceded by \"'\".")
 716
 717 (defcalcmodevar calc-incomplete-algebraic-mode nil
 718   "Like calc-algebraic-mode except only affects ( and [ keys.")
 719
 720 (defcalcmodevar calc-symbolic-mode nil
 721   "If non-nil, inexact numeric computations like sqrt(2) are postponed.
 722 If nil, computations on numbers always yield numbers where possible.")
 723
 724 (defcalcmodevar calc-matrix-mode nil
 725   "If `matrix', variables are assumed to be matrix-valued.
 726 If a number, variables are assumed to be NxN matrices.
 727 If `sqmatrix', variables are assumed to be square matrices of an unspecified size.
 728 If `scalar', variables are assumed to be scalar-valued.
 729 If nil, symbolic math routines make no assumptions about variables.")
 730
 731 (defcalcmodevar calc-twos-complement-mode nil
 732   "If non-nil, display integers in two's complement mode.")
 733
 734
 735 (defcalcmodevar calc-shift-prefix nil
 736   "If non-nil, shifted letter keys are prefix keys rather than normal meanings.")
 737
 738 (defcalcmodevar calc-window-height 7
 739   "Initial height of Calculator window.")
 740
 741 (defcalcmodevar calc-display-trail t
 742   "If non-nil, M-x calc creates a window to display Calculator trail.")
 743
 744 (defcalcmodevar calc-show-selections t
 745   "If non-nil, selected sub-formulas are shown by obscuring rest of formula.
 746 If nil, selected sub-formulas are highlighted by obscuring the sub-formulas.")
 747
 748 (defcalcmodevar calc-use-selections t
 749   "If non-nil, commands operate only on selected portions of formulas.
 750 If nil, selections displayed but ignored.")
 751
 752 (defcalcmodevar calc-assoc-selections t
 753   "If non-nil, selection hides deep structure of associative formulas.")
 754
 755 (defcalcmodevar calc-display-working-message 'lots
 756   "If non-nil, display \"Working...\" for potentially slow Calculator commands.")
 757
 758 (defcalcmodevar calc-auto-why 'maybe
 759   "If non-nil, automatically execute a \"why\" command to explain odd results.")
 760
 761 (defcalcmodevar calc-timing nil
 762   "If non-nil, display timing information on each slow command.")
 763
 764 (defcalcmodevar calc-mode-save-mode 'local)
 765
 766 (defcalcmodevar calc-standard-date-formats
 767   '("N"
 768     "<H:mm:SSpp >Www Mmm D, YYYY"
 769     "D Mmm YYYY<, h:mm:SS>"
 770     "Www Mmm BD< hh:mm:ss> YYYY"
 771     "M/D/Y< H:mm:SSpp>"
 772     "D.M.Y< h:mm:SS>"
 773     "M-D-Y< H:mm:SSpp>"
 774     "D-M-Y< h:mm:SS>"
 775     "j<, h:mm:SS>"
 776     "YYddd< hh:mm:ss>"))
 777
 778 (defcalcmodevar calc-autorange-units nil
 779   "If non-nil, automatically set unit prefixes to keep units in a reasonable range.")
 780
 781 (defcalcmodevar calc-was-keypad-mode nil
 782   "Non-nil if Calc was last invoked in keypad mode.")
 783
 784 (defcalcmodevar calc-full-mode nil
 785   "Non-nil if Calc was last invoked in full-screen mode.")
 786
 787 (defcalcmodevar calc-user-parse-tables nil
 788   "Alist of languages with user-defined parse rules.")
 789
 790 (defcalcmodevar calc-gnuplot-default-device "default"
 791   "The default device name for GNUPLOT plotting.")
 792
 793 (defcalcmodevar calc-gnuplot-default-output "STDOUT"
 794   "The default output file for GNUPLOT plotting.")
 795
 796 (defcalcmodevar calc-gnuplot-print-device "postscript"
 797   "The default device name for GNUPLOT printing.")
 798
 799 (defcalcmodevar calc-gnuplot-print-output "auto"
 800   "The default output for GNUPLOT printing.")
 801
 802 (defcalcmodevar calc-gnuplot-geometry nil
 803   "The default geometry for the GNUPLOT window.")
 804
 805 (defcalcmodevar calc-graph-default-resolution 15
 806   "The default number of data points when plotting curves.")
 807
 808 (defcalcmodevar calc-graph-default-resolution-3d 5
 809   "The default number of x- and y- data points when plotting surfaces.")
 810
 811 (defcalcmodevar calc-invocation-macro nil
 812   "A user defined macro for starting Calc.
 813 Used by `calc-user-invocation'.")
 814
 815 (defcalcmodevar calc-show-banner t
 816   "*If non-nil, show a friendly greeting above the stack.")
 817
 818 (defconst calc-local-var-list '(calc-stack
 819                                 calc-stack-top
 820                                 calc-undo-list
 821                                 calc-redo-list
 822                                 calc-always-load-extensions
 823                                 calc-mode-save-mode
 824                                 calc-display-raw
 825                                 calc-line-numbering
 826                                 calc-line-breaking
 827                                 calc-display-just
 828                                 calc-display-origin
 829                                 calc-left-label
 830                                 calc-right-label
 831                                 calc-auto-why
 832                                 calc-algebraic-mode
 833                                 calc-incomplete-algebraic-mode
 834                                 calc-symbolic-mode
 835                                 calc-matrix-mode
 836                                 calc-inverse-flag
 837                                 calc-hyperbolic-flag
 838                                 calc-option-flag
 839                                 calc-keep-args-flag
 840                                 calc-angle-mode
 841                                 calc-number-radix
 842                                 calc-leading-zeros
 843                                 calc-group-digits
 844                                 calc-group-char
 845                                 calc-point-char
 846                                 calc-frac-format
 847                                 calc-prefer-frac
 848                                 calc-hms-format
 849                                 calc-date-format
 850                                 calc-standard-date-formats
 851                                 calc-float-format
 852                                 calc-full-float-format
 853                                 calc-complex-format
 854                                 calc-matrix-just
 855                                 calc-full-vectors
 856                                 calc-full-trail-vectors
 857                                 calc-break-vectors
 858                                 calc-vector-commas
 859                                 calc-vector-brackets
 860                                 calc-matrix-brackets
 861                                 calc-complex-mode
 862                                 calc-infinite-mode
 863                                 calc-display-strings
 864                                 calc-simplify-mode
 865                                 calc-auto-recompute
 866                                 calc-autorange-units
 867                                 calc-show-plain
 868                                 calc-show-selections
 869                                 calc-use-selections
 870                                 calc-assoc-selections
 871                                 calc-word-size
 872                                 calc-internal-prec))
 873
 874 (defvar calc-mode-hook nil
 875   "Hook run when entering calc-mode.")
 876
 877 (defvar calc-trail-mode-hook nil
 878   "Hook run when entering calc-trail-mode.")
 879
 880 (defvar calc-start-hook nil
 881   "Hook run when calc is started.")
 882
 883 (defvar calc-end-hook nil
 884   "Hook run when calc is quit.")
 885
 886 (defvar calc-load-hook nil
 887   "Hook run when calc.el is loaded.")
 888
 889 (defvar calc-window-hook nil
 890   "Hook called to create the Calc window.")
 891
 892 (defvar calc-trail-window-hook nil
 893   "Hook called to create the Calc trail window.")
 894
 895 (defvar calc-embedded-new-buffer-hook nil
 896   "Hook run when starting embedded mode in a new buffer.")
 897
 898 (defvar calc-embedded-new-formula-hook nil
 899   "Hook run when starting embedded mode in a new formula.")
 900
 901 (defvar calc-embedded-mode-hook nil
 902   "Hook run when starting embedded mode.")
 903
 904 ;; Set up the autoloading linkage.
 905 (let ((name (and (fboundp 'calc-dispatch)
 906                  (eq (car-safe (symbol-function 'calc-dispatch)) 'autoload)
 907                  (nth 1 (symbol-function 'calc-dispatch))))
 908       (p load-path))
 909
 910   ;; If Calc files exist on the load-path, we're all set.
 911   (while (and p (not (file-exists-p
 912                       (expand-file-name "calc-misc.elc" (car p)))))
 913     (setq p (cdr p)))
 914   (or p
 915
 916       ;; If Calc is autoloaded using a path name, look there for Calc files.
 917       ;; This works for both relative ("calc/calc.elc") and absolute paths.
 918       (and name (file-name-directory name)
 919            (let ((p2 load-path)
 920                  (name2 (concat (file-name-directory name)
 921                                 "calc-misc.elc")))
 922              (while (and p2 (not (file-exists-p
 923                                   (expand-file-name name2 (car p2)))))
 924                (setq p2 (cdr p2)))
 925              (when p2
 926                (setq load-path (nconc load-path
 927                                       (list
 928                                        (directory-file-name
 929                                         (file-name-directory
 930                                          (expand-file-name
 931                                           name (car p2))))))))))))
 932
 933 ;; The following modes use specially-formatted data.
 934 (put 'calc-mode 'mode-class 'special)
 935 (put 'calc-trail-mode 'mode-class 'special)
 936
 937 ;; Define "inexact-result" as an e-lisp error symbol.
 938 (put 'inexact-result 'error-conditions '(error inexact-result calc-error))
 939 (put 'inexact-result 'error-message "Calc internal error (inexact-result)")
 940
 941 ;; Define "math-overflow" and "math-underflow" as e-lisp error symbols.
 942 (put 'math-overflow 'error-conditions '(error math-overflow calc-error))
 943 (put 'math-overflow 'error-message "Floating-point overflow occurred")
 944 (put 'math-underflow 'error-conditions '(error math-underflow calc-error))
 945 (put 'math-underflow 'error-message "Floating-point underflow occurred")
 946
 947 (defvar calc-trail-pointer nil
 948   "The \"current\" entry in trail buffer.")
 949 (defvar calc-trail-overlay nil
 950   "The value of overlay-arrow-string.")
 951 (defvar calc-undo-list nil
 952   "The list of previous operations for undo.")
 953 (defvar calc-redo-list nil
 954   "The list of recent undo operations.")
 955 (defvar calc-main-buffer nil
 956   "A pointer to Calculator buffer.")
 957 (defvar calc-buffer-list nil
 958   "A list of all Calc buffers.")
 959 (defvar calc-trail-buffer nil
 960   "A pointer to Calc Trail buffer.")
 961 (defvar calc-why nil
 962   "Explanations of most recent errors.")
 963 (defvar calc-next-why nil)
 964 (defvar calc-inverse-flag nil
 965   "If non-nil, next operation is Inverse.")
 966 (defvar calc-hyperbolic-flag nil
 967   "If non-nil, next operation is Hyperbolic.")
 968 (defvar calc-option-flag nil
 969   "If non-nil, next operation has Optional behavior.")
 970 (defvar calc-keep-args-flag nil
 971   "If non-nil, next operation should not remove its arguments from stack.")
 972 (defvar calc-function-open "("
 973   "Open-parenthesis string for function call notation.")
 974 (defvar calc-function-close ")"
 975   "Close-parenthesis string for function call notation.")
 976 (defvar calc-language-output-filter nil
 977   "Function through which to pass strings after formatting.")
 978 (defvar calc-language-input-filter nil
 979   "Function through which to pass strings before parsing.")
 980 (defvar calc-radix-formatter nil
 981   "Formatting function used for non-decimal numbers.")
 982 (defvar calc-lang-slash-idiv nil
 983   "A list of languages in which / might represent integer division.")
 984 (defvar calc-lang-allow-underscores nil
 985   "A list of languages which allow underscores in variable names.")
 986 (defvar calc-lang-allow-percentsigns nil
 987   "A list of languages which allow percent signs in variable names.")
 988 (defvar calc-lang-c-type-hex nil
 989   "Languages in which octal and hex numbers are written with leading 0 and 0x,")
 990 (defvar calc-lang-brackets-are-subscripts nil
 991   "Languages in which subscripts are indicated by brackets.")
 992 (defvar calc-lang-parens-are-subscripts nil
 993   "Languages in which subscripts are indicated by parentheses.")
 994
 995 (defvar calc-last-kill nil
 996   "The last number killed in calc-mode.")
 997 (defvar calc-dollar-values nil
 998   "Values to be used for '$'.")
 999 (defvar calc-dollar-used nil
1000   "The highest order of '$' that occurred.")
1001 (defvar calc-hashes-used nil
1002   "The highest order of '#' that occurred.")
1003 (defvar calc-quick-prev-results nil
1004   "Previous results from Quick Calc.")
1005 (defvar calc-said-hello nil
1006   "Non-nil if the welcomd message has been displayed.")
1007 (defvar calc-executing-macro nil
1008   "Non-nil if a keyboard macro is executing from the \"K\" key.")
1009 (defvar calc-any-selections nil
1010   "Non-nil if there are selections present.")
1011 (defvar calc-help-phase 0
1012   "The number of consecutive \"?\" keystrokes.")
1013 (defvar calc-full-help-flag nil
1014   "Non-nil if `calc-full-help' is being executed.")
1015 (defvar calc-refresh-count 0
1016   "The number of `calc-refresh' calls.")
1017 (defvar calc-display-dirty nil
1018   "Non-nil if the stack display might not reflect the latest mode settings.")
1019 (defvar calc-prepared-composition nil)
1020 (defvar calc-selection-cache-default-entry nil)
1021 (defvar calc-embedded-info nil
1022   "If non-nil, a vector consisting of information for embedded mode.")
1023 (defvar calc-embedded-active nil
1024   "Alist of buffers with sorted lists of calc-embedded-infos.")
1025 (defvar calc-standalone-flag nil
1026   "Non-nil if Emacs started with standalone Calc.")
1027 (defvar var-EvalRules nil
1028   "User defined rules that Calc will apply automatically.")
1029 (defvar math-eval-rules-cache-tag t)
1030 (defvar math-radix-explicit-format t)
1031 (defvar math-expr-function-mapping nil
1032   "Alist of language specific functions with Calc functions.")
1033 (defvar math-expr-variable-mapping nil
1034   "Alist of language specific variables with Calc variables.")
1035 (defvar math-read-expr-quotes nil)
1036 (defvar math-working-step nil)
1037 (defvar math-working-step-2 nil)
1038 (defvar var-i '(special-const (math-imaginary 1)))
1039 (defvar var-pi '(special-const (math-pi)))
1040 (defvar var-π '(special-const (math-pi)))
1041 (defvar var-e '(special-const (math-e)))
1042 (defvar var-phi '(special-const (math-phi)))
1043 (defvar var-φ '(special-const (math-phi)))
1044 (defvar var-gamma '(special-const (math-gamma-const)))
1045 (defvar var-γ '(special-const (math-gamma-const)))
1046 (defvar var-Modes '(special-const (math-get-modes-vec)))
1047
1048 (mapc (lambda (v) (or (boundp v) (set v nil)))
1049       calc-local-var-list)
1050
1051 (defvar calc-mode-map
1052   (let ((map (make-keymap)))
1053     (suppress-keymap map t)
1054     (define-key map "+" 'calc-plus)
1055     (define-key map "-" 'calc-minus)
1056     (define-key map "*" 'calc-times)
1057     (define-key map "/" 'calc-divide)
1058     (define-key map "%" 'calc-mod)
1059     (define-key map "&" 'calc-inv)
1060     (define-key map "^" 'calc-power)
1061     (define-key map "\M-%" 'calc-percent)
1062     (define-key map "e" 'calcDigit-start)
1063     (define-key map "i" 'calc-info)
1064     (define-key map "n" 'calc-change-sign)
1065     (define-key map "q" 'calc-quit)
1066     (define-key map "Y" 'nil)
1067     (define-key map "Y?" 'calc-shift-Y-prefix-help)
1068     (define-key map "?" 'calc-help)
1069     (define-key map " " 'calc-enter)
1070     (define-key map "'" 'calc-algebraic-entry)
1071     (define-key map "$" 'calc-auto-algebraic-entry)
1072     (define-key map "\"" 'calc-auto-algebraic-entry)
1073     (define-key map "\t" 'calc-roll-down)
1074     (define-key map "\M-\t" 'calc-roll-up)
1075     (define-key map "\C-x\C-t" 'calc-transpose-lines)
1076     (define-key map "\C-m" 'calc-enter)
1077     (define-key map "\M-\C-m" 'calc-last-args-stub)
1078     (define-key map "\C-j" 'calc-over)
1079     (define-key map "\C-y" 'calc-yank)
1080     (define-key map [mouse-2] 'calc-yank)
1081     (define-key map [remap undo] 'calc-undo)
1082
1083     (mapc (lambda (x) (define-key map (char-to-string x) 'undefined))
1084           "lOW")
1085     (mapc (lambda (x) (define-key map (char-to-string x) 'calc-missing-key))
1086           (concat "ABCDEFGHIJKLMNOPQRSTUVXZabcdfghjkmoprstuvwxyz"
1087                   ":\\|!()[]<>{},;=~`\C-k\C-w"))
1088     (define-key map "\M-w" 'calc-missing-key)
1089     (define-key map "\M-k" 'calc-missing-key)
1090     (define-key map "\M-\C-w" 'calc-missing-key)
1091     (mapc (lambda (x) (define-key map (char-to-string x) 'calcDigit-start))
1092           "_0123456789.#@")
1093     map)
1094   "The key map for Calc.")
1095
1096 (defvar calc-digit-map
1097   (let ((map (make-keymap)))
1098     (map-keymap (lambda (key bind)
1099                   (define-key map (vector key)
1100                     (if (eq bind 'undefined)
1101                         'undefined 'calcDigit-nondigit)))
1102                 calc-mode-map)
1103     (mapc (lambda (x) (define-key map (char-to-string x) 'calcDigit-key))
1104           "_0123456789.e+-:n#@oh'\"mspM")
1105     (mapc (lambda (x) (define-key map (char-to-string x) 'calcDigit-letter))
1106           "abcdfgijklqrtuvwxyzABCDEFGHIJKLNOPQRSTUVWXYZ")
1107     (define-key map "'" 'calcDigit-algebraic)
1108     (define-key map "`" 'calcDigit-edit)
1109     (define-key map "\C-g" 'abort-recursive-edit)
1110     map)
1111   "The key map for entering Calc digits.")
1112
1113 (mapc (lambda (x)
1114         (condition-case err
1115             (progn
1116               (define-key calc-digit-map x 'calcDigit-backspace)
1117               (define-key calc-mode-map x 'calc-pop)
1118               (define-key calc-mode-map
1119                 (if (and (vectorp x) (featurep 'xemacs))
1120                     (if (= (length x) 1)
1121                         (vector (if (consp (aref x 0))
1122                                     (cons 'meta (aref x 0))
1123                                   (list 'meta (aref x 0))))
1124                       "\e\C-d")
1125                   (vconcat "\e" x))
1126                 'calc-pop-above))
1127           (error nil)))
1128       (if calc-scan-for-dels
1129           (append (where-is-internal 'delete-backward-char global-map)
1130                   (where-is-internal 'backward-delete-char global-map)
1131                   (where-is-internal 'backward-delete-char-untabify global-map)
1132                   '("\C-d"))
1133         '("\177" "\C-d")))
1134
1135 (defvar calc-dispatch-map
1136   (let ((map (make-keymap)))
1137     (mapc (lambda (x)
1138             (let* ((x-chr (car x))
1139                    (x-str (char-to-string x-chr))
1140                    (x-def (cdr x)))
1141               (define-key map x-str x-def)
1142               (when (string-match "[a-z]" x-str)
1143                 ;; Map upper case char to same definition.
1144                 (define-key map (upcase x-str) x-def)
1145                 (unless (string-match "[gmv]" x-str)
1146                   ;; Map control prefixed char to same definition.
1147                   (define-key map (vector (list 'control x-chr)) x-def)))
1148               (define-key map (format "\e%c" x-chr) x-def)))
1149           '( ( ?a . calc-embedded-activate )
1150              ( ?b . calc-big-or-small )
1151              ( ?c . calc )
1152              ( ?d . calc-embedded-duplicate )
1153              ( ?e . calc-embedded )
1154              ( ?f . calc-embedded-new-formula )
1155              ( ?g . calc-grab-region )
1156              ( ?h . calc-dispatch-help )
1157              ( ?i . calc-info )
1158              ( ?j . calc-embedded-select )
1159              ( ?k . calc-keypad )
1160              ( ?l . calc-load-everything )
1161              ( ?m . read-kbd-macro )
1162              ( ?n . calc-embedded-next )
1163              ( ?o . calc-other-window )
1164              ( ?p . calc-embedded-previous )
1165              ( ?q . quick-calc )
1166              ( ?r . calc-grab-rectangle )
1167              ( ?s . calc-info-summary )
1168              ( ?t . calc-tutorial )
1169              ( ?u . calc-embedded-update-formula )
1170              ( ?w . calc-embedded-word )
1171              ( ?x . calc-quit )
1172              ( ?y . calc-copy-to-buffer )
1173              ( ?z . calc-user-invocation )
1174              ( ?\' . calc-embedded-new-formula )
1175              ( ?\` . calc-embedded-edit )
1176              ( ?: . calc-grab-sum-down )
1177              ( ?_ . calc-grab-sum-across )
1178              ( ?0 . calc-reset )
1179              ( ?? . calc-dispatch-help )
1180              ( ?# . calc-same-interface )
1181              ( ?& . calc-same-interface )
1182              ( ?\\ . calc-same-interface )
1183              ( ?= . calc-same-interface )
1184              ( ?* . calc-same-interface )
1185              ( ?/ . calc-same-interface )
1186              ( ?+ . calc-same-interface )
1187              ( ?- . calc-same-interface ) ))
1188     map)
1189   "The key map for starting Calc.")
1190
1191
1192 ;;;; (Autoloads here)
1193 (load "calc-loaddefs.el" nil t)
1194
1195 ;;;###autoload (define-key ctl-x-map "*" 'calc-dispatch)
1196
1197 ;;;###autoload
1198 (defun calc-dispatch (&optional arg)
1199   "Invoke the GNU Emacs Calculator.  See `calc-dispatch-help' for details."
1200   (interactive "P")
1201 ;  (sit-for echo-keystrokes)
1202   (condition-case err   ; look for other keys bound to calc-dispatch
1203       (let ((keys (this-command-keys)))
1204         (unless (or (not (stringp keys))
1205                     (string-match "\\`\C-u\\|\\`\e[-0-9#]\\|`[\M--\M-0-\M-9]" keys)
1206                     (eq (lookup-key calc-dispatch-map keys) 'calc-same-interface))
1207           (when (and (string-match "\\`[\C-@-\C-_]" keys)
1208                      (symbolp
1209                       (lookup-key calc-dispatch-map (substring keys 0 1))))
1210             (define-key calc-dispatch-map (substring keys 0 1) nil))
1211           (define-key calc-dispatch-map keys 'calc-same-interface)))
1212     (error nil))
1213   (calc-do-dispatch arg))
1214
1215 (defvar calc-dispatch-help nil)
1216 (defun calc-do-dispatch (arg)
1217   "Start the Calculator."
1218   (let ((key (calc-read-key-sequence
1219               (if calc-dispatch-help
1220                   "Calc options: Calc, Keypad, Quick, Embed; eXit; Info, Tutorial; Grab; ?=more"
1221                 (format "%s  (Type ? for a list of Calc options)"
1222                         (key-description (this-command-keys))))
1223               calc-dispatch-map)))
1224     (setq key (lookup-key calc-dispatch-map key))
1225     (message "")
1226     (if key
1227         (progn
1228           (or (commandp key) (require 'calc-ext))
1229           (call-interactively key))
1230       (beep))))
1231
1232 (defun calc-read-key-sequence (prompt map)
1233   "Read keys, with prompt PROMPT and keymap MAP."
1234   (let ((prompt2 (format "%s " (key-description (this-command-keys))))
1235         (glob (current-global-map))
1236         (loc (current-local-map)))
1237     (or (input-pending-p) (message "%s" prompt))
1238     (let ((key (calc-read-key t)))
1239       (calc-unread-command (cdr key))
1240       (unwind-protect
1241           (progn
1242             (use-global-map map)
1243             (use-local-map nil)
1244             (read-key-sequence nil))
1245         (use-global-map glob)
1246         (use-local-map loc)))))
1247
1248 (defvar calc-alg-map) ; Defined in calc-ext.el
1249
1250
1251 (defvar calc-embedded-modes) ; Defined in calc-embed.el
1252 (defvar calc-override-minor-modes) ; Defined in calc-embed.el
1253 (defun calc-kill-stack-buffer ()
1254   "Check to see if user wants to kill the Calc stack buffer.
1255 This will look for buffers using the Calc buffer for embedded mode,
1256 and inform the user if there are any.
1257 If the user wants to kill the Calc buffer, this will remove
1258 embedded information from the appropriate buffers and tidy up
1259 the trail buffer."
1260   (let ((cb (current-buffer))
1261         (info-list nil)
1262         (buflist)
1263 ;        (plural nil)
1264         (cea calc-embedded-active))
1265     ;; Get a list of all buffers using this buffer for
1266     ;; embedded Calc.
1267     (while cea
1268       (when (and (eq cb (aref (nth 1 (car cea)) 1))
1269                  (buffer-name (car (car cea))))
1270         (setq info-list (cons (car cea) info-list)))
1271       (setq cea (cdr cea)))
1272     ;; Eventually, prompt user with a list of buffers using embedded mode.
1273     (when (and
1274            info-list
1275            (yes-or-no-p
1276             (concat "This Calc stack is being used for embedded mode. Kill anyway?")))
1277       (while info-list
1278         (with-current-buffer (car (car info-list))
1279           (when calc-embedded-info
1280             (setq calc-embedded-info nil
1281                   mode-line-buffer-identification (car calc-embedded-modes)
1282                   truncate-lines (nth 2 calc-embedded-modes)
1283                   buffer-read-only nil)
1284             (use-local-map (nth 1 calc-embedded-modes))
1285             (setq minor-mode-overriding-map-alist
1286                   (remq calc-override-minor-modes minor-mode-overriding-map-alist))
1287             (let ((str mode-line-buffer-identification))
1288               (setq mode-line-buffer-identification str))
1289             (set-buffer-modified-p (buffer-modified-p))))
1290         (setq calc-embedded-active
1291               (delete (car info-list) calc-embedded-active))
1292         (setq info-list (cdr info-list))))
1293     (if (not info-list)
1294         (progn
1295           (setq calc-buffer-list (delete cb calc-buffer-list))
1296           (with-current-buffer calc-trail-buffer
1297             (if (eq cb calc-main-buffer)
1298                 ;; If there are other Calc stacks, make another one
1299                 ;; the calc-main-buffer ...
1300                 (if calc-buffer-list
1301                     (setq calc-main-buffer (car calc-buffer-list))
1302                   ;; ... otherwise kill the trail and its windows.
1303                   (let ((wl (get-buffer-window-list calc-trail-buffer)))
1304                     (while wl
1305                       (delete-window (car wl))
1306                       (setq wl (cdr wl))))
1307                   (kill-buffer calc-trail-buffer)
1308                   (setq calc-trail-buffer nil))))
1309           t))))
1310
1311 (defun calc-mode ()
1312   "Calculator major mode.
1313
1314 This is an RPN calculator featuring arbitrary-precision integer, rational,
1315 floating-point, complex, matrix, and symbolic arithmetic.
1316
1317 RPN calculation:  2 RET 3 +    produces 5.
1318 Algebraic style:  ' 2+3 RET    produces 5.
1319
1320 Basic operators are +, -, *, /, ^, & (reciprocal), % (modulo), n (change-sign).
1321
1322 Press ? repeatedly for more complete help.  Press `h i' to read the
1323 Calc manual on-line, `h s' to read the summary, or `h t' for the tutorial.
1324
1325 Notations:  3.14e6     3.14 * 10^6
1326             _23        negative number -23 (or type `23 n')
1327             17:3       the fraction 17/3
1328             5:2:3      the fraction 5 and 2/3
1329             16#12C     the integer 12C base 16 = 300 base 10
1330             8#177:100  the fraction 177:100 base 8 = 127:64 base 10
1331             (2, 4)     complex number 2 + 4i
1332             (2; 4)     polar complex number (r; theta)
1333             [1, 2, 3]  vector  ([[1, 2], [3, 4]] is a matrix)
1334             [1 .. 4)   semi-open interval, 1 <= x < 4
1335             2 +/- 3    (p key) number with mean 2, standard deviation 3
1336             2 mod 3    (M key) number 2 computed modulo 3
1337             <1 jan 91> Date form (enter using ' key)
1338
1339
1340 \\{calc-mode-map}
1341 "
1342   (interactive)
1343   (mapc (function
1344          (lambda (v) (set-default v (symbol-value v)))) calc-local-var-list)
1345   (kill-all-local-variables)
1346   (use-local-map (if (eq calc-algebraic-mode 'total)
1347                      (progn (require 'calc-ext) calc-alg-map) calc-mode-map))
1348   (mapc (function (lambda (v) (make-local-variable v))) calc-local-var-list)
1349   (make-local-variable 'overlay-arrow-position)
1350   (make-local-variable 'overlay-arrow-string)
1351   (add-hook 'change-major-mode-hook 'font-lock-defontify nil t)
1352   (add-hook 'kill-buffer-query-functions
1353             'calc-kill-stack-buffer
1354             t t)
1355   (setq truncate-lines t)
1356   (setq buffer-read-only t)
1357   (setq major-mode 'calc-mode)
1358   (setq mode-name "Calculator")
1359   (setq calc-stack-top (length (or (memq (assq 'top-of-stack calc-stack)
1360                                          calc-stack)
1361                                    (setq calc-stack (list (list 'top-of-stack
1362                                                                 1 nil))))))
1363   (setq calc-stack-top (- (length calc-stack) calc-stack-top -1))
1364   (or calc-loaded-settings-file
1365       (null calc-settings-file)
1366       (equal calc-settings-file user-init-file)
1367       (progn
1368         (setq calc-loaded-settings-file t)
1369         (load (file-name-sans-extension calc-settings-file) t)))   ; t = missing-ok
1370   (let ((p command-line-args))
1371     (while p
1372       (and (equal (car p) "-f")
1373            (string-match "calc" (nth 1 p))
1374            (string-match "full" (nth 1 p))
1375            (setq calc-standalone-flag t))
1376       (setq p (cdr p))))
1377   (require 'calc-menu)
1378   (run-mode-hooks 'calc-mode-hook)
1379   (calc-refresh t)
1380   (calc-set-mode-line)
1381   (calc-check-defines)
1382   (if calc-buffer-list (setq calc-stack (copy-sequence calc-stack)))
1383   (add-to-list 'calc-buffer-list (current-buffer) t))
1384
1385 (defvar calc-check-defines 'calc-check-defines)  ; suitable for run-hooks
1386 (defun calc-check-defines ()
1387   (if (symbol-plist 'calc-define)
1388       (let ((plist (copy-sequence (symbol-plist 'calc-define))))
1389         (while (and plist (null (nth 1 plist)))
1390           (setq plist (cdr (cdr plist))))
1391         (if plist
1392             (save-excursion
1393               (require 'calc-ext)
1394               (require 'calc-macs)
1395               (set-buffer "*Calculator*")
1396               (while plist
1397                 (put 'calc-define (car plist) nil)
1398                 (eval (nth 1 plist))
1399                 (setq plist (cdr (cdr plist))))
1400               ;; See if this has added any more calc-define properties.
1401               (calc-check-defines))
1402           (setplist 'calc-define nil)))))
1403
1404 (defun calc-trail-mode (&optional buf)
1405   "Calc Trail mode.
1406 This mode is used by the *Calc Trail* buffer, which records all results
1407 obtained by the GNU Emacs Calculator.
1408
1409 Calculator commands beginning with the `t' key are used to manipulate
1410 the Trail.
1411
1412 This buffer uses the same key map as the *Calculator* buffer; calculator
1413 commands given here will actually operate on the *Calculator* stack."
1414   (interactive)
1415   (fundamental-mode)
1416   (use-local-map calc-mode-map)
1417   (setq major-mode 'calc-trail-mode)
1418   (setq mode-name "Calc Trail")
1419   (setq truncate-lines t)
1420   (setq buffer-read-only t)
1421   (make-local-variable 'overlay-arrow-position)
1422   (make-local-variable 'overlay-arrow-string)
1423   (when buf
1424     (set (make-local-variable 'calc-main-buffer) buf))
1425   (when (= (buffer-size) 0)
1426     (let ((buffer-read-only nil))
1427       (insert (propertize "Emacs Calculator Trail\n" 'face 'italic))))
1428   (run-mode-hooks 'calc-trail-mode-hook))
1429
1430 (defun calc-create-buffer ()
1431   "Create and initialize a buffer for the Calculator."
1432   (set-buffer (get-buffer-create "*Calculator*"))
1433   (or (eq major-mode 'calc-mode)
1434       (calc-mode))
1435   (setq max-lisp-eval-depth (max max-lisp-eval-depth 1000))
1436   (when calc-always-load-extensions
1437     (require 'calc-ext))
1438   (when calc-language
1439     (require 'calc-ext)
1440     (calc-set-language calc-language calc-language-option t)))
1441
1442 ;;;###autoload
1443 (defun calc (&optional arg full-display interactive)
1444   "The Emacs Calculator.  Full documentation is listed under \"calc-mode\"."
1445   (interactive "P\ni\np")
1446   (if arg
1447       (unless (eq arg 0)
1448         (require 'calc-ext)
1449         (if (= (prefix-numeric-value arg) -1)
1450             (calc-grab-region (region-beginning) (region-end) nil)
1451           (when (= (prefix-numeric-value arg) -2)
1452             (calc-keypad))))
1453     (when (get-buffer-window "*Calc Keypad*")
1454       (calc-keypad)
1455       (set-buffer (window-buffer (selected-window))))
1456     (if (eq major-mode 'calc-mode)
1457         (calc-quit)
1458       (let ((oldbuf (current-buffer)))
1459         (calc-create-buffer)
1460         (setq calc-was-keypad-mode nil)
1461         (if (or (eq full-display t)
1462                 (and (null full-display) calc-full-mode))
1463             (switch-to-buffer (current-buffer) t)
1464           (if (get-buffer-window (current-buffer))
1465               (select-window (get-buffer-window (current-buffer)))
1466             (if calc-window-hook
1467                 (run-hooks 'calc-window-hook)
1468               (let ((w (get-largest-window)))
1469                 (if (and pop-up-windows
1470                          (> (window-height w)
1471                             (+ window-min-height calc-window-height 2)))
1472                     (progn
1473                       (setq w (split-window w
1474                                             (- (window-height w)
1475                                                calc-window-height 2)
1476                                             nil))
1477                       (set-window-buffer w (current-buffer))
1478                       (select-window w))
1479                   (pop-to-buffer (current-buffer)))))))
1480         (with-current-buffer (calc-trail-buffer)
1481           (and calc-display-trail
1482                (= (window-width) (frame-width))
1483                (calc-trail-display 1 t)))
1484         (message "Welcome to the GNU Emacs Calculator!  Press `?' or `h' for help, `q' to quit")
1485         (run-hooks 'calc-start-hook)
1486         (and (windowp full-display)
1487              (window-point full-display)
1488              (select-window full-display))
1489         (calc-check-defines)
1490         (when (and calc-said-hello interactive)
1491           (sit-for 2)
1492           (message ""))
1493         (setq calc-said-hello t)))))
1494
1495 ;;;###autoload
1496 (defun full-calc (&optional interactive)
1497   "Invoke the Calculator and give it a full-sized window."
1498   (interactive "p")
1499   (calc nil t interactive))
1500
1501 (defun calc-same-interface (arg)
1502   "Invoke the Calculator using the most recent interface (calc or calc-keypad)."
1503   (interactive "P")
1504   (if (and (equal (buffer-name) "*Gnuplot Trail*")
1505            (> (recursion-depth) 0))
1506       (exit-recursive-edit)
1507     (if (eq major-mode 'calc-edit-mode)
1508         (calc-edit-finish arg)
1509       (if calc-was-keypad-mode
1510           (calc-keypad)
1511         (calc arg calc-full-mode t)))))
1512
1513 (defun calc-quit (&optional non-fatal interactive)
1514   "Quit the Calculator in an appropriate manner."
1515   (interactive "i\np")
1516   (and calc-standalone-flag (not non-fatal)
1517        (save-buffers-kill-emacs nil))
1518   (if (and (equal (buffer-name) "*Gnuplot Trail*")
1519            (> (recursion-depth) 0))
1520       (exit-recursive-edit))
1521   (if (eq major-mode 'calc-edit-mode)
1522       (calc-edit-cancel)
1523     (if (and interactive
1524              calc-embedded-info
1525              (eq (current-buffer) (aref calc-embedded-info 0)))
1526         (calc-embedded nil)
1527       (unless (eq major-mode 'calc-mode)
1528         (calc-create-buffer))
1529       (run-hooks 'calc-end-hook)
1530       (if (integerp calc-undo-length)
1531           (cond
1532            ((= calc-undo-length 0)
1533             (setq calc-undo-list nil calc-redo-list nil))
1534            ((> calc-undo-length 0)
1535             (let ((tail (nthcdr (1- calc-undo-length) calc-undo-list)))
1536               (if tail (setcdr tail nil)))
1537             (setq calc-redo-list nil))))
1538       (mapc (function (lambda (v) (set-default v (symbol-value v))))
1539             calc-local-var-list)
1540       (let ((buf (current-buffer))
1541             (win (get-buffer-window (current-buffer)))
1542             (kbuf (get-buffer "*Calc Keypad*")))
1543         (delete-windows-on (calc-trail-buffer))
1544         ;; The next few lines will set `calc-window-height' so that the
1545         ;; next time Calc is called, the window will be the same size
1546         ;; as the current window.
1547         (if (and win
1548                  (not (window-full-height-p win))
1549                  (window-full-width-p win) ; avoid calc-keypad
1550                  (not (get-buffer-window "*Calc Keypad*")))
1551             (setq calc-window-height (- (window-height win) 2)))
1552         (progn
1553           (delete-windows-on buf)
1554           (and kbuf (delete-windows-on kbuf)))
1555         (bury-buffer buf)
1556         (bury-buffer calc-trail-buffer)
1557         (and kbuf (bury-buffer kbuf))))))
1558
1559 ;;;###autoload
1560 (defun quick-calc ()
1561   "Do a quick calculation in the minibuffer without invoking full Calculator."
1562   (interactive)
1563   (calc-do-quick-calc))
1564
1565 ;;;###autoload
1566 (defun calc-eval (str &optional separator &rest args)
1567   "Do a quick calculation and return the result as a string.
1568 Return value will either be the formatted result in string form,
1569 or a list containing a character position and an error message in string form."
1570   (calc-do-calc-eval str separator args))
1571
1572 ;;;###autoload
1573 (defun calc-keypad (&optional interactive)
1574   "Invoke the Calculator in \"visual keypad\" mode.
1575 This is most useful in the X window system.
1576 In this mode, click on the Calc \"buttons\" using the left mouse button.
1577 Or, position the cursor manually and do M-x calc-keypad-press."
1578   (interactive "p")
1579   (require 'calc-ext)
1580   (calc-do-keypad calc-full-mode interactive))
1581
1582 ;;;###autoload
1583 (defun full-calc-keypad (&optional interactive)
1584   "Invoke the Calculator in full-screen \"visual keypad\" mode.
1585 See calc-keypad for details."
1586   (interactive "p")
1587   (require 'calc-ext)
1588   (calc-do-keypad t interactive))
1589
1590
1591 (defvar calc-aborted-prefix nil)
1592 (defvar calc-start-time nil)
1593 (defvar calc-command-flags nil)
1594 (defvar calc-final-point-line)
1595 (defvar calc-final-point-column)
1596 ;;; Note that modifications to this function may break calc-pass-errors.
1597 (defun calc-do (do-body &optional do-slow)
1598   (calc-check-defines)
1599   (let* ((calc-command-flags nil)
1600          (calc-start-time (and calc-timing (not calc-start-time)
1601                                (require 'calc-ext)
1602                                (current-time-string)))
1603          (gc-cons-threshold (max gc-cons-threshold
1604                                  (if calc-timing 2000000 100000)))
1605          calc-final-point-line calc-final-point-column)
1606     (setq calc-aborted-prefix "")
1607     (unwind-protect
1608         (condition-case err
1609             (save-excursion
1610               (if calc-embedded-info
1611                   (calc-embedded-select-buffer)
1612                 (calc-select-buffer))
1613               (and (eq calc-algebraic-mode 'total)
1614                    (require 'calc-ext)
1615                    (use-local-map calc-alg-map))
1616               (when (and do-slow calc-display-working-message)
1617                 (message "Working...")
1618                 (calc-set-command-flag 'clear-message))
1619               (funcall do-body)
1620               (setq calc-aborted-prefix nil)
1621               (when (memq 'renum-stack calc-command-flags)
1622                 (calc-renumber-stack))
1623               (when (memq 'clear-message calc-command-flags)
1624                 (message "")))
1625           (error
1626            (if (and (eq (car err) 'error)
1627                     (stringp (nth 1 err))
1628                     (string-match "max-specpdl-size\\|max-lisp-eval-depth"
1629                                   (nth 1 err)))
1630                (error "Computation got stuck or ran too long.  Type `M' to increase the limit")
1631              (setq calc-aborted-prefix nil)
1632              (signal (car err) (cdr err)))))
1633       (when calc-aborted-prefix
1634         (calc-record "<Aborted>" calc-aborted-prefix))
1635       (and calc-start-time
1636            (let* ((calc-internal-prec 12)
1637                   (calc-date-format nil)
1638                   (end-time (current-time-string))
1639                   (time (if (equal calc-start-time end-time)
1640                             0
1641                           (math-sub
1642                            (calcFunc-unixtime (math-parse-date end-time) 0)
1643                            (calcFunc-unixtime (math-parse-date calc-start-time)
1644                                               0)))))
1645              (if (math-lessp 1 time)
1646                  (calc-record time "(t)"))))
1647       (or (memq 'no-align calc-command-flags)
1648           (eq major-mode 'calc-trail-mode)
1649           (calc-align-stack-window))
1650       (and (memq 'position-point calc-command-flags)
1651            (if (eq major-mode 'calc-mode)
1652                (progn
1653                  (goto-char (point-min))
1654                  (forward-line (1- calc-final-point-line))
1655                  (move-to-column calc-final-point-column))
1656              (save-current-buffer
1657                (calc-select-buffer)
1658                (goto-char (point-min))
1659                (forward-line (1- calc-final-point-line))
1660                (move-to-column calc-final-point-column))))
1661       (unless (memq 'keep-flags calc-command-flags)
1662         (save-excursion
1663           (calc-select-buffer)
1664           (setq calc-inverse-flag nil
1665                 calc-hyperbolic-flag nil
1666                 calc-option-flag nil
1667                 calc-keep-args-flag nil)))
1668       (when (memq 'do-edit calc-command-flags)
1669         (switch-to-buffer (get-buffer-create "*Calc Edit*")))
1670       (calc-set-mode-line)
1671       (when calc-embedded-info
1672         (calc-embedded-finish-command))))
1673   (identity nil))  ; allow a GC after timing is done
1674
1675
1676 (defun calc-set-command-flag (f)
1677   (unless (memq f calc-command-flags)
1678     (setq calc-command-flags (cons f calc-command-flags))))
1679
1680 (defun calc-select-buffer ()
1681   (or (eq major-mode 'calc-mode)
1682       (if calc-main-buffer
1683           (set-buffer calc-main-buffer)
1684         (let ((buf (get-buffer "*Calculator*")))
1685           (if buf
1686               (set-buffer buf)
1687             (error "Calculator buffer not available"))))))
1688
1689 (defun calc-cursor-stack-index (&optional index)
1690   (goto-char (point-max))
1691   (forward-line (- (calc-substack-height (or index 1)))))
1692
1693 (defun calc-stack-size ()
1694   (- (length calc-stack) calc-stack-top))
1695
1696 (defun calc-substack-height (n)
1697   (let ((sum 0)
1698         (stack calc-stack))
1699     (setq n (+ n calc-stack-top))
1700     (while (and (> n 0) stack)
1701       (setq sum (+ sum (nth 1 (car stack)))
1702             n (1- n)
1703             stack (cdr stack)))
1704     sum))
1705
1706 (defun calc-set-mode-line ()
1707   (save-excursion
1708     (calc-select-buffer)
1709     (let* ((fmt (car calc-float-format))
1710            (figs (nth 1 calc-float-format))
1711            (new-mode-string
1712             (format "Calc%s%s: %d %s %-14s"
1713                     (if (and calc-embedded-info
1714                              (eq (aref calc-embedded-info 1) (current-buffer)))
1715                         "Embed" "")
1716                     (if (and (> (length (buffer-name)) 12)
1717                              (equal (substring (buffer-name) 0 12)
1718                                     "*Calculator*"))
1719                         (substring (buffer-name) 12)
1720                       "")
1721                     calc-internal-prec
1722                     (capitalize (symbol-name calc-angle-mode))
1723                     (concat
1724
1725                      ;; Input-related modes
1726                      (if (eq calc-algebraic-mode 'total) "Alg* "
1727                        (if calc-algebraic-mode "Alg "
1728                          (if calc-incomplete-algebraic-mode "Alg[( " "")))
1729
1730                      ;; Computational modes
1731                      (if calc-symbolic-mode "Symb " "")
1732                      (cond ((eq calc-matrix-mode 'matrix) "Matrix ")
1733                            ((integerp calc-matrix-mode)
1734                             (format "Matrix%d " calc-matrix-mode))
1735                            ((eq calc-matrix-mode 'sqmatrix) "SqMatrix ")
1736                            ((eq calc-matrix-mode 'scalar) "Scalar ")
1737                            (t ""))
1738                      (if (eq calc-complex-mode 'polar) "Polar " "")
1739                      (if calc-prefer-frac "Frac " "")
1740                      (cond ((null calc-infinite-mode) "")
1741                            ((eq calc-infinite-mode 1) "+Inf ")
1742                            (t "Inf "))
1743                      (cond ((eq calc-simplify-mode 'none) "NoSimp ")
1744                            ((eq calc-simplify-mode 'num) "NumSimp ")
1745                            ((eq calc-simplify-mode 'binary)
1746                             (format "BinSimp%d " calc-word-size))
1747                            ((eq calc-simplify-mode 'alg) "AlgSimp ")
1748                            ((eq calc-simplify-mode 'ext) "ExtSimp ")
1749                            ((eq calc-simplify-mode 'units) "UnitSimp ")
1750                            (t ""))
1751
1752                      ;; Display modes
1753                      (cond ((= calc-number-radix 10) "")
1754                            ((= calc-number-radix 2) "Bin ")
1755                            ((= calc-number-radix 8) "Oct ")
1756                            ((= calc-number-radix 16) "Hex ")
1757                            (t (format "Radix%d " calc-number-radix)))
1758                      (if calc-twos-complement-mode "TwosComp " "")
1759                      (if calc-leading-zeros "Zero " "")
1760                      (cond ((null calc-language) "")
1761                            ((get calc-language 'math-lang-name)
1762                             (concat (get calc-language 'math-lang-name) " "))
1763                            (t (concat
1764                                (capitalize (symbol-name calc-language))
1765                                " ")))
1766                      (cond ((eq fmt 'float)
1767                             (if (zerop figs) "" (format "Norm%d " figs)))
1768                            ((eq fmt 'fix) (format "Fix%d " figs))
1769                            ((eq fmt 'sci)
1770                             (if (zerop figs) "Sci " (format "Sci%d " figs)))
1771                            ((eq fmt 'eng)
1772                             (if (zerop figs) "Eng " (format "Eng%d " figs))))
1773                      (cond ((not calc-display-just)
1774                             (if calc-display-origin
1775                                 (format "Left%d " calc-display-origin) ""))
1776                            ((eq calc-display-just 'right)
1777                             (if calc-display-origin
1778                                 (format "Right%d " calc-display-origin)
1779                               "Right "))
1780                            (t
1781                             (if calc-display-origin
1782                                 (format "Center%d " calc-display-origin)
1783                               "Center ")))
1784                      (cond ((integerp calc-line-breaking)
1785                             (format "Wid%d " calc-line-breaking))
1786                            (calc-line-breaking "")
1787                            (t "Wide "))
1788
1789                      ;; Miscellaneous other modes/indicators
1790                      (if calc-assoc-selections "" "Break ")
1791                      (cond ((eq calc-mode-save-mode 'save) "Save ")
1792                            ((not calc-embedded-info) "")
1793                            ((eq calc-mode-save-mode 'local) "Local ")
1794                            ((eq calc-mode-save-mode 'edit) "LocEdit ")
1795                            ((eq calc-mode-save-mode 'perm) "LocPerm ")
1796                            ((eq calc-mode-save-mode 'global) "Global ")
1797                            (t ""))
1798                      (if calc-auto-recompute "" "Manual ")
1799                      (if (and (fboundp 'calc-gnuplot-alive)
1800                               (calc-gnuplot-alive)) "Graph " "")
1801                      (if (and calc-embedded-info
1802                               (> (calc-stack-size) 0)
1803                               (calc-top 1 'sel)) "Sel " "")
1804                      (if calc-display-dirty "Dirty " "")
1805                      (if calc-option-flag "Opt " "")
1806                      (if calc-inverse-flag "Inv " "")
1807                      (if calc-hyperbolic-flag "Hyp " "")
1808                      (if calc-keep-args-flag "Keep " "")
1809                      (if (/= calc-stack-top 1) "Narrow " "")
1810                      (apply 'concat calc-other-modes)))))
1811       (if (equal new-mode-string mode-line-buffer-identification)
1812           nil
1813         (setq mode-line-buffer-identification new-mode-string)
1814         (set-buffer-modified-p (buffer-modified-p))
1815         (and calc-embedded-info (calc-embedded-mode-line-change))))))
1816
1817 (defun calc-align-stack-window ()
1818   (if (eq major-mode 'calc-mode)
1819       (progn
1820         (let ((win (get-buffer-window (current-buffer))))
1821           (if win
1822               (progn
1823                 (calc-cursor-stack-index 0)
1824                 (vertical-motion (- 2 (window-height win)))
1825                 (set-window-start win (point)))))
1826         (calc-cursor-stack-index 0)
1827         (if (looking-at " *\\.$")
1828             (goto-char (1- (match-end 0)))))
1829     (save-excursion
1830       (calc-select-buffer)
1831       (calc-align-stack-window))))
1832
1833 (defun calc-check-stack (n)
1834   (if (> n (calc-stack-size))
1835       (error "Too few elements on stack"))
1836   (if (< n 0)
1837       (error "Invalid argument")))
1838
1839 (defun calc-push-list (vals &optional m sels)
1840   (while vals
1841     (if calc-executing-macro
1842         (calc-push-list-in-macro vals m sels)
1843       (save-excursion
1844         (calc-select-buffer)
1845         (let* ((val (car vals))
1846                (entry (list val 1 (car sels)))
1847                (mm (+ (or m 1) calc-stack-top)))
1848           (calc-cursor-stack-index (1- (or m 1)))
1849           (if (> mm 1)
1850               (setcdr (nthcdr (- mm 2) calc-stack)
1851                       (cons entry (nthcdr (1- mm) calc-stack)))
1852             (setq calc-stack (cons entry calc-stack)))
1853           (let ((buffer-read-only nil))
1854             (insert (math-format-stack-value entry) "\n"))
1855           (calc-record-undo (list 'push mm))
1856           (calc-set-command-flag 'renum-stack))))
1857     (setq vals (cdr vals)
1858           sels (cdr sels))))
1859
1860 (defun calc-pop-push-list (n vals &optional m sels)
1861   (if (and calc-any-selections (null sels))
1862       (calc-replace-selections n vals m)
1863     (calc-pop-stack n m sels)
1864     (calc-push-list vals m sels)))
1865
1866 (defun calc-pop-push-record-list (n prefix vals &optional m sels)
1867   (or (and (consp vals)
1868            (or (integerp (car vals))
1869                (consp (car vals))))
1870       (and vals (setq vals (list vals)
1871                       sels (and sels (list sels)))))
1872   (calc-check-stack (+ n (or m 1) -1))
1873   (if prefix
1874       (if (cdr vals)
1875           (calc-record-list vals prefix)
1876         (calc-record (car vals) prefix)))
1877   (calc-pop-push-list n vals m sels))
1878
1879 (defun calc-enter-result (n prefix vals &optional m)
1880   (setq calc-aborted-prefix prefix)
1881   (if (and (consp vals)
1882            (or (integerp (car vals))
1883                (consp (car vals))))
1884       (setq vals (mapcar 'calc-normalize vals))
1885     (setq vals (calc-normalize vals)))
1886   (or (and (consp vals)
1887            (or (integerp (car vals))
1888                (consp (car vals))))
1889       (setq vals (list vals)))
1890   (if (equal vals '((nil)))
1891       (setq vals nil))
1892   (calc-pop-push-record-list n prefix vals m)
1893   (calc-handle-whys))
1894
1895 (defun calc-normalize (val)
1896   (if (memq calc-simplify-mode '(nil none num))
1897       (math-normalize val)
1898     (require 'calc-ext)
1899     (calc-normalize-fancy val)))
1900
1901 (defun calc-handle-whys ()
1902   (if calc-next-why
1903       (calc-do-handle-whys)))
1904
1905
1906 (defun calc-pop-stack (&optional n m sel-ok)  ; pop N objs at level M of stack.
1907   (or n (setq n 1))
1908   (or m (setq m 1))
1909   (or calc-keep-args-flag
1910       (let ((mm (+ m calc-stack-top)))
1911         (if (and calc-any-selections (not sel-ok)
1912                  (calc-top-selected n m))
1913             (calc-sel-error))
1914         (if calc-executing-macro
1915             (calc-pop-stack-in-macro n mm)
1916           (calc-record-undo (list 'pop mm (calc-top-list n m 'full)))
1917           (save-excursion
1918             (calc-select-buffer)
1919             (let ((buffer-read-only nil))
1920               (if (> mm 1)
1921                   (progn
1922                     (calc-cursor-stack-index (1- m))
1923                     (let ((bot (point)))
1924                       (calc-cursor-stack-index (+ n m -1))
1925                       (delete-region (point) bot))
1926                     (setcdr (nthcdr (- mm 2) calc-stack)
1927                             (nthcdr (+ n mm -1) calc-stack)))
1928                 (calc-cursor-stack-index n)
1929                 (setq calc-stack (nthcdr n calc-stack))
1930                 (delete-region (point) (point-max))))
1931             (calc-set-command-flag 'renum-stack))))))
1932
1933 (defvar sel-mode)
1934 (defun calc-get-stack-element (x)
1935   (cond ((eq sel-mode 'entry)
1936          x)
1937         ((eq sel-mode 'sel)
1938          (nth 2 x))
1939         ((or (null (nth 2 x))
1940              (eq sel-mode 'full)
1941              (not calc-use-selections))
1942          (car x))
1943         (sel-mode
1944          (calc-sel-error))
1945         (t (nth 2 x))))
1946
1947 ;; Get the Nth element of the stack (N=1 is the top element).
1948 (defun calc-top (&optional n sel-mode)
1949   (or n (setq n 1))
1950   (calc-check-stack n)
1951   (calc-get-stack-element (nth (+ n calc-stack-top -1) calc-stack)))
1952
1953 (defun calc-top-n (&optional n sel-mode)    ; in case precision has changed
1954   (math-check-complete (calc-normalize (calc-top n sel-mode))))
1955
1956 (defun calc-top-list (&optional n m sel-mode)
1957   (or n (setq n 1))
1958   (or m (setq m 1))
1959   (calc-check-stack (+ n m -1))
1960   (and (> n 0)
1961        (let ((top (copy-sequence (nthcdr (+ m calc-stack-top -1)
1962                                          calc-stack))))
1963          (setcdr (nthcdr (1- n) top) nil)
1964          (nreverse (mapcar 'calc-get-stack-element top)))))
1965
1966 (defun calc-top-list-n (&optional n m sel-mode)
1967   (mapcar 'math-check-complete
1968           (mapcar 'calc-normalize (calc-top-list n m sel-mode))))
1969
1970
1971 (defun calc-renumber-stack ()
1972   (if calc-line-numbering
1973       (save-excursion
1974         (calc-cursor-stack-index 0)
1975         (let ((lnum 1)
1976               (buffer-read-only nil)
1977               (stack (nthcdr calc-stack-top calc-stack)))
1978           (if (re-search-forward "^[0-9]+[:*]" nil t)
1979               (progn
1980                 (beginning-of-line)
1981                 (while (re-search-forward "^[0-9]+[:*]" nil t)
1982                   (let ((buffer-read-only nil))
1983                     (beginning-of-line)
1984                     (delete-char 4)
1985                     (insert "    ")))
1986                 (calc-cursor-stack-index 0)))
1987           (while (re-search-backward "^[0-9]+[:*]" nil t)
1988             (delete-char 4)
1989             (if (> lnum 999)
1990                 (insert (format "%03d%s" (% lnum 1000)
1991                                 (if (and (nth 2 (car stack))
1992                                          calc-use-selections) "*" ":")))
1993               (let ((prefix (int-to-string lnum)))
1994                 (insert prefix (if (and (nth 2 (car stack))
1995                                         calc-use-selections) "*" ":")
1996                         (make-string (- 3 (length prefix)) 32))))
1997             (beginning-of-line)
1998             (setq lnum (1+ lnum)
1999                   stack (cdr stack))))))
2000   (and calc-embedded-info (calc-embedded-stack-change)))
2001
2002 (defvar calc-any-evaltos nil)
2003 (defun calc-refresh (&optional align)
2004   (interactive)
2005   (and (eq major-mode 'calc-mode)
2006        (not calc-executing-macro)
2007        (let* ((buffer-read-only nil)
2008               (save-point (point))
2009               (save-mark (condition-case err (mark) (error nil)))
2010               (save-aligned (looking-at "\\.$"))
2011               (thing calc-stack)
2012               (calc-any-evaltos nil))
2013          (setq calc-any-selections nil)
2014          (erase-buffer)
2015          (when calc-show-banner
2016            (insert (propertize "--- Emacs Calculator Mode ---\n"
2017                                'face 'italic)))
2018          (while thing
2019            (goto-char (point-min))
2020            (when calc-show-banner
2021              (forward-line 1))
2022            (insert (math-format-stack-value (car thing)) "\n")
2023            (setq thing (cdr thing)))
2024          (calc-renumber-stack)
2025          (if calc-display-dirty
2026              (calc-wrapper (setq calc-display-dirty nil)))
2027          (and calc-any-evaltos calc-auto-recompute
2028               (calc-wrapper (calc-refresh-evaltos)))
2029          (if (or align save-aligned)
2030              (calc-align-stack-window)
2031            (goto-char save-point))
2032          (if save-mark (set-mark save-mark))))
2033   (and calc-embedded-info (not (eq major-mode 'calc-mode))
2034        (with-current-buffer (aref calc-embedded-info 1)
2035          (calc-refresh align)))
2036   (setq calc-refresh-count (1+ calc-refresh-count)))
2037
2038 ;;;; The Calc Trail buffer.
2039
2040 (defun calc-check-trail-aligned ()
2041   (save-excursion
2042     (let ((win (get-buffer-window (current-buffer))))
2043       (and win
2044            (pos-visible-in-window-p (1- (point-max)) win)))))
2045
2046 (defun calc-trail-buffer ()
2047   (and (or (null calc-trail-buffer)
2048            (null (buffer-name calc-trail-buffer)))
2049        (save-excursion
2050          (setq calc-trail-buffer (get-buffer-create "*Calc Trail*"))
2051          (let ((buf (or (and (not (eq major-mode 'calc-mode))
2052                              (get-buffer "*Calculator*"))
2053                         (current-buffer))))
2054            (set-buffer calc-trail-buffer)
2055            (or (eq major-mode 'calc-trail-mode)
2056                (calc-trail-mode buf)))))
2057   (or (and calc-trail-pointer
2058            (eq (marker-buffer calc-trail-pointer) calc-trail-buffer))
2059       (with-current-buffer calc-trail-buffer
2060         (goto-char (point-min))
2061         (forward-line 1)
2062         (setq calc-trail-pointer (point-marker))))
2063   calc-trail-buffer)
2064
2065 (defun calc-record (val &optional prefix)
2066   (setq calc-aborted-prefix nil)
2067   (or calc-executing-macro
2068       (let* ((mainbuf (current-buffer))
2069              (buf (calc-trail-buffer))
2070              (calc-display-raw nil)
2071              (calc-can-abbrev-vectors t)
2072              (fval (if val
2073                        (if (stringp val)
2074                            val
2075                          (math-showing-full-precision
2076                           (math-format-flat-expr val 0)))
2077                      "")))
2078         (with-current-buffer buf
2079           (let ((aligned (calc-check-trail-aligned))
2080                 (buffer-read-only nil))
2081             (goto-char (point-max))
2082             (cond ((null prefix) (insert "     "))
2083                   ((and (> (length prefix) 4)
2084                         (string-match " " prefix 4))
2085                    (insert (substring prefix 0 4) " "))
2086                   (t (insert (format "%4s " prefix))))
2087             (insert fval "\n")
2088             (let ((win (get-buffer-window buf)))
2089               (if (and aligned win (not (memq 'hold-trail calc-command-flags)))
2090                   (calc-trail-here))
2091               (goto-char (1- (point-max))))))))
2092   val)
2093
2094
2095 (defun calc-trail-display (flag &optional no-refresh interactive)
2096   (interactive "P\ni\np")
2097   (let ((win (get-buffer-window (calc-trail-buffer))))
2098     (if (setq calc-display-trail
2099               (not (if flag (memq flag '(nil 0)) win)))
2100         (if (null win)
2101             (progn
2102               (if calc-trail-window-hook
2103                   (run-hooks 'calc-trail-window-hook)
2104                 (let ((w (split-window nil (/ (* (window-width) 2) 3) t)))
2105                   (set-window-buffer w calc-trail-buffer)))
2106               (calc-wrapper
2107                (setq overlay-arrow-string calc-trail-overlay
2108                      overlay-arrow-position calc-trail-pointer)
2109                (or no-refresh
2110                    (if interactive
2111                        (calc-do-refresh)
2112                      (calc-refresh))))))
2113       (if win
2114           (progn
2115             (delete-window win)
2116             (calc-wrapper
2117              (or no-refresh
2118                  (if interactive
2119                      (calc-do-refresh)
2120                    (calc-refresh))))))))
2121   calc-trail-buffer)
2122
2123 (defun calc-trail-here ()
2124   (interactive)
2125   (if (eq major-mode 'calc-trail-mode)
2126       (progn
2127         (beginning-of-line)
2128         (if (bobp)
2129             (forward-line 1)
2130           (if (eobp)
2131               (forward-line -1)))
2132         (if (or (bobp) (eobp))
2133             (setq overlay-arrow-position nil)   ; trail is empty
2134           (set-marker calc-trail-pointer (point) (current-buffer))
2135           (setq calc-trail-overlay (concat (buffer-substring (point)
2136                                                              (+ (point) 4))
2137                                            ">")
2138                 overlay-arrow-string calc-trail-overlay
2139                 overlay-arrow-position calc-trail-pointer)
2140           (forward-char 4)
2141           (let ((win (get-buffer-window (current-buffer))))
2142             (if win
2143                 (save-excursion
2144                   (forward-line (/ (window-height win) 2))
2145                   (forward-line (- 1 (window-height win)))
2146                   (set-window-start win (point))
2147                   (set-window-point win (+ calc-trail-pointer 4))
2148                   (set-buffer calc-main-buffer)
2149                   (setq overlay-arrow-string calc-trail-overlay
2150                         overlay-arrow-position calc-trail-pointer))))))
2151     (error "Not in Calc Trail buffer")))
2152
2153
2154
2155
2156 ;;;; The Undo list.
2157
2158 (defun calc-record-undo (rec)
2159   (or calc-executing-macro
2160       (if (memq 'undo calc-command-flags)
2161           (setq calc-undo-list (cons (cons rec (car calc-undo-list))
2162                                      (cdr calc-undo-list)))
2163         (setq calc-undo-list (cons (list rec) calc-undo-list)
2164               calc-redo-list nil)
2165         (calc-set-command-flag 'undo))))
2166
2167
2168
2169
2170 ;;; Arithmetic commands.
2171
2172 (defun calc-binary-op (name func arg &optional ident unary func2)
2173   (setq calc-aborted-prefix name)
2174   (if (null arg)
2175       (calc-enter-result 2 name (cons (or func2 func)
2176                                       (mapcar 'math-check-complete
2177                                               (calc-top-list 2))))
2178     (require 'calc-ext)
2179     (calc-binary-op-fancy name func arg ident unary)))
2180
2181 (defun calc-unary-op (name func arg &optional func2)
2182   (setq calc-aborted-prefix name)
2183   (if (null arg)
2184       (calc-enter-result 1 name (list (or func2 func)
2185                                       (math-check-complete (calc-top 1))))
2186     (require 'calc-ext)
2187     (calc-unary-op-fancy name func arg)))
2188
2189
2190 (defun calc-plus (arg)
2191   (interactive "P")
2192   (calc-slow-wrapper
2193    (calc-binary-op "+" 'calcFunc-add arg 0 nil '+)))
2194
2195 (defun calc-minus (arg)
2196   (interactive "P")
2197   (calc-slow-wrapper
2198    (calc-binary-op "-" 'calcFunc-sub arg 0 'neg '-)))
2199
2200 (defun calc-times (arg)
2201   (interactive "P")
2202   (calc-slow-wrapper
2203    (calc-binary-op "*" 'calcFunc-mul arg 1 nil '*)))
2204
2205 (defun calc-divide (arg)
2206   (interactive "P")
2207   (calc-slow-wrapper
2208    (calc-binary-op "/" 'calcFunc-div arg 0 'calcFunc-inv '/)))
2209
2210 (defun calc-left-divide (arg)
2211   (interactive "P")
2212   (calc-slow-wrapper
2213    (calc-binary-op "ldiv" 'calcFunc-ldiv arg 0 nil nil)))
2214
2215 (defun calc-change-sign (arg)
2216   (interactive "P")
2217   (calc-wrapper
2218    (calc-unary-op "chs" 'neg arg)))
2219
2220
2221
2222 ;;; Stack management commands.
2223
2224 (defun calc-enter (n)
2225   (interactive "p")
2226   (calc-wrapper
2227    (cond ((< n 0)
2228           (calc-push-list (calc-top-list 1 (- n))))
2229          ((= n 0)
2230           (calc-push-list (calc-top-list (calc-stack-size))))
2231          (t
2232           (calc-push-list (calc-top-list n))))))
2233
2234
2235 (defun calc-pop (n)
2236   (interactive "P")
2237   (calc-wrapper
2238    (let* ((nn (prefix-numeric-value n))
2239           (top (and (null n) (calc-top 1))))
2240      (cond ((and (null n)
2241                  (eq (car-safe top) 'incomplete)
2242                  (> (length top) (if (eq (nth 1 top) 'intv) 3 2)))
2243             (calc-pop-push-list 1 (let ((tt (copy-sequence top)))
2244                                     (setcdr (nthcdr (- (length tt) 2) tt) nil)
2245                                     (list tt))))
2246            ((< nn 0)
2247             (if (and calc-any-selections
2248                      (calc-top-selected 1 (- nn)))
2249                 (calc-delete-selection (- nn))
2250               (calc-pop-stack 1 (- nn) t)))
2251            ((= nn 0)
2252             (calc-pop-stack (calc-stack-size) 1 t))
2253            (t
2254             (if (and calc-any-selections
2255                      (= nn 1)
2256                      (calc-top-selected 1 1))
2257                 (calc-delete-selection 1)
2258               (calc-pop-stack nn)))))))
2259
2260
2261
2262
2263 ;;;; Reading a number using the minibuffer.
2264 (defvar calc-buffer)
2265 (defvar calc-prev-char)
2266 (defvar calc-prev-prev-char)
2267 (defvar calc-digit-value)
2268 (defun calcDigit-start ()
2269   (interactive)
2270   (calc-wrapper
2271    (if (or calc-algebraic-mode
2272            (and (> calc-number-radix 14) (eq last-command-event ?e)))
2273        (calc-alg-digit-entry)
2274      (calc-unread-command)
2275      (setq calc-aborted-prefix nil)
2276      (let* ((calc-digit-value nil)
2277             (calc-prev-char nil)
2278             (calc-prev-prev-char nil)
2279             (calc-buffer (current-buffer))
2280             (buf (if (featurep 'xemacs)
2281                      (catch 'calc-foo
2282                        (catch 'execute-kbd-macro
2283                          (throw 'calc-foo
2284                                 (read-from-minibuffer
2285                                  "Calc: " "" calc-digit-map)))
2286                        (error "XEmacs requires RET after %s"
2287                               "digit entry in kbd macro"))
2288                    (let ((old-esc (lookup-key global-map "\e")))
2289                      (unwind-protect
2290                          (progn
2291                            (define-key global-map "\e" nil)
2292                            (read-from-minibuffer "Calc: " "" calc-digit-map))
2293                        (define-key global-map "\e" old-esc))))))
2294        (or calc-digit-value (setq calc-digit-value (math-read-number buf)))
2295        (if (stringp calc-digit-value)
2296            (calc-alg-entry calc-digit-value)
2297          (if calc-digit-value
2298              (calc-push-list (list (calc-record (calc-normalize
2299                                                  calc-digit-value))))))
2300        (if (eq calc-prev-char 'dots)
2301            (progn
2302              (require 'calc-ext)
2303              (calc-dots)))))))
2304
2305 (defsubst calc-minibuffer-size ()
2306   (- (point-max) (minibuffer-prompt-end)))
2307
2308 (defun calcDigit-nondigit ()
2309   (interactive)
2310   ;; Exercise for the reader:  Figure out why this is a good precaution!
2311   (or (boundp 'calc-buffer)
2312       (use-local-map minibuffer-local-map))
2313   (let ((str (minibuffer-contents)))
2314     (setq calc-digit-value (with-current-buffer calc-buffer
2315                              (math-read-number str))))
2316   (if (and (null calc-digit-value) (> (calc-minibuffer-size) 0))
2317       (progn
2318         (beep)
2319         (calc-temp-minibuffer-message " [Bad format]"))
2320     (or (memq last-command-event '(32 13))
2321         (progn (setq prefix-arg current-prefix-arg)
2322                (calc-unread-command (if (and (eq last-command-event 27)
2323                                              (>= last-input-event 128))
2324                                         last-input-event
2325                                       nil))))
2326     (exit-minibuffer)))
2327
2328
2329 (defun calc-minibuffer-contains (rex)
2330   (save-excursion
2331     (goto-char (minibuffer-prompt-end))
2332     (looking-at rex)))
2333
2334 (defun calcDigit-key ()
2335   (interactive)
2336   (goto-char (point-max))
2337   (if (or (and (memq last-command-event '(?+ ?-))
2338                (> (buffer-size) 0)
2339                (/= (preceding-char) ?e))
2340           (and (memq last-command-event '(?m ?s))
2341                (not (calc-minibuffer-contains "[-+]?[0-9]+\\.?0*[@oh].*"))
2342                (not (calc-minibuffer-contains "[-+]?\\(1[1-9]\\|[2-9][0-9]\\)#.*"))))
2343       (calcDigit-nondigit)
2344     (if (calc-minibuffer-contains "\\([-+]?\\|.* \\)\\'")
2345         (cond ((memq last-command-event '(?. ?@)) (insert "0"))
2346               ((and (memq last-command-event '(?o ?h ?m))
2347                     (not (calc-minibuffer-contains ".*#.*"))) (insert "0"))
2348               ((memq last-command-event '(?: ?e)) (insert "1"))
2349               ((eq last-command-event ?#)
2350                (insert (int-to-string calc-number-radix)))))
2351     (if (and (calc-minibuffer-contains "\\([-+]?[0-9]+#\\|[^:]*:\\)\\'")
2352              (eq last-command-event ?:))
2353         (insert "1"))
2354     (if (and (calc-minibuffer-contains "[-+]?[0-9]+#\\'")
2355              (eq last-command-event ?.))
2356         (insert "0"))
2357     (if (and (calc-minibuffer-contains "[-+]?0*\\([2-9]\\|1[0-4]\\)#\\'")
2358              (eq last-command-event ?e))
2359         (insert "1"))
2360     (if (or (and (memq last-command-event '(?h ?o ?m ?s ?p))
2361                  (calc-minibuffer-contains ".*#.*"))
2362             (and (eq last-command-event ?e)
2363                  (calc-minibuffer-contains "[-+]?\\(1[5-9]\\|[2-9][0-9]\\)#.*"))
2364             (and (eq last-command-event ?n)
2365                  (calc-minibuffer-contains "[-+]?\\(2[4-9]\\|[3-9][0-9]\\)#.*")))
2366         (setq last-command-event (upcase last-command-event)))
2367     (cond
2368      ((memq last-command-event '(?_ ?n))
2369       (goto-char (minibuffer-prompt-end))
2370       (if (and (search-forward " +/- " nil t)
2371                (not (search-forward "e" nil t)))
2372           (beep)
2373         (and (not (calc-minibuffer-contains "[-+]?\\(1[5-9]\\|[2-9][0-9]\\)#.*"))
2374              (search-forward "e" nil t))
2375         (if (looking-at "+")
2376             (delete-char 1))
2377         (if (looking-at "-")
2378             (delete-char 1)
2379           (insert "-")))
2380       (goto-char (point-max)))
2381      ((eq last-command-event ?p)
2382       (if (or (calc-minibuffer-contains ".*\\+/-.*")
2383               (calc-minibuffer-contains ".*mod.*")
2384               (calc-minibuffer-contains ".*#.*")
2385               (calc-minibuffer-contains ".*[-+e:]\\'"))
2386           (beep)
2387         (if (not (calc-minibuffer-contains ".* \\'"))
2388             (insert " "))
2389         (insert "+/- ")))
2390      ((and (eq last-command-event ?M)
2391            (not (calc-minibuffer-contains
2392                  "[-+]?\\(2[3-9]\\|[3-9][0-9]\\)#.*")))
2393       (if (or (calc-minibuffer-contains ".*\\+/-.*")
2394               (calc-minibuffer-contains ".*mod *[^ ]+")
2395               (calc-minibuffer-contains ".*[-+e:]\\'"))
2396           (beep)
2397         (if (calc-minibuffer-contains ".*mod \\'")
2398             (if calc-previous-modulo
2399                 (insert (math-format-flat-expr calc-previous-modulo 0))
2400               (beep))
2401           (if (not (calc-minibuffer-contains ".* \\'"))
2402               (insert " "))
2403           (insert "mod "))))
2404      (t
2405       (insert (char-to-string last-command-event))
2406       (if (or (and (calc-minibuffer-contains "[-+]?\\(.*\\+/- *\\|.*mod *\\)?\\([0-9][0-9]?\\)#[#]?[0-9a-zA-Z]*\\(:[0-9a-zA-Z]*\\(:[0-9a-zA-Z]*\\)?\\|.[0-9a-zA-Z]*\\(e[-+]?[0-9]*\\)?\\)?\\'")
2407                    (let ((radix (string-to-number
2408                                  (buffer-substring
2409                                   (match-beginning 2) (match-end 2)))))
2410                      (and (>= radix 2)
2411                           (<= radix 36)
2412                           (or (memq last-command-event '(?# ?: ?. ?e ?+ ?-))
2413                               (let ((dig (math-read-radix-digit
2414                                           (upcase last-command-event))))
2415                                 (and dig
2416                                      (< dig radix)))))))
2417               (calc-minibuffer-contains
2418                "[-+]?\\(.*\\+/- *\\|.*mod *\\)?\\([0-9]+\\.?0*[@oh] *\\)?\\([0-9]+\\.?0*['m] *\\)?[0-9]*\\(\\.?[0-9]*\\(e[-+]?[0-3]?[0-9]?[0-9]?[0-9]?[0-9]?[0-9]?[0-9]?\\)?\\|[0-9]:\\([0-9]+:\\)?[0-9]*\\)?[\"s]?\\'"))
2419           (if (and (memq last-command-event '(?@ ?o ?h ?\' ?m))
2420                    (string-match " " calc-hms-format))
2421               (insert " "))
2422         (if (and (eq this-command last-command)
2423                  (eq last-command-event ?.))
2424             (progn
2425               (require 'calc-ext)
2426               (calc-digit-dots))
2427           (delete-char -1)
2428           (beep)
2429           (calc-temp-minibuffer-message " [Bad format]"))))))
2430   (setq calc-prev-prev-char calc-prev-char
2431         calc-prev-char last-command-event))
2432
2433
2434 (defun calcDigit-backspace ()
2435   (interactive)
2436   (goto-char (point-max))
2437   (cond ((calc-minibuffer-contains ".* \\+/- \\'")
2438          (backward-delete-char 5))
2439         ((calc-minibuffer-contains ".* mod \\'")
2440          (backward-delete-char 5))
2441         ((calc-minibuffer-contains ".* \\'")
2442          (backward-delete-char 2))
2443         ((eq last-command 'calcDigit-start)
2444          (erase-buffer))
2445         (t (backward-delete-char 1)))
2446   (if (= (calc-minibuffer-size) 0)
2447       (progn
2448         (setq last-command-event 13)
2449         (calcDigit-nondigit))))
2450
2451
2452
2453
2454 (defconst math-bignum-digit-length
2455   (truncate (/ (log10 (/ most-positive-fixnum 2)) 2))
2456   "The length of a \"digit\" in Calc bignums.
2457 If a big integer is of the form (bigpos N0 N1 ...), this is the
2458 length of the allowable Emacs integers N0, N1,...
2459 The value of 2*10^(2*MATH-BIGNUM-DIGIT-LENGTH) must be less than the
2460 largest Emacs integer.")
2461
2462 (defconst math-bignum-digit-size
2463   (expt 10 math-bignum-digit-length)
2464   "An upper bound for the size of the \"digit\"s in Calc bignums.")
2465
2466 (defconst math-small-integer-size
2467   (expt math-bignum-digit-size 2)
2468   "An upper bound for the size of \"small integer\"s in Calc.")
2469
2470
2471 ;;;; Arithmetic routines.
2472 ;;
2473 ;; An object as manipulated by one of these routines may take any of the
2474 ;; following forms:
2475 ;;
2476 ;; integer                 An integer.  For normalized numbers, this format
2477 ;;                          is used only for
2478 ;;                         negative math-small-integer-size + 1 to
2479 ;;                         math-small-integer-size - 1
2480 ;;
2481 ;; (bigpos N0 N1 N2 ...)   A big positive integer,
2482 ;;                           N0 + N1*math-bignum-digit-size
2483 ;;                              + N2*(math-bignum-digit-size)^2 ...
2484 ;; (bigneg N0 N1 N2 ...)   A big negative integer,
2485 ;;                           - N0 - N1*math-bignum-digit-size ...
2486 ;;                          Each digit N is in the range
2487 ;;                             0 ... math-bignum-digit-size -1.
2488 ;;                          Normalized, always at least three N present,
2489 ;;                          and the most significant N is nonzero.
2490 ;;
2491 ;; (frac NUM DEN)          A fraction.  NUM and DEN are small or big integers.
2492 ;;                         Normalized, DEN > 1.
2493 ;;
2494 ;; (float NUM EXP)         A floating-point number, NUM * 10^EXP;
2495 ;;                         NUM is a small or big integer, EXP is a small int.
2496 ;;                          Normalized, NUM is not a multiple of 10, and
2497 ;;                          abs(NUM) < 10^calc-internal-prec.
2498 ;;                          Normalized zero is stored as (float 0 0).
2499 ;;
2500 ;; (cplx REAL IMAG)        A complex number; REAL and IMAG are any of above.
2501 ;;                          Normalized, IMAG is nonzero.
2502 ;;
2503 ;; (polar R THETA)         Polar complex number.  Normalized, R > 0 and THETA
2504 ;;                         is neither zero nor 180 degrees (pi radians).
2505 ;;
2506 ;; (vec A B C ...)         Vector of objects A, B, C, ...  A matrix is a
2507 ;;                         vector of vectors.
2508 ;;
2509 ;; (hms H M S)             Angle in hours-minutes-seconds form.  All three
2510 ;;                         components have the same sign; H and M must be
2511 ;;                         numerically integers; M and S are expected to
2512 ;;                         lie in the range [0,60).
2513 ;;
2514 ;; (date N)                A date or date/time object.  N is an integer to
2515 ;;                          store a date only, or a fraction or float to
2516 ;;                          store a date and time.
2517 ;;
2518 ;; (sdev X SIGMA)          Error form, X +/- SIGMA.  When normalized,
2519 ;;                         SIGMA > 0.  X is any complex number and SIGMA
2520 ;;                          is real numbers; or these may be symbolic
2521 ;;                         expressions where SIGMA is assumed real.
2522 ;;
2523 ;; (intv MASK LO HI)       Interval form.  MASK is 0=(), 1=(], 2=[), or 3=[].
2524 ;;                         LO and HI are any real numbers, or symbolic
2525 ;;                          expressions which are assumed real, and LO < HI.
2526 ;;                          For [LO..HI], if LO = HI normalization produces LO,
2527 ;;                          and if LO > HI normalization produces [LO..LO).
2528 ;;                          For other intervals, if LO > HI normalization
2529 ;;                          sets HI equal to LO.
2530 ;;
2531 ;; (mod N M)                Number modulo M.  When normalized, 0 <= N < M.
2532 ;;                          N and M are real numbers.
2533 ;;
2534 ;; (var V S)                Symbolic variable.  V is a Lisp symbol which
2535 ;;                          represents the variable's visible name.  S is
2536 ;;                          the symbol which actually stores the variable's
2537 ;;                          value:  (var pi var-pi).
2538 ;;
2539 ;; In general, combining rational numbers in a calculation always produces
2540 ;; a rational result, but if either argument is a float, result is a float.
2541
2542 ;; In the following comments, [x y z] means result is x, args must be y, z,
2543 ;; respectively, where the code letters are:
2544 ;;
2545 ;;    O  Normalized object (vector or number)
2546 ;;    V  Normalized vector
2547 ;;    N  Normalized number of any type
2548 ;;    N  Normalized complex number
2549 ;;    R  Normalized real number (float or rational)
2550 ;;    F  Normalized floating-point number
2551 ;;    T  Normalized rational number
2552 ;;    I  Normalized integer
2553 ;;    B  Normalized big integer
2554 ;;    S  Normalized small integer
2555 ;;    D  Digit (small integer, 0..999)
2556 ;;    L  Normalized bignum digit list (without "bigpos" or "bigneg" symbol)
2557 ;;       or normalized vector element list (without "vec")
2558 ;;    P  Predicate (truth value)
2559 ;;    X  Any Lisp object
2560 ;;    Z  "nil"
2561 ;;
2562 ;; Lower-case letters signify possibly un-normalized values.
2563 ;; "L.D" means a cons of an L and a D.
2564 ;; [N N; n n] means result will be normalized if argument is.
2565 ;; Also, [Public] marks routines intended to be called from outside.
2566 ;; [This notation has been neglected in many recent routines.]
2567
2568 (defvar math-eval-rules-cache)
2569 (defvar math-eval-rules-cache-other)
2570 ;;; Reduce an object to canonical (normalized) form.  [O o; Z Z] [Public]
2571
2572 (defvar math-normalize-a)
2573 (defun math-normalize (math-normalize-a)
2574   (cond
2575    ((not (consp math-normalize-a))
2576     (if (integerp math-normalize-a)
2577         (if (or (>= math-normalize-a math-small-integer-size)
2578                 (<= math-normalize-a (- math-small-integer-size)))
2579             (math-bignum math-normalize-a)
2580           math-normalize-a)
2581       math-normalize-a))
2582    ((eq (car math-normalize-a) 'bigpos)
2583     (if (eq (nth (1- (length math-normalize-a)) math-normalize-a) 0)
2584         (let* ((last (setq math-normalize-a
2585                            (copy-sequence math-normalize-a))) (digs math-normalize-a))
2586           (while (setq digs (cdr digs))
2587             (or (eq (car digs) 0) (setq last digs)))
2588           (setcdr last nil)))
2589     (if (cdr (cdr (cdr math-normalize-a)))
2590         math-normalize-a
2591       (cond
2592        ((cdr (cdr math-normalize-a)) (+ (nth 1 math-normalize-a)
2593                                         (* (nth 2 math-normalize-a)
2594                                            math-bignum-digit-size)))
2595        ((cdr math-normalize-a) (nth 1 math-normalize-a))
2596        (t 0))))
2597    ((eq (car math-normalize-a) 'bigneg)
2598     (if (eq (nth (1- (length math-normalize-a)) math-normalize-a) 0)
2599         (let* ((last (setq math-normalize-a (copy-sequence math-normalize-a)))
2600                (digs math-normalize-a))
2601           (while (setq digs (cdr digs))
2602             (or (eq (car digs) 0) (setq last digs)))
2603           (setcdr last nil)))
2604     (if (cdr (cdr (cdr math-normalize-a)))
2605         math-normalize-a
2606       (cond
2607        ((cdr (cdr math-normalize-a)) (- (+ (nth 1 math-normalize-a)
2608                                            (* (nth 2 math-normalize-a)
2609                                               math-bignum-digit-size))))
2610        ((cdr math-normalize-a) (- (nth 1 math-normalize-a)))
2611        (t 0))))
2612    ((eq (car math-normalize-a) 'float)
2613     (math-make-float (math-normalize (nth 1 math-normalize-a))
2614                      (nth 2 math-normalize-a)))
2615    ((or (memq (car math-normalize-a)
2616               '(frac cplx polar hms date mod sdev intv vec var quote
2617                      special-const calcFunc-if calcFunc-lambda
2618                      calcFunc-quote calcFunc-condition
2619                      calcFunc-evalto))
2620         (integerp (car math-normalize-a))
2621         (and (consp (car math-normalize-a))
2622              (not (eq (car (car math-normalize-a)) 'lambda))))
2623     (require 'calc-ext)
2624     (math-normalize-fancy math-normalize-a))
2625    (t
2626     (or (and calc-simplify-mode
2627              (require 'calc-ext)
2628              (math-normalize-nonstandard))
2629         (let ((args (mapcar 'math-normalize (cdr math-normalize-a))))
2630           (or (condition-case err
2631                   (let ((func
2632                          (assq (car math-normalize-a) '( ( + . math-add )
2633                                                          ( - . math-sub )
2634                                                          ( * . math-mul )
2635                                                          ( / . math-div )
2636                                                          ( % . math-mod )
2637                                                          ( ^ . math-pow )
2638                                                          ( neg . math-neg )
2639                                                          ( | . math-concat ) ))))
2640                     (or (and var-EvalRules
2641                              (progn
2642                                (or (eq var-EvalRules math-eval-rules-cache-tag)
2643                                    (progn
2644                                      (require 'calc-ext)
2645                                      (math-recompile-eval-rules)))
2646                                (and (or math-eval-rules-cache-other
2647                                         (assq (car math-normalize-a)
2648                                               math-eval-rules-cache))
2649                                     (math-apply-rewrites
2650                                      (cons (car math-normalize-a) args)
2651                                      (cdr math-eval-rules-cache)
2652                                      nil math-eval-rules-cache))))
2653                         (if func
2654                             (apply (cdr func) args)
2655                           (and (or (consp (car math-normalize-a))
2656                                    (fboundp (car math-normalize-a))
2657                                    (and (not (featurep 'calc-ext))
2658                                         (require 'calc-ext)
2659                                         (fboundp (car math-normalize-a))))
2660                                (apply (car math-normalize-a) args)))))
2661                 (wrong-number-of-arguments
2662                  (calc-record-why "*Wrong number of arguments"
2663                                   (cons (car math-normalize-a) args))
2664                  nil)
2665                 (wrong-type-argument
2666                  (or calc-next-why
2667                      (calc-record-why "Wrong type of argument"
2668                                       (cons (car math-normalize-a) args)))
2669                  nil)
2670                 (args-out-of-range
2671                  (calc-record-why "*Argument out of range"
2672                                   (cons (car math-normalize-a) args))
2673                  nil)
2674                 (inexact-result
2675                  (calc-record-why "No exact representation for result"
2676                                   (cons (car math-normalize-a) args))
2677                  nil)
2678                 (math-overflow
2679                  (calc-record-why "*Floating-point overflow occurred"
2680                                   (cons (car math-normalize-a) args))
2681                  nil)
2682                 (math-underflow
2683                  (calc-record-why "*Floating-point underflow occurred"
2684                                   (cons (car math-normalize-a) args))
2685                  nil)
2686                 (void-variable
2687                  (if (eq (nth 1 err) 'var-EvalRules)
2688                      (progn
2689                        (setq var-EvalRules nil)
2690                        (math-normalize (cons (car math-normalize-a) args)))
2691                    (calc-record-why "*Variable is void" (nth 1 err)))))
2692               (if (consp (car math-normalize-a))
2693                   (math-dimension-error)
2694                 (cons (car math-normalize-a) args))))))))
2695
2696
2697
2698 ;; True if A is a floating-point real or complex number.  [P x] [Public]
2699 (defun math-floatp (a)
2700   (cond ((eq (car-safe a) 'float) t)
2701         ((memq (car-safe a) '(cplx polar mod sdev intv))
2702          (or (math-floatp (nth 1 a))
2703              (math-floatp (nth 2 a))
2704              (and (eq (car a) 'intv) (math-floatp (nth 3 a)))))
2705         ((eq (car-safe a) 'date)
2706          (math-floatp (nth 1 a)))))
2707
2708
2709
2710 ;; Verify that A is a complete object and return A.  [x x] [Public]
2711 (defun math-check-complete (a)
2712   (cond ((integerp a) a)
2713         ((eq (car-safe a) 'incomplete)
2714          (calc-incomplete-error a))
2715         ((consp a) a)
2716         (t (error "Invalid data object encountered"))))
2717
2718
2719
2720 ;; Coerce integer A to be a bignum.  [B S]
2721 (defun math-bignum (a)
2722   (if (>= a 0)
2723       (cons 'bigpos (math-bignum-big a))
2724     (cons 'bigneg (math-bignum-big (- a)))))
2725
2726 (defun math-bignum-big (a)   ; [L s]
2727   (if (= a 0)
2728       nil
2729     (cons (% a math-bignum-digit-size)
2730           (math-bignum-big (/ a math-bignum-digit-size)))))
2731
2732
2733 ;; Build a normalized floating-point number.  [F I S]
2734 (defun math-make-float (mant exp)
2735   (if (eq mant 0)
2736       '(float 0 0)
2737     (let* ((ldiff (- calc-internal-prec (math-numdigs mant))))
2738       (if (< ldiff 0)
2739           (setq mant (math-scale-rounding mant ldiff)
2740                 exp (- exp ldiff))))
2741     (if (consp mant)
2742         (let ((digs (cdr mant)))
2743           (if (= (% (car digs) 10) 0)
2744               (progn
2745                 (while (= (car digs) 0)
2746                   (setq digs (cdr digs)
2747                         exp (+ exp math-bignum-digit-length)))
2748                 (while (= (% (car digs) 10) 0)
2749                   (setq digs (math-div10-bignum digs)
2750                         exp (1+ exp)))
2751                 (setq mant (math-normalize (cons (car mant) digs))))))
2752       (while (= (% mant 10) 0)
2753         (setq mant (/ mant 10)
2754               exp (1+ exp))))
2755     (if (and (<= exp -4000000)
2756              (<= (+ exp (math-numdigs mant) -1) -4000000))
2757         (signal 'math-underflow nil)
2758       (if (and (>= exp 3000000)
2759                (>= (+ exp (math-numdigs mant) -1) 4000000))
2760           (signal 'math-overflow nil)
2761         (list 'float mant exp)))))
2762
2763 (defun math-div10-bignum (a)   ; [l l]
2764   (if (cdr a)
2765       (cons (+ (/ (car a) 10) (* (% (nth 1 a) 10)
2766                                  (expt 10 (1- math-bignum-digit-length))))
2767             (math-div10-bignum (cdr a)))
2768     (list (/ (car a) 10))))
2769
2770 ;;; Coerce A to be a float.  [F N; V V] [Public]
2771 (defun math-float (a)
2772   (cond ((Math-integerp a) (math-make-float a 0))
2773         ((eq (car a) 'frac) (math-div (math-float (nth 1 a)) (nth 2 a)))
2774         ((eq (car a) 'float) a)
2775         ((memq (car a) '(cplx polar vec hms date sdev mod))
2776          (cons (car a) (mapcar 'math-float (cdr a))))
2777         (t (math-float-fancy a))))
2778
2779
2780 (defun math-neg (a)
2781   (cond ((not (consp a)) (- a))
2782         ((eq (car a) 'bigpos) (cons 'bigneg (cdr a)))
2783         ((eq (car a) 'bigneg) (cons 'bigpos (cdr a)))
2784         ((memq (car a) '(frac float))
2785          (list (car a) (Math-integer-neg (nth 1 a)) (nth 2 a)))
2786         ((memq (car a) '(cplx vec hms date calcFunc-idn))
2787          (cons (car a) (mapcar 'math-neg (cdr a))))
2788         (t (math-neg-fancy a))))
2789
2790
2791 ;;; Compute the number of decimal digits in integer A.  [S I]
2792 (defun math-numdigs (a)
2793   (if (consp a)
2794       (if (cdr a)
2795           (let* ((len (1- (length a)))
2796                  (top (nth len a)))
2797             (+ (* (1- len) math-bignum-digit-length) (math-numdigs top)))
2798         0)
2799     (cond ((>= a 100) (+ (math-numdigs (/ a 1000)) 3))
2800           ((>= a 10) 2)
2801           ((>= a 1) 1)
2802           ((= a 0) 0)
2803           ((> a -10) 1)
2804           ((> a -100) 2)
2805           (t (math-numdigs (- a))))))
2806
2807 ;;; Multiply (with truncation toward 0) the integer A by 10^N.  [I i S]
2808 (defun math-scale-int (a n)
2809   (cond ((= n 0) a)
2810         ((> n 0) (math-scale-left a n))
2811         (t (math-normalize (math-scale-right a (- n))))))
2812
2813 (defun math-scale-left (a n)   ; [I I S]
2814   (if (= n 0)
2815       a
2816     (if (consp a)
2817         (cons (car a) (math-scale-left-bignum (cdr a) n))
2818       (if (>= n math-bignum-digit-length)
2819           (if (or (>= a math-bignum-digit-size)
2820                   (<= a (- math-bignum-digit-size)))
2821               (math-scale-left (math-bignum a) n)
2822             (math-scale-left (* a math-bignum-digit-size)
2823                              (- n math-bignum-digit-length)))
2824         (let ((sz (expt 10 (- (* 2 math-bignum-digit-length) n))))
2825           (if (or (>= a sz) (<= a (- sz)))
2826               (math-scale-left (math-bignum a) n)
2827             (* a (expt 10 n))))))))
2828
2829 (defun math-scale-left-bignum (a n)
2830   (if (>= n math-bignum-digit-length)
2831       (while (>= (setq a (cons 0 a)
2832                        n (- n math-bignum-digit-length))
2833                  math-bignum-digit-length)))
2834   (if (> n 0)
2835       (math-mul-bignum-digit a (expt 10 n) 0)
2836     a))
2837
2838 (defun math-scale-right (a n)   ; [i i S]
2839   (if (= n 0)
2840       a
2841     (if (consp a)
2842         (cons (car a) (math-scale-right-bignum (cdr a) n))
2843       (if (<= a 0)
2844           (if (= a 0)
2845               0
2846             (- (math-scale-right (- a) n)))
2847         (if (>= n math-bignum-digit-length)
2848             (while (and (> (setq a (/ a math-bignum-digit-size)) 0)
2849                         (>= (setq n (- n math-bignum-digit-length))
2850                             math-bignum-digit-length))))
2851         (if (> n 0)
2852             (/ a (expt 10 n))
2853           a)))))
2854
2855 (defun math-scale-right-bignum (a n)   ; [L L S; l l S]
2856   (if (>= n math-bignum-digit-length)
2857       (setq a (nthcdr (/ n math-bignum-digit-length) a)
2858             n (% n math-bignum-digit-length)))
2859   (if (> n 0)
2860       (cdr (math-mul-bignum-digit a (expt 10 (- math-bignum-digit-length n)) 0))
2861     a))
2862
2863 ;;; Multiply (with rounding) the integer A by 10^N.   [I i S]
2864 (defun math-scale-rounding (a n)
2865   (cond ((>= n 0)
2866          (math-scale-left a n))
2867         ((consp a)
2868          (math-normalize
2869           (cons (car a)
2870                 (let ((val (if (< n (- math-bignum-digit-length))
2871                                (math-scale-right-bignum
2872                                 (cdr a)
2873                                 (- (- math-bignum-digit-length) n))
2874                              (if (< n 0)
2875                                  (math-mul-bignum-digit
2876                                   (cdr a)
2877                                   (expt 10 (+ math-bignum-digit-length n)) 0)
2878                                (cdr a)))))  ; n = -math-bignum-digit-length
2879                   (if (and val (>= (car val) (/ math-bignum-digit-size 2)))
2880                       (if (cdr val)
2881                           (if (eq (car (cdr val)) (1- math-bignum-digit-size))
2882                               (math-add-bignum (cdr val) '(1))
2883                             (cons (1+ (car (cdr val))) (cdr (cdr val))))
2884                         '(1))
2885                     (cdr val))))))
2886         (t
2887          (if (< a 0)
2888              (- (math-scale-rounding (- a) n))
2889            (if (= n -1)
2890                (/ (+ a 5) 10)
2891              (/ (+ (math-scale-right a (- -1 n)) 5) 10))))))
2892
2893
2894 ;;; Compute the sum of A and B.  [O O O] [Public]
2895 (defun math-add (a b)
2896   (or
2897    (and (not (or (consp a) (consp b)))
2898         (progn
2899           (setq a (+ a b))
2900           (if (or (<= a (- math-small-integer-size)) (>= a math-small-integer-size))
2901               (math-bignum a)
2902             a)))
2903    (and (Math-zerop a) (not (eq (car-safe a) 'mod))
2904         (if (and (math-floatp a) (Math-ratp b)) (math-float b) b))
2905    (and (Math-zerop b) (not (eq (car-safe b) 'mod))
2906         (if (and (math-floatp b) (Math-ratp a)) (math-float a) a))
2907    (and (Math-objvecp a) (Math-objvecp b)
2908         (or
2909          (and (Math-integerp a) (Math-integerp b)
2910               (progn
2911                 (or (consp a) (setq a (math-bignum a)))
2912                 (or (consp b) (setq b (math-bignum b)))
2913                 (if (eq (car a) 'bigneg)
2914                     (if (eq (car b) 'bigneg)
2915                         (cons 'bigneg (math-add-bignum (cdr a) (cdr b)))
2916                       (math-normalize
2917                        (let ((diff (math-sub-bignum (cdr b) (cdr a))))
2918                          (if (eq diff 'neg)
2919                              (cons 'bigneg (math-sub-bignum (cdr a) (cdr b)))
2920                            (cons 'bigpos diff)))))
2921                   (if (eq (car b) 'bigneg)
2922                       (math-normalize
2923                        (let ((diff (math-sub-bignum (cdr a) (cdr b))))
2924                          (if (eq diff 'neg)
2925                              (cons 'bigneg (math-sub-bignum (cdr b) (cdr a)))
2926                            (cons 'bigpos diff))))
2927                     (cons 'bigpos (math-add-bignum (cdr a) (cdr b)))))))
2928          (and (Math-ratp a) (Math-ratp b)
2929               (require 'calc-ext)
2930               (calc-add-fractions a b))
2931          (and (Math-realp a) (Math-realp b)
2932               (progn
2933                 (or (and (consp a) (eq (car a) 'float))
2934                     (setq a (math-float a)))
2935                 (or (and (consp b) (eq (car b) 'float))
2936                     (setq b (math-float b)))
2937                 (math-add-float a b)))
2938          (and (require 'calc-ext)
2939               (math-add-objects-fancy a b))))
2940    (and (require 'calc-ext)
2941         (math-add-symb-fancy a b))))
2942
2943 (defun math-add-bignum (a b)   ; [L L L; l l l]
2944   (if a
2945       (if b
2946           (let* ((a (copy-sequence a)) (aa a) (carry nil) sum)
2947             (while (and aa b)
2948               (if carry
2949                   (if (< (setq sum (+ (car aa) (car b)))
2950                          (1- math-bignum-digit-size))
2951                       (progn
2952                         (setcar aa (1+ sum))
2953                         (setq carry nil))
2954                     (setcar aa (- sum (1- math-bignum-digit-size))))
2955                 (if (< (setq sum (+ (car aa) (car b))) math-bignum-digit-size)
2956                     (setcar aa sum)
2957                   (setcar aa (- sum math-bignum-digit-size))
2958                   (setq carry t)))
2959               (setq aa (cdr aa)
2960                     b (cdr b)))
2961             (if carry
2962                 (if b
2963                     (nconc a (math-add-bignum b '(1)))
2964                   (while (eq (car aa) (1- math-bignum-digit-size))
2965                     (setcar aa 0)
2966                     (setq aa (cdr aa)))
2967                   (if aa
2968                       (progn
2969                         (setcar aa (1+ (car aa)))
2970                         a)
2971                     (nconc a '(1))))
2972               (if b
2973                   (nconc a b)
2974                 a)))
2975         a)
2976     b))
2977
2978 (defun math-sub-bignum (a b)   ; [l l l]
2979   (if b
2980       (if a
2981           (let* ((a (copy-sequence a)) (aa a) (borrow nil) sum diff)
2982             (while (and aa b)
2983               (if borrow
2984                   (if (>= (setq diff (- (car aa) (car b))) 1)
2985                       (progn
2986                         (setcar aa (1- diff))
2987                         (setq borrow nil))
2988                     (setcar aa (+ diff (1- math-bignum-digit-size))))
2989                 (if (>= (setq diff (- (car aa) (car b))) 0)
2990                     (setcar aa diff)
2991                   (setcar aa (+ diff math-bignum-digit-size))
2992                   (setq borrow t)))
2993               (setq aa (cdr aa)
2994                     b (cdr b)))
2995             (if borrow
2996                 (progn
2997                   (while (eq (car aa) 0)
2998                     (setcar aa (1- math-bignum-digit-size))
2999                     (setq aa (cdr aa)))
3000                   (if aa
3001                       (progn
3002                         (setcar aa (1- (car aa)))
3003                         a)
3004                     'neg))
3005               (while (eq (car b) 0)
3006                 (setq b (cdr b)))
3007               (if b
3008                   'neg
3009                 a)))
3010         (while (eq (car b) 0)
3011           (setq b (cdr b)))
3012         (and b
3013              'neg))
3014     a))
3015
3016 (defun math-add-float (a b)   ; [F F F]
3017   (let ((ediff (- (nth 2 a) (nth 2 b))))
3018     (if (>= ediff 0)
3019         (if (>= ediff (+ calc-internal-prec calc-internal-prec))
3020             a
3021           (math-make-float (math-add (nth 1 b)
3022                                      (if (eq ediff 0)
3023                                          (nth 1 a)
3024                                        (math-scale-left (nth 1 a) ediff)))
3025                            (nth 2 b)))
3026       (if (>= (setq ediff (- ediff))
3027               (+ calc-internal-prec calc-internal-prec))
3028           b
3029         (math-make-float (math-add (nth 1 a)
3030                                    (math-scale-left (nth 1 b) ediff))
3031                          (nth 2 a))))))
3032
3033 ;;; Compute the difference of A and B.  [O O O] [Public]
3034 (defun math-sub (a b)
3035   (if (or (consp a) (consp b))
3036       (math-add a (math-neg b))
3037     (setq a (- a b))
3038     (if (or (<= a (- math-small-integer-size)) (>= a math-small-integer-size))
3039         (math-bignum a)
3040       a)))
3041
3042 (defun math-sub-float (a b)   ; [F F F]
3043   (let ((ediff (- (nth 2 a) (nth 2 b))))
3044     (if (>= ediff 0)
3045         (if (>= ediff (+ calc-internal-prec calc-internal-prec))
3046             a
3047           (math-make-float (math-add (Math-integer-neg (nth 1 b))
3048                                      (if (eq ediff 0)
3049                                          (nth 1 a)
3050                                        (math-scale-left (nth 1 a) ediff)))
3051                            (nth 2 b)))
3052       (if (>= (setq ediff (- ediff))
3053               (+ calc-internal-prec calc-internal-prec))
3054           b
3055         (math-make-float (math-add (nth 1 a)
3056                                    (Math-integer-neg
3057                                     (math-scale-left (nth 1 b) ediff)))
3058                          (nth 2 a))))))
3059
3060
3061 ;;; Compute the product of A and B.  [O O O] [Public]
3062 (defun math-mul (a b)
3063   (or
3064    (and (not (consp a)) (not (consp b))
3065         (< a math-bignum-digit-size) (> a (- math-bignum-digit-size))
3066         (< b math-bignum-digit-size) (> b (- math-bignum-digit-size))
3067         (* a b))
3068    (and (Math-zerop a) (not (eq (car-safe b) 'mod))
3069         (if (Math-scalarp b)
3070             (if (and (math-floatp b) (Math-ratp a)) (math-float a) a)
3071           (require 'calc-ext)
3072           (math-mul-zero a b)))
3073    (and (Math-zerop b) (not (eq (car-safe a) 'mod))
3074         (if (Math-scalarp a)
3075             (if (and (math-floatp a) (Math-ratp b)) (math-float b) b)
3076           (require 'calc-ext)
3077           (math-mul-zero b a)))
3078    (and (Math-objvecp a) (Math-objvecp b)
3079         (or
3080          (and (Math-integerp a) (Math-integerp b)
3081               (progn
3082                 (or (consp a) (setq a (math-bignum a)))
3083                 (or (consp b) (setq b (math-bignum b)))
3084                 (math-normalize
3085                  (cons (if (eq (car a) (car b)) 'bigpos 'bigneg)
3086                        (if (cdr (cdr a))
3087                            (if (cdr (cdr b))
3088                                (math-mul-bignum (cdr a) (cdr b))
3089                              (math-mul-bignum-digit (cdr a) (nth 1 b) 0))
3090                          (math-mul-bignum-digit (cdr b) (nth 1 a) 0))))))
3091          (and (Math-ratp a) (Math-ratp b)
3092               (require 'calc-ext)
3093               (calc-mul-fractions a b))
3094          (and (Math-realp a) (Math-realp b)
3095               (progn
3096                 (or (and (consp a) (eq (car a) 'float))
3097                     (setq a (math-float a)))
3098                 (or (and (consp b) (eq (car b) 'float))
3099                     (setq b (math-float b)))
3100                 (math-make-float (math-mul (nth 1 a) (nth 1 b))
3101                                  (+ (nth 2 a) (nth 2 b)))))
3102          (and (require 'calc-ext)
3103               (math-mul-objects-fancy a b))))
3104    (and (require 'calc-ext)
3105         (math-mul-symb-fancy a b))))
3106
3107 (defun math-infinitep (a &optional undir)
3108   (while (and (consp a) (memq (car a) '(* / neg)))
3109     (if (or (not (eq (car a) '*)) (math-infinitep (nth 1 a)))
3110         (setq a (nth 1 a))
3111       (setq a (nth 2 a))))
3112   (and (consp a)
3113        (eq (car a) 'var)
3114        (memq (nth 2 a) '(var-inf var-uinf var-nan))
3115        (if (and undir (eq (nth 2 a) 'var-inf))
3116            '(var uinf var-uinf)
3117          a)))
3118
3119 ;;; Multiply digit lists A and B.  [L L L; l l l]
3120 (defun math-mul-bignum (a b)
3121   (and a b
3122        (let* ((sum (if (<= (car b) 1)
3123                        (if (= (car b) 0)
3124                            (list 0)
3125                          (copy-sequence a))
3126                      (math-mul-bignum-digit a (car b) 0)))
3127               (sump sum) c d aa ss prod)
3128          (while (setq b (cdr b))
3129            (setq ss (setq sump (or (cdr sump) (setcdr sump (list 0))))
3130                  d (car b)
3131                  c 0
3132                  aa a)
3133            (while (progn
3134                     (setcar ss (% (setq prod (+ (+ (car ss) (* (car aa) d))
3135                                                 c)) math-bignum-digit-size))
3136                     (setq aa (cdr aa)))
3137              (setq c (/ prod math-bignum-digit-size)
3138                    ss (or (cdr ss) (setcdr ss (list 0)))))
3139            (if (>= prod math-bignum-digit-size)
3140                (if (cdr ss)
3141                    (setcar (cdr ss) (+ (/ prod math-bignum-digit-size) (car (cdr ss))))
3142                  (setcdr ss (list (/ prod math-bignum-digit-size))))))
3143          sum)))
3144
3145 ;;; Multiply digit list A by digit D.  [L L D D; l l D D]
3146 (defun math-mul-bignum-digit (a d c)
3147   (if a
3148       (if (<= d 1)
3149           (and (= d 1) a)
3150         (let* ((a (copy-sequence a)) (aa a) prod)
3151           (while (progn
3152                    (setcar aa
3153                            (% (setq prod (+ (* (car aa) d) c))
3154                               math-bignum-digit-size))
3155                    (cdr aa))
3156             (setq aa (cdr aa)
3157                   c (/ prod math-bignum-digit-size)))
3158           (if (>= prod math-bignum-digit-size)
3159               (setcdr aa (list (/ prod math-bignum-digit-size))))
3160           a))
3161     (and (> c 0)
3162          (list c))))
3163
3164
3165 ;;; Compute the integer (quotient . remainder) of A and B, which may be
3166 ;;; small or big integers.  Type and consistency of truncation is undefined
3167 ;;; if A or B is negative.  B must be nonzero.  [I.I I I] [Public]
3168 (defun math-idivmod (a b)
3169   (if (eq b 0)
3170       (math-reject-arg a "*Division by zero"))
3171   (if (or (consp a) (consp b))
3172       (if (and (natnump b) (< b math-bignum-digit-size))
3173           (let ((res (math-div-bignum-digit (cdr a) b)))
3174             (cons
3175              (math-normalize (cons (car a) (car res)))
3176              (cdr res)))
3177         (or (consp a) (setq a (math-bignum a)))
3178         (or (consp b) (setq b (math-bignum b)))
3179         (let ((res (math-div-bignum (cdr a) (cdr b))))
3180           (cons
3181            (math-normalize (cons (if (eq (car a) (car b)) 'bigpos 'bigneg)
3182                                  (car res)))
3183            (math-normalize (cons (car a) (cdr res))))))
3184     (cons (/ a b) (% a b))))
3185
3186 (defun math-quotient (a b)   ; [I I I] [Public]
3187   (if (and (not (consp a)) (not (consp b)))
3188       (if (= b 0)
3189           (math-reject-arg a "*Division by zero")
3190         (/ a b))
3191     (if (and (natnump b) (< b math-bignum-digit-size))
3192         (if (= b 0)
3193             (math-reject-arg a "*Division by zero")
3194           (math-normalize (cons (car a)
3195                                 (car (math-div-bignum-digit (cdr a) b)))))
3196       (or (consp a) (setq a (math-bignum a)))
3197       (or (consp b) (setq b (math-bignum b)))
3198       (let* ((alen (1- (length a)))
3199              (blen (1- (length b)))
3200              (d (/ math-bignum-digit-size (1+ (nth (1- blen) (cdr b)))))
3201              (res (math-div-bignum-big (math-mul-bignum-digit (cdr a) d 0)
3202                                        (math-mul-bignum-digit (cdr b) d 0)
3203                                        alen blen)))
3204         (math-normalize (cons (if (eq (car a) (car b)) 'bigpos 'bigneg)
3205                               (car res)))))))
3206
3207
3208 ;;; Divide a bignum digit list by another.  [l.l l L]
3209 ;;; The following division algorithm is borrowed from Knuth vol. II, sec. 4.3.1
3210 (defun math-div-bignum (a b)
3211   (if (cdr b)
3212       (let* ((alen (length a))
3213              (blen (length b))
3214              (d (/ math-bignum-digit-size (1+ (nth (1- blen) b))))
3215              (res (math-div-bignum-big (math-mul-bignum-digit a d 0)
3216                                        (math-mul-bignum-digit b d 0)
3217                                        alen blen)))
3218         (if (= d 1)
3219             res
3220           (cons (car res)
3221                 (car (math-div-bignum-digit (cdr res) d)))))
3222     (let ((res (math-div-bignum-digit a (car b))))
3223       (cons (car res) (list (cdr res))))))
3224
3225 ;;; Divide a bignum digit list by a digit.  [l.D l D]
3226 (defun math-div-bignum-digit (a b)
3227   (if a
3228       (let* ((res (math-div-bignum-digit (cdr a) b))
3229              (num (+ (* (cdr res) math-bignum-digit-size) (car a))))
3230         (cons
3231          (cons (/ num b) (car res))
3232          (% num b)))
3233     '(nil . 0)))
3234
3235 (defun math-div-bignum-big (a b alen blen)   ; [l.l l L]
3236   (if (< alen blen)
3237       (cons nil a)
3238     (let* ((res (math-div-bignum-big (cdr a) b (1- alen) blen))
3239            (num (cons (car a) (cdr res)))
3240            (res2 (math-div-bignum-part num b blen)))
3241       (cons
3242        (cons (car res2) (car res))
3243        (cdr res2)))))
3244
3245 (defun math-div-bignum-part (a b blen)   ; a < b*math-bignum-digit-size  [D.l l L]
3246   (let* ((num (+ (* (or (nth blen a) 0) math-bignum-digit-size)
3247                  (or (nth (1- blen) a) 0)))
3248          (den (nth (1- blen) b))
3249          (guess (min (/ num den) (1- math-bignum-digit-size))))
3250     (math-div-bignum-try a b (math-mul-bignum-digit b guess 0) guess)))
3251
3252 (defun math-div-bignum-try (a b c guess)   ; [D.l l l D]
3253   (let ((rem (math-sub-bignum a c)))
3254     (if (eq rem 'neg)
3255         (math-div-bignum-try a b (math-sub-bignum c b) (1- guess))
3256       (cons guess rem))))
3257
3258
3259 ;;; Compute the quotient of A and B.  [O O N] [Public]
3260 (defun math-div (a b)
3261   (or
3262    (and (Math-zerop b)
3263         (require 'calc-ext)
3264         (math-div-by-zero a b))
3265    (and (Math-zerop a) (not (eq (car-safe b) 'mod))
3266         (if (Math-scalarp b)
3267             (if (and (math-floatp b) (Math-ratp a)) (math-float a) a)
3268           (require 'calc-ext)
3269           (math-div-zero a b)))
3270    (and (Math-objvecp a) (Math-objvecp b)
3271         (or
3272          (and (Math-integerp a) (Math-integerp b)
3273               (let ((q (math-idivmod a b)))
3274                 (if (eq (cdr q) 0)
3275                     (car q)
3276                   (if calc-prefer-frac
3277                       (progn
3278                         (require 'calc-ext)
3279                         (math-make-frac a b))
3280                     (math-div-float (math-make-float a 0)
3281                                     (math-make-float b 0))))))
3282          (and (Math-ratp a) (Math-ratp b)
3283               (require 'calc-ext)
3284               (calc-div-fractions a b))
3285          (and (Math-realp a) (Math-realp b)
3286               (progn
3287                 (or (and (consp a) (eq (car a) 'float))
3288                     (setq a (math-float a)))
3289                 (or (and (consp b) (eq (car b) 'float))
3290                     (setq b (math-float b)))
3291                 (math-div-float a b)))
3292          (and (require 'calc-ext)
3293               (math-div-objects-fancy a b))))
3294    (and (require 'calc-ext)
3295         (math-div-symb-fancy a b))))
3296
3297 (defun math-div-float (a b)   ; [F F F]
3298   (let ((ldiff (max (- (1+ calc-internal-prec)
3299                        (- (math-numdigs (nth 1 a)) (math-numdigs (nth 1 b))))
3300                     0)))
3301     (math-make-float (math-quotient (math-scale-int (nth 1 a) ldiff) (nth 1 b))
3302                      (- (- (nth 2 a) (nth 2 b)) ldiff))))
3303
3304
3305
3306
3307 (defvar calc-selection-cache-entry)
3308 ;;; Format the number A as a string.  [X N; X Z] [Public]
3309 (defun math-format-stack-value (entry)
3310   (setq calc-selection-cache-entry calc-selection-cache-default-entry)
3311   (let* ((a (car entry))
3312          (math-comp-selected (nth 2 entry))
3313          (c (cond ((null a) "<nil>")
3314                   ((eq calc-display-raw t) (format "%s" a))
3315                   ((stringp a) a)
3316                   ((eq a 'top-of-stack) (propertize "." 'font-lock-face 'bold))
3317                   (calc-prepared-composition
3318                    calc-prepared-composition)
3319                   ((and (Math-scalarp a)
3320                         (memq calc-language '(nil flat unform))
3321                         (null math-comp-selected))
3322                    (math-format-number a))
3323                   (t (require 'calc-ext)
3324                      (math-compose-expr a 0))))
3325          (off (math-stack-value-offset c))
3326          s w)
3327     (and math-comp-selected (setq calc-any-selections t))
3328     (setq w (cdr off)
3329           off (car off))
3330     (when (> off 0)
3331       (setq c (math-comp-concat (make-string off ?\s) c)))
3332     (or (equal calc-left-label "")
3333         (setq c (math-comp-concat (if (eq a 'top-of-stack)
3334                                       (make-string (length calc-left-label) ?\s)
3335                                     calc-left-label)
3336                                   c)))
3337     (when calc-line-numbering
3338       (setq c (math-comp-concat (if (eq calc-language 'big)
3339                                     (if math-comp-selected
3340                                         '(tag t "1:  ")
3341                                       "1:  ")
3342                                   "    ")
3343                                 c)))
3344     (unless (or (equal calc-right-label "")
3345                 (eq a 'top-of-stack))
3346       (require 'calc-ext)
3347       (setq c (list 'horiz c
3348                     (make-string (max (- w (math-comp-width c)
3349                                          (length calc-right-label)) 0) ?\s)
3350                     '(break -1)
3351                     calc-right-label)))
3352     (setq s (if (stringp c)
3353                 (if calc-display-raw
3354                     (prin1-to-string c)
3355                   c)
3356               (math-composition-to-string c w)))
3357     (when calc-language-output-filter
3358       (setq s (funcall calc-language-output-filter s)))
3359     (if (eq calc-language 'big)
3360         (setq s (concat s "\n"))
3361       (when calc-line-numbering
3362         (setq s (concat "1:" (substring s 2)))))
3363     (setcar (cdr entry) (calc-count-lines s))
3364     s))
3365
3366 ;; The variables math-svo-c, math-svo-wid and math-svo-off are local
3367 ;; to math-stack-value-offset, but are used by math-stack-value-offset-fancy
3368 ;; in calccomp.el.
3369
3370 (defun math-stack-value-offset (math-svo-c)
3371   (let* ((num (if calc-line-numbering 4 0))
3372          (math-svo-wid (calc-window-width))
3373          math-svo-off)
3374     (if calc-display-just
3375         (progn
3376           (require 'calc-ext)
3377           (math-stack-value-offset-fancy))
3378       (setq math-svo-off (or calc-display-origin 0))
3379       (when (integerp calc-line-breaking)
3380         (setq math-svo-wid calc-line-breaking)))
3381     (cons (max (- math-svo-off (length calc-left-label)) 0)
3382           (+ math-svo-wid num))))
3383
3384 (defun calc-count-lines (s)
3385   (let ((pos 0)
3386         (num 1))
3387     (while (setq pos (string-match "\n" s pos))
3388       (setq pos (1+ pos)
3389             num (1+ num)))
3390     num))
3391
3392 (defun math-format-value (a &optional w)
3393   (if (and (Math-scalarp a)
3394            (memq calc-language '(nil flat unform)))
3395       (math-format-number a)
3396     (require 'calc-ext)
3397     (let ((calc-line-breaking nil))
3398       (math-composition-to-string (math-compose-expr a 0) w))))
3399
3400 (defun calc-window-width ()
3401   (if calc-embedded-info
3402       (let ((win (get-buffer-window (aref calc-embedded-info 0))))
3403         (1- (if win (window-width win) (frame-width))))
3404     (- (window-width (get-buffer-window (current-buffer)))
3405        (if calc-line-numbering 5 1))))
3406
3407 (defun math-comp-concat (c1 c2)
3408   (if (and (stringp c1) (stringp c2))
3409       (concat c1 c2)
3410     (list 'horiz c1 c2)))
3411
3412
3413
3414 ;;; Format an expression as a one-line string suitable for re-reading.
3415
3416 (defun math-format-flat-expr (a prec)
3417   (cond
3418    ((or (not (or (consp a) (integerp a)))
3419         (eq calc-display-raw t))
3420     (let ((print-escape-newlines t))
3421       (concat "'" (prin1-to-string a))))
3422    ((Math-scalarp a)
3423     (let ((calc-group-digits nil)
3424           (calc-point-char ".")
3425           (calc-frac-format (if (> (length (car calc-frac-format)) 1)
3426                                 '("::" nil) '(":" nil)))
3427           (calc-complex-format nil)
3428           (calc-hms-format "%s@ %s' %s\"")
3429           (calc-language nil))
3430       (math-format-number a)))
3431    (t
3432     (require 'calc-ext)
3433     (math-format-flat-expr-fancy a prec))))
3434
3435
3436
3437 ;;; Format a number as a string.
3438 (defvar math-half-2-word-size)
3439 (defun math-format-number (a &optional prec)   ; [X N]   [Public]
3440   (cond
3441    ((eq calc-display-raw t) (format "%s" a))
3442    ((and calc-twos-complement-mode
3443          math-radix-explicit-format
3444          (Math-integerp a)
3445          (or (eq a 0)
3446              (and (Math-integer-posp a)
3447                   (Math-lessp a math-half-2-word-size))
3448              (and (Math-integer-negp a)
3449                   (require 'calc-ext)
3450                   (let ((comparison
3451                          (math-compare (Math-integer-neg a) math-half-2-word-size)))
3452                     (or (= comparison 0)
3453                         (= comparison -1))))))
3454     (require 'calc-bin)
3455     (math-format-twos-complement a))
3456    ((and (nth 1 calc-frac-format) (Math-integerp a))
3457     (require 'calc-ext)
3458     (math-format-number (math-adjust-fraction a)))
3459    ((integerp a)
3460     (if (not (or calc-group-digits calc-leading-zeros))
3461         (if (= calc-number-radix 10)
3462             (int-to-string a)
3463           (if (< a 0)
3464               (concat "-" (math-format-number (- a)))
3465             (require 'calc-ext)
3466             (if math-radix-explicit-format
3467                 (if calc-radix-formatter
3468                     (funcall calc-radix-formatter
3469                              calc-number-radix
3470                              (if (= calc-number-radix 2)
3471                                  (math-format-binary a)
3472                                (math-format-radix a)))
3473                   (format "%d#%s" calc-number-radix
3474                           (if (= calc-number-radix 2)
3475                               (math-format-binary a)
3476                             (math-format-radix a))))
3477               (math-format-radix a))))
3478       (math-format-number (math-bignum a))))
3479    ((stringp a) a)
3480    ((not (consp a)) (prin1-to-string a))
3481    ((eq (car a) 'bigpos) (math-format-bignum (cdr a)))
3482    ((eq (car a) 'bigneg) (concat "-" (math-format-bignum (cdr a))))
3483    ((and (eq (car a) 'float) (= calc-number-radix 10))
3484     (if (Math-integer-negp (nth 1 a))
3485         (concat "-" (math-format-number (math-neg a)))
3486       (let ((mant (nth 1 a))
3487             (exp (nth 2 a))
3488             (fmt (car calc-float-format))
3489             (figs (nth 1 calc-float-format))
3490             (point calc-point-char)
3491             str)
3492         (if (and (eq fmt 'fix)
3493                  (or (and (< figs 0) (setq figs (- figs)))
3494                      (> (+ exp (math-numdigs mant)) (- figs))))
3495             (progn
3496               (setq mant (math-scale-rounding mant (+ exp figs))
3497                     str (if (integerp mant)
3498                             (int-to-string mant)
3499                           (math-format-bignum-decimal (cdr mant))))
3500               (if (<= (length str) figs)
3501                   (setq str (concat (make-string (1+ (- figs (length str))) ?0)
3502                                     str)))
3503               (if (> figs 0)
3504                   (setq str (concat (substring str 0 (- figs)) point
3505                                     (substring str (- figs))))
3506                 (setq str (concat str point)))
3507               (when calc-group-digits
3508                 (require 'calc-ext)
3509                 (setq str (math-group-float str))))
3510           (when (< figs 0)
3511             (setq figs (+ calc-internal-prec figs)))
3512           (when (> figs 0)
3513             (let ((adj (- figs (math-numdigs mant))))
3514               (when (< adj 0)
3515                 (setq mant (math-scale-rounding mant adj)
3516                       exp (- exp adj)))))
3517           (setq str (if (integerp mant)
3518                         (int-to-string mant)
3519                       (math-format-bignum-decimal (cdr mant))))
3520           (let* ((len (length str))
3521                  (dpos (+ exp len)))
3522             (if (and (eq fmt 'float)
3523                      (<= dpos (+ calc-internal-prec calc-display-sci-high))
3524                      (>= dpos (+ calc-display-sci-low 2)))
3525                 (progn
3526                   (cond
3527                    ((= dpos 0)
3528                     (setq str (concat "0" point str)))
3529                    ((and (<= exp 0) (> dpos 0))
3530                     (setq str (concat (substring str 0 dpos) point
3531                                       (substring str dpos))))
3532                    ((> exp 0)
3533                     (setq str (concat str (make-string exp ?0) point)))
3534                    (t   ; (< dpos 0)
3535                     (setq str (concat "0" point
3536                                       (make-string (- dpos) ?0) str))))
3537                   (when calc-group-digits
3538                     (require 'calc-ext)
3539                     (setq str (math-group-float str))))
3540               (let* ((eadj (+ exp len))
3541                      (scale (if (eq fmt 'eng)
3542                                 (1+ (math-mod (+ eadj 300002) 3))
3543                               1)))
3544                 (if (> scale (length str))
3545                     (setq str (concat str (make-string (- scale (length str))
3546                                                        ?0))))
3547                 (if (< scale (length str))
3548                     (setq str (concat (substring str 0 scale) point
3549                                       (substring str scale))))
3550                 (when calc-group-digits
3551                   (require 'calc-ext)
3552                   (setq str (math-group-float str)))
3553                 (setq str (format (if (memq calc-language '(math maple))
3554                                       (if (and prec (> prec 191))
3555                                           "(%s*10.^%d)" "%s*10.^%d")
3556                                     "%se%d")
3557                                   str (- eadj scale)))))))
3558         str)))
3559    (t
3560     (require 'calc-ext)
3561     (math-format-number-fancy a prec))))
3562
3563 (defun math-format-bignum (a)   ; [X L]
3564   (if (and (= calc-number-radix 10)
3565            (not calc-leading-zeros)
3566            (not calc-group-digits))
3567       (math-format-bignum-decimal a)
3568     (require 'calc-ext)
3569     (math-format-bignum-fancy a)))
3570
3571 (defun math-format-bignum-decimal (a)   ; [X L]
3572   (if a
3573       (let ((s ""))
3574         (while (cdr (cdr a))
3575           (setq s (concat
3576                    (format
3577                     (concat "%0"
3578                             (number-to-string (* 2 math-bignum-digit-length))
3579                             "d")
3580                     (+ (* (nth 1 a) math-bignum-digit-size) (car a))) s)
3581                 a (cdr (cdr a))))
3582         (concat (int-to-string
3583                  (+ (* (or (nth 1 a) 0) math-bignum-digit-size) (car a))) s))
3584     "0"))
3585
3586
3587
3588 ;;; Parse a simple number in string form.   [N X] [Public]
3589 (defun math-read-number (s &optional decimal)
3590   "Convert the string S into a Calc number."
3591   (math-normalize
3592    (save-match-data
3593      (cond
3594
3595       ;; Integers (most common case)
3596       ((string-match "\\` *\\([0-9]+\\) *\\'" s)
3597        (let ((digs (math-match-substring s 1)))
3598          (if (and (memq calc-language calc-lang-c-type-hex)
3599                   (> (length digs) 1)
3600                   (eq (aref digs 0) ?0)
3601                   (null decimal))
3602              (math-read-number (concat "8#" digs))
3603            (if (<= (length digs) (* 2 math-bignum-digit-length))
3604                (string-to-number digs)
3605              (cons 'bigpos (math-read-bignum digs))))))
3606
3607       ;; Clean up the string if necessary
3608       ((string-match "\\`\\(.*\\)[ \t\n]+\\([^\001]*\\)\\'" s)
3609        (math-read-number (concat (math-match-substring s 1)
3610                                  (math-match-substring s 2))))
3611
3612       ;; Plus and minus signs
3613       ((string-match "^[-_+]\\(.*\\)$" s)
3614        (let ((val (math-read-number (math-match-substring s 1))))
3615          (and val (if (eq (aref s 0) ?+) val (math-neg val)))))
3616
3617       ;; Forms that require extensions module
3618       ((string-match "[^-+0-9eE.]" s)
3619        (require 'calc-ext)
3620        (math-read-number-fancy s))
3621
3622       ;; Decimal point
3623       ((string-match "^\\([0-9]*\\)\\.\\([0-9]*\\)$" s)
3624        (let ((int (math-match-substring s 1))
3625              (frac (math-match-substring s 2)))
3626          (let ((ilen (length int))
3627                (flen (length frac)))
3628            (let ((int (if (> ilen 0) (math-read-number int t) 0))
3629                  (frac (if (> flen 0) (math-read-number frac t) 0)))
3630              (and int frac (or (> ilen 0) (> flen 0))
3631                   (list 'float
3632                         (math-add (math-scale-int int flen) frac)
3633                         (- flen)))))))
3634
3635       ;; "e" notation
3636       ((string-match "^\\(.*\\)[eE]\\([-+]?[0-9]+\\)$" s)
3637        (let ((mant (math-match-substring s 1))
3638              (exp (math-match-substring s 2)))
3639          (let ((mant (if (> (length mant) 0) (math-read-number mant t) 1))
3640                (exp (if (<= (length exp) (if (memq (aref exp 0) '(?+ ?-)) 8 7))
3641                         (string-to-number exp))))
3642            (and mant exp (Math-realp mant) (> exp -4000000) (< exp 4000000)
3643                 (let ((mant (math-float mant)))
3644                   (list 'float (nth 1 mant) (+ (nth 2 mant) exp)))))))
3645
3646       ;; Syntax error!
3647       (t nil)))))
3648
3649 ;;; Parse a very simple number, keeping all digits.
3650 (defun math-read-number-simple (s)
3651   "Convert the string S into a Calc number.
3652 S is assumed to be a simple number (integer or float without an exponent)
3653 and all digits are kept, regardless of Calc's current precision."
3654   (save-match-data
3655     (cond
3656      ;; Integer
3657      ((string-match "^[0-9]+$" s)
3658       (if (string-match "^\\(0+\\)" s)
3659           (setq s (substring s (match-end 0))))
3660       (if (<= (length s) (* 2 math-bignum-digit-length))
3661           (string-to-number s)
3662         (cons 'bigpos (math-read-bignum s))))
3663      ;; Minus sign
3664      ((string-match "^-[0-9]+$" s)
3665       (if (<= (length s) (1+ (* 2 math-bignum-digit-length)))
3666           (string-to-number s)
3667         (cons 'bigneg (math-read-bignum (substring s 1)))))
3668      ;; Decimal point
3669      ((string-match "^\\(-?[0-9]*\\)\\.\\([0-9]*\\)$" s)
3670       (let ((int (math-match-substring s 1))
3671             (frac (math-match-substring s 2)))
3672         (list 'float (math-read-number-simple (concat int frac))
3673               (- (length frac)))))
3674      ;; Syntax error!
3675      (t nil))))
3676
3677 (defun math-match-substring (s n)
3678   (if (match-beginning n)
3679       (substring s (match-beginning n) (match-end n))
3680     ""))
3681
3682 (defun math-read-bignum (s)   ; [l X]
3683   (if (> (length s) math-bignum-digit-length)
3684       (cons (string-to-number (substring s (- math-bignum-digit-length)))
3685             (math-read-bignum (substring s 0 (- math-bignum-digit-length))))
3686     (list (string-to-number s))))
3687
3688 (defconst math-standard-opers
3689   '( ( "_"     calcFunc-subscr 1200 1201 )
3690      ( "%"     calcFunc-percent 1100 -1 )
3691      ( "u!"    calcFunc-lnot -1 1000 )
3692      ( "mod"   mod           400 400 185 )
3693      ( "+/-"   sdev          300 300 185 )
3694      ( "!!"    calcFunc-dfact 210 -1 )
3695      ( "!"     calcFunc-fact 210  -1 )
3696      ( "^"     ^             201 200 )
3697      ( "**"    ^             201 200 )
3698      ( "u+"    ident         -1  197 )
3699      ( "u-"    neg           -1  197 )
3700      ( "/"     /             190 191 )
3701      ( "%"     %             190 191 )
3702      ( "\\"    calcFunc-idiv 190 191 )
3703      ( "+"     +             180 181 )
3704      ( "-"     -             180 181 )
3705      ( "|"     |             170 171 )
3706      ( "<"     calcFunc-lt   160 161 )
3707      ( ">"     calcFunc-gt   160 161 )
3708      ( "<="    calcFunc-leq  160 161 )
3709      ( ">="    calcFunc-geq  160 161 )
3710      ( "="     calcFunc-eq   160 161 )
3711      ( "=="    calcFunc-eq   160 161 )
3712      ( "!="    calcFunc-neq  160 161 )
3713      ( "&&"    calcFunc-land 110 111 )
3714      ( "||"    calcFunc-lor  100 101 )
3715      ( "?"     (math-read-if) 91  90 )
3716      ( "!!!"   calcFunc-pnot  -1  85 )
3717      ( "&&&"   calcFunc-pand  80  81 )
3718      ( "|||"   calcFunc-por   75  76 )
3719      ( ":="    calcFunc-assign 51 50 )
3720      ( "::"    calcFunc-condition 45 46 )
3721      ( "=>"    calcFunc-evalto 40 41 )
3722      ( "=>"    calcFunc-evalto 40 -1 )))
3723
3724 (defun math-standard-ops ()
3725   (if calc-multiplication-has-precedence
3726       (cons
3727        '( "*"     *             196 195 )
3728        (cons
3729         '( "2x"    *             196 195 )
3730         math-standard-opers))
3731     (cons
3732      '( "*"     *             190 191 )
3733      (cons
3734       '( "2x"    *             190 191 )
3735       math-standard-opers))))
3736
3737 (defvar math-expr-opers (math-standard-ops))
3738
3739 (defun math-standard-ops-p ()
3740   (let ((meo (caar math-expr-opers)))
3741     (and (stringp meo)
3742          (string= meo "*"))))
3743
3744 (defun math-expr-ops ()
3745   (if (math-standard-ops-p)
3746       (math-standard-ops)
3747     math-expr-opers))
3748
3749 ;;;###autoload
3750 (defun calc-grab-region (top bot arg)
3751   "Parse the region as a vector of numbers and push it on the Calculator stack."
3752   (interactive "r\nP")
3753   (require 'calc-ext)
3754   (calc-do-grab-region top bot arg))
3755
3756 ;;;###autoload
3757 (defun calc-grab-rectangle (top bot arg)
3758   "Parse a rectangle as a matrix of numbers and push it on the Calculator stack."
3759   (interactive "r\nP")
3760   (require 'calc-ext)
3761   (calc-do-grab-rectangle top bot arg))
3762
3763 (defun calc-grab-sum-down (top bot arg)
3764   "Parse a rectangle as a matrix of numbers and sum its columns."
3765   (interactive "r\nP")
3766   (require 'calc-ext)
3767   (calc-do-grab-rectangle top bot arg 'calcFunc-reduced))
3768
3769 (defun calc-grab-sum-across (top bot arg)
3770   "Parse a rectangle as a matrix of numbers and sum its rows."
3771   (interactive "r\nP")
3772   (require 'calc-ext)
3773   (calc-do-grab-rectangle top bot arg 'calcFunc-reducea))
3774
3775
3776 ;;;###autoload
3777 (defun calc-embedded (arg &optional end obeg oend)
3778   "Start Calc Embedded mode on the formula surrounding point."
3779   (interactive "P")
3780   (require 'calc-ext)
3781   (calc-do-embedded arg end obeg oend))
3782
3783 ;;;###autoload
3784 (defun calc-embedded-activate (&optional arg cbuf)
3785   "Scan the current editing buffer for all embedded := and => formulas.
3786 Also looks for the equivalent TeX words, \\gets and \\evalto."
3787   (interactive "P")
3788   (calc-do-embedded-activate arg cbuf))
3789
3790 (defun calc-user-invocation ()
3791   (interactive)
3792   (unless calc-invocation-macro
3793     (error "Use `Z I' inside Calc to define a `C-x * Z' keyboard macro"))
3794   (execute-kbd-macro calc-invocation-macro nil))
3795
3796 ;;; User-programmability.
3797
3798 ;;;###autoload
3799 (defmacro defmath (func args &rest body)   ;  [Public]
3800   "Define Calc function.
3801
3802 Like `defun' except that code in the body of the definition can
3803 make use of the full range of Calc data types and the usual
3804 arithmetic operations are converted to their Calc equivalents.
3805
3806 The prefix `calcFunc-' is added to the specified name to get the
3807 actual Lisp function name.
3808
3809 See Info node `(calc)Defining Functions'."
3810   (declare (doc-string 3))
3811   (require 'calc-ext)
3812   (math-do-defmath func args body))
3813
3814 ;;; Functions needed for Lucid Emacs support.
3815
3816 (defun calc-read-key (&optional optkey)
3817   (cond ((featurep 'xemacs)
3818          (let ((event (next-command-event)))
3819            (let ((key (event-to-character event t t)))
3820              (or key optkey (error "Expected a plain keystroke"))
3821              (cons key event))))
3822         (t
3823          (let ((key (read-event)))
3824            (cons key key)))))
3825
3826 (defun calc-unread-command (&optional input)
3827   (if (featurep 'xemacs)
3828       (setq unread-command-event
3829             (if (integerp input) (character-to-event input)
3830               (or input last-command-event)))
3831     (push (or input last-command-event) unread-command-events)))
3832
3833 (defun calc-clear-unread-commands ()
3834   (if (featurep 'xemacs)
3835       (setq unread-command-event nil)
3836     (setq unread-command-events nil)))
3837
3838 (defcalcmodevar math-2-word-size
3839   (math-read-number-simple "4294967296")
3840   "Two to the power of `calc-word-size'.")
3841
3842 (defcalcmodevar math-half-2-word-size
3843   (math-read-number-simple "2147483648")
3844   "One-half of two to the power of `calc-word-size'.")
3845
3846 (when calc-always-load-extensions
3847   (require 'calc-ext)
3848   (calc-load-everything))
3849
3850
3851 (run-hooks 'calc-load-hook)
3852
3853 (provide 'calc)
3854
3855 ;; Local variables:
3856 ;; coding: utf-8
3857 ;; End:
3858
3859 ;;; calc.el ends here