(calc-inverse, calc-hyperbolic): Give more thorough messages.

[gnu-emacs] / lisp / calc / calc-ext.el

;;; calc-ext.el --- various extension functions for Calc

;; Copyright (C) 1990, 1991, 1992, 1993, 2001, 2002, 2004 Free Software Foundation, Inc.

;; Author: David Gillespie <daveg@synaptics.com>
;; Maintainer: Jay Belanger <belanger@truman.edu>

;; This file is part of GNU Emacs.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY.  No author or distributor
;; accepts responsibility to anyone for the consequences of using it
;; or for whether it serves any particular purpose or works at all,
;; unless he says so in writing.  Refer to the GNU Emacs General Public
;; License for full details.

;; Everyone is granted permission to copy, modify and redistribute
;; GNU Emacs, but only under the conditions described in the
;; GNU Emacs General Public License.   A copy of this license is
;; supposed to have been given to you along with GNU Emacs so you
;; can know your rights and responsibilities.  It should be in a
;; file named COPYING.  Among other things, the copyright notice
;; and this notice must be preserved on all copies.

;;; Commentary:

;;; Code:

(require 'calc)
(require 'calc-macs)

(defvar math-simplifying nil)
(defvar math-living-dangerously nil)   ; true if unsafe simplifications are okay.
(defvar math-integrating nil)

(defvar math-rewrite-selections nil)

(defvar math-compose-level 0)
(defvar math-comp-selected nil)
(defvar math-comp-tagged nil)
(defvar math-comp-sel-hpos nil)
(defvar math-comp-sel-vpos nil)
(defvar math-comp-sel-cpos nil)
(defvar math-compose-hash-args nil)

;;; The following was made a function so that it could be byte-compiled.
(defun calc-init-extensions ()

  (define-key calc-mode-map ":" 'calc-fdiv)
  (define-key calc-mode-map "\\" 'calc-idiv)
  (define-key calc-mode-map "|" 'calc-concat)
  (define-key calc-mode-map "!" 'calc-factorial)
  (define-key calc-mode-map "C" 'calc-cos)
  (define-key calc-mode-map "E" 'calc-exp)
  (define-key calc-mode-map "H" 'calc-hyperbolic)
  (define-key calc-mode-map "I" 'calc-inverse)
  (define-key calc-mode-map "J" 'calc-conj)
  (define-key calc-mode-map "L" 'calc-ln)
  (define-key calc-mode-map "N" 'calc-eval-num)
  (define-key calc-mode-map "P" 'calc-pi)
  (define-key calc-mode-map "Q" 'calc-sqrt)
  (define-key calc-mode-map "R" 'calc-round)
  (define-key calc-mode-map "S" 'calc-sin)
  (define-key calc-mode-map "T" 'calc-tan)
  (define-key calc-mode-map "U" 'calc-undo)
  (define-key calc-mode-map "X" 'calc-call-last-kbd-macro)
  (define-key calc-mode-map "o" 'calc-realign)
  (define-key calc-mode-map "p" 'calc-precision)
  (define-key calc-mode-map "w" 'calc-why)
  (define-key calc-mode-map "x" 'calc-execute-extended-command)
  (define-key calc-mode-map "y" 'calc-copy-to-buffer)

  (define-key calc-mode-map "(" 'calc-begin-complex)
  (define-key calc-mode-map ")" 'calc-end-complex)
  (define-key calc-mode-map "[" 'calc-begin-vector)
  (define-key calc-mode-map "]" 'calc-end-vector)
  (define-key calc-mode-map "," 'calc-comma)
  (define-key calc-mode-map ";" 'calc-semi)
  (define-key calc-mode-map "`" 'calc-edit)
  (define-key calc-mode-map "=" 'calc-evaluate)
  (define-key calc-mode-map "~" 'calc-num-prefix)
  (define-key calc-mode-map "<" 'calc-scroll-left)
  (define-key calc-mode-map ">" 'calc-scroll-right)
  (define-key calc-mode-map "{" 'calc-scroll-down)
  (define-key calc-mode-map "}" 'calc-scroll-up)
  (define-key calc-mode-map "\C-k" 'calc-kill)
  (define-key calc-mode-map "\M-k" 'calc-copy-as-kill)
  (define-key calc-mode-map "\C-w" 'calc-kill-region)
  (define-key calc-mode-map "\M-w" 'calc-copy-region-as-kill)
  (define-key calc-mode-map "\C-y" 'calc-yank)
  (define-key calc-mode-map [mouse-2] 'calc-yank)
  (define-key calc-mode-map "\C-_" 'calc-undo)
  (define-key calc-mode-map "\C-xu" 'calc-undo)
  (define-key calc-mode-map "\M-\C-m" 'calc-last-args)

  (define-key calc-mode-map "a" nil)
  (define-key calc-mode-map "a?" 'calc-a-prefix-help)
  (define-key calc-mode-map "aa" 'calc-apart)
  (define-key calc-mode-map "ab" 'calc-substitute)
  (define-key calc-mode-map "ac" 'calc-collect)
  (define-key calc-mode-map "ad" 'calc-derivative)
  (define-key calc-mode-map "ae" 'calc-simplify-extended)
  (define-key calc-mode-map "af" 'calc-factor)
  (define-key calc-mode-map "ag" 'calc-poly-gcd)
  (define-key calc-mode-map "ai" 'calc-integral)
  (define-key calc-mode-map "am" 'calc-match)
  (define-key calc-mode-map "an" 'calc-normalize-rat)
  (define-key calc-mode-map "ap" 'calc-poly-interp)
  (define-key calc-mode-map "ar" 'calc-rewrite)
  (define-key calc-mode-map "as" 'calc-simplify)
  (define-key calc-mode-map "at" 'calc-taylor)
  (define-key calc-mode-map "av" 'calc-alg-evaluate)
  (define-key calc-mode-map "ax" 'calc-expand)
  (define-key calc-mode-map "aA" 'calc-abs)
  (define-key calc-mode-map "aF" 'calc-curve-fit)
  (define-key calc-mode-map "aI" 'calc-num-integral)
  (define-key calc-mode-map "aM" 'calc-map-equation)
  (define-key calc-mode-map "aN" 'calc-find-minimum)
  (define-key calc-mode-map "aP" 'calc-poly-roots)
  (define-key calc-mode-map "aS" 'calc-solve-for)
  (define-key calc-mode-map "aR" 'calc-find-root)
  (define-key calc-mode-map "aT" 'calc-tabulate)
  (define-key calc-mode-map "aX" 'calc-find-maximum)
  (define-key calc-mode-map "a+" 'calc-summation)
  (define-key calc-mode-map "a-" 'calc-alt-summation)
  (define-key calc-mode-map "a*" 'calc-product)
  (define-key calc-mode-map "a\\" 'calc-poly-div)
  (define-key calc-mode-map "a%" 'calc-poly-rem)
  (define-key calc-mode-map "a/" 'calc-poly-div-rem)
  (define-key calc-mode-map "a=" 'calc-equal-to)
  (define-key calc-mode-map "a#" 'calc-not-equal-to)
  (define-key calc-mode-map "a<" 'calc-less-than)
  (define-key calc-mode-map "a>" 'calc-greater-than)
  (define-key calc-mode-map "a[" 'calc-less-equal)
  (define-key calc-mode-map "a]" 'calc-greater-equal)
  (define-key calc-mode-map "a." 'calc-remove-equal)
  (define-key calc-mode-map "a{" 'calc-in-set)
  (define-key calc-mode-map "a&" 'calc-logical-and)
  (define-key calc-mode-map "a|" 'calc-logical-or)
  (define-key calc-mode-map "a!" 'calc-logical-not)
  (define-key calc-mode-map "a:" 'calc-logical-if)
  (define-key calc-mode-map "a_" 'calc-subscript)
  (define-key calc-mode-map "a\"" 'calc-expand-formula)

  (define-key calc-mode-map "b" nil)
  (define-key calc-mode-map "b?" 'calc-b-prefix-help)
  (define-key calc-mode-map "ba" 'calc-and)
  (define-key calc-mode-map "bc" 'calc-clip)
  (define-key calc-mode-map "bd" 'calc-diff)
  (define-key calc-mode-map "bl" 'calc-lshift-binary)
  (define-key calc-mode-map "bn" 'calc-not)
  (define-key calc-mode-map "bo" 'calc-or)
  (define-key calc-mode-map "bp" 'calc-pack-bits)
  (define-key calc-mode-map "br" 'calc-rshift-binary)
  (define-key calc-mode-map "bt" 'calc-rotate-binary)
  (define-key calc-mode-map "bu" 'calc-unpack-bits)
  (define-key calc-mode-map "bw" 'calc-word-size)
  (define-key calc-mode-map "bx" 'calc-xor)
  (define-key calc-mode-map "bB" 'calc-log)
  (define-key calc-mode-map "bD" 'calc-fin-ddb)
  (define-key calc-mode-map "bF" 'calc-fin-fv)
  (define-key calc-mode-map "bI" 'calc-fin-irr)
  (define-key calc-mode-map "bL" 'calc-lshift-arith)
  (define-key calc-mode-map "bM" 'calc-fin-pmt)
  (define-key calc-mode-map "bN" 'calc-fin-npv)
  (define-key calc-mode-map "bP" 'calc-fin-pv)
  (define-key calc-mode-map "bR" 'calc-rshift-arith)
  (define-key calc-mode-map "bS" 'calc-fin-sln)
  (define-key calc-mode-map "bT" 'calc-fin-rate)
  (define-key calc-mode-map "bY" 'calc-fin-syd)
  (define-key calc-mode-map "b#" 'calc-fin-nper)
  (define-key calc-mode-map "b%" 'calc-percent-change)

  (define-key calc-mode-map "c" nil)
  (define-key calc-mode-map "c?" 'calc-c-prefix-help)
  (define-key calc-mode-map "cc" 'calc-clean)
  (define-key calc-mode-map "cd" 'calc-to-degrees)
  (define-key calc-mode-map "cf" 'calc-float)
  (define-key calc-mode-map "ch" 'calc-to-hms)
  (define-key calc-mode-map "cp" 'calc-polar)
  (define-key calc-mode-map "cr" 'calc-to-radians)
  (define-key calc-mode-map "cC" 'calc-cos)
  (define-key calc-mode-map "cF" 'calc-fraction)
  (define-key calc-mode-map "c%" 'calc-convert-percent)

  (define-key calc-mode-map "d" nil)
  (define-key calc-mode-map "d?" 'calc-d-prefix-help)
  (define-key calc-mode-map "d0" 'calc-decimal-radix)
  (define-key calc-mode-map "d2" 'calc-binary-radix)
  (define-key calc-mode-map "d6" 'calc-hex-radix)
  (define-key calc-mode-map "d8" 'calc-octal-radix)
  (define-key calc-mode-map "db" 'calc-line-breaking)
  (define-key calc-mode-map "dc" 'calc-complex-notation)
  (define-key calc-mode-map "dd" 'calc-date-notation)
  (define-key calc-mode-map "de" 'calc-eng-notation)
  (define-key calc-mode-map "df" 'calc-fix-notation)
  (define-key calc-mode-map "dg" 'calc-group-digits)
  (define-key calc-mode-map "dh" 'calc-hms-notation)
  (define-key calc-mode-map "di" 'calc-i-notation)
  (define-key calc-mode-map "dj" 'calc-j-notation)
  (define-key calc-mode-map "dl" 'calc-line-numbering)
  (define-key calc-mode-map "dn" 'calc-normal-notation)
  (define-key calc-mode-map "do" 'calc-over-notation)
  (define-key calc-mode-map "dp" 'calc-show-plain)
  (define-key calc-mode-map "dr" 'calc-radix)
  (define-key calc-mode-map "ds" 'calc-sci-notation)
  (define-key calc-mode-map "dt" 'calc-truncate-stack)
  (define-key calc-mode-map "dw" 'calc-auto-why)
  (define-key calc-mode-map "dz" 'calc-leading-zeros)
  (define-key calc-mode-map "dB" 'calc-big-language)
  (define-key calc-mode-map "dD" 'calc-redo)
  (define-key calc-mode-map "dC" 'calc-c-language)
  (define-key calc-mode-map "dE" 'calc-eqn-language)
  (define-key calc-mode-map "dF" 'calc-fortran-language)
  (define-key calc-mode-map "dM" 'calc-mathematica-language)
  (define-key calc-mode-map "dN" 'calc-normal-language)
  (define-key calc-mode-map "dO" 'calc-flat-language)
  (define-key calc-mode-map "dP" 'calc-pascal-language)
  (define-key calc-mode-map "dT" 'calc-tex-language)
  (define-key calc-mode-map "dU" 'calc-unformatted-language)
  (define-key calc-mode-map "dW" 'calc-maple-language)
  (define-key calc-mode-map "d[" 'calc-truncate-up)
  (define-key calc-mode-map "d]" 'calc-truncate-down)
  (define-key calc-mode-map "d." 'calc-point-char)
  (define-key calc-mode-map "d," 'calc-group-char)
  (define-key calc-mode-map "d\"" 'calc-display-strings)
  (define-key calc-mode-map "d<" 'calc-left-justify)
  (define-key calc-mode-map "d=" 'calc-center-justify)
  (define-key calc-mode-map "d>" 'calc-right-justify)
  (define-key calc-mode-map "d{" 'calc-left-label)
  (define-key calc-mode-map "d}" 'calc-right-label)
  (define-key calc-mode-map "d'" 'calc-display-raw)
  (define-key calc-mode-map "d " 'calc-refresh)
  (define-key calc-mode-map "d\r" 'calc-refresh-top)
  (define-key calc-mode-map "d@" 'calc-toggle-banner)

  (define-key calc-mode-map "f" nil)
  (define-key calc-mode-map "f?" 'calc-f-prefix-help)
  (define-key calc-mode-map "fb" 'calc-beta)
  (define-key calc-mode-map "fe" 'calc-erf)
  (define-key calc-mode-map "fg" 'calc-gamma)
  (define-key calc-mode-map "fh" 'calc-hypot)
  (define-key calc-mode-map "fi" 'calc-im)
  (define-key calc-mode-map "fj" 'calc-bessel-J)
  (define-key calc-mode-map "fn" 'calc-min)
  (define-key calc-mode-map "fr" 'calc-re)
  (define-key calc-mode-map "fs" 'calc-sign)
  (define-key calc-mode-map "fx" 'calc-max)
  (define-key calc-mode-map "fy" 'calc-bessel-Y)
  (define-key calc-mode-map "fA" 'calc-abssqr)
  (define-key calc-mode-map "fB" 'calc-inc-beta)
  (define-key calc-mode-map "fE" 'calc-expm1)
  (define-key calc-mode-map "fF" 'calc-floor)
  (define-key calc-mode-map "fG" 'calc-inc-gamma)
  (define-key calc-mode-map "fI" 'calc-ilog)
  (define-key calc-mode-map "fL" 'calc-lnp1)
  (define-key calc-mode-map "fM" 'calc-mant-part)
  (define-key calc-mode-map "fQ" 'calc-isqrt)
  (define-key calc-mode-map "fS" 'calc-scale-float)
  (define-key calc-mode-map "fT" 'calc-arctan2)
  (define-key calc-mode-map "fX" 'calc-xpon-part)
  (define-key calc-mode-map "f[" 'calc-decrement)
  (define-key calc-mode-map "f]" 'calc-increment)

  (define-key calc-mode-map "g" nil)
  (define-key calc-mode-map "g?" 'calc-g-prefix-help)
  (define-key calc-mode-map "ga" 'calc-graph-add)
  (define-key calc-mode-map "gb" 'calc-graph-border)
  (define-key calc-mode-map "gc" 'calc-graph-clear)
  (define-key calc-mode-map "gd" 'calc-graph-delete)
  (define-key calc-mode-map "gf" 'calc-graph-fast)
  (define-key calc-mode-map "gg" 'calc-graph-grid)
  (define-key calc-mode-map "gh" 'calc-graph-header)
  (define-key calc-mode-map "gk" 'calc-graph-key)
  (define-key calc-mode-map "gj" 'calc-graph-juggle)
  (define-key calc-mode-map "gl" 'calc-graph-log-x)
  (define-key calc-mode-map "gn" 'calc-graph-name)
  (define-key calc-mode-map "gp" 'calc-graph-plot)
  (define-key calc-mode-map "gq" 'calc-graph-quit)
  (define-key calc-mode-map "gr" 'calc-graph-range-x)
  (define-key calc-mode-map "gs" 'calc-graph-line-style)
  (define-key calc-mode-map "gt" 'calc-graph-title-x)
  (define-key calc-mode-map "gv" 'calc-graph-view-commands)
  (define-key calc-mode-map "gx" 'calc-graph-display)
  (define-key calc-mode-map "gz" 'calc-graph-zero-x)
  (define-key calc-mode-map "gA" 'calc-graph-add-3d)
  (define-key calc-mode-map "gC" 'calc-graph-command)
  (define-key calc-mode-map "gD" 'calc-graph-device)
  (define-key calc-mode-map "gF" 'calc-graph-fast-3d)
  (define-key calc-mode-map "gG" 'calc-argument)
  (define-key calc-mode-map "gH" 'calc-graph-hide)
  (define-key calc-mode-map "gK" 'calc-graph-kill)
  (define-key calc-mode-map "gL" 'calc-graph-log-y)
  (define-key calc-mode-map "gN" 'calc-graph-num-points)
  (define-key calc-mode-map "gO" 'calc-graph-output)
  (define-key calc-mode-map "gP" 'calc-graph-print)
  (define-key calc-mode-map "gR" 'calc-graph-range-y)
  (define-key calc-mode-map "gS" 'calc-graph-point-style)
  (define-key calc-mode-map "gT" 'calc-graph-title-y)
  (define-key calc-mode-map "gV" 'calc-graph-view-trail)
  (define-key calc-mode-map "gX" 'calc-graph-geometry)
  (define-key calc-mode-map "gZ" 'calc-graph-zero-y)
  (define-key calc-mode-map "g\C-l" 'calc-graph-log-z)
  (define-key calc-mode-map "g\C-r" 'calc-graph-range-z)
  (define-key calc-mode-map "g\C-t" 'calc-graph-title-z)

  (define-key calc-mode-map "h" 'calc-help-prefix)

  (define-key calc-mode-map "j" nil)
  (define-key calc-mode-map "j?" 'calc-j-prefix-help)
  (define-key calc-mode-map "ja" 'calc-select-additional)
  (define-key calc-mode-map "jb" 'calc-break-selections)
  (define-key calc-mode-map "jc" 'calc-clear-selections)
  (define-key calc-mode-map "jd" 'calc-show-selections)
  (define-key calc-mode-map "je" 'calc-enable-selections)
  (define-key calc-mode-map "jl" 'calc-select-less)
  (define-key calc-mode-map "jm" 'calc-select-more)
  (define-key calc-mode-map "jn" 'calc-select-next)
  (define-key calc-mode-map "jo" 'calc-select-once)
  (define-key calc-mode-map "jp" 'calc-select-previous)
  (define-key calc-mode-map "jr" 'calc-rewrite-selection)
  (define-key calc-mode-map "js" 'calc-select-here)
  (define-key calc-mode-map "jv" 'calc-sel-evaluate)
  (define-key calc-mode-map "ju" 'calc-unselect)
  (define-key calc-mode-map "jC" 'calc-sel-commute)
  (define-key calc-mode-map "jD" 'calc-sel-distribute)
  (define-key calc-mode-map "jE" 'calc-sel-jump-equals)
  (define-key calc-mode-map "jI" 'calc-sel-isolate)
  (define-key calc-mode-map "jJ" 'calc-conj)
  (define-key calc-mode-map "jL" 'calc-commute-left)
  (define-key calc-mode-map "jM" 'calc-sel-merge)
  (define-key calc-mode-map "jN" 'calc-sel-negate)
  (define-key calc-mode-map "jO" 'calc-select-once-maybe)
  (define-key calc-mode-map "jR" 'calc-commute-right)
  (define-key calc-mode-map "jS" 'calc-select-here-maybe)
  (define-key calc-mode-map "jU" 'calc-sel-unpack)
  (define-key calc-mode-map "j&" 'calc-sel-invert)
  (define-key calc-mode-map "j\r" 'calc-copy-selection)
  (define-key calc-mode-map "j\n" 'calc-copy-selection)
  (define-key calc-mode-map "j\010" 'calc-del-selection)
  (define-key calc-mode-map "j\177" 'calc-del-selection)
  (define-key calc-mode-map "j'" 'calc-enter-selection)
  (define-key calc-mode-map "j`" 'calc-edit-selection)
  (define-key calc-mode-map "j+" 'calc-sel-add-both-sides)
  (define-key calc-mode-map "j-" 'calc-sel-sub-both-sides)
  (define-key calc-mode-map "j*" 'calc-sel-mult-both-sides)
  (define-key calc-mode-map "j/" 'calc-sel-div-both-sides)
  (define-key calc-mode-map "j\"" 'calc-sel-expand-formula)

  (define-key calc-mode-map "k" nil)
  (define-key calc-mode-map "k?" 'calc-k-prefix-help)
  (define-key calc-mode-map "ka" 'calc-random-again)
  (define-key calc-mode-map "kb" 'calc-bernoulli-number)
  (define-key calc-mode-map "kc" 'calc-choose)
  (define-key calc-mode-map "kd" 'calc-double-factorial)
  (define-key calc-mode-map "ke" 'calc-euler-number)
  (define-key calc-mode-map "kf" 'calc-prime-factors)
  (define-key calc-mode-map "kg" 'calc-gcd)
  (define-key calc-mode-map "kh" 'calc-shuffle)
  (define-key calc-mode-map "kl" 'calc-lcm)
  (define-key calc-mode-map "km" 'calc-moebius)
  (define-key calc-mode-map "kn" 'calc-next-prime)
  (define-key calc-mode-map "kp" 'calc-prime-test)
  (define-key calc-mode-map "kr" 'calc-random)
  (define-key calc-mode-map "ks" 'calc-stirling-number)
  (define-key calc-mode-map "kt" 'calc-totient)
  (define-key calc-mode-map "kB" 'calc-utpb)
  (define-key calc-mode-map "kC" 'calc-utpc)
  (define-key calc-mode-map "kE" 'calc-extended-gcd)
  (define-key calc-mode-map "kF" 'calc-utpf)
  (define-key calc-mode-map "kK" 'calc-keep-args)
  (define-key calc-mode-map "kN" 'calc-utpn)
  (define-key calc-mode-map "kP" 'calc-utpp)
  (define-key calc-mode-map "kT" 'calc-utpt)

  (define-key calc-mode-map "m" nil)
  (define-key calc-mode-map "m?" 'calc-m-prefix-help)
  (define-key calc-mode-map "ma" 'calc-algebraic-mode)
  (define-key calc-mode-map "md" 'calc-degrees-mode)
  (define-key calc-mode-map "mf" 'calc-frac-mode)
  (define-key calc-mode-map "mg" 'calc-get-modes)
  (define-key calc-mode-map "mh" 'calc-hms-mode)
  (define-key calc-mode-map "mi" 'calc-infinite-mode)
  (define-key calc-mode-map "mm" 'calc-save-modes)
  (define-key calc-mode-map "mp" 'calc-polar-mode)
  (define-key calc-mode-map "mr" 'calc-radians-mode)
  (define-key calc-mode-map "ms" 'calc-symbolic-mode)
  (define-key calc-mode-map "mt" 'calc-total-algebraic-mode)
  (define-key calc-mode-map "\emt" 'calc-total-algebraic-mode)
  (define-key calc-mode-map "\em\et" 'calc-total-algebraic-mode)
  (define-key calc-mode-map "mv" 'calc-matrix-mode)
  (define-key calc-mode-map "mw" 'calc-working)
  (define-key calc-mode-map "mx" 'calc-always-load-extensions)
  (define-key calc-mode-map "mA" 'calc-alg-simplify-mode)
  (define-key calc-mode-map "mB" 'calc-bin-simplify-mode)
  (define-key calc-mode-map "mC" 'calc-auto-recompute)
  (define-key calc-mode-map "mD" 'calc-default-simplify-mode)
  (define-key calc-mode-map "mE" 'calc-ext-simplify-mode)
  (define-key calc-mode-map "mF" 'calc-settings-file-name)
  (define-key calc-mode-map "mM" 'calc-more-recursion-depth)
  (define-key calc-mode-map "mN" 'calc-num-simplify-mode)
  (define-key calc-mode-map "mO" 'calc-no-simplify-mode)
  (define-key calc-mode-map "mR" 'calc-mode-record-mode)
  (define-key calc-mode-map "mS" 'calc-shift-prefix)
  (define-key calc-mode-map "mU" 'calc-units-simplify-mode)
  (define-key calc-mode-map "mX" 'calc-load-everything)

  (define-key calc-mode-map "r" nil)
  (define-key calc-mode-map "r?" 'calc-r-prefix-help)

  (define-key calc-mode-map "s" nil)
  (define-key calc-mode-map "s?" 'calc-s-prefix-help)
  (define-key calc-mode-map "sc" 'calc-copy-variable)
  (define-key calc-mode-map "sd" 'calc-declare-variable)
  (define-key calc-mode-map "se" 'calc-edit-variable)
  (define-key calc-mode-map "si" 'calc-insert-variables)
  (define-key calc-mode-map "sl" 'calc-let)
  (define-key calc-mode-map "sm" 'calc-store-map)
  (define-key calc-mode-map "sn" 'calc-store-neg)
  (define-key calc-mode-map "sp" 'calc-permanent-variable)
  (define-key calc-mode-map "sr" 'calc-recall)
  (define-key calc-mode-map "ss" 'calc-store)
  (define-key calc-mode-map "st" 'calc-store-into)
  (define-key calc-mode-map "su" 'calc-unstore)
  (define-key calc-mode-map "sx" 'calc-store-exchange)
  (define-key calc-mode-map "sA" 'calc-edit-AlgSimpRules)
  (define-key calc-mode-map "sD" 'calc-edit-Decls)
  (define-key calc-mode-map "sE" 'calc-edit-EvalRules)
  (define-key calc-mode-map "sF" 'calc-edit-FitRules)
  (define-key calc-mode-map "sG" 'calc-edit-GenCount)
  (define-key calc-mode-map "sH" 'calc-edit-Holidays)
  (define-key calc-mode-map "sI" 'calc-edit-IntegLimit)
  (define-key calc-mode-map "sL" 'calc-edit-LineStyles)
  (define-key calc-mode-map "sP" 'calc-edit-PointStyles)
  (define-key calc-mode-map "sR" 'calc-edit-PlotRejects)
  (define-key calc-mode-map "sS" 'calc-sin)
  (define-key calc-mode-map "sT" 'calc-edit-TimeZone)
  (define-key calc-mode-map "sU" 'calc-edit-Units)
  (define-key calc-mode-map "sX" 'calc-edit-ExtSimpRules)
  (define-key calc-mode-map "s+" 'calc-store-plus)
  (define-key calc-mode-map "s-" 'calc-store-minus)
  (define-key calc-mode-map "s*" 'calc-store-times)
  (define-key calc-mode-map "s/" 'calc-store-div)
  (define-key calc-mode-map "s^" 'calc-store-power)
  (define-key calc-mode-map "s|" 'calc-store-concat)
  (define-key calc-mode-map "s&" 'calc-store-inv)
  (define-key calc-mode-map "s[" 'calc-store-decr)
  (define-key calc-mode-map "s]" 'calc-store-incr)
  (define-key calc-mode-map "s:" 'calc-assign)
  (define-key calc-mode-map "s=" 'calc-evalto)

  (define-key calc-mode-map "t" nil)
  (define-key calc-mode-map "t?" 'calc-t-prefix-help)
  (define-key calc-mode-map "tb" 'calc-trail-backward)
  (define-key calc-mode-map "td" 'calc-trail-display)
  (define-key calc-mode-map "tf" 'calc-trail-forward)
  (define-key calc-mode-map "th" 'calc-trail-here)
  (define-key calc-mode-map "ti" 'calc-trail-in)
  (define-key calc-mode-map "tk" 'calc-trail-kill)
  (define-key calc-mode-map "tm" 'calc-trail-marker)
  (define-key calc-mode-map "tn" 'calc-trail-next)
  (define-key calc-mode-map "to" 'calc-trail-out)
  (define-key calc-mode-map "tp" 'calc-trail-previous)
  (define-key calc-mode-map "tr" 'calc-trail-isearch-backward)
  (define-key calc-mode-map "ts" 'calc-trail-isearch-forward)
  (define-key calc-mode-map "ty" 'calc-trail-yank)
  (define-key calc-mode-map "t[" 'calc-trail-first)
  (define-key calc-mode-map "t]" 'calc-trail-last)
  (define-key calc-mode-map "t<" 'calc-trail-scroll-left)
  (define-key calc-mode-map "t>" 'calc-trail-scroll-right)
  (define-key calc-mode-map "t{" 'calc-trail-backward)
  (define-key calc-mode-map "t}" 'calc-trail-forward)
  (define-key calc-mode-map "t." 'calc-full-trail-vectors)
  (define-key calc-mode-map "tC" 'calc-convert-time-zones)
  (define-key calc-mode-map "tD" 'calc-date)
  (define-key calc-mode-map "tI" 'calc-inc-month)
  (define-key calc-mode-map "tJ" 'calc-julian)
  (define-key calc-mode-map "tM" 'calc-new-month)
  (define-key calc-mode-map "tN" 'calc-now)
  (define-key calc-mode-map "tP" 'calc-date-part)
  (define-key calc-mode-map "tT" 'calc-tan)
  (define-key calc-mode-map "tU" 'calc-unix-time)
  (define-key calc-mode-map "tW" 'calc-new-week)
  (define-key calc-mode-map "tY" 'calc-new-year)
  (define-key calc-mode-map "tZ" 'calc-time-zone)
  (define-key calc-mode-map "t+" 'calc-business-days-plus)
  (define-key calc-mode-map "t-" 'calc-business-days-minus)

  (define-key calc-mode-map "u" 'nil)
  (define-key calc-mode-map "u?" 'calc-u-prefix-help)
  (define-key calc-mode-map "ua" 'calc-autorange-units)
  (define-key calc-mode-map "ub" 'calc-base-units)
  (define-key calc-mode-map "uc" 'calc-convert-units)
  (define-key calc-mode-map "ud" 'calc-define-unit)
  (define-key calc-mode-map "ue" 'calc-explain-units)
  (define-key calc-mode-map "ug" 'calc-get-unit-definition)
  (define-key calc-mode-map "up" 'calc-permanent-units)
  (define-key calc-mode-map "ur" 'calc-remove-units)
  (define-key calc-mode-map "us" 'calc-simplify-units)
  (define-key calc-mode-map "ut" 'calc-convert-temperature)
  (define-key calc-mode-map "uu" 'calc-undefine-unit)
  (define-key calc-mode-map "uv" 'calc-enter-units-table)
  (define-key calc-mode-map "ux" 'calc-extract-units)
  (define-key calc-mode-map "uV" 'calc-view-units-table)
  (define-key calc-mode-map "uC" 'calc-vector-covariance)
  (define-key calc-mode-map "uG" 'calc-vector-geometric-mean)
  (define-key calc-mode-map "uM" 'calc-vector-mean)
  (define-key calc-mode-map "uN" 'calc-vector-min)
  (define-key calc-mode-map "uS" 'calc-vector-sdev)
  (define-key calc-mode-map "uU" 'calc-undo)
  (define-key calc-mode-map "uX" 'calc-vector-max)
  (define-key calc-mode-map "u#" 'calc-vector-count)
  (define-key calc-mode-map "u+" 'calc-vector-sum)
  (define-key calc-mode-map "u*" 'calc-vector-product)

  (define-key calc-mode-map "v" 'nil)
  (define-key calc-mode-map "v?" 'calc-v-prefix-help)
  (define-key calc-mode-map "va" 'calc-arrange-vector)
  (define-key calc-mode-map "vb" 'calc-build-vector)
  (define-key calc-mode-map "vc" 'calc-mcol)
  (define-key calc-mode-map "vd" 'calc-diag)
  (define-key calc-mode-map "ve" 'calc-expand-vector)
  (define-key calc-mode-map "vf" 'calc-vector-find)
  (define-key calc-mode-map "vh" 'calc-head)
  (define-key calc-mode-map "vi" 'calc-ident)
  (define-key calc-mode-map "vk" 'calc-cons)
  (define-key calc-mode-map "vl" 'calc-vlength)
  (define-key calc-mode-map "vm" 'calc-mask-vector)
  (define-key calc-mode-map "vn" 'calc-rnorm)
  (define-key calc-mode-map "vp" 'calc-pack)
  (define-key calc-mode-map "vr" 'calc-mrow)
  (define-key calc-mode-map "vs" 'calc-subvector)
  (define-key calc-mode-map "vt" 'calc-transpose)
  (define-key calc-mode-map "vu" 'calc-unpack)
  (define-key calc-mode-map "vv" 'calc-reverse-vector)
  (define-key calc-mode-map "vx" 'calc-index)
  (define-key calc-mode-map "vA" 'calc-apply)
  (define-key calc-mode-map "vC" 'calc-cross)
  (define-key calc-mode-map "vD" 'calc-mdet)
  (define-key calc-mode-map "vE" 'calc-set-enumerate)
  (define-key calc-mode-map "vF" 'calc-set-floor)
  (define-key calc-mode-map "vG" 'calc-grade)
  (define-key calc-mode-map "vH" 'calc-histogram)
  (define-key calc-mode-map "vI" 'calc-inner-product)
  (define-key calc-mode-map "vJ" 'calc-conj-transpose)
  (define-key calc-mode-map "vL" 'calc-mlud)
  (define-key calc-mode-map "vM" 'calc-map)
  (define-key calc-mode-map "vN" 'calc-cnorm)
  (define-key calc-mode-map "vO" 'calc-outer-product)
  (define-key calc-mode-map "vR" 'calc-reduce)
  (define-key calc-mode-map "vS" 'calc-sort)
  (define-key calc-mode-map "vT" 'calc-mtrace)
  (define-key calc-mode-map "vU" 'calc-accumulate)
  (define-key calc-mode-map "vV" 'calc-set-union)
  (define-key calc-mode-map "vX" 'calc-set-xor)
  (define-key calc-mode-map "v^" 'calc-set-intersect)
  (define-key calc-mode-map "v-" 'calc-set-difference)
  (define-key calc-mode-map "v~" 'calc-set-complement)
  (define-key calc-mode-map "v:" 'calc-set-span)
  (define-key calc-mode-map "v#" 'calc-set-cardinality)
  (define-key calc-mode-map "v+" 'calc-remove-duplicates)
  (define-key calc-mode-map "v&" 'calc-inv)
  (define-key calc-mode-map "v<" 'calc-matrix-left-justify)
  (define-key calc-mode-map "v=" 'calc-matrix-center-justify)
  (define-key calc-mode-map "v>" 'calc-matrix-right-justify)
  (define-key calc-mode-map "v." 'calc-full-vectors)
  (define-key calc-mode-map "v/" 'calc-break-vectors)
  (define-key calc-mode-map "v," 'calc-vector-commas)
  (define-key calc-mode-map "v[" 'calc-vector-brackets)
  (define-key calc-mode-map "v]" 'calc-matrix-brackets)
  (define-key calc-mode-map "v{" 'calc-vector-braces)
  (define-key calc-mode-map "v}" 'calc-matrix-brackets)
  (define-key calc-mode-map "v(" 'calc-vector-parens)
  (define-key calc-mode-map "v)" 'calc-matrix-brackets)
  ;; We can't rely on the automatic upper->lower conversion because
  ;; in the global map V is explicitly bound, so we need to bind it
  ;; explicitly as well :-(  --stef
  (define-key calc-mode-map "V" (lookup-key calc-mode-map "v"))

  (define-key calc-mode-map "z" 'nil)
  (define-key calc-mode-map "z?" 'calc-z-prefix-help)

  (define-key calc-mode-map "Z" 'nil)
  (define-key calc-mode-map "Z?" 'calc-shift-Z-prefix-help)
  (define-key calc-mode-map "ZC" 'calc-user-define-composition)
  (define-key calc-mode-map "ZD" 'calc-user-define)
  (define-key calc-mode-map "ZE" 'calc-user-define-edit)
  (define-key calc-mode-map "ZF" 'calc-user-define-formula)
  (define-key calc-mode-map "ZG" 'calc-get-user-defn)
  (define-key calc-mode-map "ZI" 'calc-user-define-invocation)
  (define-key calc-mode-map "ZK" 'calc-user-define-kbd-macro)
  (define-key calc-mode-map "ZP" 'calc-user-define-permanent)
  (define-key calc-mode-map "ZS" 'calc-edit-user-syntax)
  (define-key calc-mode-map "ZT" 'calc-timing)
  (define-key calc-mode-map "ZU" 'calc-user-undefine)
  (define-key calc-mode-map "Z[" 'calc-kbd-if)
  (define-key calc-mode-map "Z:" 'calc-kbd-else)
  (define-key calc-mode-map "Z|" 'calc-kbd-else-if)
  (define-key calc-mode-map "Z]" 'calc-kbd-end-if)
  (define-key calc-mode-map "Z<" 'calc-kbd-repeat)
  (define-key calc-mode-map "Z>" 'calc-kbd-end-repeat)
  (define-key calc-mode-map "Z(" 'calc-kbd-for)
  (define-key calc-mode-map "Z)" 'calc-kbd-end-for)
  (define-key calc-mode-map "Z{" 'calc-kbd-loop)
  (define-key calc-mode-map "Z}" 'calc-kbd-end-loop)
  (define-key calc-mode-map "Z/" 'calc-kbd-break)
  (define-key calc-mode-map "Z`" 'calc-kbd-push)
  (define-key calc-mode-map "Z'" 'calc-kbd-pop)
  (define-key calc-mode-map "Z=" 'calc-kbd-report)
  (define-key calc-mode-map "Z#" 'calc-kbd-query)

  (calc-init-prefixes)

  (mapcar (function
           (lambda (x)
             (define-key calc-mode-map (format "c%c" x) 'calc-clean-num)
             (define-key calc-mode-map (format "j%c" x) 'calc-select-part)
             (define-key calc-mode-map (format "r%c" x) 'calc-recall-quick)
             (define-key calc-mode-map (format "s%c" x) 'calc-store-quick)
             (define-key calc-mode-map (format "t%c" x) 'calc-store-into-quick)
             (define-key calc-mode-map (format "u%c" x) 'calc-quick-units)))
          "0123456789")

  (let ((i ?A))
    (while (<= i ?z)
      (if (eq (car-safe (aref (nth 1 calc-mode-map) i)) 'keymap)
          (aset (nth 1 calc-mode-map) i
                (cons 'keymap (cons (cons ?\e (aref (nth 1 calc-mode-map) i))
                                    (cdr (aref (nth 1 calc-mode-map) i))))))
      (setq i (1+ i))))
  
  (setq calc-alg-map (copy-keymap calc-mode-map)
        calc-alg-esc-map (copy-keymap esc-map))
  (let ((i 32))
    (while (< i 127)
      (or (memq i '(?' ?` ?= ??))
          (aset (nth 1 calc-alg-map) i 'calc-auto-algebraic-entry))
      (or (memq i '(?# ?x ?0 ?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))
          (aset (nth 1 calc-alg-esc-map) i (aref (nth 1 calc-mode-map) i)))
      (setq i (1+ i))))
  (define-key calc-alg-map "\e" calc-alg-esc-map)
  (define-key calc-alg-map "\e\t" 'calc-roll-up)
  (define-key calc-alg-map "\e\C-m" 'calc-last-args-stub)
  (define-key calc-alg-map "\e\177" 'calc-pop-above)

;;;; (Autoloads here)
  (mapcar (function (lambda (x)
    (mapcar (function (lambda (func)
      (autoload func (car x)))) (cdr x))))
    '(

 ("calc-alg" calc-has-rules math-defsimplify
calc-modify-simplify-mode calcFunc-collect calcFunc-esimplify
calcFunc-islin calcFunc-islinnt calcFunc-lin calcFunc-linnt
calcFunc-simplify calcFunc-subst math-beforep
math-build-polynomial-expr math-expand-formula math-expr-contains
math-expr-contains-count math-expr-depends math-expr-height
math-expr-subst math-expr-weight math-integer-plus math-is-linear
math-is-multiple math-is-polynomial math-linear-in math-multiple-of
math-poly-depends math-poly-mix math-poly-mul
math-poly-simplify math-poly-zerop math-polynomial-base
math-polynomial-p math-recompile-eval-rules math-simplify
math-simplify-exp math-simplify-extended math-simplify-sqrt
math-to-simple-fraction)

 ("calcalg2" calcFunc-asum calcFunc-deriv
calcFunc-ffinv calcFunc-finv calcFunc-fsolve calcFunc-gpoly
calcFunc-integ calcFunc-poly calcFunc-prod calcFunc-roots
calcFunc-solve calcFunc-sum calcFunc-table calcFunc-taylor
calcFunc-tderiv math-expr-calls math-integral-q02 math-integral-q12
math-integral-rational-funcs math-lcm-denoms math-looks-evenp
math-poly-all-roots math-prod-rec math-reject-solution math-solve-eqn
math-solve-for math-sum-rec math-try-integral)

 ("calcalg3" calcFunc-efit calcFunc-fit
calcFunc-fitdummy calcFunc-fitparam calcFunc-fitvar
calcFunc-hasfitparams calcFunc-hasfitvars calcFunc-maximize
calcFunc-minimize calcFunc-ninteg calcFunc-polint calcFunc-ratint
calcFunc-root calcFunc-wmaximize calcFunc-wminimize calcFunc-wroot
calcFunc-xfit math-find-minimum math-find-root math-ninteg-evaluate
math-ninteg-midpoint math-ninteg-romberg math-poly-interp)

 ("calc-arith" calcFunc-abs calcFunc-abssqr
calcFunc-add calcFunc-ceil calcFunc-decr calcFunc-deven calcFunc-dimag
calcFunc-dint calcFunc-div calcFunc-dnatnum calcFunc-dneg
calcFunc-dnonneg calcFunc-dnonzero calcFunc-dnumint calcFunc-dodd
calcFunc-dpos calcFunc-drange calcFunc-drat calcFunc-dreal
calcFunc-dscalar calcFunc-fceil calcFunc-ffloor calcFunc-float
calcFunc-fround calcFunc-frounde calcFunc-froundu calcFunc-ftrunc
calcFunc-idiv calcFunc-incr calcFunc-mant calcFunc-max calcFunc-min
calcFunc-mod calcFunc-mul calcFunc-neg calcFunc-percent calcFunc-pow
calcFunc-relch calcFunc-round calcFunc-rounde calcFunc-roundu
calcFunc-scf calcFunc-sub calcFunc-xpon math-abs math-abs-approx
math-add-objects-fancy math-add-or-sub math-add-symb-fancy
math-ceiling math-combine-prod math-combine-sum math-div-by-zero
math-div-objects-fancy math-div-symb-fancy math-div-zero
math-float-fancy math-floor-fancy math-floor-special math-guess-if-neg
math-intv-constp math-known-evenp math-known-imagp math-known-integerp
math-known-matrixp math-known-negp math-known-nonnegp
math-known-nonposp math-known-nonzerop math-known-num-integerp
math-known-oddp math-known-posp math-known-realp math-known-scalarp
math-max math-min math-mod-fancy math-mul-float math-mul-objects-fancy
math-mul-or-div math-mul-symb-fancy math-mul-zero math-neg-fancy
math-neg-float math-okay-neg math-possible-signs math-possible-types
math-pow-fancy math-pow-mod math-pow-of-zero math-pow-zero
math-quarter-integer math-round math-setup-declarations math-sqr
math-sqr-float math-trunc-fancy math-trunc-special)

 ("calc-bin" calcFunc-and calcFunc-ash
calcFunc-clip calcFunc-diff calcFunc-lsh calcFunc-not calcFunc-or
calcFunc-rash calcFunc-rot calcFunc-rsh calcFunc-xor math-clip
math-compute-max-digits math-convert-radix-digits math-float-parts
math-format-bignum-binary math-format-bignum-hex
math-format-bignum-octal math-format-bignum-radix math-format-binary
math-format-radix math-format-radix-float math-integer-log2
math-power-of-2 math-radix-float-power)

 ("calc-comb"  calc-report-prime-test
calcFunc-choose calcFunc-dfact calcFunc-egcd calcFunc-fact
calcFunc-gcd calcFunc-lcm calcFunc-moebius calcFunc-nextprime
calcFunc-perm calcFunc-prevprime calcFunc-prfac calcFunc-prime
calcFunc-random calcFunc-shuffle calcFunc-stir1 calcFunc-stir2
calcFunc-totient math-init-random-base math-member math-prime-test
math-random-base)

 ("calccomp" calcFunc-cascent calcFunc-cdescent
calcFunc-cheight calcFunc-cwidth math-comp-ascent math-comp-descent
math-comp-height math-comp-width math-compose-expr
math-composition-to-string math-stack-value-offset-fancy
math-vector-is-string math-vector-to-string)

 ("calc-cplx" calcFunc-arg calcFunc-conj
calcFunc-im calcFunc-polar calcFunc-re calcFunc-rect math-complex
math-fix-circular math-imaginary math-imaginary-i math-normalize-polar
math-polar math-want-polar)

 ("calc-embed" calc-do-embedded
calc-do-embedded-activate calc-embedded-evaluate-expr
calc-embedded-modes-change calc-embedded-var-change)

 ("calc-fin" calc-to-percentage calcFunc-ddb
calcFunc-fv calcFunc-fvb calcFunc-fvl calcFunc-irr calcFunc-irrb
calcFunc-nper calcFunc-nperb calcFunc-nperl calcFunc-npv calcFunc-npvb
calcFunc-pmt calcFunc-pmtb calcFunc-pv calcFunc-pvb calcFunc-pvl
calcFunc-rate calcFunc-rateb calcFunc-ratel calcFunc-sln calcFunc-syd)

 ("calc-forms" calcFunc-badd calcFunc-bsub
calcFunc-date calcFunc-day calcFunc-dsadj calcFunc-hms
calcFunc-holiday calcFunc-hour calcFunc-incmonth calcFunc-incyear
calcFunc-intv calcFunc-julian calcFunc-makemod calcFunc-minute
calcFunc-month calcFunc-newmonth calcFunc-newweek calcFunc-newyear
calcFunc-now calcFunc-pwday calcFunc-sdev calcFunc-second
calcFunc-time calcFunc-tzconv calcFunc-tzone calcFunc-unixtime
calcFunc-weekday calcFunc-year calcFunc-yearday math-combine-intervals
math-date-parts math-date-to-dt math-div-mod math-dt-to-date
math-format-date math-from-business-day math-from-hms math-make-intv
math-make-mod math-make-sdev math-mod-intv math-normalize-hms
math-normalize-mod math-parse-date math-read-angle-brackets
math-setup-add-holidays math-setup-holidays math-setup-year-holidays
math-sort-intv math-to-business-day math-to-hms)

 ("calc-frac" calc-add-fractions
calc-div-fractions calc-mul-fractions calcFunc-fdiv calcFunc-frac
math-make-frac)

 ("calc-funcs" calc-prob-dist calcFunc-bern
calcFunc-besJ calcFunc-besY calcFunc-beta calcFunc-betaB
calcFunc-betaI calcFunc-erf calcFunc-erfc calcFunc-euler
calcFunc-gamma calcFunc-gammaG calcFunc-gammaP calcFunc-gammaQ
calcFunc-gammag calcFunc-ltpb calcFunc-ltpc calcFunc-ltpf
calcFunc-ltpn calcFunc-ltpp calcFunc-ltpt calcFunc-utpb calcFunc-utpc
calcFunc-utpf calcFunc-utpn calcFunc-utpp calcFunc-utpt
math-bernoulli-number math-gammap1-raw)

 ("calc-graph" calc-graph-show-tty)

 ("calc-incom" calc-digit-dots)

 ("calc-keypd" calc-do-keypad
calc-keypad-x-left-click calc-keypad-x-middle-click
calc-keypad-x-right-click)

 ("calc-lang" calc-set-language
math-read-big-balance math-read-big-rec)

 ("calc-map" calc-get-operator calcFunc-accum
calcFunc-afixp calcFunc-anest calcFunc-apply calcFunc-call
calcFunc-fixp calcFunc-inner calcFunc-map calcFunc-mapa calcFunc-mapc
calcFunc-mapd calcFunc-mapeq calcFunc-mapeqp calcFunc-mapeqr
calcFunc-mapr calcFunc-nest calcFunc-outer calcFunc-raccum
calcFunc-reduce calcFunc-reducea calcFunc-reducec calcFunc-reduced
calcFunc-reducer calcFunc-rreduce calcFunc-rreducea calcFunc-rreducec
calcFunc-rreduced calcFunc-rreducer math-build-call
math-calcFunc-to-var math-multi-subst math-multi-subst-rec
math-var-to-calcFunc)

 ("calc-mtx" calcFunc-det calcFunc-lud calcFunc-tr
math-col-matrix math-lud-solve math-matrix-inv-raw math-matrix-lud
math-mul-mat-vec math-mul-mats math-row-matrix)

 ("calc-math" calcFunc-alog calcFunc-arccos
calcFunc-arccosh calcFunc-arcsin calcFunc-arcsincos calcFunc-arcsinh
calcFunc-arctan calcFunc-arctan2 calcFunc-arctanh calcFunc-cos
calcFunc-cosh calcFunc-deg calcFunc-exp calcFunc-exp10 calcFunc-expm1
calcFunc-hypot calcFunc-ilog calcFunc-isqrt calcFunc-ln calcFunc-lnp1
calcFunc-log calcFunc-log10 calcFunc-nroot calcFunc-rad calcFunc-sin
calcFunc-sincos calcFunc-sinh calcFunc-sqr calcFunc-sqrt calcFunc-tan
calcFunc-tanh math-arccos-raw math-arcsin-raw math-arctan-raw
math-arctan2-raw math-cos-raw math-exp-minus-1-raw math-exp-raw
math-from-radians math-from-radians-2 math-hypot math-infinite-dir
math-isqrt-small math-ln-raw math-nearly-equal math-nearly-equal-float
math-nearly-zerop math-nearly-zerop-float math-nth-root
math-sin-cos-raw math-sin-raw math-sqrt math-sqrt-float math-sqrt-raw
math-tan-raw math-to-radians math-to-radians-2)

 ("calc-mode" math-get-modes-vec)

 ("calc-poly" calcFunc-apart calcFunc-expand
calcFunc-expandpow calcFunc-factor calcFunc-factors calcFunc-nrat
calcFunc-pcont calcFunc-pdeg calcFunc-pdiv calcFunc-pdivide
calcFunc-pdivrem calcFunc-pgcd calcFunc-plead calcFunc-pprim
calcFunc-prem math-accum-factors math-atomic-factorp
math-div-poly-const math-div-thru math-expand-power math-expand-term
math-factor-contains math-factor-expr math-factor-expr-part
math-factor-expr-try math-factor-finish math-factor-poly-coefs
math-factor-protect math-mul-thru math-padded-polynomial
math-partial-fractions math-poly-degree math-poly-deriv-coefs
math-poly-gcd-frac-list math-poly-modulus-rec math-ratpoly-p
math-to-ratpoly math-to-ratpoly-rec)

 ("calc-prog" calc-default-formula-arglist
calc-execute-kbd-macro calc-finish-user-syntax-edit
calc-fix-token-name calc-fix-user-formula calc-read-parse-table
calc-read-parse-table-part calc-subsetp calc-write-parse-table
calc-write-parse-table-part calcFunc-constant calcFunc-eq calcFunc-geq
calcFunc-gt calcFunc-if calcFunc-in calcFunc-integer calcFunc-istrue
calcFunc-land calcFunc-leq calcFunc-lnot calcFunc-lor calcFunc-lt
calcFunc-negative calcFunc-neq calcFunc-nonvar calcFunc-real
calcFunc-refers calcFunc-rmeq calcFunc-typeof calcFunc-variable
math-body-refers-to math-break math-composite-inequalities
math-do-defmath math-handle-for math-handle-foreach
math-normalize-logical-op math-return)

 ("calc-rewr" calcFunc-match calcFunc-matches
calcFunc-matchnot calcFunc-rewrite calcFunc-vmatches
math-apply-rewrites math-compile-patterns math-compile-rewrites
math-flatten-lands math-match-patterns math-rewrite
math-rewrite-heads)

 ("calc-rules" calc-CommuteRules calc-DistribRules calc-FactorRules
calc-FitRules calc-IntegAfterRules calc-InvertRules calc-JumpRules
calc-MergeRules calc-NegateRules
calc-compile-rule-set)

 ("calc-sel" calc-auto-selection
calc-delete-selection calc-encase-atoms calc-find-assoc-parent-formula
calc-find-parent-formula calc-find-sub-formula calc-prepare-selection
calc-preserve-point calc-replace-selections calc-replace-sub-formula
calc-roll-down-with-selections calc-roll-up-with-selections
calc-sel-error)

 ("calc-stat" calc-vector-op calcFunc-agmean
calcFunc-vcorr calcFunc-vcount calcFunc-vcov calcFunc-vflat
calcFunc-vgmean calcFunc-vhmean calcFunc-vmax calcFunc-vmean
calcFunc-vmeane calcFunc-vmedian calcFunc-vmin calcFunc-vpcov
calcFunc-vprod calcFunc-vpsdev calcFunc-vpvar calcFunc-vsdev
calcFunc-vsum calcFunc-vvar math-flatten-many-vecs)

 ("calc-store" calc-read-var-name
calc-store-value calc-var-name)

 ("calc-stuff" calc-explain-why calcFunc-clean
calcFunc-pclean calcFunc-pfloat calcFunc-pfrac)

 ("calc-units" calcFunc-usimplify
math-build-units-table math-build-units-table-buffer
math-check-unit-name math-convert-temperature math-convert-units
math-extract-units math-remove-units math-simplify-units
math-single-units-in-expr-p math-to-standard-units
math-units-in-expr-p)

 ("calc-vec" calcFunc-append calcFunc-appendrev
calcFunc-arrange calcFunc-cnorm calcFunc-cons calcFunc-cross
calcFunc-ctrn calcFunc-cvec calcFunc-diag calcFunc-find
calcFunc-getdiag calcFunc-grade calcFunc-head calcFunc-histogram
calcFunc-idn calcFunc-index calcFunc-mcol calcFunc-mdims
calcFunc-mrcol calcFunc-mrow calcFunc-mrrow calcFunc-pack
calcFunc-rcons calcFunc-rdup calcFunc-rev calcFunc-rgrade
calcFunc-rhead calcFunc-rnorm calcFunc-rsort calcFunc-rsubvec
calcFunc-rtail calcFunc-sort calcFunc-subscr calcFunc-subvec
calcFunc-tail calcFunc-trn calcFunc-unpack calcFunc-unpackt
calcFunc-vcard calcFunc-vcompl calcFunc-vconcat calcFunc-vconcatrev
calcFunc-vdiff calcFunc-vec calcFunc-venum calcFunc-vexp
calcFunc-vfloor calcFunc-vint calcFunc-vlen calcFunc-vmask
calcFunc-vpack calcFunc-vspan calcFunc-vunion calcFunc-vunpack
calcFunc-vxor math-check-for-commas math-clean-set math-copy-matrix
math-dimension-error math-dot-product math-flatten-vector math-map-vec
math-map-vec-2 math-mat-col math-mimic-ident math-prepare-set
math-read-brackets math-reduce-cols math-reduce-vec math-transpose)

 ("calc-yank" calc-alg-edit calc-clean-newlines
calc-do-grab-rectangle calc-do-grab-region calc-finish-stack-edit
calc-force-refresh calc-locate-cursor-element calc-show-edit-buffer)

))

  (mapcar (function (lambda (x)
    (mapcar (function (lambda (cmd)
      (autoload cmd (car x) nil t))) (cdr x))))
    '(

 ("calc-alg" calc-alg-evaluate calc-apart calc-collect calc-expand
calc-expand-formula calc-factor calc-normalize-rat calc-poly-div
calc-poly-div-rem calc-poly-gcd calc-poly-rem calc-simplify
calc-simplify-extended calc-substitute)

 ("calcalg2" calc-alt-summation calc-derivative
calc-dump-integral-cache calc-integral calc-num-integral
calc-poly-roots calc-product calc-solve-for calc-summation
calc-tabulate calc-taylor)

 ("calcalg3" calc-curve-fit calc-find-maximum calc-find-minimum
calc-find-root calc-poly-interp)

 ("calc-arith" calc-abs calc-abssqr calc-ceiling calc-decrement
calc-floor calc-idiv calc-increment calc-mant-part calc-max calc-min
calc-round calc-scale-float calc-sign calc-trunc calc-xpon-part)

 ("calc-bin" calc-and calc-binary-radix calc-clip calc-decimal-radix
calc-diff calc-hex-radix calc-leading-zeros calc-lshift-arith
calc-lshift-binary calc-not calc-octal-radix calc-or calc-radix
calc-rotate-binary calc-rshift-arith calc-rshift-binary calc-word-size
calc-xor)

 ("calc-comb" calc-choose calc-double-factorial calc-extended-gcd
calc-factorial calc-gamma calc-gcd calc-lcm calc-moebius
calc-next-prime calc-perm calc-prev-prime calc-prime-factors
calc-prime-test calc-random calc-random-again calc-rrandom
calc-shuffle calc-totient)

 ("calc-cplx" calc-argument calc-complex-notation calc-i-notation
calc-im calc-j-notation calc-polar calc-polar-mode calc-re)

 ("calc-embed" calc-embedded-copy-formula-as-kill
calc-embedded-duplicate calc-embedded-edit calc-embedded-forget
calc-embedded-kill-formula calc-embedded-mark-formula
calc-embedded-new-formula calc-embedded-next calc-embedded-previous
calc-embedded-select calc-embedded-update-formula calc-embedded-word
calc-find-globals calc-show-plain)

 ("calc-fin" calc-convert-percent calc-fin-ddb calc-fin-fv
calc-fin-irr calc-fin-nper calc-fin-npv calc-fin-pmt calc-fin-pv
calc-fin-rate calc-fin-sln calc-fin-syd calc-percent-change)

 ("calc-forms" calc-business-days-minus calc-business-days-plus
calc-convert-time-zones calc-date calc-date-notation calc-date-part
calc-from-hms calc-hms-mode calc-hms-notation calc-inc-month
calc-julian calc-new-month calc-new-week calc-new-year calc-now
calc-time calc-time-zone calc-to-hms calc-unix-time)

 ("calc-frac" calc-fdiv calc-frac-mode calc-fraction
calc-over-notation calc-slash-notation)

 ("calc-funcs" calc-bernoulli-number calc-bessel-J calc-bessel-Y
calc-beta calc-erf calc-erfc calc-euler-number calc-inc-beta
calc-inc-gamma calc-stirling-number calc-utpb calc-utpc calc-utpf
calc-utpn calc-utpp calc-utpt)

 ("calc-graph" calc-graph-add calc-graph-add-3d calc-graph-border
calc-graph-clear calc-graph-command calc-graph-delete
calc-graph-device calc-graph-display calc-graph-fast
calc-graph-fast-3d calc-graph-geometry calc-graph-grid
calc-graph-header calc-graph-hide calc-graph-juggle calc-graph-key
calc-graph-kill calc-graph-line-style calc-graph-log-x
calc-graph-log-y calc-graph-log-z calc-graph-name
calc-graph-num-points calc-graph-output calc-graph-plot
calc-graph-point-style calc-graph-print calc-graph-quit
calc-graph-range-x calc-graph-range-y calc-graph-range-z
calc-graph-show-dumb calc-graph-title-x calc-graph-title-y
calc-graph-title-z calc-graph-view-commands calc-graph-view-trail
calc-graph-zero-x calc-graph-zero-y)

 ("calc-help" calc-a-prefix-help calc-b-prefix-help calc-c-prefix-help
calc-d-prefix-help calc-describe-function calc-describe-key
calc-describe-key-briefly calc-describe-variable calc-f-prefix-help
calc-full-help calc-g-prefix-help calc-help-prefix
calc-hyperbolic-prefix-help calc-inv-hyp-prefix-help
calc-inverse-prefix-help calc-j-prefix-help calc-k-prefix-help
calc-m-prefix-help calc-r-prefix-help calc-s-prefix-help
calc-t-prefix-help calc-u-prefix-help calc-v-prefix-help)

 ("calc-incom" calc-begin-complex calc-begin-vector calc-comma
calc-dots calc-end-complex calc-end-vector calc-semi)

 ("calc-keypd" calc-keypad-menu calc-keypad-menu-back
calc-keypad-press)

 ("calc-lang" calc-big-language calc-c-language calc-eqn-language
calc-flat-language calc-fortran-language calc-maple-language
calc-mathematica-language calc-normal-language calc-pascal-language
calc-tex-language calc-unformatted-language)

 ("calc-map" calc-accumulate calc-apply calc-inner-product calc-map
calc-map-equation calc-map-stack calc-outer-product calc-reduce)

 ("calc-mtx" calc-mdet calc-mlud calc-mtrace)

 ("calc-math" calc-arccos calc-arccosh calc-arcsin calc-arcsinh
calc-arctan calc-arctan2 calc-arctanh calc-conj calc-cos calc-cosh
calc-degrees-mode calc-exp calc-expm1 calc-hypot calc-ilog
calc-imaginary calc-isqrt calc-ln calc-lnp1 calc-log calc-log10
calc-pi calc-radians-mode calc-sin calc-sincos calc-sinh calc-sqrt
calc-tan calc-tanh calc-to-degrees calc-to-radians)

 ("calc-mode" calc-alg-simplify-mode calc-algebraic-mode
calc-always-load-extensions calc-auto-recompute calc-auto-why
calc-bin-simplify-mode calc-break-vectors calc-center-justify
calc-default-simplify-mode calc-display-raw calc-eng-notation
calc-ext-simplify-mode calc-fix-notation calc-full-trail-vectors
calc-full-vectors calc-get-modes calc-group-char calc-group-digits
calc-infinite-mode calc-left-justify calc-left-label
calc-line-breaking calc-line-numbering calc-matrix-brackets
calc-matrix-center-justify calc-matrix-left-justify calc-matrix-mode
calc-matrix-right-justify calc-mode-record-mode calc-no-simplify-mode
calc-normal-notation calc-num-simplify-mode calc-point-char
calc-right-justify calc-right-label calc-save-modes calc-sci-notation
calc-settings-file-name calc-shift-prefix calc-symbolic-mode
calc-total-algebraic-mode calc-truncate-down calc-truncate-stack
calc-truncate-up calc-units-simplify-mode calc-vector-braces
calc-vector-brackets calc-vector-commas calc-vector-parens
calc-working)

 ("calc-prog" calc-call-last-kbd-macro calc-edit-user-syntax
calc-equal-to calc-get-user-defn calc-greater-equal calc-greater-than
calc-in-set calc-kbd-break calc-kbd-else calc-kbd-else-if
calc-kbd-end-for calc-kbd-end-if calc-kbd-end-loop calc-kbd-end-repeat
calc-kbd-for calc-kbd-if calc-kbd-loop calc-kbd-pop calc-kbd-push
calc-kbd-query calc-kbd-repeat calc-kbd-report calc-less-equal
calc-less-than calc-logical-and calc-logical-if calc-logical-not
calc-logical-or calc-not-equal-to calc-pass-errors calc-remove-equal
calc-timing calc-user-define calc-user-define-composition
calc-user-define-edit calc-user-define-formula
calc-user-define-invocation calc-user-define-kbd-macro
calc-user-define-permanent calc-user-undefine)

 ("calc-rewr" calc-match calc-rewrite calc-rewrite-selection)

 ("calc-sel" calc-break-selections calc-clear-selections
calc-copy-selection calc-del-selection calc-edit-selection
calc-enable-selections calc-enter-selection calc-sel-add-both-sides
calc-sel-div-both-sides calc-sel-evaluate calc-sel-expand-formula
calc-sel-mult-both-sides calc-sel-sub-both-sides
calc-select-additional calc-select-here calc-select-here-maybe
calc-select-less calc-select-more calc-select-next calc-select-once
calc-select-once-maybe calc-select-part calc-select-previous
calc-show-selections calc-unselect)

 ("calcsel2" calc-commute-left calc-commute-right calc-sel-commute
calc-sel-distribute calc-sel-invert calc-sel-isolate
calc-sel-jump-equals calc-sel-merge calc-sel-negate calc-sel-unpack)

 ("calc-stat" calc-vector-correlation calc-vector-count
calc-vector-covariance calc-vector-geometric-mean
calc-vector-harmonic-mean calc-vector-max calc-vector-mean
calc-vector-mean-error calc-vector-median calc-vector-min
calc-vector-pop-covariance calc-vector-pop-sdev
calc-vector-pop-variance calc-vector-product calc-vector-sdev
calc-vector-sum calc-vector-variance)

 ("calc-store" calc-assign calc-copy-variable calc-declare-variable
calc-edit-AlgSimpRules calc-edit-Decls calc-edit-EvalRules
calc-edit-ExtSimpRules calc-edit-FitRules calc-edit-GenCount
calc-edit-Holidays calc-edit-IntegLimit calc-edit-LineStyles
calc-edit-PlotRejects calc-edit-PointStyles calc-edit-TimeZone
calc-edit-Units calc-edit-variable calc-evalto calc-insert-variables
calc-let calc-permanent-variable calc-recall calc-recall-quick
calc-store calc-store-concat calc-store-decr calc-store-div
calc-store-exchange calc-store-incr calc-store-into
calc-store-into-quick calc-store-inv calc-store-map calc-store-minus
calc-store-neg calc-store-plus calc-store-power calc-store-quick
calc-store-times calc-subscript calc-unstore)

 ("calc-stuff" calc-clean calc-clean-num calc-flush-caches
calc-less-recursion-depth calc-more-recursion-depth calc-num-prefix
calc-version calc-why)

 ("calc-trail" calc-trail-backward calc-trail-first calc-trail-forward
calc-trail-in calc-trail-isearch-backward calc-trail-isearch-forward
calc-trail-kill calc-trail-last calc-trail-marker calc-trail-next
calc-trail-out calc-trail-previous calc-trail-scroll-left
calc-trail-scroll-right calc-trail-yank)

 ("calc-undo" calc-last-args calc-redo calc-undo)

 ("calc-units" calc-autorange-units calc-base-units
calc-convert-temperature calc-convert-units calc-define-unit
calc-enter-units-table calc-explain-units calc-extract-units
calc-get-unit-definition calc-permanent-units calc-quick-units
calc-remove-units calc-simplify-units calc-undefine-unit
calc-view-units-table)

 ("calc-vec" calc-arrange-vector calc-build-vector calc-cnorm
calc-conj-transpose calc-cons calc-cross calc-diag
calc-display-strings calc-expand-vector calc-grade calc-head
calc-histogram calc-ident calc-index calc-mask-vector calc-mcol
calc-mrow calc-pack calc-pack-bits calc-remove-duplicates
calc-reverse-vector calc-rnorm calc-set-cardinality
calc-set-complement calc-set-difference calc-set-enumerate
calc-set-floor calc-set-intersect calc-set-span calc-set-union
calc-set-xor calc-sort calc-subvector calc-tail calc-transpose
calc-unpack calc-unpack-bits calc-vector-find calc-vlength)

 ("calc-yank" calc-copy-as-kill calc-copy-region-as-kill
calc-copy-to-buffer calc-edit calc-edit-cancel calc-edit-mode
calc-kill calc-kill-region calc-yank))))

(defun calc-init-prefixes ()
  (if calc-shift-prefix
      (progn
        (define-key calc-mode-map "A" (lookup-key calc-mode-map "a"))
        (define-key calc-mode-map "B" (lookup-key calc-mode-map "b"))
        (define-key calc-mode-map "C" (lookup-key calc-mode-map "c"))
        (define-key calc-mode-map "D" (lookup-key calc-mode-map "d"))
        (define-key calc-mode-map "F" (lookup-key calc-mode-map "f"))
        (define-key calc-mode-map "G" (lookup-key calc-mode-map "g"))
        (define-key calc-mode-map "J" (lookup-key calc-mode-map "j"))
        (define-key calc-mode-map "K" (lookup-key calc-mode-map "k"))
        (define-key calc-mode-map "M" (lookup-key calc-mode-map "m"))
        (define-key calc-mode-map "S" (lookup-key calc-mode-map "s"))
        (define-key calc-mode-map "T" (lookup-key calc-mode-map "t"))
        (define-key calc-mode-map "U" (lookup-key calc-mode-map "u")))
    (define-key calc-mode-map "A" 'calc-abs)
    (define-key calc-mode-map "B" 'calc-log)
    (define-key calc-mode-map "C" 'calc-cos)
    (define-key calc-mode-map "D" 'calc-redo)
    (define-key calc-mode-map "F" 'calc-floor)
    (define-key calc-mode-map "G" 'calc-argument)
    (define-key calc-mode-map "J" 'calc-conj)
    (define-key calc-mode-map "K" 'calc-keep-args)
    (define-key calc-mode-map "M" 'calc-more-recursion-depth)
    (define-key calc-mode-map "S" 'calc-sin)
    (define-key calc-mode-map "T" 'calc-tan)
    (define-key calc-mode-map "U" 'calc-undo)))

(calc-init-extensions)




;;;; Miscellaneous.

;; calc-command-flags is declared in calc.el
(defvar calc-command-flags)

(defun calc-clear-command-flag (f)
  (setq calc-command-flags (delq f calc-command-flags)))


(defun calc-record-message (tag &rest args)
  (let ((msg (apply 'format args)))
    (message "%s" msg)
    (calc-record msg tag))
  (calc-clear-command-flag 'clear-message))


(defun calc-normalize-fancy (val)
  (let ((simp (if (consp calc-simplify-mode)
                  (car calc-simplify-mode)
                calc-simplify-mode)))
    (cond ((eq simp 'binary)
           (let ((s (math-normalize val)))
             (if (math-realp s)
                 (math-clip (math-round s))
               s)))
          ((eq simp 'alg)
           (math-simplify val))
          ((eq simp 'ext)
           (math-simplify-extended val))
          ((eq simp 'units)
           (math-simplify-units val))
          (t  ; nil, none, num
           (math-normalize val)))))



(if (boundp 'calc-help-map)
    nil
  (setq calc-help-map (make-keymap))
  (define-key calc-help-map "b" 'calc-describe-bindings)
  (define-key calc-help-map "c" 'calc-describe-key-briefly)
  (define-key calc-help-map "f" 'calc-describe-function)
  (define-key calc-help-map "h" 'calc-full-help)
  (define-key calc-help-map "i" 'calc-info)
  (define-key calc-help-map "k" 'calc-describe-key)
  (define-key calc-help-map "n" 'calc-view-news)
  (define-key calc-help-map "s" 'calc-info-summary)
  (define-key calc-help-map "t" 'calc-tutorial)
  (define-key calc-help-map "v" 'calc-describe-variable)
  (define-key calc-help-map "\C-c" 'calc-describe-copying)
  (define-key calc-help-map "\C-d" 'calc-describe-distribution)
  (define-key calc-help-map "\C-n" 'calc-view-news)
  (define-key calc-help-map "\C-w" 'calc-describe-no-warranty)
  (define-key calc-help-map "?" 'calc-help-for-help)
  (define-key calc-help-map "\C-h" 'calc-help-for-help))

(defvar calc-prefix-help-phase 0)
(defun calc-do-prefix-help (msgs group key)
  (if calc-full-help-flag
      (list msgs group key)
    (if (cdr msgs)
        (progn
          (setq calc-prefix-help-phase
                (if (eq this-command last-command)
                    (% (1+ calc-prefix-help-phase) (1+ (length msgs)))
                  0))
          (let ((msg (nth calc-prefix-help-phase msgs)))
            (message "%s" (if msg
                              (concat group ": " msg ":"
                                      (make-string
                                       (- (apply 'max (mapcar 'length msgs))
                                          (length msg)) 32)
                                      "  [MORE]"
                                      (if key
                                          (concat "  " (char-to-string key)
                                                  "-")
                                        ""))
                            (if key (format "%c-" key) "")))))
      (setq calc-prefix-help-phase 0)
      (if key
          (if msgs
              (message "%s: %s: %c-" group (car msgs) key)
            (message "%s: (none)  %c-" group key))
        (message "%s: %s" group (car msgs))))
    (and key (calc-unread-command key))))

;;;; Commands.


;;; General.

(defun calc-reset (arg)
  (interactive "P")
  (save-excursion
    (or (eq major-mode 'calc-mode)
        (calc-create-buffer))
    (if calc-embedded-info
        (calc-embedded nil))
    (or arg
        (setq calc-stack nil))
    (setq calc-undo-list nil
          calc-redo-list nil)
    (let (calc-stack calc-user-parse-tables calc-standard-date-formats
                     calc-invocation-macro)
      (mapcar (function (lambda (v) (set v nil))) calc-local-var-list)
      (mapcar (function (lambda (v) (set (car v) (nth 1 v))))
              calc-mode-var-list))
    (calc-set-language nil nil t)
    (calc-mode)
    (calc-flush-caches t)
    (run-hooks 'calc-reset-hook))
  (calc-wrapper
   (let ((win (get-buffer-window (current-buffer))))
     (calc-realign 0)
     (if win
         (let ((height (- (window-height win) 2)))
           (set-window-point win (point))
           (or (= height calc-window-height)
               (let ((swin (selected-window)))
                 (select-window win)
                 (enlarge-window (- calc-window-height height))
                 (select-window swin)))))))
  (message "(Calculator reset)"))

;; What a pain; scroll-left behaves differently when called non-interactively.
(defun calc-scroll-left (n)
  (interactive "P")
  (setq prefix-arg (or n (/ (window-width) 2)))
  (call-interactively #'scroll-left))

(defun calc-scroll-right (n)
  (interactive "P")
  (setq prefix-arg (or n (/ (window-width) 2)))
  (call-interactively #'scroll-right))

(defun calc-scroll-up (n)
  (interactive "P")
  (condition-case err
      (scroll-up (or n (/ (window-height) 2)))
    (error nil))
  (if (pos-visible-in-window-p (max 1 (- (point-max) 2)))
      (if (eq major-mode 'calc-mode)
          (calc-realign)
        (goto-char (point-max))
        (set-window-start (selected-window)
                          (save-excursion
                            (forward-line (- (1- (window-height))))
                            (point)))
        (forward-line -1))))

(defun calc-scroll-down (n)
  (interactive "P")
  (or (pos-visible-in-window-p 1)
      (scroll-down (or n (/ (window-height) 2)))))


(defun calc-precision (n)
  (interactive "NPrecision: ")
  (calc-wrapper
   (if (< (prefix-numeric-value n) 3)
       (error "Precision must be at least 3 digits")
     (calc-change-mode 'calc-internal-prec (prefix-numeric-value n)
                       (and (memq (car calc-float-format) '(float sci eng))
                            (< (nth 1 calc-float-format)
                                (if (= calc-number-radix 10) 0 1))))
     (calc-record calc-internal-prec "prec"))
   (message "Floating-point precision is %d digits" calc-internal-prec)))


(defun calc-inverse (&optional n)
  (interactive "P")
  (let* ((hyp-flag (if (eq major-mode 'calc-keypad-mode)
                       (with-current-buffer calc-main-buffer
                         calc-hyperbolic-flag)
                     calc-hyperbolic-flag))
         (msg (if hyp-flag 
                 "Inverse Hyperbolic..."
               "Inverse...")))
    (calc-fancy-prefix 'calc-inverse-flag msg n)))

(defconst calc-fancy-prefix-map
  (let ((map (make-sparse-keymap)))
    (define-key map [t] 'calc-fancy-prefix-other-key)
    (define-key map (vector meta-prefix-char t) 'calc-fancy-prefix-other-key)
    (define-key map [switch-frame] nil)
    (define-key map [?\C-u] 'universal-argument)
    (define-key map [?0] 'digit-argument)
    (define-key map [?1] 'digit-argument)
    (define-key map [?2] 'digit-argument)
    (define-key map [?3] 'digit-argument)
    (define-key map [?4] 'digit-argument)
    (define-key map [?5] 'digit-argument)
    (define-key map [?6] 'digit-argument)
    (define-key map [?7] 'digit-argument)
    (define-key map [?8] 'digit-argument)
    (define-key map [?9] 'digit-argument)
    map)
  "Keymap used while processing calc-fancy-prefix.")

(defvar calc-is-keypad-press nil)
(defun calc-fancy-prefix (flag msg n)
  (let (prefix)
    (calc-wrapper
     (calc-set-command-flag 'keep-flags)
     (calc-set-command-flag 'no-align)
     (setq prefix (set flag (not (symbol-value flag)))
           prefix-arg n)
     (message (if prefix msg "")))
    (and prefix
         (not calc-is-keypad-press)
         (if (boundp 'overriding-terminal-local-map)
             (setq overriding-terminal-local-map calc-fancy-prefix-map)
           (let ((event (calc-read-key t)))
             (if (eq (setq last-command-char (car event)) ?\C-u)
                 (universal-argument)
               (if (or (not (integerp last-command-char))
                       (and (>= last-command-char 0) (< last-command-char ? )
                            (not (memq last-command-char '(?\e)))))
                   (calc-wrapper))  ; clear flags if not a Calc command.
               (setq last-command-event (cdr event))
               (if (or (not (integerp last-command-char))
                       (eq last-command-char ?-))
                   (calc-unread-command)
                 (digit-argument n))))))))

(defun calc-fancy-prefix-other-key (arg)
  (interactive "P")
  (if (or (not (integerp last-command-char))
          (and (>= last-command-char 0) (< last-command-char ? )
               (not (eq last-command-char meta-prefix-char))))
     (calc-wrapper))  ; clear flags if not a Calc command.
  (calc-unread-command)
  (setq overriding-terminal-local-map nil))

(defun calc-invert-func ()
  (save-excursion
    (calc-select-buffer)
    (setq calc-inverse-flag (not (calc-is-inverse))
          calc-hyperbolic-flag (calc-is-hyperbolic)
          current-prefix-arg nil)))

(defun calc-is-inverse ()
  calc-inverse-flag)

(defun calc-hyperbolic (&optional n)
  (interactive "P")
  (let* ((inv-flag (if (eq major-mode 'calc-keypad-mode)
                       (with-current-buffer calc-main-buffer
                         calc-inverse-flag)
                     calc-inverse-flag))
         (msg (if inv-flag 
                  "Inverse Hyperbolic..."
                "Hyperbolic...")))
    (calc-fancy-prefix 'calc-hyperbolic-flag msg n)))

(defun calc-hyperbolic-func ()
  (save-excursion
    (calc-select-buffer)
    (setq calc-inverse-flag (calc-is-inverse)
          calc-hyperbolic-flag (not (calc-is-hyperbolic))
          current-prefix-arg nil)))

(defun calc-is-hyperbolic ()
  calc-hyperbolic-flag)

(defun calc-keep-args (&optional n)
  (interactive "P")
  (calc-fancy-prefix 'calc-keep-args-flag "Keep args..." n))


(defun calc-change-mode (var value &optional refresh option)
  (if option
      (setq value (if value
                      (> (prefix-numeric-value value) 0)
                    (not (symbol-value var)))))
  (or (consp var) (setq var (list var) value (list value)))
  (if calc-inverse-flag
      (let ((old nil))
        (or refresh (error "Not a display-mode command"))
        (calc-check-stack 1)
        (unwind-protect
            (let ((v var))
              (while v
                (setq old (cons (symbol-value (car v)) old))
                (set (car v) (car value))
                (setq v (cdr v)
                      value (cdr value)))
              (calc-refresh-top 1)
              (calc-refresh-evaltos)
              (symbol-value (car var)))
          (let ((v var))
            (setq old (nreverse old))
            (while v
              (set (car v) (car old))
              (setq v (cdr v)
                    old (cdr old)))
            (if (eq (car var) 'calc-language)
                (calc-set-language calc-language calc-language-option t)))))
    (let ((chg nil)
          (v var))
      (while v
        (or (equal (symbol-value (car v)) (car value))
            (progn
              (set (car v) (car value))
              (if (eq (car v) 'calc-float-format)
                  (setq calc-full-float-format
                        (list (if (eq (car (car value)) 'fix)
                                  'float
                                (car (car value)))
                              0)))
              (setq chg t)))
        (setq v (cdr v)
              value (cdr value)))
      (if chg
          (progn
            (or (and refresh (calc-do-refresh))
                (calc-refresh-evaltos))
            (and (eq calc-mode-save-mode 'save)
                 (not (equal var '(calc-mode-save-mode)))
                 (calc-save-modes))))
      (if calc-embedded-info (calc-embedded-modes-change var))
      (symbol-value (car var)))))

(defun calc-toggle-banner ()
  "Toggle display of the friendly greeting calc normally shows above the stack."
  (interactive)
  (setq calc-show-banner (not calc-show-banner))
  (calc-refresh))

(defun calc-refresh-top (n)
  (interactive "p")
  (calc-wrapper
   (cond ((< n 0)
          (setq n (- n))
          (let ((entry (calc-top n 'entry))
                (calc-undo-list nil) (calc-redo-list nil))
            (calc-pop-stack 1 n t)
            (calc-push-list (list (car entry)) n (list (nth 2 entry)))))
         ((= n 0)
          (calc-refresh))
         (t
          (let ((entries (calc-top-list n 1 'entry))
                (calc-undo-list nil) (calc-redo-list nil))
            (calc-pop-stack n 1 t)
            (calc-push-list (mapcar 'car entries)
                            1
                            (mapcar (function (lambda (x) (nth 2 x)))
                                    entries)))))))

(defvar calc-refreshing-evaltos nil)
(defvar calc-no-refresh-evaltos nil)
(defun calc-refresh-evaltos (&optional which-var)
  (and calc-any-evaltos calc-auto-recompute (not calc-no-refresh-evaltos)
       (let ((calc-refreshing-evaltos t)
             (num (calc-stack-size))
             (calc-undo-list nil) (calc-redo-list nil)
             value new-val)
         (while (> num 0)
           (setq value (calc-top num 'entry))
           (if (and (not (nth 2 value))
                    (setq value (car value))
                    (or (eq (car-safe value) 'calcFunc-evalto)
                        (and (eq (car-safe value) 'vec)
                             (eq (car-safe (nth 1 value)) 'calcFunc-evalto))))
               (progn
                 (setq new-val (math-normalize value))
                 (or (equal new-val value)
                     (progn
                       (calc-push-list (list new-val) num)
                       (calc-pop-stack 1 (1+ num) t)))))
           (setq num (1- num)))))
  (and calc-embedded-active which-var
       (calc-embedded-var-change which-var)))

(defun calc-push (&rest vals)
  (calc-push-list vals))

(defun calc-pop-push (n &rest vals)
  (calc-pop-push-list n vals))

(defun calc-pop-push-record (n prefix &rest vals)
  (calc-pop-push-record-list n prefix vals))


(defun calc-evaluate (n)
  (interactive "p")
  (calc-slow-wrapper
   (if (= n 0)
       (setq n (calc-stack-size)))
   (calc-with-default-simplification
    (if (< n 0)
        (calc-pop-push-record-list 1 "eval"
                                   (math-evaluate-expr (calc-top (- n)))
                                   (- n))
      (calc-pop-push-record-list n "eval" (mapcar 'math-evaluate-expr
                                                  (calc-top-list n)))))
   (calc-handle-whys)))


(defun calc-eval-num (n)
  (interactive "P")
  (calc-slow-wrapper
   (let* ((nn (prefix-numeric-value n))
          (calc-internal-prec (cond ((>= nn 3) nn)
                                    ((< nn 0) (max (+ calc-internal-prec nn)
                                                   3))
                                    (t calc-internal-prec)))
          (calc-symbolic-mode nil))
     (calc-with-default-simplification
      (calc-pop-push-record 1 "num" (math-evaluate-expr (calc-top 1)))))
   (calc-handle-whys)))


(defun calc-execute-extended-command (n)
  (interactive "P")
  (let* ((prompt (concat (calc-num-prefix-name n) "M-x "))
         (cmd (intern (completing-read prompt obarray 'commandp t "calc-"))))
    (setq prefix-arg n)
    (command-execute cmd)))


(defun calc-realign (&optional num)
  (interactive "P")
  (if (and num (eq major-mode 'calc-mode))
      (progn
        (calc-check-stack num)
        (calc-cursor-stack-index num)
        (and calc-line-numbering
             (forward-char 4)))
    (if (and calc-embedded-info
             (eq (current-buffer) (aref calc-embedded-info 0)))
        (progn
          (goto-char (aref calc-embedded-info 2))
          (if (save-excursion (set-buffer (aref calc-embedded-info 1))
                              calc-show-plain)
              (forward-line 1)))
      (calc-wrapper
       (if (get-buffer-window (current-buffer))
           (set-window-hscroll (get-buffer-window (current-buffer)) 0))))))

(defvar math-cache-list nil)

(defun calc-var-value (v)
  (and (symbolp v)
       (boundp v)
       (symbol-value v)
       (if (symbolp (symbol-value v))
           (set v (funcall (symbol-value v)))
         (if (stringp (symbol-value v))
             (let ((val (math-read-expr (symbol-value v))))
               (if (eq (car-safe val) 'error)
                   (error "Bad format in variable contents: %s" (nth 2 val))
                 (set v val)))
           (symbol-value v)))))

;;; In the following table, ( OP LOPS ROPS ) means that if an OP
;;; term appears as the first argument to any LOPS term, or as the
;;; second argument to any ROPS term, then they should be treated
;;; as one large term for purposes of associative selection.
(defconst calc-assoc-ops '( ( + ( + - ) ( + ) )
                            ( - ( + - ) ( + ) )
                            ( * ( * )   ( * ) )
                            ( / ( / )   (   ) )
                            ( | ( | )   ( | ) )
                            ( calcFunc-land ( calcFunc-land )
                                            ( calcFunc-land ) )
                            ( calcFunc-lor ( calcFunc-lor )
                                           ( calcFunc-lor ) ) ))


(defvar var-CommuteRules 'calc-CommuteRules)
(defvar var-JumpRules    'calc-JumpRules)
(defvar var-DistribRules 'calc-DistribRules)
(defvar var-MergeRules   'calc-MergeRules)
(defvar var-NegateRules  'calc-NegateRules)
(defvar var-InvertRules  'calc-InvertRules)


(defconst calc-tweak-eqn-table '( ( calcFunc-eq  calcFunc-eq  calcFunc-neq )
                                  ( calcFunc-neq calcFunc-neq calcFunc-eq  )
                                  ( calcFunc-lt  calcFunc-gt  calcFunc-geq )
                                  ( calcFunc-gt  calcFunc-lt  calcFunc-leq )
                                  ( calcFunc-leq calcFunc-geq calcFunc-gt  )
                                  ( calcFunc-geq calcFunc-leq calcFunc-lt  ) ))




(defun calc-float (arg)
  (interactive "P")
  (calc-slow-wrapper
   (calc-unary-op "flt"
                  (if (calc-is-hyperbolic) 'calcFunc-float 'calcFunc-pfloat)
                  arg)))


(defvar calc-gnuplot-process nil)
(defvar calc-gnuplot-input)
(defvar calc-gnuplot-buffer)

(defun calc-gnuplot-alive ()
  (and calc-gnuplot-process
       calc-gnuplot-buffer
       (buffer-name calc-gnuplot-buffer)
       calc-gnuplot-input
       (buffer-name calc-gnuplot-input)
       (memq (process-status calc-gnuplot-process) '(run stop))))





(defun calc-load-everything ()
  (interactive)
  (require 'calc-aent)
  (require 'calc-alg)
  (require 'calc-arith)
  (require 'calc-bin)
  (require 'calc-comb)
  (require 'calc-cplx)
  (require 'calc-embed)
  (require 'calc-fin)
  (require 'calc-forms)
  (require 'calc-frac)
  (require 'calc-funcs)
  (require 'calc-graph)
  (require 'calc-help)
  (require 'calc-incom)
  (require 'calc-keypd)
  (require 'calc-lang)
  (require 'calc-macs)
  (require 'calc-map)
  (require 'calc-math)
  (require 'calc-misc)
  (require 'calc-mode)
  (require 'calc-mtx)
  (require 'calc-poly)
  (require 'calc-prog)
  (require 'calc-rewr)
  (require 'calc-rules)
  (require 'calc-sel)
  (require 'calc-stat)
  (require 'calc-store)
  (require 'calc-stuff)
  (require 'calc-trail)
  (require 'calc-undo)
  (require 'calc-units)
  (require 'calc-vec)
  (require 'calc-yank)
  (require 'calcalg2)
  (require 'calcalg3)
  (require 'calccomp)
  (require 'calcsel2)

  (message "All parts of Calc are now loaded"))


;;; Vector commands.

(defun calc-concat (arg)
  (interactive "P")
  (calc-wrapper
   (if (calc-is-inverse)
       (if (calc-is-hyperbolic)
           (calc-enter-result 2 "apnd" (list 'calcFunc-append
                                          (calc-top 1) (calc-top 2)))
         (calc-enter-result 2 "|" (list 'calcFunc-vconcat
                                        (calc-top 1) (calc-top 2))))
     (if (calc-is-hyperbolic)
         (calc-binary-op "apnd" 'calcFunc-append arg '(vec))
       (calc-binary-op "|" 'calcFunc-vconcat arg '(vec) nil '|)))))

(defun calc-append (arg)
  (interactive "P")
  (calc-hyperbolic-func)
  (calc-concat arg))


(defconst calc-arg-values '( ( var ArgA var-ArgA ) ( var ArgB var-ArgB )
                             ( var ArgC var-ArgC ) ( var ArgD var-ArgD )
                             ( var ArgE var-ArgE ) ( var ArgF var-ArgF )
                             ( var ArgG var-ArgG ) ( var ArgH var-ArgH )
                             ( var ArgI var-ArgI ) ( var ArgJ var-ArgJ )
))

(defun calc-invent-args (n)
  (nreverse (nthcdr (- (length calc-arg-values) n) (reverse calc-arg-values))))




;;; User menu.

(defun calc-user-key-map ()
  (if calc-emacs-type-lucid
      (error "User-defined keys are not supported in Lucid Emacs"))
  (let ((res (cdr (lookup-key calc-mode-map "z"))))
    (if (eq (car (car res)) 27)
        (cdr res)
      res)))

(defvar calc-z-prefix-buf nil)
(defvar calc-z-prefix-msgs nil)

(defun calc-z-prefix-help ()
  (interactive)
  (let* ((calc-z-prefix-msgs nil)
         (calc-z-prefix-buf "")
         (kmap (sort (copy-sequence (calc-user-key-map))
                     (function (lambda (x y) (< (car x) (car y))))))
         (flags (apply 'logior
                       (mapcar (function
                                (lambda (k)
                                  (calc-user-function-classify (car k))))
                               kmap))))
    (if (= (logand flags 8) 0)
        (calc-user-function-list kmap 7)
      (calc-user-function-list kmap 1)
      (setq calc-z-prefix-msgs (cons calc-z-prefix-buf calc-z-prefix-msgs)
            calc-z-prefix-buf "")
      (calc-user-function-list kmap 6))
    (if (/= flags 0)
        (setq calc-z-prefix-msgs (cons calc-z-prefix-buf calc-z-prefix-msgs)))
    (calc-do-prefix-help (nreverse calc-z-prefix-msgs) "user" ?z)))

(defun calc-user-function-classify (key)
  (cond ((/= key (downcase key))    ; upper-case
         (if (assq (downcase key) (calc-user-key-map)) 9 1))
        ((/= key (upcase key)) 2)   ; lower-case
        ((= key ??) 0)
        (t 4)))   ; other

(defun calc-user-function-list (map flags)
  (and map
       (let* ((key (car (car map)))
              (kind (calc-user-function-classify key))
              (func (cdr (car map))))
         (if (or (= (logand kind flags) 0)
                 (not (symbolp func)))
             ()
           (let* ((name (symbol-name func))
                  (name (if (string-match "\\`calc-" name)
                            (substring name 5) name))
                  (pos (string-match (char-to-string key) name))
                  (desc
                   (if (symbolp func)
                       (if (= (logand kind 3) 0)
                           (format "`%c' = %s" key name)
                         (if pos
                             (format "%s%c%s"
                                     (downcase (substring name 0 pos))
                                     (upcase key)
                                     (downcase (substring name (1+ pos))))
                           (format "%c = %s"
                                   (upcase key)
                                   (downcase name))))
                     (char-to-string (upcase key)))))
             (if (= (length calc-z-prefix-buf) 0)
                 (setq calc-z-prefix-buf (concat (if (= flags 1) "SHIFT + " "")
                                   desc))
               (if (> (+ (length calc-z-prefix-buf) (length desc)) 58)
                   (setq calc-z-prefix-msgs 
                         (cons calc-z-prefix-buf calc-z-prefix-msgs)
                         calc-z-prefix-buf (concat (if (= flags 1) "SHIFT + " "")
                                     desc))
                 (setq calc-z-prefix-buf (concat calc-z-prefix-buf ", " desc))))))
         (calc-user-function-list (cdr map) flags))))



(defun calc-shift-Z-prefix-help ()
  (interactive)
  (calc-do-prefix-help
   '("Define, Undefine, Formula, Kbd-macro, Edit, Get-defn"
     "Composition, Syntax; Invocation; Permanent; Timing"
     "kbd-macros: [ (if), : (else), | (else-if), ] (end-if)"
     "kbd-macros: < > (repeat), ( ) (for), { } (loop)"
     "kbd-macros: / (break)"
     "kbd-macros: ` (save), ' (restore)")
   "user" ?Z))


;;;; Caches.

(defmacro math-defcache (name init form)
  (let ((cache-prec (intern (concat (symbol-name name) "-cache-prec")))
        (cache-val (intern (concat (symbol-name name) "-cache")))
        (last-prec (intern (concat (symbol-name name) "-last-prec")))
        (last-val (intern (concat (symbol-name name) "-last"))))
    (list 'progn
          (list 'defvar cache-prec (if init (math-numdigs (nth 1 init)) -100))
          (list 'defvar cache-val (list 'quote init))
          (list 'defvar last-prec -100)
          (list 'defvar last-val nil)
          (list 'setq 'math-cache-list
                (list 'cons
                      (list 'quote cache-prec)
                      (list 'cons
                            (list 'quote last-prec)
                            'math-cache-list)))
          (list 'defun
                name ()
                (list 'or
                      (list '= last-prec 'calc-internal-prec)
                      (list 'setq
                            last-val
                            (list 'math-normalize
                                  (list 'progn
                                        (list 'or
                                              (list '>= cache-prec
                                                    'calc-internal-prec)
                                              (list 'setq
                                                    cache-val
                                                    (list 'let
                                                          '((calc-internal-prec
                                                             (+ calc-internal-prec
                                                                4)))
                                                          form)
                                                    cache-prec
                                                    '(+ calc-internal-prec 2)))
                                        cache-val))
                            last-prec 'calc-internal-prec))
                last-val))))
(put 'math-defcache 'lisp-indent-hook 2)

;;; Betcha didn't know that pi = 16 atan(1/5) - 4 atan(1/239).   [F] [Public]
(math-defcache math-pi (float (bigpos 463 238 793 589 653 592 141 3) -21)
  (math-add-float (math-mul-float '(float 16 0)
                                  (math-arctan-raw '(float 2 -1)))
                  (math-mul-float '(float -4 0)
                                  (math-arctan-raw
                                   (math-float '(frac 1 239))))))

(math-defcache math-two-pi nil
  (math-mul-float (math-pi) '(float 2 0)))

(math-defcache math-pi-over-2 nil
  (math-mul-float (math-pi) '(float 5 -1)))

(math-defcache math-pi-over-4 nil
  (math-mul-float (math-pi) '(float 25 -2)))

(math-defcache math-pi-over-180 nil
  (math-div-float (math-pi) '(float 18 1)))

(math-defcache math-sqrt-pi nil
  (math-sqrt-float (math-pi)))

(math-defcache math-sqrt-2 nil
  (math-sqrt-float '(float 2 0)))

(math-defcache math-sqrt-12 nil
  (math-sqrt-float '(float 12 0)))

(math-defcache math-sqrt-two-pi nil
  (math-sqrt-float (math-two-pi)))

(math-defcache math-sqrt-e (float (bigpos 849 146 128 700 270 721 648 1) -21)
  (math-add-float '(float 1 0) (math-exp-minus-1-raw '(float 5 -1))))

(math-defcache math-e nil
  (math-pow (math-sqrt-e) 2))

(math-defcache math-phi nil
  (math-mul-float (math-add-float (math-sqrt-raw '(float 5 0)) '(float 1 0))
                  '(float 5 -1)))

(math-defcache math-gamma-const nil
  '(float (bigpos 495 467 917 632 470 369 709 646 776 267 677 848 348 672
                  057 988 235 399 359 593 421 310 024 824 900 120 065 606
                  328 015 649 156 772 5) -100))

(defun math-half-circle (symb)
  (if (eq calc-angle-mode 'rad)
      (if symb
          '(var pi var-pi)
        (math-pi))
    180))

(defun math-full-circle (symb)
  (math-mul 2 (math-half-circle symb)))

(defun math-quarter-circle (symb)
  (math-div (math-half-circle symb) 2))

(defvar math-expand-formulas nil)

;;;; Miscellaneous math routines.

;;; True if A is an odd integer.  [P R R] [Public]
(defun math-oddp (a)
  (if (consp a)
      (and (memq (car a) '(bigpos bigneg))
           (= (% (nth 1 a) 2) 1))
    (/= (% a 2) 0)))

;;; True if A is a small or big integer.  [P x] [Public]
(defun math-integerp (a)
  (or (integerp a)
      (memq (car-safe a) '(bigpos bigneg))))

;;; True if A is (numerically) a non-negative integer.  [P N] [Public]
(defun math-natnump (a)
  (or (natnump a)
      (eq (car-safe a) 'bigpos)))

;;; True if A is a rational (or integer).  [P x] [Public]
(defun math-ratp (a)
  (or (integerp a)
      (memq (car-safe a) '(bigpos bigneg frac))))

;;; True if A is a real (or rational).  [P x] [Public]
(defun math-realp (a)
  (or (integerp a)
      (memq (car-safe a) '(bigpos bigneg frac float))))

;;; True if A is a real or HMS form.  [P x] [Public]
(defun math-anglep (a)
  (or (integerp a)
      (memq (car-safe a) '(bigpos bigneg frac float hms))))

;;; True if A is a number of any kind.  [P x] [Public]
(defun math-numberp (a)
  (or (integerp a)
      (memq (car-safe a) '(bigpos bigneg frac float cplx polar))))

;;; True if A is a complex number or angle.  [P x] [Public]
(defun math-scalarp (a)
  (or (integerp a)
      (memq (car-safe a) '(bigpos bigneg frac float cplx polar hms))))

;;; True if A is a vector.  [P x] [Public]
(defun math-vectorp (a)
  (eq (car-safe a) 'vec))

;;; True if A is any vector or scalar data object.  [P x]
(defun math-objvecp (a)    ;  [Public]
  (or (integerp a)
      (memq (car-safe a) '(bigpos bigneg frac float cplx polar
                                  hms date sdev intv mod vec incomplete))))

;;; True if A is an object not composed of sub-formulas .  [P x] [Public]
(defun math-primp (a)
  (or (integerp a)
      (memq (car-safe a) '(bigpos bigneg frac float cplx polar
                                  hms date mod var))))

;;; True if A is numerically (but not literally) an integer.  [P x] [Public]
(defun math-messy-integerp (a)
  (cond
   ((eq (car-safe a) 'float) (>= (nth 2 a) 0))
   ((eq (car-safe a) 'frac) (Math-integerp (math-normalize a)))))

;;; True if A is numerically an integer.  [P x] [Public]
(defun math-num-integerp (a)
  (or (Math-integerp a)
      (Math-messy-integerp a)))

;;; True if A is (numerically) a non-negative integer.  [P N] [Public]
(defun math-num-natnump (a)
  (or (natnump a)
      (eq (car-safe a) 'bigpos)
      (and (eq (car-safe a) 'float)
           (Math-natnump (nth 1 a))
           (>= (nth 2 a) 0))))

;;; True if A is an integer or will evaluate to an integer.  [P x] [Public]
(defun math-provably-integerp (a)
  (or (Math-integerp a)
      (and (memq (car-safe a) '(calcFunc-trunc
                                calcFunc-round
                                calcFunc-rounde
                                calcFunc-roundu
                                calcFunc-floor
                                calcFunc-ceil))
           (= (length a) 2))))

;;; True if A is a real or will evaluate to a real.  [P x] [Public]
(defun math-provably-realp (a)
  (or (Math-realp a)
      (math-provably-integer a)
      (memq (car-safe a) '(abs arg))))

;;; True if A is a non-real, complex number.  [P x] [Public]
(defun math-complexp (a)
  (memq (car-safe a) '(cplx polar)))

;;; True if A is a non-real, rectangular complex number.  [P x] [Public]
(defun math-rect-complexp (a)
  (eq (car-safe a) 'cplx))

;;; True if A is a non-real, polar complex number.  [P x] [Public]
(defun math-polar-complexp (a)
  (eq (car-safe a) 'polar))

;;; True if A is a matrix.  [P x] [Public]
(defun math-matrixp (a)
  (and (Math-vectorp a)
       (Math-vectorp (nth 1 a))
       (cdr (nth 1 a))
       (let ((len (length (nth 1 a))))
         (setq a (cdr a))
         (while (and (setq a (cdr a))
                     (Math-vectorp (car a))
                     (= (length (car a)) len)))
         (null a))))

(defun math-matrixp-step (a len)   ; [P L]
  (or (null a)
      (and (Math-vectorp (car a))
           (= (length (car a)) len)
           (math-matrixp-step (cdr a) len))))

;;; True if A is a square matrix.  [P V] [Public]
(defun math-square-matrixp (a)
  (let ((dims (math-mat-dimens a)))
    (and (cdr dims)
         (= (car dims) (nth 1 dims)))))

;;; True if A is any scalar data object.  [P x]
(defun math-objectp (a)    ;  [Public]
  (or (integerp a)
      (memq (car-safe a) '(bigpos bigneg frac float cplx
                                  polar hms date sdev intv mod))))

;;; Verify that A is an integer and return A in integer form.  [I N; - x]
(defun math-check-integer (a)   ;  [Public]
  (cond ((integerp a) a)  ; for speed
        ((math-integerp a) a)
        ((math-messy-integerp a)
         (math-trunc a))
        (t (math-reject-arg a 'integerp))))

;;; Verify that A is a small integer and return A in integer form.  [S N; - x]
(defun math-check-fixnum (a &optional allow-inf)   ;  [Public]
  (cond ((integerp a) a)  ; for speed
        ((Math-num-integerp a)
         (let ((a (math-trunc a)))
           (if (integerp a)
               a
             (if (or (Math-lessp (lsh -1 -1) a)
                     (Math-lessp a (- (lsh -1 -1))))
                 (math-reject-arg a 'fixnump)
               (math-fixnum a)))))
        ((and allow-inf (equal a '(var inf var-inf)))
         (lsh -1 -1))
        ((and allow-inf (equal a '(neg (var inf var-inf))))
         (- (lsh -1 -1)))
        (t (math-reject-arg a 'fixnump))))

;;; Verify that A is an integer >= 0 and return A in integer form.  [I N; - x]
(defun math-check-natnum (a)    ;  [Public]
  (cond ((natnump a) a)
        ((and (not (math-negp a))
              (Math-num-integerp a))
         (math-trunc a))
        (t (math-reject-arg a 'natnump))))

;;; Verify that A is in floating-point form, or force it to be a float.  [F N]
(defun math-check-float (a)    ; [Public]
  (cond ((eq (car-safe a) 'float) a)
        ((Math-vectorp a) (math-map-vec 'math-check-float a))
        ((Math-objectp a) (math-float a))
        (t a)))

;;; Verify that A is a constant.
(defun math-check-const (a &optional exp-ok)
  (if (or (math-constp a)
          (and exp-ok math-expand-formulas))
      a
    (math-reject-arg a 'constp)))


;;; Coerce integer A to be a small integer.  [S I]
(defun math-fixnum (a)
  (if (consp a)
      (if (cdr a)
          (if (eq (car a) 'bigneg)
              (- (math-fixnum-big (cdr a)))
            (math-fixnum-big (cdr a)))
        0)
    a))

(defun math-fixnum-big (a)
  (if (cdr a)
      (+ (car a) (* (math-fixnum-big (cdr a)) 1000))
    (car a)))

(defvar math-simplify-only nil)

(defun math-normalize-fancy (a)
  (cond ((eq (car a) 'frac)
         (math-make-frac (math-normalize (nth 1 a))
                         (math-normalize (nth 2 a))))
        ((eq (car a) 'cplx)
         (let ((real (math-normalize (nth 1 a)))
               (imag (math-normalize (nth 2 a))))
           (if (and (math-zerop imag)
                    (not math-simplify-only))   ; oh, what a kludge!
               real
             (list 'cplx real imag))))
        ((eq (car a) 'polar)
         (math-normalize-polar a))
        ((eq (car a) 'hms)
         (math-normalize-hms a))
        ((eq (car a) 'date)
         (list 'date (math-normalize (nth 1 a))))
        ((eq (car a) 'mod)
         (math-normalize-mod a))
        ((eq (car a) 'sdev)
         (let ((x (math-normalize (nth 1 a)))
               (s (math-normalize (nth 2 a))))
           (if (or (and (Math-objectp x) (not (Math-scalarp x)))
                   (and (Math-objectp s) (not (Math-scalarp s))))
               (list 'calcFunc-sdev x s)
             (math-make-sdev x s))))
        ((eq (car a) 'intv)
         (let ((mask (math-normalize (nth 1 a)))
               (lo (math-normalize (nth 2 a)))
               (hi (math-normalize (nth 3 a))))
           (if (if (eq (car-safe lo) 'date)
                   (not (eq (car-safe hi) 'date))
                 (or (and (Math-objectp lo) (not (Math-anglep lo)))
                     (and (Math-objectp hi) (not (Math-anglep hi)))))
               (list 'calcFunc-intv mask lo hi)
             (math-make-intv mask lo hi))))
        ((eq (car a) 'vec)
         (cons 'vec (mapcar 'math-normalize (cdr a))))
        ((eq (car a) 'quote)
         (math-normalize (nth 1 a)))
        ((eq (car a) 'special-const)
         (calc-with-default-simplification
          (math-normalize (nth 1 a))))
        ((eq (car a) 'var)
         (cons 'var (cdr a)))   ; need to re-cons for selection routines
        ((eq (car a) 'calcFunc-if)
         (math-normalize-logical-op a))
        ((memq (car a) '(calcFunc-lambda calcFunc-quote calcFunc-condition))
         (let ((calc-simplify-mode 'none))
           (cons (car a) (mapcar 'math-normalize (cdr a)))))
        ((eq (car a) 'calcFunc-evalto)
         (setq a (or (nth 1 a) 0))
         (or calc-refreshing-evaltos
             (setq a (let ((calc-simplify-mode 'none)) (math-normalize a))))
         (let ((b (if (and (eq (car-safe a) 'calcFunc-assign)
                           (= (length a) 3))
                      (nth 2 a)
                    a)))
           (list 'calcFunc-evalto
                 a
                 (if (eq calc-simplify-mode 'none)
                     (math-normalize b)
                   (calc-with-default-simplification
                    (math-evaluate-expr b))))))
        ((or (integerp (car a)) (consp (car a)))
         (if (null (cdr a))
             (math-normalize (car a))
           (error "Can't use multi-valued function in an expression")))))

;; The variable math-normalize-a is local to math-normalize in calc.el,
;; but is used by math-normalize-nonstandard, which is called by
;; math-normalize.
(defvar math-normalize-a)

(defun math-normalize-nonstandard ()
  (if (consp calc-simplify-mode)
      (progn
        (setq calc-simplify-mode 'none
              math-simplify-only (car-safe (cdr-safe math-normalize-a)))
        nil)
    (and (symbolp (car math-normalize-a))
         (or (eq calc-simplify-mode 'none)
             (and (eq calc-simplify-mode 'num)
                  (let ((aptr (setq math-normalize-a 
                                    (cons
                                     (car math-normalize-a)
                                     (mapcar 'math-normalize 
                                             (cdr math-normalize-a))))))
                    (while (and aptr (math-constp (car aptr)))
                      (setq aptr (cdr aptr)))
                    aptr)))
         (cons (car math-normalize-a) 
               (mapcar 'math-normalize (cdr math-normalize-a))))))


;;; Normalize a bignum digit list by trimming high-end zeros.  [L l]
(defun math-norm-bignum (a)
  (let ((digs a) (last nil))
    (while digs
      (or (eq (car digs) 0) (setq last digs))
      (setq digs (cdr digs)))
    (and last
         (progn
           (setcdr last nil)
           a))))

(defun math-bignum-test (a)   ; [B N; B s; b b]
  (if (consp a)
      a
    (math-bignum a)))


;;; Return 0 for zero, -1 for negative, 1 for positive.  [S n] [Public]
(defun calcFunc-sign (a &optional x)
  (let ((signs (math-possible-signs a)))
    (cond ((eq signs 4) (or x 1))
          ((eq signs 2) 0)
          ((eq signs 1) (if x (math-neg x) -1))
          ((math-looks-negp a) (math-neg (calcFunc-sign (math-neg a))))
          (t (calc-record-why 'realp a)
             (if x
                 (list 'calcFunc-sign a x)
               (list 'calcFunc-sign a))))))

;;; Return 0 if A is numerically equal to B, <0 if less, >0 if more.
;;; Arguments must be normalized!  [S N N]
(defun math-compare (a b)
  (cond ((equal a b)
         (if (and (consp a)
                  (memq (car a) '(var neg * /))
                  (math-infinitep a))
             2
           0))
        ((and (integerp a) (Math-integerp b))
         (if (consp b)
             (if (eq (car b) 'bigpos) -1 1)
           (if (< a b) -1 1)))
        ((and (eq (car-safe a) 'bigpos) (Math-integerp b))
         (if (eq (car-safe b) 'bigpos)
             (math-compare-bignum (cdr a) (cdr b))
           1))
        ((and (eq (car-safe a) 'bigneg) (Math-integerp b))
         (if (eq (car-safe b) 'bigneg)
             (math-compare-bignum (cdr b) (cdr a))
           -1))
        ((eq (car-safe a) 'frac)
         (if (eq (car-safe b) 'frac)
             (math-compare (math-mul (nth 1 a) (nth 2 b))
                           (math-mul (nth 1 b) (nth 2 a)))
           (math-compare (nth 1 a) (math-mul b (nth 2 a)))))
        ((eq (car-safe b) 'frac)
         (math-compare (math-mul a (nth 2 b)) (nth 1 b)))
        ((and (eq (car-safe a) 'float) (eq (car-safe b) 'float))
         (if (math-lessp-float a b) -1 1))
        ((and (eq (car-safe a) 'date) (eq (car-safe b) 'date))
         (math-compare (nth 1 a) (nth 1 b)))
        ((and (or (Math-anglep a)
                  (and (eq (car a) 'cplx) (eq (nth 2 a) 0)))
              (or (Math-anglep b)
                  (and (eq (car b) 'cplx) (eq (nth 2 b) 0))))
         (calcFunc-sign (math-add a (math-neg b))))
        ((and (eq (car-safe a) 'intv)
              (or (Math-anglep b) (eq (car-safe b) 'date)))
         (let ((res (math-compare (nth 2 a) b)))
           (cond ((eq res 1) 1)
                 ((and (eq res 0) (memq (nth 1 a) '(0 1))) 1)
                 ((eq (setq res (math-compare (nth 3 a) b)) -1) -1)
                 ((and (eq res 0) (memq (nth 1 a) '(0 2))) -1)
                 (t 2))))
        ((and (eq (car-safe b) 'intv)
              (or (Math-anglep a) (eq (car-safe a) 'date)))
         (let ((res (math-compare a (nth 2 b))))
           (cond ((eq res -1) -1)
                 ((and (eq res 0) (memq (nth 1 b) '(0 1))) -1)
                 ((eq (setq res (math-compare a (nth 3 b))) 1) 1)
                 ((and (eq res 0) (memq (nth 1 b) '(0 2))) 1)
                 (t 2))))
        ((and (eq (car-safe a) 'intv) (eq (car-safe b) 'intv))
         (let ((res (math-compare (nth 3 a) (nth 2 b))))
           (cond ((eq res -1) -1)
                 ((and (eq res 0) (or (memq (nth 1 a) '(0 2))
                                      (memq (nth 1 b) '(0 1)))) -1)
                 ((eq (setq res (math-compare (nth 2 a) (nth 3 b))) 1) 1)
                 ((and (eq res 0) (or (memq (nth 1 a) '(0 1))
                                      (memq (nth 1 b) '(0 2)))) 1)
                 (t 2))))
        ((math-infinitep a)
         (if (or (equal a '(var uinf var-uinf))
                 (equal a '(var nan var-nan)))
             2
           (let ((dira (math-infinite-dir a)))
             (if (math-infinitep b)
                 (if (or (equal b '(var uinf var-uinf))
                         (equal b '(var nan var-nan)))
                     2
                   (let ((dirb (math-infinite-dir b)))
                     (cond ((and (eq dira 1) (eq dirb -1)) 1)
                           ((and (eq dira -1) (eq dirb 1)) -1)
                           (t 2))))
               (cond ((eq dira 1) 1)
                     ((eq dira -1) -1)
                     (t 2))))))
        ((math-infinitep b)
         (if (or (equal b '(var uinf var-uinf))
                 (equal b '(var nan var-nan)))
             2
           (let ((dirb (math-infinite-dir b)))
             (cond ((eq dirb 1) -1)
                   ((eq dirb -1) 1)
                   (t 2)))))
        ((and (eq (car-safe a) 'calcFunc-exp)
              (eq (car-safe b) '^)
              (equal (nth 1 b) '(var e var-e)))
         (math-compare (nth 1 a) (nth 2 b)))
        ((and (eq (car-safe b) 'calcFunc-exp)
              (eq (car-safe a) '^)
              (equal (nth 1 a) '(var e var-e)))
         (math-compare (nth 2 a) (nth 1 b)))
        ((or (and (eq (car-safe a) 'calcFunc-sqrt)
                  (eq (car-safe b) '^)
                  (or (equal (nth 2 b) '(frac 1 2))
                      (equal (nth 2 b) '(float 5 -1))))
             (and (eq (car-safe b) 'calcFunc-sqrt)
                  (eq (car-safe a) '^)
                  (or (equal (nth 2 a) '(frac 1 2))
                      (equal (nth 2 a) '(float 5 -1)))))
         (math-compare (nth 1 a) (nth 1 b)))
        ((eq (car-safe a) 'var)
         2)
        (t
         (if (and (consp a) (consp b)
                  (eq (car a) (car b))
                  (math-compare-lists (cdr a) (cdr b)))
             0
           2))))

;;; Compare two bignum digit lists, return -1 for A<B, 0 for A=B, 1 for A>B.
(defun math-compare-bignum (a b)   ; [S l l]
  (let ((res 0))
    (while (and a b)
      (if (< (car a) (car b))
          (setq res -1)
        (if (> (car a) (car b))
            (setq res 1)))
      (setq a (cdr a)
            b (cdr b)))
    (if a
        (progn
          (while (eq (car a) 0) (setq a (cdr a)))
          (if a 1 res))
      (while (eq (car b) 0) (setq b (cdr b)))
      (if b -1 res))))

(defun math-compare-lists (a b)
  (cond ((null a) (null b))
        ((null b) nil)
        (t (and (Math-equal (car a) (car b))
                (math-compare-lists (cdr a) (cdr b))))))

(defun math-lessp-float (a b)   ; [P F F]
  (let ((ediff (- (nth 2 a) (nth 2 b))))
    (if (>= ediff 0)
        (if (>= ediff (+ calc-internal-prec calc-internal-prec))
            (if (eq (nth 1 a) 0)
                (Math-integer-posp (nth 1 b))
              (Math-integer-negp (nth 1 a)))
          (Math-lessp (math-scale-int (nth 1 a) ediff)
                      (nth 1 b)))
      (if (>= (setq ediff (- ediff))
              (+ calc-internal-prec calc-internal-prec))
          (if (eq (nth 1 b) 0)
              (Math-integer-negp (nth 1 a))
            (Math-integer-posp (nth 1 b)))
        (Math-lessp (nth 1 a)
                    (math-scale-int (nth 1 b) ediff))))))

;;; True if A is numerically equal to B.  [P N N] [Public]
(defun math-equal (a b)
  (= (math-compare a b) 0))

;;; True if A is numerically less than B.  [P R R] [Public]
(defun math-lessp (a b)
  (= (math-compare a b) -1))

;;; True if A is numerically equal to the integer B.  [P N S] [Public]
;;; B must not be a multiple of 10.
(defun math-equal-int (a b)
  (or (eq a b)
      (and (eq (car-safe a) 'float)
           (eq (nth 1 a) b)
           (= (nth 2 a) 0))))




;;; Return the dimensions of a matrix as a list.  [l x] [Public]
(defun math-mat-dimens (m)
  (if (math-vectorp m)
      (if (math-matrixp m)
          (cons (1- (length m))
                (math-mat-dimens (nth 1 m)))
        (list (1- (length m))))
    nil))



(defun calc-binary-op-fancy (name func arg ident unary)
  (let ((n (prefix-numeric-value arg)))
    (cond ((> n 1)
           (calc-enter-result n
                              name
                              (list 'calcFunc-reduce
                                    (math-calcFunc-to-var func)
                                    (cons 'vec (calc-top-list-n n)))))
          ((= n 1)
           (if unary
               (calc-enter-result 1 name (list unary (calc-top-n 1)))))
          ((= n 0)
           (if ident
               (calc-enter-result 0 name ident)
             (error "Argument must be nonzero")))
          (t
           (let ((rhs (calc-top-n 1)))
             (calc-enter-result (- 1 n)
                                name
                                (mapcar (function
                                         (lambda (x)
                                           (list func x rhs)))
                                        (calc-top-list-n (- n) 2))))))))

(defun calc-unary-op-fancy (name func arg)
  (let ((n (prefix-numeric-value arg)))
    (if (= n 0) (setq n (calc-stack-size)))
    (cond ((> n 0)
           (calc-enter-result n
                              name
                              (mapcar (function
                                       (lambda (x)
                                         (list func x)))
                                      (calc-top-list-n n))))
          ((< n 0)
           (calc-enter-result 1
                              name
                              (list func (calc-top-n (- n)))
                              (- n))))))

(defvar var-Holidays '(vec (var sat var-sat) (var sun var-sun)))
(defvar var-Decls (list 'vec))


(defun math-inexact-result ()
  (and calc-symbolic-mode
       (signal 'inexact-result nil)))

(defun math-overflow (&optional exp)
  (if (and exp (math-negp exp))
      (math-underflow)
    (signal 'math-overflow nil)))

(defun math-underflow ()
  (signal 'math-underflow nil))

;;; Compute the greatest common divisor of A and B.   [I I I] [Public]
(defun math-gcd (a b)
  (cond ((not (or (consp a) (consp b)))
         (if (< a 0) (setq a (- a)))
         (if (< b 0) (setq b (- b)))
         (let (c)
           (if (< a b)
               (setq c b b a a c))
           (while (> b 0)
             (setq c b
                   b (% a b)
                   a c))
           a))
        ((eq a 0) b)
        ((eq b 0) a)
        (t
         (if (Math-integer-negp a) (setq a (math-neg a)))
         (if (Math-integer-negp b) (setq b (math-neg b)))
         (let (c)
           (if (Math-natnum-lessp a b)
               (setq c b b a a c))
           (while (and (consp a) (not (eq b 0)))
             (setq c b
                   b (math-imod a b)
                   a c))
           (while (> b 0)
             (setq c b
                   b (% a b)
                   a c))
           a))))


;;;; Algebra.

;;; Evaluate variables in an expression.
(defun math-evaluate-expr (x)  ; [Public]
  (if calc-embedded-info
      (calc-embedded-evaluate-expr x)
    (calc-normalize (math-evaluate-expr-rec x))))

(defalias 'calcFunc-evalv 'math-evaluate-expr)

(defun calcFunc-evalvn (x &optional prec)
  (if prec
      (progn
        (or (math-num-integerp prec)
            (if (and (math-vectorp prec)
                     (= (length prec) 2)
                     (math-num-integerp (nth 1 prec)))
                (setq prec (math-add (nth 1 prec) calc-internal-prec))
              (math-reject-arg prec 'integerp)))
        (setq prec (math-trunc prec))
        (if (< prec 3) (setq prec 3))
        (if (> prec calc-internal-prec)
            (math-normalize
             (let ((calc-internal-prec prec))
               (calcFunc-evalvn x)))
          (let ((calc-internal-prec prec))
            (calcFunc-evalvn x))))
    (let ((calc-symbolic-mode nil))
      (math-evaluate-expr x))))

(defun math-evaluate-expr-rec (x)
  (if (consp x)
      (if (memq (car x) '(calcFunc-quote calcFunc-condition
                                         calcFunc-evalto calcFunc-assign))
          (if (and (eq (car x) 'calcFunc-assign)
                   (= (length x) 3))
              (list (car x) (nth 1 x) (math-evaluate-expr-rec (nth 2 x)))
            x)
        (if (eq (car x) 'var)
            (if (and (calc-var-value (nth 2 x))
                     (not (eq (car-safe (symbol-value (nth 2 x)))
                              'incomplete)))
                (let ((val (symbol-value (nth 2 x))))
                  (if (eq (car-safe val) 'special-const)
                      (if calc-symbolic-mode
                          x
                        val)
                    val))
              x)
          (if (Math-primp x)
              x
            (cons (car x) (mapcar 'math-evaluate-expr-rec (cdr x))))))
    x))

(defun math-any-floats (expr)
  (if (Math-primp expr)
      (math-floatp expr)
    (while (and (setq expr (cdr expr)) (not (math-any-floats (car expr)))))
    expr))

(defvar var-FactorRules 'calc-FactorRules)

(defvar math-mt-many nil)
(defvar math-mt-func nil)

(defun math-map-tree (math-mt-func mmt-expr &optional math-mt-many)
  (or math-mt-many (setq math-mt-many 1000000))
  (math-map-tree-rec mmt-expr))

(defun math-map-tree-rec (mmt-expr)
  (or (= math-mt-many 0)
      (let ((mmt-done nil)
            mmt-nextval)
        (while (not mmt-done)
          (while (and (/= math-mt-many 0)
                      (setq mmt-nextval (funcall math-mt-func mmt-expr))
                      (not (equal mmt-expr mmt-nextval)))
            (setq mmt-expr mmt-nextval
                  math-mt-many (if (> math-mt-many 0) 
                                   (1- math-mt-many) 
                                 (1+ math-mt-many))))
          (if (or (Math-primp mmt-expr)
                  (<= math-mt-many 0))
              (setq mmt-done t)
            (setq mmt-nextval (cons (car mmt-expr)
                                    (mapcar 'math-map-tree-rec
                                            (cdr mmt-expr))))
            (if (equal mmt-nextval mmt-expr)
                (setq mmt-done t)
              (setq mmt-expr mmt-nextval))))))
  mmt-expr)

(defun math-is-true (expr)
  (if (Math-numberp expr)
      (not (Math-zerop expr))
    (math-known-nonzerop expr)))

(defun math-const-var (expr)
  (and (consp expr)
       (eq (car expr) 'var)
       (or (and (symbolp (nth 2 expr))
                (boundp (nth 2 expr))
                (eq (car-safe (symbol-value (nth 2 expr))) 'special-const))
           (memq (nth 2 expr) '(var-inf var-uinf var-nan)))))

;; The variable math-integral-cache is originally declared in calcalg2.el,
;; but is set by math-defintegral and math-definitegral2.
(defvar math-integral-cache)

(defmacro math-defintegral (funcs &rest code)
  (setq math-integral-cache nil)
  (append '(progn)
          (mapcar (function
                   (lambda (func)
                     (list 'put (list 'quote func) ''math-integral
                           (list 'nconc
                                 (list 'get (list 'quote func) ''math-integral)
                                 (list 'list
                                       (list 'function
                                             (append '(lambda (u))
                                                     code)))))))
                  (if (symbolp funcs) (list funcs) funcs))))
(put 'math-defintegral 'lisp-indent-hook 1)

(defmacro math-defintegral-2 (funcs &rest code)
  (setq math-integral-cache nil)
  (append '(progn)
          (mapcar (function
                   (lambda (func)
                     (list 'put (list 'quote func) ''math-integral-2
                           (list 'nconc
                                 (list 'get (list 'quote func)
                                       ''math-integral-2)
                                 (list 'list
                                       (list 'function
                                             (append '(lambda (u v))
                                                     code)))))))
                  (if (symbolp funcs) (list funcs) funcs))))
(put 'math-defintegral-2 'lisp-indent-hook 1)

(defvar var-IntegAfterRules 'calc-IntegAfterRules)

(defvar var-FitRules 'calc-FitRules)

(defvar math-poly-base-variable nil)
(defvar math-poly-neg-powers nil)
(defvar math-poly-mult-powers 1)
(defvar math-poly-frac-powers nil)
(defvar math-poly-exp-base nil)

(defun math-build-var-name (name)
  (if (stringp name)
      (setq name (intern name)))
  (if (string-match "\\`var-." (symbol-name name))
      (list 'var (intern (substring (symbol-name name) 4)) name)
    (list 'var name (intern (concat "var-" (symbol-name name))))))

(defvar math-simplifying-units nil)
(defvar math-combining-units t)

;;; Nontrivial number parsing.

(defun math-read-number-fancy (s)
  (cond

   ;; Integer+fractions
   ((string-match "^\\([0-9]*\\)[:/]\\([0-9]*\\)[:/]\\([0-9]*\\)$" s)
    (let ((int (math-match-substring s 1))
          (num (math-match-substring s 2))
          (den (math-match-substring s 3)))
      (let ((int (if (> (length int) 0) (math-read-number int) 0))
            (num (if (> (length num) 0) (math-read-number num) 1))
            (den (if (> (length num) 0) (math-read-number den) 1)))
        (and int num den
             (math-integerp int) (math-integerp num) (math-integerp den)
             (not (math-zerop den))
             (list 'frac (math-add num (math-mul int den)) den)))))

   ;; Fractions
   ((string-match "^\\([0-9]*\\)[:/]\\([0-9]*\\)$" s)
    (let ((num (math-match-substring s 1))
          (den (math-match-substring s 2)))
      (let ((num (if (> (length num) 0) (math-read-number num) 1))
            (den (if (> (length num) 0) (math-read-number den) 1)))
        (and num den (math-integerp num) (math-integerp den)
             (not (math-zerop den))
             (list 'frac num den)))))

   ;; Modulo forms
   ((string-match "^\\(.*\\) *mod *\\(.*\\)$" s)
    (let* ((n (math-match-substring s 1))
           (m (math-match-substring s 2))
           (n (math-read-number n))
           (m (math-read-number m)))
      (and n m (math-anglep n) (math-anglep m)
           (list 'mod n m))))

   ;; Error forms
   ((string-match "^\\(.*\\) *\\+/- *\\(.*\\)$" s)
    (let* ((x (math-match-substring s 1))
           (sigma (math-match-substring s 2))
           (x (math-read-number x))
           (sigma (math-read-number sigma)))
      (and x sigma (math-scalarp x) (math-anglep sigma)
           (list 'sdev x sigma))))

   ;; Hours (or degrees)
   ((or (string-match "^\\([^#^]+\\)[@oOhH]\\(.*\\)$" s)
        (string-match "^\\([^#^]+\\)[dD][eE]?[gG]?\\(.*\\)$" s))
    (let* ((hours (math-match-substring s 1))
           (minsec (math-match-substring s 2))
           (hours (math-read-number hours))
           (minsec (if (> (length minsec) 0) (math-read-number minsec) 0)))
      (and hours minsec
           (math-num-integerp hours)
           (not (math-negp hours)) (not (math-negp minsec))
           (cond ((math-num-integerp minsec)
                  (and (Math-lessp minsec 60)
                       (list 'hms hours minsec 0)))
                 ((and (eq (car-safe minsec) 'hms)
                       (math-zerop (nth 1 minsec)))
                  (math-add (list 'hms hours 0 0) minsec))
                 (t nil)))))

   ;; Minutes
   ((string-match "^\\([^'#^]+\\)[mM']\\(.*\\)$" s)
    (let* ((minutes (math-match-substring s 1))
           (seconds (math-match-substring s 2))
           (minutes (math-read-number minutes))
           (seconds (if (> (length seconds) 0) (math-read-number seconds) 0)))
      (and minutes seconds
           (math-num-integerp minutes)
           (not (math-negp minutes)) (not (math-negp seconds))
           (cond ((math-realp seconds)
                  (and (Math-lessp minutes 60)
                       (list 'hms 0 minutes seconds)))
                 ((and (eq (car-safe seconds) 'hms)
                       (math-zerop (nth 1 seconds))
                       (math-zerop (nth 2 seconds)))
                  (math-add (list 'hms 0 minutes 0) seconds))
                 (t nil)))))

   ;; Seconds
   ((string-match "^\\([^\"#^]+\\)[sS\"]$" s)
    (let ((seconds (math-read-number (math-match-substring s 1))))
      (and seconds (math-realp seconds)
           (not (math-negp seconds))
           (Math-lessp seconds 60)
           (list 'hms 0 0 seconds))))

   ;; Integer+fraction with explicit radix
   ((string-match "^\\([0-9]+\\)\\(#\\|\\^\\^\\)\\([0-9a-zA-Z]*\\)[:/]\\([0-9a-zA-Z]*\\)[:/]\\([0-9a-zA-Z]\\)$" s)
    (let ((radix (string-to-int (math-match-substring s 1)))
          (int (math-match-substring s 3))
          (num (math-match-substring s 4))
          (den (math-match-substring s 5)))
      (let ((int (if (> (length int) 0) (math-read-radix int radix) 0))
            (num (if (> (length num) 0) (math-read-radix num radix) 1))
            (den (if (> (length den) 0) (math-read-radix den radix) 1)))
        (and int num den (not (math-zerop den))
             (list 'frac
                   (math-add num (math-mul int den))
                   den)))))

   ;; Fraction with explicit radix
   ((string-match "^\\([0-9]+\\)\\(#\\|\\^\\^\\)\\([0-9a-zA-Z]*\\)[:/]\\([0-9a-zA-Z]*\\)$" s)
    (let ((radix (string-to-int (math-match-substring s 1)))
          (num (math-match-substring s 3))
          (den (math-match-substring s 4)))
      (let ((num (if (> (length num) 0) (math-read-radix num radix) 1))
            (den (if (> (length den) 0) (math-read-radix den radix) 1)))
        (and num den (not (math-zerop den)) (list 'frac num den)))))

   ;; Float with explicit radix and exponent
   ((or (string-match "^0*\\(\\([2-9]\\|1[0-4]\\)\\(#\\|\\^\\^\\)[0-9a-dA-D.]+\\)[eE]\\([-+]?[0-9]+\\)$" s)
        (string-match "^\\(\\([0-9]+\\)\\(#\\|\\^\\^\\)[0-9a-zA-Z.]+\\) *\\* *\\2\\.? *\\^ *\\([-+]?[0-9]+\\)$" s))
    (let ((radix (string-to-int (math-match-substring s 2)))
          (mant (math-match-substring s 1))
          (exp (math-match-substring s 4)))
      (let ((mant (math-read-number mant))
            (exp (math-read-number exp)))
        (and mant exp
             (math-mul mant (math-pow (math-float radix) exp))))))

   ;; Float with explicit radix, no exponent
   ((string-match "^\\([0-9]+\\)\\(#\\|\\^\\^\\)\\([0-9a-zA-Z]*\\)\\.\\([0-9a-zA-Z]*\\)$" s)
    (let ((radix (string-to-int (math-match-substring s 1)))
          (int (math-match-substring s 3))
          (fracs (math-match-substring s 4)))
      (let ((int (if (> (length int) 0) (math-read-radix int radix) 0))
            (frac (if (> (length fracs) 0) (math-read-radix fracs radix) 0))
            (calc-prefer-frac nil))
        (and int frac
             (math-add int (math-div frac (math-pow radix (length fracs))))))))

   ;; Integer with explicit radix
   ((string-match "^\\([0-9]+\\)\\(#\\|\\^\\^\\)\\([0-9a-zA-Z]+\\)$" s)
    (math-read-radix (math-match-substring s 3)
                     (string-to-int (math-match-substring s 1))))

   ;; C language hexadecimal notation
   ((and (eq calc-language 'c)
         (string-match "^0[xX]\\([0-9a-fA-F]+\\)$" s))
    (let ((digs (math-match-substring s 1)))
      (math-read-radix digs 16)))

   ;; Pascal language hexadecimal notation
   ((and (eq calc-language 'pascal)
         (string-match "^\\$\\([0-9a-fA-F]+\\)$" s))
    (let ((digs (math-match-substring s 1)))
      (math-read-radix digs 16)))

   ;; Fraction using "/" instead of ":"
   ((string-match "^\\([0-9]+\\)/\\([0-9/]+\\)$" s)
    (math-read-number (concat (math-match-substring s 1) ":"
                              (math-match-substring s 2))))

   ;; Syntax error!
   (t nil)))

(defun math-read-radix (s r)   ; [I X D]
  (setq s (upcase s))
  (let ((i 0)
        (res 0)
        dig)
    (while (and (< i (length s))
                (setq dig (math-read-radix-digit (elt s i)))
                (< dig r))
      (setq res (math-add (math-mul res r) dig)
            i (1+ i)))
    (and (= i (length s))
         res)))



;;; Expression parsing.

(defvar math-expr-data)

(defvar math-read-replacement-list
  '(;; Misc symbols
    ("±" "+/-")  ; plus or minus
    ("×" "*")    ; multiplication sign
    ("÷" ":")    ; division sign
    ("−" "-")    ; subtraction sign
    ("∕" "/")    ; division sign
    ("∗" "*")    ; asterisk multiplication
    ("∞" "inf")  ; infinity symbol
    ("≤" "<=")
    ("≥" ">=")
    ("≦" "<=")
    ("≧" ">=")
    ;; fractions
    ("¼" "(1:4)") ; 1/4
    ("½" "(1:2)") ; 1/2
    ("¾" "(3:4)") ; 3/4
    ("⅓" "(1:3)") ; 1/3
    ("⅔" "(2:3)") ; 2/3
    ("⅕" "(1:5)") ; 1/5
    ("⅖" "(2:5)") ; 2/5
    ("⅗" "(3:5)") ; 3/5
    ("⅘" "(4:5)") ; 4/5
    ("⅙" "(1:6)") ; 1/6
    ("⅚" "(5:6)") ; 5/6
    ("⅛" "(1:8)") ; 1/8
    ("⅜" "(3:8)") ; 3/8
    ("⅝" "(5:8)") ; 5/8
    ("⅞" "(7:8)") ; 7/8
    ("⅟" "1:")    ; 1/...
    ;; superscripts
    ("⁰" "0")  ; 0
    ("¹" "1")  ; 1
    ("²" "2")  ; 2
    ("³" "3")  ; 3
    ("⁴" "4")  ; 4
    ("⁵" "5")  ; 5
    ("⁶" "6")  ; 6
    ("⁷" "7")  ; 7
    ("⁸" "8")  ; 8
    ("⁹" "9")  ; 9
    ("⁺" "+")  ; +
    ("⁻" "-")  ; -
    ("⁽" "(")  ; (
    ("⁾" ")")  ; )
    ("ⁿ" "n")  ; n
    ("ⁱ" "i")) ; i
  "A list whose elements (old new) indicate replacements to make
in Calc algebraic input.")

(defvar math-read-superscripts
  "⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁽⁾ⁿⁱ" ; 0123456789+-()ni
  "A string consisting of the superscripts allowed by Calc.")

(defun math-read-preprocess-string (str)
  "Replace some substrings of STR by Calc equivalents."
  (setq str
        (replace-regexp-in-string (concat "[" math-read-superscripts "]+")
                                  "^(\\&)" str))
  (let ((rep-list math-read-replacement-list))
    (while rep-list
      (setq str
            (replace-regexp-in-string (nth 0 (car rep-list))
                                      (nth 1 (car rep-list)) str))
      (setq rep-list (cdr rep-list))))
  str)

(defun math-read-expr (math-exp-str)
  (let ((math-exp-pos 0)
        (math-exp-old-pos 0)
        (math-exp-keep-spaces nil)
        math-exp-token math-expr-data)
    (setq math-exp-str (math-read-preprocess-string math-exp-str))
    (while (setq math-exp-token (string-match "\\.\\.\\([^.]\\|.[^.]\\)" math-exp-str))
      (setq math-exp-str (concat (substring math-exp-str 0 math-exp-token) "\\dots"
                            (substring math-exp-str (+ math-exp-token 2)))))
    (math-build-parse-table)
    (math-read-token)
    (let ((val (catch 'syntax (math-read-expr-level 0))))
      (if (stringp val)
          (list 'error math-exp-old-pos val)
        (if (equal math-exp-token 'end)
            val
          (list 'error math-exp-old-pos "Syntax error"))))))

(defun math-read-plain-expr (exp-str &optional error-check)
  (let* ((calc-language nil)
         (math-expr-opers math-standard-opers)
         (val (math-read-expr exp-str)))
    (and error-check
         (eq (car-safe val) 'error)
         (error "%s: %s" (nth 2 val) exp-str))
    val))


(defun math-read-string ()
  (let ((str (read-from-string (concat math-expr-data "\""))))
    (or (and (= (cdr str) (1+ (length math-expr-data)))
             (stringp (car str)))
        (throw 'syntax "Error in string constant"))
    (math-read-token)
    (append '(vec) (car str) nil)))



;;; They said it couldn't be done...

(defun math-read-big-expr (str)
  (and (> (length calc-left-label) 0)
       (string-match (concat "^" (regexp-quote calc-left-label)) str)
       (setq str (concat (substring str 0 (match-beginning 0))
                         (substring str (match-end 0)))))
  (and (> (length calc-right-label) 0)
       (string-match (concat (regexp-quote calc-right-label) " *$") str)
       (setq str (concat (substring str 0 (match-beginning 0))
                         (substring str (match-end 0)))))
  (if (string-match "\\\\[^ \n|]" str)
      (if (eq calc-language 'tex)
          (math-read-expr str)
        (let ((calc-language 'tex)
              (calc-language-option nil)
              (math-expr-opers (get 'tex 'math-oper-table))
              (math-expr-function-mapping (get 'tex 'math-function-table))
              (math-expr-variable-mapping (get 'tex 'math-variable-table)))
          (math-read-expr str)))
    (let ((math-read-big-lines nil)
          (pos 0)
          (width 0)
          (math-read-big-err-msg nil)
          math-read-big-baseline math-read-big-h2
          new-pos p)
      (while (setq new-pos (string-match "\n" str pos))
        (setq math-read-big-lines 
              (cons (substring str pos new-pos) math-read-big-lines)
              pos (1+ new-pos)))
      (setq math-read-big-lines 
            (nreverse (cons (substring str pos) math-read-big-lines))
            p math-read-big-lines)
      (while p
        (setq width (max width (length (car p)))
              p (cdr p)))
      (if (math-read-big-bigp math-read-big-lines)
          (or (catch 'syntax
                (math-read-big-rec 0 0 width (length math-read-big-lines)))
              math-read-big-err-msg
              '(error 0 "Syntax error"))
        (math-read-expr str)))))

(defun math-read-big-bigp (math-read-big-lines)
  (and (cdr math-read-big-lines)
       (let ((matrix nil)
             (v 0)
             (height (if (> (length (car math-read-big-lines)) 0) 1 0)))
         (while (and (cdr math-read-big-lines)
                     (let* ((i 0)
                            j
                            (l1 (car math-read-big-lines))
                            (l2 (nth 1 math-read-big-lines))
                            (len (min (length l1) (length l2))))
                       (if (> (length l2) 0)
                           (setq height (1+ height)))
                       (while (and (< i len)
                                   (or (memq (aref l1 i) '(?\  ?\- ?\_))
                                       (memq (aref l2 i) '(?\  ?\-))
                                       (and (memq (aref l1 i) '(?\| ?\,))
                                            (= (aref l2 i) (aref l1 i)))
                                       (and (eq (aref l1 i) ?\[)
                                            (eq (aref l2 i) ?\[)
                                            (let ((math-rb-h2 (length l1)))
                                              (setq j (math-read-big-balance
                                                       (1+ i) v "[")))
                                            (setq i (1- j)))))
                         (setq i (1+ i)))
                       (or (= i len)
                           (and (eq (aref l1 i) ?\[)
                                (eq (aref l2 i) ?\[)
                                (setq matrix t)
                                nil))))
           (setq math-read-big-lines (cdr math-read-big-lines)
                 v (1+ v)))
         (or (and (> height 1)
                  (not (cdr math-read-big-lines)))
             matrix))))

;;; Nontrivial "flat" formatting.

(defvar math-format-hash-args nil)
(defvar calc-can-abbrev-vectors nil)

(defun math-format-flat-expr-fancy (a prec)
  (cond
   ((eq (car a) 'incomplete)
    (format "<incomplete %s>" (nth 1 a)))
   ((eq (car a) 'vec)
    (if (or calc-full-trail-vectors (not calc-can-abbrev-vectors)
            (< (length a) 7))
        (concat "[" (math-format-flat-vector (cdr a) ", "
                                             (if (cdr (cdr a)) 0 1000)) "]")
      (concat "["
              (math-format-flat-expr (nth 1 a) 0) ", "
              (math-format-flat-expr (nth 2 a) 0) ", "
              (math-format-flat-expr (nth 3 a) 0) ", ..., "
              (math-format-flat-expr (nth (1- (length a)) a) 0) "]")))
   ((eq (car a) 'intv)
    (concat (if (memq (nth 1 a) '(0 1)) "(" "[")
            (math-format-flat-expr (nth 2 a) 1000)
            " .. "
            (math-format-flat-expr (nth 3 a) 1000)
            (if (memq (nth 1 a) '(0 2)) ")" "]")))
   ((eq (car a) 'date)
    (concat "<" (math-format-date a) ">"))
   ((and (eq (car a) 'calcFunc-lambda) (> (length a) 2))
    (let ((p (cdr a))
          (ap calc-arg-values)
          (math-format-hash-args (if (= (length a) 3) 1 t)))
      (while (and (cdr p) (equal (car p) (car ap)))
        (setq p (cdr p) ap (cdr ap)))
      (concat "<"
              (if (cdr p)
                  (concat (math-format-flat-vector
                           (nreverse (cdr (reverse (cdr a)))) ", " 0)
                          " : ")
                "")
              (math-format-flat-expr (nth (1- (length a)) a) 0)
              ">")))
   ((eq (car a) 'var)
    (or (and math-format-hash-args
             (let ((p calc-arg-values) (v 1))
               (while (and p (not (equal (car p) a)))
                 (setq p (and (eq math-format-hash-args t) (cdr p))
                       v (1+ v)))
               (and p
                    (if (eq math-format-hash-args 1)
                        "#"
                      (format "#%d" v)))))
        (symbol-name (nth 1 a))))
   ((and (memq (car a) '(calcFunc-string calcFunc-bstring))
         (= (length a) 2)
         (math-vectorp (nth 1 a))
         (math-vector-is-string (nth 1 a)))
    (concat (substring (symbol-name (car a)) 9)
            "(" (math-vector-to-string (nth 1 a) t) ")"))
   (t
    (let ((op (math-assq2 (car a) math-standard-opers)))
      (cond ((and op (= (length a) 3))
             (if (> prec (min (nth 2 op) (nth 3 op)))
                 (concat "(" (math-format-flat-expr a 0) ")")
               (let ((lhs (math-format-flat-expr (nth 1 a) (nth 2 op)))
                     (rhs (math-format-flat-expr (nth 2 a) (nth 3 op))))
                 (setq op (car op))
                 (if (or (equal op "^") (equal op "_"))
                     (if (= (aref lhs 0) ?-)
                         (setq lhs (concat "(" lhs ")")))
                   (setq op (concat " " op " ")))
                 (concat lhs op rhs))))
            ((eq (car a) 'neg)
             (concat "-" (math-format-flat-expr (nth 1 a) 1000)))
            (t
             (concat (math-remove-dashes
                      (if (string-match "\\`calcFunc-\\([a-zA-Z0-9']+\\)\\'"
                                        (symbol-name (car a)))
                          (math-match-substring (symbol-name (car a)) 1)
                        (symbol-name (car a))))
                     "("
                     (math-format-flat-vector (cdr a) ", " 0)
                     ")")))))))

(defun math-format-flat-vector (vec sep prec)
  (if vec
      (let ((buf (math-format-flat-expr (car vec) prec)))
        (while (setq vec (cdr vec))
          (setq buf (concat buf sep (math-format-flat-expr (car vec) prec))))
        buf)
    ""))

(defun math-format-nice-expr (x w)
  (cond ((and (eq (car-safe x) 'vec)
              (cdr (cdr x))
              (let ((ops '(vec calcFunc-assign calcFunc-condition
                               calcFunc-schedule calcFunc-iterations
                               calcFunc-phase)))
                (or (memq (car-safe (nth 1 x)) ops)
                    (memq (car-safe (nth 2 x)) ops)
                    (memq (car-safe (nth 3 x)) ops)
                    calc-break-vectors)))
         (concat "[ " (math-format-flat-vector (cdr x) ",\n  " 0) " ]"))
        (t
         (let ((str (math-format-flat-expr x 0))
               (pos 0) p)
           (or (string-match "\"" str)
               (while (<= (setq p (+ pos w)) (length str))
                 (while (and (> (setq p (1- p)) pos)
                             (not (= (aref str p) ? ))))
                 (if (> p (+ pos 5))
                     (setq str (concat (substring str 0 p)
                                       "\n "
                                       (substring str p))
                           pos (1+ p))
                   (setq pos (+ pos w)))))
           str))))

(defun math-assq2 (v a)
  (while (and a (not (eq v (nth 1 (car a)))))
    (setq a (cdr a)))
  (car a))

(defun math-format-number-fancy (a prec)
  (cond
   ((eq (car a) 'float)    ; non-decimal radix
    (if (Math-integer-negp (nth 1 a))
        (concat "-" (math-format-number (math-neg a)))
      (let ((str (if (and calc-radix-formatter
                          (not (memq calc-language '(c pascal))))
                     (funcall calc-radix-formatter
                              calc-number-radix
                              (math-format-radix-float a prec))
                   (format "%d#%s" calc-number-radix
                           (math-format-radix-float a prec)))))
        (if (and prec (> prec 191) (string-match "\\*" str))
            (concat "(" str ")")
          str))))
   ((eq (car a) 'frac)
    (setq a (math-adjust-fraction a))
    (if (> (length (car calc-frac-format)) 1)
        (if (Math-integer-negp (nth 1 a))
            (concat "-" (math-format-number (math-neg a)))
          (let ((q (math-idivmod (nth 1 a) (nth 2 a))))
            (concat (let ((calc-frac-format nil))
                      (math-format-number (car q)))
                    (substring (car calc-frac-format) 0 1)
                    (let ((math-radix-explicit-format nil)
                          (calc-frac-format nil))
                      (math-format-number (cdr q)))
                    (substring (car calc-frac-format) 1 2)
                    (let ((math-radix-explicit-format nil)
                          (calc-frac-format nil))
                      (math-format-number (nth 2 a))))))
      (concat (let ((calc-frac-format nil))
                (math-format-number (nth 1 a)))
              (car calc-frac-format)
              (let ((math-radix-explicit-format nil)
                    (calc-frac-format nil))
                (math-format-number (nth 2 a))))))
   ((eq (car a) 'cplx)
    (if (math-zerop (nth 2 a))
        (math-format-number (nth 1 a))
      (if (null calc-complex-format)
          (concat "(" (math-format-number (nth 1 a))
                  ", " (math-format-number (nth 2 a)) ")")
        (if (math-zerop (nth 1 a))
            (if (math-equal-int (nth 2 a) 1)
                (symbol-name calc-complex-format)
              (if (math-equal-int (nth 2 a) -1)
                  (concat "-" (symbol-name calc-complex-format))
                (if prec
                    (math-compose-expr (list '* (nth 2 a) '(cplx 0 1)) prec)
                  (concat (math-format-number (nth 2 a)) " "
                          (symbol-name calc-complex-format)))))
          (if prec
              (math-compose-expr (list (if (math-negp (nth 2 a)) '- '+)
                                       (nth 1 a)
                                       (list 'cplx 0 (math-abs (nth 2 a))))
                                 prec)
            (concat (math-format-number (nth 1 a))
                    (if (math-negp (nth 2 a)) " - " " + ")
                    (math-format-number
                     (list 'cplx 0 (math-abs (nth 2 a))))))))))
   ((eq (car a) 'polar)
    (concat "(" (math-format-number (nth 1 a))
            "; " (math-format-number (nth 2 a)) ")"))
   ((eq (car a) 'hms)
    (if (math-negp a)
        (concat "-" (math-format-number (math-neg a)))
      (let ((calc-number-radix 10)
            (calc-leading-zeros nil)
            (calc-group-digits nil))
        (format calc-hms-format
                (let ((calc-frac-format '(":" nil)))
                  (math-format-number (nth 1 a)))
                (let ((calc-frac-format '(":" nil)))
                  (math-format-number (nth 2 a)))
                (math-format-number (nth 3 a))))))
   ((eq (car a) 'intv)
    (concat (if (memq (nth 1 a) '(0 1)) "(" "[")
            (math-format-number (nth 2 a))
            " .. "
            (math-format-number (nth 3 a))
            (if (memq (nth 1 a) '(0 2)) ")" "]")))
   ((eq (car a) 'sdev)
    (concat (math-format-number (nth 1 a))
            " +/- "
            (math-format-number (nth 2 a))))
   ((eq (car a) 'vec)
    (math-format-flat-expr a 0))
   (t (format "%s" a))))

(defun math-adjust-fraction (a)
  (if (nth 1 calc-frac-format)
      (progn
        (if (Math-integerp a) (setq a (list 'frac a 1)))
        (let ((g (math-quotient (nth 1 calc-frac-format)
                                (math-gcd (nth 2 a)
                                          (nth 1 calc-frac-format)))))
          (list 'frac (math-mul (nth 1 a) g) (math-mul (nth 2 a) g))))
    a))

(defun math-format-bignum-fancy (a)   ; [X L]
  (let ((str (cond ((= calc-number-radix 10)
                    (math-format-bignum-decimal a))
                   ((= calc-number-radix 2)
                    (math-format-bignum-binary a))
                   ((= calc-number-radix 8)
                    (math-format-bignum-octal a))
                   ((= calc-number-radix 16)
                    (math-format-bignum-hex a))
                   (t (math-format-bignum-radix a)))))
    (if calc-leading-zeros
        (let* ((calc-internal-prec 6)
               (digs (math-compute-max-digits (math-abs calc-word-size)
                                              calc-number-radix))
               (len (length str)))
          (if (< len digs)
              (setq str (concat (make-string (- digs len) ?0) str)))))
    (if calc-group-digits
        (let ((i (length str))
              (g (if (integerp calc-group-digits)
                     (math-abs calc-group-digits)
                   (if (memq calc-number-radix '(2 16)) 4 3))))
          (while (> i g)
            (setq i (- i g)
                  str (concat (substring str 0 i)
                              calc-group-char
                              (substring str i))))
          str))
    (if (and (/= calc-number-radix 10)
             math-radix-explicit-format)
        (if calc-radix-formatter
            (funcall calc-radix-formatter calc-number-radix str)
          (format "%d#%s" calc-number-radix str))
      str)))


(defun math-group-float (str)   ; [X X]
  (let* ((pt (or (string-match "[^0-9a-zA-Z]" str) (length str)))
         (g (if (integerp calc-group-digits) (math-abs calc-group-digits) 3))
         (i pt))
    (if (and (integerp calc-group-digits) (< calc-group-digits 0))
        (while (< (setq i (+ (1+ i) g)) (length str))
          (setq str (concat (substring str 0 i)
                            calc-group-char
                            (substring str i))
                i (+ i (1- (length calc-group-char))))))
    (setq i pt)
    (while (> i g)
      (setq i (- i g)
            str (concat (substring str 0 i)
                        calc-group-char
                        (substring str i))))
    str))

;;; Users can redefine this in their .emacs files.
(defvar calc-keypad-user-menu nil
  "If non-nil, this describes an additional menu for calc-keypad.
It should contain a list of three rows.
Each row should be a list of six keys.
Each key should be a list of a label string, plus a Calc command name spec.
A command spec is a command name symbol, a keyboard macro string, a
list containing a numeric entry string, or nil.
A key may contain additional specs for Inverse, Hyperbolic, and Inv+Hyp.")

(run-hooks 'calc-ext-load-hook)

(provide 'calc-ext)

;;; arch-tag: 1814ba7f-a390-49dc-9e25-a5adc205e97e
;;; calc-ext.el ends here