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

   1 ;;; calc-ext.el --- various extension functions for Calc
   2
   3 ;; Copyright (C) 1990-1993, 2001-2016 Free Software Foundation, Inc.
   4
   5 ;; Author: David Gillespie <daveg@synaptics.com>
   6
   7 ;; This file is part of GNU Emacs.
   8
   9 ;; GNU Emacs is free software: you can redistribute it and/or modify
  10 ;; it under the terms of the GNU General Public License as published by
  11 ;; the Free Software Foundation, either version 3 of the License, or
  12 ;; (at your option) any later version.
  13
  14 ;; GNU Emacs is distributed in the hope that it will be useful,
  15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 ;; GNU General Public License for more details.
  18
  19 ;; You should have received a copy of the GNU General Public License
  20 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  21
  22 ;;; Commentary:
  23
  24 ;;; Code:
  25
  26 (require 'calc)
  27 (require 'calc-macs)
  28
  29 ;; Declare functions which are defined elsewhere.
  30 (declare-function math-clip "calc-bin" (a &optional w))
  31 (declare-function math-round "calc-arith" (a &optional prec))
  32 (declare-function math-simplify "calc-alg" (top-expr))
  33 (declare-function math-simplify-extended "calc-alg" (a))
  34 (declare-function math-simplify-units "calc-units" (a))
  35 (declare-function calc-set-language "calc-lang" (lang &optional option no-refresh))
  36 (declare-function calc-flush-caches "calc-stuff" (&optional inhibit-msg))
  37 (declare-function calc-save-modes "calc-mode" ())
  38 (declare-function calc-embedded-modes-change "calc-embed" (vars))
  39 (declare-function calc-embedded-var-change "calc-embed" (var &optional buf))
  40 (declare-function math-mul-float "calc-arith" (a b))
  41 (declare-function math-arctan-raw "calc-math" (x))
  42 (declare-function math-sqrt-raw "calc-math" (a &optional guess))
  43 (declare-function math-sqrt-float "calc-math" (a &optional guess))
  44 (declare-function math-exp-minus-1-raw "calc-math" (x))
  45 (declare-function math-normalize-polar "calc-cplx" (a))
  46 (declare-function math-normalize-hms "calc-forms" (a))
  47 (declare-function math-normalize-mod "calc-forms" (a))
  48 (declare-function math-make-sdev "calc-forms" (x sigma))
  49 (declare-function math-make-intv "calc-forms" (mask lo hi))
  50 (declare-function math-normalize-logical-op "calc-prog" (a))
  51 (declare-function math-possible-signs "calc-arith" (a &optional origin))
  52 (declare-function math-infinite-dir "calc-math" (a &optional inf))
  53 (declare-function math-calcFunc-to-var "calc-map" (f))
  54 (declare-function calc-embedded-evaluate-expr "calc-embed" (x))
  55 (declare-function math-known-nonzerop "calc-arith" (a))
  56 (declare-function math-read-expr-level "calc-aent" (exp-prec &optional exp-term))
  57 (declare-function math-read-big-rec "calc-lang" (math-rb-h1 math-rb-v1 math-rb-h2 math-rb-v2 &optional baseline prec short))
  58 (declare-function math-read-big-balance "calc-lang" (h v what &optional commas))
  59 (declare-function math-format-date "calc-forms" (math-fd-date))
  60 (declare-function math-vector-is-string "calccomp" (a))
  61 (declare-function math-vector-to-string "calccomp" (a &optional quoted))
  62 (declare-function math-format-radix-float "calc-bin" (a prec))
  63 (declare-function math-compose-expr "calccomp" (a prec &optional div))
  64 (declare-function math-abs "calc-arith" (a))
  65 (declare-function math-format-bignum-binary "calc-bin" (a))
  66 (declare-function math-format-bignum-octal "calc-bin" (a))
  67 (declare-function math-format-bignum-hex "calc-bin" (a))
  68 (declare-function math-format-bignum-radix "calc-bin" (a))
  69 (declare-function math-compute-max-digits "calc-bin" (w r))
  70 (declare-function math-map-vec "calc-vec" (f a))
  71 (declare-function math-make-frac "calc-frac" (num den))
  72
  73
  74 (defvar math-simplifying nil)
  75 (defvar math-living-dangerously nil)   ; true if unsafe simplifications are okay.
  76 (defvar math-integrating nil)
  77
  78 (defvar math-rewrite-selections nil)
  79
  80 (defvar math-compose-level 0)
  81 (defvar math-comp-selected nil)
  82 (defvar math-comp-tagged nil)
  83 (defvar math-comp-sel-hpos nil)
  84 (defvar math-comp-sel-vpos nil)
  85 (defvar math-comp-sel-cpos nil)
  86 (defvar math-compose-hash-args nil)
  87
  88 (defvar calc-alg-map)
  89 (defvar calc-alg-esc-map)
  90
  91 ;;; The following was made a function so that it could be byte-compiled.
  92 (defun calc-init-extensions ()
  93
  94   (define-key calc-mode-map ":" 'calc-fdiv)
  95   (define-key calc-mode-map "\\" 'calc-idiv)
  96   (define-key calc-mode-map "|" 'calc-concat)
  97   (define-key calc-mode-map "!" 'calc-factorial)
  98   (define-key calc-mode-map "C" 'calc-cos)
  99   (define-key calc-mode-map "E" 'calc-exp)
 100   (define-key calc-mode-map "H" 'calc-hyperbolic)
 101   (define-key calc-mode-map "I" 'calc-inverse)
 102   (define-key calc-mode-map "J" 'calc-conj)
 103   (define-key calc-mode-map "L" 'calc-ln)
 104   (define-key calc-mode-map "N" 'calc-eval-num)
 105   (define-key calc-mode-map "O" 'calc-option)
 106   (define-key calc-mode-map "P" 'calc-pi)
 107   (define-key calc-mode-map "Q" 'calc-sqrt)
 108   (define-key calc-mode-map "R" 'calc-round)
 109   (define-key calc-mode-map "S" 'calc-sin)
 110   (define-key calc-mode-map "T" 'calc-tan)
 111   (define-key calc-mode-map "U" 'calc-undo)
 112   (define-key calc-mode-map "X" 'calc-call-last-kbd-macro)
 113   (define-key calc-mode-map "o" 'calc-realign)
 114   (define-key calc-mode-map "p" 'calc-precision)
 115   (define-key calc-mode-map "w" 'calc-why)
 116   (define-key calc-mode-map "x" 'calc-execute-extended-command)
 117   (define-key calc-mode-map "y" 'calc-copy-to-buffer)
 118
 119   (define-key calc-mode-map "(" 'calc-begin-complex)
 120   (define-key calc-mode-map ")" 'calc-end-complex)
 121   (define-key calc-mode-map "[" 'calc-begin-vector)
 122   (define-key calc-mode-map "]" 'calc-end-vector)
 123   (define-key calc-mode-map "," 'calc-comma)
 124   (define-key calc-mode-map ";" 'calc-semi)
 125   (define-key calc-mode-map "`" 'calc-edit)
 126   (define-key calc-mode-map "=" 'calc-evaluate)
 127   (define-key calc-mode-map "~" 'calc-num-prefix)
 128   (define-key calc-mode-map "<" 'calc-scroll-left)
 129   (define-key calc-mode-map ">" 'calc-scroll-right)
 130   (define-key calc-mode-map "{" 'calc-scroll-down)
 131   (define-key calc-mode-map "}" 'calc-scroll-up)
 132   (define-key calc-mode-map "\C-k" 'calc-kill)
 133   (define-key calc-mode-map "\M-k" 'calc-copy-as-kill)
 134   (define-key calc-mode-map "\C-w" 'calc-kill-region)
 135   (define-key calc-mode-map "\M-w" 'calc-copy-region-as-kill)
 136   (define-key calc-mode-map "\M-\C-w" 'kill-ring-save)
 137   (define-key calc-mode-map "\M-\C-m" 'calc-last-args)
 138
 139   (define-key calc-mode-map "a" nil)
 140   (define-key calc-mode-map "a?" 'calc-a-prefix-help)
 141   (define-key calc-mode-map "aa" 'calc-apart)
 142   (define-key calc-mode-map "ab" 'calc-substitute)
 143   (define-key calc-mode-map "ac" 'calc-collect)
 144   (define-key calc-mode-map "ad" 'calc-derivative)
 145   (define-key calc-mode-map "ae" 'calc-simplify-extended)
 146   (define-key calc-mode-map "af" 'calc-factor)
 147   (define-key calc-mode-map "ag" 'calc-poly-gcd)
 148   (define-key calc-mode-map "ai" 'calc-integral)
 149   (define-key calc-mode-map "am" 'calc-match)
 150   (define-key calc-mode-map "an" 'calc-normalize-rat)
 151   (define-key calc-mode-map "ap" 'calc-poly-interp)
 152   (define-key calc-mode-map "ar" 'calc-rewrite)
 153   (define-key calc-mode-map "as" 'calc-simplify)
 154   (define-key calc-mode-map "at" 'calc-taylor)
 155   (define-key calc-mode-map "av" 'calc-alg-evaluate)
 156   (define-key calc-mode-map "ax" 'calc-expand)
 157   (define-key calc-mode-map "aA" 'calc-abs)
 158   (define-key calc-mode-map "aF" 'calc-curve-fit)
 159   (define-key calc-mode-map "aI" 'calc-num-integral)
 160   (define-key calc-mode-map "aM" 'calc-map-equation)
 161   (define-key calc-mode-map "aN" 'calc-find-minimum)
 162   (define-key calc-mode-map "aP" 'calc-poly-roots)
 163   (define-key calc-mode-map "aS" 'calc-solve-for)
 164   (define-key calc-mode-map "aR" 'calc-find-root)
 165   (define-key calc-mode-map "aT" 'calc-tabulate)
 166   (define-key calc-mode-map "aX" 'calc-find-maximum)
 167   (define-key calc-mode-map "a+" 'calc-summation)
 168   (define-key calc-mode-map "a-" 'calc-alt-summation)
 169   (define-key calc-mode-map "a*" 'calc-product)
 170   (define-key calc-mode-map "a\\" 'calc-poly-div)
 171   (define-key calc-mode-map "a%" 'calc-poly-rem)
 172   (define-key calc-mode-map "a/" 'calc-poly-div-rem)
 173   (define-key calc-mode-map "a=" 'calc-equal-to)
 174   (define-key calc-mode-map "a#" 'calc-not-equal-to)
 175   (define-key calc-mode-map "a<" 'calc-less-than)
 176   (define-key calc-mode-map "a>" 'calc-greater-than)
 177   (define-key calc-mode-map "a[" 'calc-less-equal)
 178   (define-key calc-mode-map "a]" 'calc-greater-equal)
 179   (define-key calc-mode-map "a." 'calc-remove-equal)
 180   (define-key calc-mode-map "a{" 'calc-in-set)
 181   (define-key calc-mode-map "a&" 'calc-logical-and)
 182   (define-key calc-mode-map "a|" 'calc-logical-or)
 183   (define-key calc-mode-map "a!" 'calc-logical-not)
 184   (define-key calc-mode-map "a:" 'calc-logical-if)
 185   (define-key calc-mode-map "a_" 'calc-subscript)
 186   (define-key calc-mode-map "a\"" 'calc-expand-formula)
 187
 188   (define-key calc-mode-map "b" nil)
 189   (define-key calc-mode-map "b?" 'calc-b-prefix-help)
 190   (define-key calc-mode-map "ba" 'calc-and)
 191   (define-key calc-mode-map "bc" 'calc-clip)
 192   (define-key calc-mode-map "bd" 'calc-diff)
 193   (define-key calc-mode-map "bl" 'calc-lshift-binary)
 194   (define-key calc-mode-map "bn" 'calc-not)
 195   (define-key calc-mode-map "bo" 'calc-or)
 196   (define-key calc-mode-map "bp" 'calc-pack-bits)
 197   (define-key calc-mode-map "br" 'calc-rshift-binary)
 198   (define-key calc-mode-map "bt" 'calc-rotate-binary)
 199   (define-key calc-mode-map "bu" 'calc-unpack-bits)
 200   (define-key calc-mode-map "bw" 'calc-word-size)
 201   (define-key calc-mode-map "bx" 'calc-xor)
 202   (define-key calc-mode-map "bB" 'calc-log)
 203   (define-key calc-mode-map "bD" 'calc-fin-ddb)
 204   (define-key calc-mode-map "bF" 'calc-fin-fv)
 205   (define-key calc-mode-map "bI" 'calc-fin-irr)
 206   (define-key calc-mode-map "bL" 'calc-lshift-arith)
 207   (define-key calc-mode-map "bM" 'calc-fin-pmt)
 208   (define-key calc-mode-map "bN" 'calc-fin-npv)
 209   (define-key calc-mode-map "bP" 'calc-fin-pv)
 210   (define-key calc-mode-map "bR" 'calc-rshift-arith)
 211   (define-key calc-mode-map "bS" 'calc-fin-sln)
 212   (define-key calc-mode-map "bT" 'calc-fin-rate)
 213   (define-key calc-mode-map "bY" 'calc-fin-syd)
 214   (define-key calc-mode-map "b#" 'calc-fin-nper)
 215   (define-key calc-mode-map "b%" 'calc-percent-change)
 216
 217   (define-key calc-mode-map "c" nil)
 218   (define-key calc-mode-map "c?" 'calc-c-prefix-help)
 219   (define-key calc-mode-map "cc" 'calc-clean)
 220   (define-key calc-mode-map "cd" 'calc-to-degrees)
 221   (define-key calc-mode-map "cf" 'calc-float)
 222   (define-key calc-mode-map "ch" 'calc-to-hms)
 223   (define-key calc-mode-map "cp" 'calc-polar)
 224   (define-key calc-mode-map "cr" 'calc-to-radians)
 225   (define-key calc-mode-map "cC" 'calc-cos)
 226   (define-key calc-mode-map "cF" 'calc-fraction)
 227   (define-key calc-mode-map "c%" 'calc-convert-percent)
 228
 229   (define-key calc-mode-map "d" nil)
 230   (define-key calc-mode-map "d?" 'calc-d-prefix-help)
 231   (define-key calc-mode-map "d0" 'calc-decimal-radix)
 232   (define-key calc-mode-map "d2" 'calc-binary-radix)
 233   (define-key calc-mode-map "d6" 'calc-hex-radix)
 234   (define-key calc-mode-map "d8" 'calc-octal-radix)
 235   (define-key calc-mode-map "db" 'calc-line-breaking)
 236   (define-key calc-mode-map "dc" 'calc-complex-notation)
 237   (define-key calc-mode-map "dd" 'calc-date-notation)
 238   (define-key calc-mode-map "de" 'calc-eng-notation)
 239   (define-key calc-mode-map "df" 'calc-fix-notation)
 240   (define-key calc-mode-map "dg" 'calc-group-digits)
 241   (define-key calc-mode-map "dh" 'calc-hms-notation)
 242   (define-key calc-mode-map "di" 'calc-i-notation)
 243   (define-key calc-mode-map "dj" 'calc-j-notation)
 244   (define-key calc-mode-map "dl" 'calc-line-numbering)
 245   (define-key calc-mode-map "dn" 'calc-normal-notation)
 246   (define-key calc-mode-map "do" 'calc-over-notation)
 247   (define-key calc-mode-map "dp" 'calc-show-plain)
 248   (define-key calc-mode-map "dr" 'calc-radix)
 249   (define-key calc-mode-map "ds" 'calc-sci-notation)
 250   (define-key calc-mode-map "dt" 'calc-truncate-stack)
 251   (define-key calc-mode-map "dw" 'calc-auto-why)
 252   (define-key calc-mode-map "dz" 'calc-leading-zeros)
 253   (define-key calc-mode-map "dA" 'calc-giac-language)
 254   (define-key calc-mode-map "dB" 'calc-big-language)
 255   (define-key calc-mode-map "dD" 'calc-redo)
 256   (define-key calc-mode-map "dC" 'calc-c-language)
 257   (define-key calc-mode-map "dE" 'calc-eqn-language)
 258   (define-key calc-mode-map "dF" 'calc-fortran-language)
 259   (define-key calc-mode-map "dM" 'calc-mathematica-language)
 260   (define-key calc-mode-map "dN" 'calc-normal-language)
 261   (define-key calc-mode-map "dO" 'calc-flat-language)
 262   (define-key calc-mode-map "dP" 'calc-pascal-language)
 263   (define-key calc-mode-map "dT" 'calc-tex-language)
 264   (define-key calc-mode-map "dL" 'calc-latex-language)
 265   (define-key calc-mode-map "dU" 'calc-unformatted-language)
 266   (define-key calc-mode-map "dW" 'calc-maple-language)
 267   (define-key calc-mode-map "dX" 'calc-maxima-language)
 268   (define-key calc-mode-map "dY" 'calc-yacas-language)
 269   (define-key calc-mode-map "d[" 'calc-truncate-up)
 270   (define-key calc-mode-map "d]" 'calc-truncate-down)
 271   (define-key calc-mode-map "d." 'calc-point-char)
 272   (define-key calc-mode-map "d," 'calc-group-char)
 273   (define-key calc-mode-map "d\"" 'calc-display-strings)
 274   (define-key calc-mode-map "d<" 'calc-left-justify)
 275   (define-key calc-mode-map "d=" 'calc-center-justify)
 276   (define-key calc-mode-map "d>" 'calc-right-justify)
 277   (define-key calc-mode-map "d{" 'calc-left-label)
 278   (define-key calc-mode-map "d}" 'calc-right-label)
 279   (define-key calc-mode-map "d'" 'calc-display-raw)
 280   (define-key calc-mode-map "d " 'calc-refresh)
 281   (define-key calc-mode-map "d\r" 'calc-refresh-top)
 282   (define-key calc-mode-map "d@" 'calc-toggle-banner)
 283
 284   (define-key calc-mode-map "f" nil)
 285   (define-key calc-mode-map "f?" 'calc-f-prefix-help)
 286   (define-key calc-mode-map "fb" 'calc-beta)
 287   (define-key calc-mode-map "fe" 'calc-erf)
 288   (define-key calc-mode-map "fg" 'calc-gamma)
 289   (define-key calc-mode-map "fh" 'calc-hypot)
 290   (define-key calc-mode-map "fi" 'calc-im)
 291   (define-key calc-mode-map "fj" 'calc-bessel-J)
 292   (define-key calc-mode-map "fn" 'calc-min)
 293   (define-key calc-mode-map "fr" 'calc-re)
 294   (define-key calc-mode-map "fs" 'calc-sign)
 295   (define-key calc-mode-map "fx" 'calc-max)
 296   (define-key calc-mode-map "fy" 'calc-bessel-Y)
 297   (define-key calc-mode-map "fA" 'calc-abssqr)
 298   (define-key calc-mode-map "fB" 'calc-inc-beta)
 299   (define-key calc-mode-map "fE" 'calc-expm1)
 300   (define-key calc-mode-map "fF" 'calc-floor)
 301   (define-key calc-mode-map "fG" 'calc-inc-gamma)
 302   (define-key calc-mode-map "fI" 'calc-ilog)
 303   (define-key calc-mode-map "fL" 'calc-lnp1)
 304   (define-key calc-mode-map "fM" 'calc-mant-part)
 305   (define-key calc-mode-map "fQ" 'calc-isqrt)
 306   (define-key calc-mode-map "fS" 'calc-scale-float)
 307   (define-key calc-mode-map "fT" 'calc-arctan2)
 308   (define-key calc-mode-map "fX" 'calc-xpon-part)
 309   (define-key calc-mode-map "f[" 'calc-decrement)
 310   (define-key calc-mode-map "f]" 'calc-increment)
 311
 312   (define-key calc-mode-map "g" nil)
 313   (define-key calc-mode-map "g?" 'calc-g-prefix-help)
 314   (define-key calc-mode-map "ga" 'calc-graph-add)
 315   (define-key calc-mode-map "gb" 'calc-graph-border)
 316   (define-key calc-mode-map "gc" 'calc-graph-clear)
 317   (define-key calc-mode-map "gd" 'calc-graph-delete)
 318   (define-key calc-mode-map "gf" 'calc-graph-fast)
 319   (define-key calc-mode-map "gg" 'calc-graph-grid)
 320   (define-key calc-mode-map "gh" 'calc-graph-header)
 321   (define-key calc-mode-map "gk" 'calc-graph-key)
 322   (define-key calc-mode-map "gj" 'calc-graph-juggle)
 323   (define-key calc-mode-map "gl" 'calc-graph-log-x)
 324   (define-key calc-mode-map "gn" 'calc-graph-name)
 325   (define-key calc-mode-map "gp" 'calc-graph-plot)
 326   (define-key calc-mode-map "gq" 'calc-graph-quit)
 327   (define-key calc-mode-map "gr" 'calc-graph-range-x)
 328   (define-key calc-mode-map "gs" 'calc-graph-line-style)
 329   (define-key calc-mode-map "gt" 'calc-graph-title-x)
 330   (define-key calc-mode-map "gv" 'calc-graph-view-commands)
 331   (define-key calc-mode-map "gx" 'calc-graph-display)
 332   (define-key calc-mode-map "gz" 'calc-graph-zero-x)
 333   (define-key calc-mode-map "gA" 'calc-graph-add-3d)
 334   (define-key calc-mode-map "gC" 'calc-graph-command)
 335   (define-key calc-mode-map "gD" 'calc-graph-device)
 336   (define-key calc-mode-map "gF" 'calc-graph-fast-3d)
 337   (define-key calc-mode-map "gG" 'calc-argument)
 338   (define-key calc-mode-map "gH" 'calc-graph-hide)
 339   (define-key calc-mode-map "gK" 'calc-graph-kill)
 340   (define-key calc-mode-map "gL" 'calc-graph-log-y)
 341   (define-key calc-mode-map "gN" 'calc-graph-num-points)
 342   (define-key calc-mode-map "gO" 'calc-graph-output)
 343   (define-key calc-mode-map "gP" 'calc-graph-print)
 344   (define-key calc-mode-map "gR" 'calc-graph-range-y)
 345   (define-key calc-mode-map "gS" 'calc-graph-point-style)
 346   (define-key calc-mode-map "gT" 'calc-graph-title-y)
 347   (define-key calc-mode-map "gV" 'calc-graph-view-trail)
 348   (define-key calc-mode-map "gX" 'calc-graph-geometry)
 349   (define-key calc-mode-map "gZ" 'calc-graph-zero-y)
 350   (define-key calc-mode-map "g\C-l" 'calc-graph-log-z)
 351   (define-key calc-mode-map "g\C-r" 'calc-graph-range-z)
 352   (define-key calc-mode-map "g\C-t" 'calc-graph-title-z)
 353
 354   (define-key calc-mode-map "h" 'calc-help-prefix)
 355
 356   (define-key calc-mode-map "j" nil)
 357   (define-key calc-mode-map "j?" 'calc-j-prefix-help)
 358   (define-key calc-mode-map "ja" 'calc-select-additional)
 359   (define-key calc-mode-map "jb" 'calc-break-selections)
 360   (define-key calc-mode-map "jc" 'calc-clear-selections)
 361   (define-key calc-mode-map "jd" 'calc-show-selections)
 362   (define-key calc-mode-map "je" 'calc-enable-selections)
 363   (define-key calc-mode-map "jl" 'calc-select-less)
 364   (define-key calc-mode-map "jm" 'calc-select-more)
 365   (define-key calc-mode-map "jn" 'calc-select-next)
 366   (define-key calc-mode-map "jo" 'calc-select-once)
 367   (define-key calc-mode-map "jp" 'calc-select-previous)
 368   (define-key calc-mode-map "jr" 'calc-rewrite-selection)
 369   (define-key calc-mode-map "js" 'calc-select-here)
 370   (define-key calc-mode-map "jv" 'calc-sel-evaluate)
 371   (define-key calc-mode-map "ju" 'calc-unselect)
 372   (define-key calc-mode-map "jC" 'calc-sel-commute)
 373   (define-key calc-mode-map "jD" 'calc-sel-distribute)
 374   (define-key calc-mode-map "jE" 'calc-sel-jump-equals)
 375   (define-key calc-mode-map "jI" 'calc-sel-isolate)
 376   (define-key calc-mode-map "jJ" 'calc-conj)
 377   (define-key calc-mode-map "jL" 'calc-commute-left)
 378   (define-key calc-mode-map "jM" 'calc-sel-merge)
 379   (define-key calc-mode-map "jN" 'calc-sel-negate)
 380   (define-key calc-mode-map "jO" 'calc-select-once-maybe)
 381   (define-key calc-mode-map "jR" 'calc-commute-right)
 382   (define-key calc-mode-map "jS" 'calc-select-here-maybe)
 383   (define-key calc-mode-map "jU" 'calc-sel-unpack)
 384   (define-key calc-mode-map "j&" 'calc-sel-invert)
 385   (define-key calc-mode-map "j\r" 'calc-copy-selection)
 386   (define-key calc-mode-map "j\n" 'calc-copy-selection)
 387   (define-key calc-mode-map "j\010" 'calc-del-selection)
 388   (define-key calc-mode-map "j\177" 'calc-del-selection)
 389   (define-key calc-mode-map "j'" 'calc-enter-selection)
 390   (define-key calc-mode-map "j`" 'calc-edit-selection)
 391   (define-key calc-mode-map "j+" 'calc-sel-add-both-sides)
 392   (define-key calc-mode-map "j-" 'calc-sel-sub-both-sides)
 393   (define-key calc-mode-map "j*" 'calc-sel-mult-both-sides)
 394   (define-key calc-mode-map "j/" 'calc-sel-div-both-sides)
 395   (define-key calc-mode-map "j\"" 'calc-sel-expand-formula)
 396
 397   (define-key calc-mode-map "k" nil)
 398   (define-key calc-mode-map "k?" 'calc-k-prefix-help)
 399   (define-key calc-mode-map "ka" 'calc-random-again)
 400   (define-key calc-mode-map "kb" 'calc-bernoulli-number)
 401   (define-key calc-mode-map "kc" 'calc-choose)
 402   (define-key calc-mode-map "kd" 'calc-double-factorial)
 403   (define-key calc-mode-map "ke" 'calc-euler-number)
 404   (define-key calc-mode-map "kf" 'calc-prime-factors)
 405   (define-key calc-mode-map "kg" 'calc-gcd)
 406   (define-key calc-mode-map "kh" 'calc-shuffle)
 407   (define-key calc-mode-map "kl" 'calc-lcm)
 408   (define-key calc-mode-map "km" 'calc-moebius)
 409   (define-key calc-mode-map "kn" 'calc-next-prime)
 410   (define-key calc-mode-map "kp" 'calc-prime-test)
 411   (define-key calc-mode-map "kr" 'calc-random)
 412   (define-key calc-mode-map "ks" 'calc-stirling-number)
 413   (define-key calc-mode-map "kt" 'calc-totient)
 414   (define-key calc-mode-map "kB" 'calc-utpb)
 415   (define-key calc-mode-map "kC" 'calc-utpc)
 416   (define-key calc-mode-map "kE" 'calc-extended-gcd)
 417   (define-key calc-mode-map "kF" 'calc-utpf)
 418   (define-key calc-mode-map "kK" 'calc-keep-args)
 419   (define-key calc-mode-map "kN" 'calc-utpn)
 420   (define-key calc-mode-map "kP" 'calc-utpp)
 421   (define-key calc-mode-map "kT" 'calc-utpt)
 422
 423   (define-key calc-mode-map "l" nil)
 424   (define-key calc-mode-map "lq" 'calc-lu-quant)
 425   (define-key calc-mode-map "ld" 'calc-db)
 426   (define-key calc-mode-map "ln" 'calc-np)
 427   (define-key calc-mode-map "l+" 'calc-lu-plus)
 428   (define-key calc-mode-map "l-" 'calc-lu-minus)
 429   (define-key calc-mode-map "l*" 'calc-lu-times)
 430   (define-key calc-mode-map "l/" 'calc-lu-divide)
 431   (define-key calc-mode-map "ls" 'calc-spn)
 432   (define-key calc-mode-map "lm" 'calc-midi)
 433   (define-key calc-mode-map "lf" 'calc-freq)
 434
 435   (define-key calc-mode-map "l?" 'calc-l-prefix-help)
 436
 437   (define-key calc-mode-map "m" nil)
 438   (define-key calc-mode-map "m?" 'calc-m-prefix-help)
 439   (define-key calc-mode-map "ma" 'calc-algebraic-mode)
 440   (define-key calc-mode-map "md" 'calc-degrees-mode)
 441   (define-key calc-mode-map "me" 'calc-embedded-preserve-modes)
 442   (define-key calc-mode-map "mf" 'calc-frac-mode)
 443   (define-key calc-mode-map "mg" 'calc-get-modes)
 444   (define-key calc-mode-map "mh" 'calc-hms-mode)
 445   (define-key calc-mode-map "mi" 'calc-infinite-mode)
 446   (define-key calc-mode-map "mm" 'calc-save-modes)
 447   (define-key calc-mode-map "mp" 'calc-polar-mode)
 448   (define-key calc-mode-map "mr" 'calc-radians-mode)
 449   (define-key calc-mode-map "ms" 'calc-symbolic-mode)
 450   (define-key calc-mode-map "mt" 'calc-total-algebraic-mode)
 451   (define-key calc-mode-map "\emt" 'calc-total-algebraic-mode)
 452   (define-key calc-mode-map "\em\et" 'calc-total-algebraic-mode)
 453   (define-key calc-mode-map "mv" 'calc-matrix-mode)
 454   (define-key calc-mode-map "mw" 'calc-working)
 455   (define-key calc-mode-map "mx" 'calc-always-load-extensions)
 456   (define-key calc-mode-map "mA" 'calc-alg-simplify-mode)
 457   (define-key calc-mode-map "mB" 'calc-bin-simplify-mode)
 458   (define-key calc-mode-map "mC" 'calc-auto-recompute)
 459   (define-key calc-mode-map "mD" 'calc-default-simplify-mode)
 460   (define-key calc-mode-map "mE" 'calc-ext-simplify-mode)
 461   (define-key calc-mode-map "mF" 'calc-settings-file-name)
 462   (define-key calc-mode-map "mI" 'calc-basic-simplify-mode)
 463   (define-key calc-mode-map "mM" 'calc-more-recursion-depth)
 464   (define-key calc-mode-map "mN" 'calc-num-simplify-mode)
 465   (define-key calc-mode-map "mO" 'calc-no-simplify-mode)
 466   (define-key calc-mode-map "mR" 'calc-mode-record-mode)
 467   (define-key calc-mode-map "mS" 'calc-shift-prefix)
 468   (define-key calc-mode-map "mU" 'calc-units-simplify-mode)
 469   (define-key calc-mode-map "mX" 'calc-load-everything)
 470
 471   (define-key calc-mode-map "r" nil)
 472   (define-key calc-mode-map "ri" 'calc-insert-register)
 473   (define-key calc-mode-map "rs" 'calc-copy-to-register)
 474   (define-key calc-mode-map "r?" 'calc-r-prefix-help)
 475
 476   (define-key calc-mode-map "s" nil)
 477   (define-key calc-mode-map "s?" 'calc-s-prefix-help)
 478   (define-key calc-mode-map "sc" 'calc-copy-variable)
 479   (define-key calc-mode-map "sd" 'calc-declare-variable)
 480   (define-key calc-mode-map "se" 'calc-edit-variable)
 481   (define-key calc-mode-map "si" 'calc-insert-variables)
 482   (define-key calc-mode-map "sk" 'calc-copy-special-constant)
 483   (define-key calc-mode-map "sl" 'calc-let)
 484   (define-key calc-mode-map "sm" 'calc-store-map)
 485   (define-key calc-mode-map "sn" 'calc-store-neg)
 486   (define-key calc-mode-map "sp" 'calc-permanent-variable)
 487   (define-key calc-mode-map "sr" 'calc-recall)
 488   (define-key calc-mode-map "ss" 'calc-store)
 489   (define-key calc-mode-map "st" 'calc-store-into)
 490   (define-key calc-mode-map "su" 'calc-unstore)
 491   (define-key calc-mode-map "sx" 'calc-store-exchange)
 492   (define-key calc-mode-map "sA" 'calc-edit-AlgSimpRules)
 493   (define-key calc-mode-map "sD" 'calc-edit-Decls)
 494   (define-key calc-mode-map "sE" 'calc-edit-EvalRules)
 495   (define-key calc-mode-map "sF" 'calc-edit-FitRules)
 496   (define-key calc-mode-map "sG" 'calc-edit-GenCount)
 497   (define-key calc-mode-map "sH" 'calc-edit-Holidays)
 498   (define-key calc-mode-map "sI" 'calc-edit-IntegLimit)
 499   (define-key calc-mode-map "sL" 'calc-edit-LineStyles)
 500   (define-key calc-mode-map "sP" 'calc-edit-PointStyles)
 501   (define-key calc-mode-map "sR" 'calc-edit-PlotRejects)
 502   (define-key calc-mode-map "sS" 'calc-sin)
 503   (define-key calc-mode-map "sT" 'calc-edit-TimeZone)
 504   (define-key calc-mode-map "sU" 'calc-edit-Units)
 505   (define-key calc-mode-map "sX" 'calc-edit-ExtSimpRules)
 506   (define-key calc-mode-map "s+" 'calc-store-plus)
 507   (define-key calc-mode-map "s-" 'calc-store-minus)
 508   (define-key calc-mode-map "s*" 'calc-store-times)
 509   (define-key calc-mode-map "s/" 'calc-store-div)
 510   (define-key calc-mode-map "s^" 'calc-store-power)
 511   (define-key calc-mode-map "s|" 'calc-store-concat)
 512   (define-key calc-mode-map "s&" 'calc-store-inv)
 513   (define-key calc-mode-map "s[" 'calc-store-decr)
 514   (define-key calc-mode-map "s]" 'calc-store-incr)
 515   (define-key calc-mode-map "s:" 'calc-assign)
 516   (define-key calc-mode-map "s=" 'calc-evalto)
 517
 518   (define-key calc-mode-map "t" nil)
 519   (define-key calc-mode-map "t?" 'calc-t-prefix-help)
 520   (define-key calc-mode-map "tb" 'calc-trail-backward)
 521   (define-key calc-mode-map "td" 'calc-trail-display)
 522   (define-key calc-mode-map "tf" 'calc-trail-forward)
 523   (define-key calc-mode-map "th" 'calc-trail-here)
 524   (define-key calc-mode-map "ti" 'calc-trail-in)
 525   (define-key calc-mode-map "tk" 'calc-trail-kill)
 526   (define-key calc-mode-map "tm" 'calc-trail-marker)
 527   (define-key calc-mode-map "tn" 'calc-trail-next)
 528   (define-key calc-mode-map "to" 'calc-trail-out)
 529   (define-key calc-mode-map "tp" 'calc-trail-previous)
 530   (define-key calc-mode-map "tr" 'calc-trail-isearch-backward)
 531   (define-key calc-mode-map "ts" 'calc-trail-isearch-forward)
 532   (define-key calc-mode-map "ty" 'calc-trail-yank)
 533   (define-key calc-mode-map "t[" 'calc-trail-first)
 534   (define-key calc-mode-map "t]" 'calc-trail-last)
 535   (define-key calc-mode-map "t<" 'calc-trail-scroll-left)
 536   (define-key calc-mode-map "t>" 'calc-trail-scroll-right)
 537   (define-key calc-mode-map "t{" 'calc-trail-backward)
 538   (define-key calc-mode-map "t}" 'calc-trail-forward)
 539   (define-key calc-mode-map "t." 'calc-full-trail-vectors)
 540   (define-key calc-mode-map "tC" 'calc-convert-time-zones)
 541   (define-key calc-mode-map "tD" 'calc-date)
 542   (define-key calc-mode-map "tI" 'calc-inc-month)
 543   (define-key calc-mode-map "tJ" 'calc-julian)
 544   (define-key calc-mode-map "tM" 'calc-new-month)
 545   (define-key calc-mode-map "tN" 'calc-now)
 546   (define-key calc-mode-map "tP" 'calc-date-part)
 547   (define-key calc-mode-map "tT" 'calc-tan)
 548   (define-key calc-mode-map "tU" 'calc-unix-time)
 549   (define-key calc-mode-map "tW" 'calc-new-week)
 550   (define-key calc-mode-map "tY" 'calc-new-year)
 551   (define-key calc-mode-map "tZ" 'calc-time-zone)
 552   (define-key calc-mode-map "t+" 'calc-business-days-plus)
 553   (define-key calc-mode-map "t-" 'calc-business-days-minus)
 554
 555   (define-key calc-mode-map "u" 'nil)
 556   (define-key calc-mode-map "u?" 'calc-u-prefix-help)
 557   (define-key calc-mode-map "ua" 'calc-autorange-units)
 558   (define-key calc-mode-map "ub" 'calc-base-units)
 559   (define-key calc-mode-map "uc" 'calc-convert-units)
 560   (define-key calc-mode-map "ud" 'calc-define-unit)
 561   (define-key calc-mode-map "ue" 'calc-explain-units)
 562   (define-key calc-mode-map "ug" 'calc-get-unit-definition)
 563   (define-key calc-mode-map "un" 'calc-convert-exact-units)
 564   (define-key calc-mode-map "up" 'calc-permanent-units)
 565   (define-key calc-mode-map "ur" 'calc-remove-units)
 566   (define-key calc-mode-map "us" 'calc-simplify-units)
 567   (define-key calc-mode-map "ut" 'calc-convert-temperature)
 568   (define-key calc-mode-map "uu" 'calc-undefine-unit)
 569   (define-key calc-mode-map "uv" 'calc-enter-units-table)
 570   (define-key calc-mode-map "ux" 'calc-extract-units)
 571   (define-key calc-mode-map "uV" 'calc-view-units-table)
 572   (define-key calc-mode-map "uC" 'calc-vector-covariance)
 573   (define-key calc-mode-map "uG" 'calc-vector-geometric-mean)
 574   (define-key calc-mode-map "uM" 'calc-vector-mean)
 575   (define-key calc-mode-map "uN" 'calc-vector-min)
 576   (define-key calc-mode-map "uR" 'calc-vector-rms)
 577   (define-key calc-mode-map "uS" 'calc-vector-sdev)
 578   (define-key calc-mode-map "uU" 'calc-undo)
 579   (define-key calc-mode-map "uX" 'calc-vector-max)
 580   (define-key calc-mode-map "u#" 'calc-vector-count)
 581   (define-key calc-mode-map "u+" 'calc-vector-sum)
 582   (define-key calc-mode-map "u*" 'calc-vector-product)
 583
 584   (define-key calc-mode-map "v" 'nil)
 585   (define-key calc-mode-map "v?" 'calc-v-prefix-help)
 586   (define-key calc-mode-map "va" 'calc-arrange-vector)
 587   (define-key calc-mode-map "vb" 'calc-build-vector)
 588   (define-key calc-mode-map "vc" 'calc-mcol)
 589   (define-key calc-mode-map "vd" 'calc-diag)
 590   (define-key calc-mode-map "ve" 'calc-expand-vector)
 591   (define-key calc-mode-map "vf" 'calc-vector-find)
 592   (define-key calc-mode-map "vh" 'calc-head)
 593   (define-key calc-mode-map "vi" 'calc-ident)
 594   (define-key calc-mode-map "vk" 'calc-cons)
 595   (define-key calc-mode-map "vl" 'calc-vlength)
 596   (define-key calc-mode-map "vm" 'calc-mask-vector)
 597   (define-key calc-mode-map "vn" 'calc-rnorm)
 598   (define-key calc-mode-map "vp" 'calc-pack)
 599   (define-key calc-mode-map "vr" 'calc-mrow)
 600   (define-key calc-mode-map "vs" 'calc-subvector)
 601   (define-key calc-mode-map "vt" 'calc-transpose)
 602   (define-key calc-mode-map "vu" 'calc-unpack)
 603   (define-key calc-mode-map "vv" 'calc-reverse-vector)
 604   (define-key calc-mode-map "vx" 'calc-index)
 605   (define-key calc-mode-map "vA" 'calc-apply)
 606   (define-key calc-mode-map "vC" 'calc-cross)
 607   (define-key calc-mode-map "vK" 'calc-kron)
 608   (define-key calc-mode-map "vD" 'calc-mdet)
 609   (define-key calc-mode-map "vE" 'calc-set-enumerate)
 610   (define-key calc-mode-map "vF" 'calc-set-floor)
 611   (define-key calc-mode-map "vG" 'calc-grade)
 612   (define-key calc-mode-map "vH" 'calc-histogram)
 613   (define-key calc-mode-map "vI" 'calc-inner-product)
 614   (define-key calc-mode-map "vJ" 'calc-conj-transpose)
 615   (define-key calc-mode-map "vL" 'calc-mlud)
 616   (define-key calc-mode-map "vM" 'calc-map)
 617   (define-key calc-mode-map "vN" 'calc-cnorm)
 618   (define-key calc-mode-map "vO" 'calc-outer-product)
 619   (define-key calc-mode-map "vR" 'calc-reduce)
 620   (define-key calc-mode-map "vS" 'calc-sort)
 621   (define-key calc-mode-map "vT" 'calc-mtrace)
 622   (define-key calc-mode-map "vU" 'calc-accumulate)
 623   (define-key calc-mode-map "vV" 'calc-set-union)
 624   (define-key calc-mode-map "vX" 'calc-set-xor)
 625   (define-key calc-mode-map "v^" 'calc-set-intersect)
 626   (define-key calc-mode-map "v-" 'calc-set-difference)
 627   (define-key calc-mode-map "v~" 'calc-set-complement)
 628   (define-key calc-mode-map "v:" 'calc-set-span)
 629   (define-key calc-mode-map "v#" 'calc-set-cardinality)
 630   (define-key calc-mode-map "v+" 'calc-remove-duplicates)
 631   (define-key calc-mode-map "v&" 'calc-inv)
 632   (define-key calc-mode-map "v<" 'calc-matrix-left-justify)
 633   (define-key calc-mode-map "v=" 'calc-matrix-center-justify)
 634   (define-key calc-mode-map "v>" 'calc-matrix-right-justify)
 635   (define-key calc-mode-map "v." 'calc-full-vectors)
 636   (define-key calc-mode-map "v/" 'calc-break-vectors)
 637   (define-key calc-mode-map "v," 'calc-vector-commas)
 638   (define-key calc-mode-map "v[" 'calc-vector-brackets)
 639   (define-key calc-mode-map "v]" 'calc-matrix-brackets)
 640   (define-key calc-mode-map "v{" 'calc-vector-braces)
 641   (define-key calc-mode-map "v}" 'calc-matrix-brackets)
 642   (define-key calc-mode-map "v(" 'calc-vector-parens)
 643   (define-key calc-mode-map "v)" 'calc-matrix-brackets)
 644   ;; We can't rely on the automatic upper->lower conversion because
 645   ;; in the global map V is explicitly bound, so we need to bind it
 646   ;; explicitly as well :-(  --stef
 647   (define-key calc-mode-map "V" (lookup-key calc-mode-map "v"))
 648
 649   (define-key calc-mode-map "z" 'nil)
 650   (define-key calc-mode-map "z?" 'calc-z-prefix-help)
 651
 652   (define-key calc-mode-map "Z" 'nil)
 653   (define-key calc-mode-map "Z?" 'calc-shift-Z-prefix-help)
 654   (define-key calc-mode-map "ZC" 'calc-user-define-composition)
 655   (define-key calc-mode-map "ZD" 'calc-user-define)
 656   (define-key calc-mode-map "ZE" 'calc-user-define-edit)
 657   (define-key calc-mode-map "ZF" 'calc-user-define-formula)
 658   (define-key calc-mode-map "ZG" 'calc-get-user-defn)
 659   (define-key calc-mode-map "ZI" 'calc-user-define-invocation)
 660   (define-key calc-mode-map "ZK" 'calc-user-define-kbd-macro)
 661   (define-key calc-mode-map "ZP" 'calc-user-define-permanent)
 662   (define-key calc-mode-map "ZS" 'calc-edit-user-syntax)
 663   (define-key calc-mode-map "ZT" 'calc-timing)
 664   (define-key calc-mode-map "ZU" 'calc-user-undefine)
 665   (define-key calc-mode-map "Z[" 'calc-kbd-if)
 666   (define-key calc-mode-map "Z:" 'calc-kbd-else)
 667   (define-key calc-mode-map "Z|" 'calc-kbd-else-if)
 668   (define-key calc-mode-map "Z]" 'calc-kbd-end-if)
 669   (define-key calc-mode-map "Z<" 'calc-kbd-repeat)
 670   (define-key calc-mode-map "Z>" 'calc-kbd-end-repeat)
 671   (define-key calc-mode-map "Z(" 'calc-kbd-for)
 672   (define-key calc-mode-map "Z)" 'calc-kbd-end-for)
 673   (define-key calc-mode-map "Z{" 'calc-kbd-loop)
 674   (define-key calc-mode-map "Z}" 'calc-kbd-end-loop)
 675   (define-key calc-mode-map "Z/" 'calc-kbd-break)
 676   (define-key calc-mode-map "Z`" 'calc-kbd-push)
 677   (define-key calc-mode-map "Z'" 'calc-kbd-pop)
 678   (define-key calc-mode-map "Z=" 'calc-kbd-report)
 679   (define-key calc-mode-map "Z#" 'calc-kbd-query)
 680
 681   (calc-init-prefixes)
 682
 683   (mapc (function
 684          (lambda (x)
 685           (define-key calc-mode-map (format "c%c" x) 'calc-clean-num)
 686           (define-key calc-mode-map (format "j%c" x) 'calc-select-part)
 687           (define-key calc-mode-map (format "r%c" x) 'calc-recall-quick)
 688           (define-key calc-mode-map (format "s%c" x) 'calc-store-quick)
 689           (define-key calc-mode-map (format "t%c" x) 'calc-store-into-quick)
 690           (define-key calc-mode-map (format "u%c" x) 'calc-quick-units)))
 691         "0123456789")
 692
 693   (let ((i ?A))
 694     (while (<= i ?z)
 695       (if (eq (car-safe (aref (nth 1 calc-mode-map) i)) 'keymap)
 696           (aset (nth 1 calc-mode-map) i
 697                 (cons 'keymap (cons (cons ?\e (aref (nth 1 calc-mode-map) i))
 698                                     (cdr (aref (nth 1 calc-mode-map) i))))))
 699       (setq i (1+ i))))
 700
 701   (setq calc-alg-map (copy-keymap calc-mode-map)
 702         calc-alg-esc-map (copy-keymap esc-map))
 703   (let ((i 32))
 704     (while (< i 127)
 705       (or (memq i '(?' ?` ?= ??))
 706           (aset (nth 1 calc-alg-map) i 'calc-auto-algebraic-entry))
 707       (or (memq i '(?# ?x ?0 ?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))
 708           (aset (nth 1 calc-alg-esc-map) i (aref (nth 1 calc-mode-map) i)))
 709       (setq i (1+ i))))
 710   (define-key calc-alg-map "\e" calc-alg-esc-map)
 711   (define-key calc-alg-map "\e\t" 'calc-roll-up)
 712   (define-key calc-alg-map "\e\C-m" 'calc-last-args-stub)
 713   (define-key calc-alg-map "\e\177" 'calc-pop-above)
 714
 715 ;;;; (Autoloads here)
 716   (mapc (function (lambda (x)
 717     (mapcar (function (lambda (func)
 718       (autoload func (car x)))) (cdr x))))
 719     '(
 720
 721  ("calc-alg" calc-has-rules math-defsimplify
 722 calc-modify-simplify-mode calcFunc-collect calcFunc-esimplify
 723 calcFunc-islin calcFunc-islinnt calcFunc-lin calcFunc-linnt
 724 calcFunc-simplify calcFunc-subst calcFunc-powerexpand math-beforep
 725 math-build-polynomial-expr math-expand-formula math-expr-contains
 726 math-expr-contains-count math-expr-depends math-expr-height
 727 math-expr-subst math-expr-weight math-integer-plus math-is-linear
 728 math-is-multiple math-is-polynomial math-linear-in math-multiple-of
 729 math-poly-depends math-poly-mix math-poly-mul
 730 math-poly-simplify math-poly-zerop math-polynomial-base
 731 math-polynomial-p math-recompile-eval-rules math-simplify
 732 math-simplify-exp math-simplify-extended math-simplify-sqrt
 733 math-to-simple-fraction)
 734
 735  ("calcalg2" calcFunc-asum calcFunc-deriv
 736 calcFunc-ffinv calcFunc-finv calcFunc-fsolve calcFunc-gpoly
 737 calcFunc-integ calcFunc-poly calcFunc-prod calcFunc-roots
 738 calcFunc-solve calcFunc-sum calcFunc-table calcFunc-taylor
 739 calcFunc-tderiv math-expr-calls math-integral-q02 math-integral-q12
 740 math-integral-rational-funcs math-lcm-denoms math-looks-evenp
 741 math-poly-all-roots math-prod-rec math-reject-solution math-solve-eqn
 742 math-solve-for math-sum-rec math-try-integral)
 743
 744  ("calcalg3" calcFunc-efit calcFunc-fit
 745 calcFunc-fitdummy calcFunc-fitparam calcFunc-fitvar
 746 calcFunc-hasfitparams calcFunc-hasfitvars calcFunc-maximize
 747 calcFunc-minimize calcFunc-ninteg calcFunc-polint calcFunc-ratint
 748 calcFunc-root calcFunc-wmaximize calcFunc-wminimize calcFunc-wroot
 749 calcFunc-xfit math-find-minimum math-find-root math-ninteg-evaluate
 750 math-ninteg-midpoint math-ninteg-romberg math-poly-interp)
 751
 752  ("calc-arith" calcFunc-abs calcFunc-abssqr
 753 calcFunc-add calcFunc-ceil calcFunc-decr calcFunc-deven calcFunc-dimag
 754 calcFunc-dint calcFunc-div calcFunc-dnatnum calcFunc-dneg
 755 calcFunc-dnonneg calcFunc-dnonzero calcFunc-dnumint calcFunc-dodd
 756 calcFunc-dpos calcFunc-drange calcFunc-drat calcFunc-dreal
 757 calcFunc-dscalar calcFunc-fceil calcFunc-ffloor calcFunc-float
 758 calcFunc-fround calcFunc-frounde calcFunc-froundu calcFunc-ftrunc
 759 calcFunc-idiv calcFunc-incr calcFunc-ldiv calcFunc-mant calcFunc-max calcFunc-min
 760 calcFunc-mod calcFunc-mul calcFunc-neg calcFunc-percent calcFunc-pow
 761 calcFunc-relch calcFunc-round calcFunc-rounde calcFunc-roundu
 762 calcFunc-scf calcFunc-sub calcFunc-xpon math-abs math-abs-approx
 763 math-add-objects-fancy math-add-or-sub math-add-symb-fancy
 764 math-ceiling math-combine-prod math-combine-sum math-div-by-zero
 765 math-div-objects-fancy math-div-symb-fancy math-div-zero
 766 math-float-fancy math-floor-fancy math-floor-special math-guess-if-neg
 767 math-intv-constp math-known-evenp math-known-imagp math-known-integerp
 768 math-known-matrixp math-known-negp math-known-nonnegp
 769 math-known-nonposp math-known-nonzerop math-known-num-integerp
 770 math-known-oddp math-known-posp math-known-realp math-known-scalarp
 771 math-max math-min math-mod-fancy math-mul-float math-mul-objects-fancy
 772 math-mul-or-div math-mul-symb-fancy math-mul-zero math-neg-fancy
 773 math-neg-float math-okay-neg math-possible-signs math-possible-types
 774 math-pow-fancy math-pow-mod math-pow-of-zero math-pow-zero
 775 math-quarter-integer math-round math-setup-declarations math-sqr
 776 math-sqr-float math-trunc-fancy math-trunc-special)
 777
 778  ("calc-bin" calcFunc-and calcFunc-ash
 779 calcFunc-clip calcFunc-diff calcFunc-lsh calcFunc-not calcFunc-or
 780 calcFunc-rash calcFunc-rot calcFunc-rsh calcFunc-xor math-clip
 781 math-compute-max-digits math-convert-radix-digits math-float-parts
 782 math-format-bignum-binary math-format-bignum-hex
 783 math-format-bignum-octal math-format-bignum-radix math-format-binary
 784 math-format-radix math-format-radix-float math-integer-log2
 785 math-power-of-2 math-radix-float-power)
 786
 787  ("calc-comb"  calc-report-prime-test
 788 calcFunc-choose calcFunc-dfact calcFunc-egcd calcFunc-fact
 789 calcFunc-gcd calcFunc-lcm calcFunc-moebius calcFunc-nextprime
 790 calcFunc-perm calcFunc-prevprime calcFunc-prfac calcFunc-prime
 791 calcFunc-random calcFunc-shuffle calcFunc-stir1 calcFunc-stir2
 792 calcFunc-totient math-init-random-base math-member math-prime-test
 793 math-random-base)
 794
 795  ("calccomp" calcFunc-cascent calcFunc-cdescent
 796 calcFunc-cheight calcFunc-cwidth math-comp-ascent math-comp-descent
 797 math-comp-height math-comp-width math-compose-expr
 798 math-composition-to-string math-stack-value-offset-fancy
 799 math-vector-is-string math-vector-to-string)
 800
 801  ("calc-cplx" calcFunc-arg calcFunc-conj
 802 calcFunc-im calcFunc-polar calcFunc-re calcFunc-rect math-complex
 803 math-fix-circular math-imaginary math-imaginary-i math-normalize-polar
 804 math-polar math-want-polar)
 805
 806  ("calc-embed" calc-do-embedded
 807 calc-do-embedded-activate calc-embedded-evaluate-expr
 808 calc-embedded-modes-change calc-embedded-var-change
 809 calc-embedded-preserve-modes)
 810
 811  ("calc-fin" calc-to-percentage calcFunc-ddb
 812 calcFunc-fv calcFunc-fvb calcFunc-fvl calcFunc-irr calcFunc-irrb
 813 calcFunc-nper calcFunc-nperb calcFunc-nperl calcFunc-npv calcFunc-npvb
 814 calcFunc-pmt calcFunc-pmtb calcFunc-pv calcFunc-pvb calcFunc-pvl
 815 calcFunc-rate calcFunc-rateb calcFunc-ratel calcFunc-sln calcFunc-syd)
 816
 817  ("calc-forms" calcFunc-badd calcFunc-bsub
 818 calcFunc-date calcFunc-day calcFunc-dsadj calcFunc-hms
 819 calcFunc-holiday calcFunc-hour calcFunc-incmonth calcFunc-incyear
 820 calcFunc-intv calcFunc-julian calcFunc-makemod calcFunc-minute
 821 calcFunc-month calcFunc-newmonth calcFunc-newweek calcFunc-newyear
 822 calcFunc-now calcFunc-pwday calcFunc-sdev calcFunc-second
 823 calcFunc-time calcFunc-tzconv calcFunc-tzone calcFunc-unixtime
 824 calcFunc-weekday calcFunc-year calcFunc-yearday math-combine-intervals
 825 math-date-parts math-date-to-dt math-div-mod math-dt-to-date
 826 math-format-date math-from-business-day math-from-hms math-make-intv
 827 math-make-mod math-make-sdev math-mod-intv math-normalize-hms
 828 math-normalize-mod math-parse-date math-read-angle-brackets
 829 math-setup-add-holidays math-setup-holidays math-setup-year-holidays
 830 math-sort-intv math-to-business-day math-to-hms)
 831
 832  ("calc-frac" calc-add-fractions
 833 calc-div-fractions calc-mul-fractions calcFunc-fdiv calcFunc-frac
 834 math-make-frac)
 835
 836  ("calc-funcs" calc-prob-dist calcFunc-bern
 837 calcFunc-besJ calcFunc-besY calcFunc-beta calcFunc-betaB
 838 calcFunc-betaI calcFunc-erf calcFunc-erfc calcFunc-euler
 839 calcFunc-gamma calcFunc-gammaG calcFunc-gammaP calcFunc-gammaQ
 840 calcFunc-gammag calcFunc-ltpb calcFunc-ltpc calcFunc-ltpf
 841 calcFunc-ltpn calcFunc-ltpp calcFunc-ltpt calcFunc-utpb calcFunc-utpc
 842 calcFunc-utpf calcFunc-utpn calcFunc-utpp calcFunc-utpt
 843 math-bernoulli-number math-gammap1-raw)
 844
 845  ("calc-graph" calc-graph-show-tty)
 846
 847  ("calc-incom" calc-digit-dots)
 848
 849  ("calc-keypd" calc-do-keypad
 850 calc-keypad-x-left-click calc-keypad-x-middle-click
 851 calc-keypad-x-right-click)
 852
 853  ("calc-lang" calc-set-language
 854 math-read-big-balance math-read-big-rec)
 855
 856  ("calc-map" calc-get-operator calcFunc-accum
 857 calcFunc-afixp calcFunc-anest calcFunc-apply calcFunc-call
 858 calcFunc-fixp calcFunc-inner calcFunc-map calcFunc-mapa calcFunc-mapc
 859 calcFunc-mapd calcFunc-mapeq calcFunc-mapeqp calcFunc-mapeqr
 860 calcFunc-mapr calcFunc-nest calcFunc-outer calcFunc-raccum
 861 calcFunc-reduce calcFunc-reducea calcFunc-reducec calcFunc-reduced
 862 calcFunc-reducer calcFunc-rreduce calcFunc-rreducea calcFunc-rreducec
 863 calcFunc-rreduced calcFunc-rreducer math-build-call
 864 math-calcFunc-to-var math-multi-subst math-multi-subst-rec
 865 math-var-to-calcFunc)
 866
 867  ("calc-mtx" calcFunc-det calcFunc-lud calcFunc-tr
 868 math-col-matrix math-lud-solve math-matrix-inv-raw math-matrix-lud
 869 math-mul-mat-vec math-mul-mats math-row-matrix)
 870
 871  ("calc-math" calcFunc-alog calcFunc-arccos
 872 calcFunc-arccosh calcFunc-arcsin calcFunc-arcsincos calcFunc-arcsinh
 873 calcFunc-arctan calcFunc-arctan2 calcFunc-arctanh calcFunc-csc
 874 calcFunc-csch calcFunc-cos calcFunc-cosh calcFunc-cot calcFunc-coth
 875 calcFunc-deg calcFunc-exp calcFunc-exp10 calcFunc-expm1
 876 calcFunc-hypot calcFunc-ilog calcFunc-isqrt calcFunc-ln calcFunc-lnp1
 877 calcFunc-log calcFunc-log10 calcFunc-nroot calcFunc-rad calcFunc-sec
 878 calcFunc-sech calcFunc-sin
 879 calcFunc-sincos calcFunc-sinh calcFunc-sqr calcFunc-sqrt calcFunc-tan
 880 calcFunc-tanh math-arccos-raw math-arcsin-raw math-arctan-raw
 881 math-arctan2-raw math-cos-raw math-cot-raw math-csc-raw
 882 math-exp-minus-1-raw math-exp-raw
 883 math-from-radians math-from-radians-2 math-hypot math-infinite-dir
 884 math-isqrt-small math-ln-raw math-nearly-equal math-nearly-equal-float
 885 math-nearly-zerop math-nearly-zerop-float math-nth-root
 886 math-sin-cos-raw math-sin-raw math-sqrt math-sqrt-float math-sqrt-raw
 887 math-tan-raw math-to-radians math-to-radians-2)
 888
 889  ("calc-mode" math-get-modes-vec)
 890
 891  ("calc-poly" calcFunc-apart calcFunc-expand
 892 calcFunc-expandpow calcFunc-factor calcFunc-factors calcFunc-nrat
 893 calcFunc-pcont calcFunc-pdeg calcFunc-pdiv calcFunc-pdivide
 894 calcFunc-pdivrem calcFunc-pgcd calcFunc-plead calcFunc-pprim
 895 calcFunc-prem math-accum-factors math-atomic-factorp
 896 math-div-poly-const math-div-thru math-expand-power math-expand-term
 897 math-factor-contains math-factor-expr math-factor-expr-part
 898 math-factor-expr-try math-factor-finish math-factor-poly-coefs
 899 math-factor-protect math-mul-thru math-padded-polynomial
 900 math-partial-fractions math-poly-degree math-poly-deriv-coefs
 901 math-poly-gcd-frac-list math-poly-modulus-rec math-ratpoly-p
 902 math-to-ratpoly math-to-ratpoly-rec)
 903
 904  ("calc-prog" calc-default-formula-arglist
 905 calc-execute-kbd-macro calc-finish-user-syntax-edit
 906 calc-fix-token-name calc-fix-user-formula calc-read-parse-table
 907 calc-read-parse-table-part calc-subsetp calc-write-parse-table
 908 calc-write-parse-table-part calcFunc-constant calcFunc-eq calcFunc-geq
 909 calcFunc-gt calcFunc-if calcFunc-in calcFunc-integer calcFunc-istrue
 910 calcFunc-land calcFunc-leq calcFunc-lnot calcFunc-lor calcFunc-lt
 911 calcFunc-negative calcFunc-neq calcFunc-nonvar calcFunc-real
 912 calcFunc-refers calcFunc-rmeq calcFunc-typeof calcFunc-variable
 913 math-body-refers-to math-break math-composite-inequalities
 914 math-do-defmath math-handle-for math-handle-foreach
 915 math-normalize-logical-op math-return)
 916
 917  ("calc-rewr" calcFunc-match calcFunc-matches
 918 calcFunc-matchnot calcFunc-rewrite calcFunc-vmatches
 919 math-apply-rewrites math-compile-patterns math-compile-rewrites
 920 math-flatten-lands math-match-patterns math-rewrite
 921 math-rewrite-heads)
 922
 923  ("calc-rules" calc-CommuteRules calc-DistribRules calc-FactorRules
 924 calc-FitRules calc-IntegAfterRules calc-InvertRules calc-JumpRules
 925 calc-MergeRules calc-NegateRules
 926 calc-compile-rule-set)
 927
 928  ("calc-sel" calc-auto-selection
 929 calc-delete-selection calc-encase-atoms calc-find-assoc-parent-formula
 930 calc-find-parent-formula calc-find-sub-formula calc-prepare-selection
 931 calc-preserve-point calc-replace-selections calc-replace-sub-formula
 932 calc-roll-down-with-selections calc-roll-up-with-selections
 933 calc-sel-error)
 934
 935  ("calc-stat" calc-vector-op calcFunc-agmean calcFunc-rms
 936 calcFunc-vcorr calcFunc-vcount calcFunc-vcov calcFunc-vflat
 937 calcFunc-vgmean calcFunc-vhmean calcFunc-vmax calcFunc-vmean
 938 calcFunc-vmeane calcFunc-vmedian calcFunc-vmin calcFunc-vpcov
 939 calcFunc-vprod calcFunc-vpsdev calcFunc-vpvar calcFunc-vsdev
 940 calcFunc-vsum calcFunc-vvar math-flatten-many-vecs)
 941
 942  ("calc-store" calc-read-var-name
 943 calc-store-value calc-var-name)
 944
 945  ("calc-stuff" calc-explain-why calcFunc-clean
 946 calcFunc-pclean calcFunc-pfloat calcFunc-pfrac)
 947
 948  ("calc-units" calcFunc-usimplify calcFunc-lufadd calcFunc-lupadd
 949 calcFunc-lufsub calcFunc-lupsub calcFunc-lufmul calcFunc-lupmul
 950 calcFunc-lufdiv calcFunc-lupdiv calcFunc-lufquant calcFunc-lupquant
 951 calcFunc-dbfield calcFunc-dbpower calcFunc-npfield
 952 calcFunc-nppower calcFunc-spn calcFunc-midi calcFunc-freq
 953 math-build-units-table math-build-units-table-buffer
 954 math-check-unit-name math-convert-temperature math-convert-units
 955 math-extract-units math-remove-units math-simplify-units
 956 math-single-units-in-expr-p math-to-standard-units
 957 math-units-in-expr-p)
 958
 959  ("calc-vec" calcFunc-append calcFunc-appendrev
 960 calcFunc-arrange calcFunc-cnorm calcFunc-cons calcFunc-cross
 961 calcFunc-kron calcFunc-ctrn calcFunc-cvec calcFunc-diag calcFunc-find
 962 calcFunc-getdiag calcFunc-grade calcFunc-head calcFunc-histogram
 963 calcFunc-idn calcFunc-index calcFunc-mcol calcFunc-mdims
 964 calcFunc-mrcol calcFunc-mrow calcFunc-mrrow calcFunc-pack
 965 calcFunc-rcons calcFunc-rdup calcFunc-rev calcFunc-rgrade
 966 calcFunc-rhead calcFunc-rnorm calcFunc-rsort calcFunc-rsubvec
 967 calcFunc-rtail calcFunc-sort calcFunc-subscr calcFunc-subvec
 968 calcFunc-tail calcFunc-trn calcFunc-unpack calcFunc-unpackt
 969 calcFunc-vcard calcFunc-vcompl calcFunc-vconcat calcFunc-vconcatrev
 970 calcFunc-vdiff calcFunc-vec calcFunc-venum calcFunc-vexp
 971 calcFunc-vfloor calcFunc-vint calcFunc-vlen calcFunc-vmask
 972 calcFunc-vpack calcFunc-vspan calcFunc-vunion calcFunc-vunpack
 973 calcFunc-vxor math-check-for-commas math-clean-set math-copy-matrix
 974 math-dimension-error math-dot-product math-flatten-vector math-map-vec
 975 math-map-vec-2 math-mat-col math-mimic-ident math-prepare-set
 976 math-read-brackets math-reduce-cols math-reduce-vec math-transpose)
 977
 978  ("calc-yank" calc-alg-edit calc-clean-newlines
 979 calc-do-grab-rectangle calc-do-grab-region calc-finish-stack-edit
 980 calc-copy-to-register calc-insert-register
 981 calc-append-to-register calc-prepend-to-register
 982 calc-force-refresh calc-locate-cursor-element calc-show-edit-buffer)
 983
 984 ))
 985
 986   (mapcar (function (lambda (x)
 987     (mapcar (function (lambda (cmd)
 988       (autoload cmd (car x) nil t))) (cdr x))))
 989     '(
 990
 991  ("calc-alg" calc-alg-evaluate calc-apart calc-collect calc-expand
 992 calc-expand-formula calc-factor calc-normalize-rat calc-poly-div
 993 calc-poly-div-rem calc-poly-gcd calc-poly-rem calc-simplify
 994 calc-simplify-extended calc-substitute calc-powerexpand)
 995
 996  ("calcalg2" calc-alt-summation calc-derivative
 997 calc-dump-integral-cache calc-integral calc-num-integral
 998 calc-poly-roots calc-product calc-solve-for calc-summation
 999 calc-tabulate calc-taylor)
1000
1001  ("calcalg3" calc-curve-fit calc-find-maximum calc-find-minimum
1002 calc-find-root calc-poly-interp)
1003
1004  ("calc-arith" calc-abs calc-abssqr calc-ceiling calc-decrement
1005 calc-floor calc-idiv calc-increment calc-mant-part calc-max calc-min
1006 calc-round calc-scale-float calc-sign calc-trunc calc-xpon-part)
1007
1008  ("calc-bin" calc-and calc-binary-radix calc-clip calc-twos-complement-mode
1009 calc-decimal-radix calc-diff calc-hex-radix calc-leading-zeros
1010 calc-lshift-arith calc-lshift-binary calc-not calc-octal-radix calc-or calc-radix
1011 calc-rotate-binary calc-rshift-arith calc-rshift-binary calc-word-size
1012 calc-xor)
1013
1014  ("calc-comb" calc-choose calc-double-factorial calc-extended-gcd
1015 calc-factorial calc-gamma calc-gcd calc-lcm calc-moebius
1016 calc-next-prime calc-perm calc-prev-prime calc-prime-factors
1017 calc-prime-test calc-random calc-random-again calc-rrandom
1018 calc-shuffle calc-totient)
1019
1020  ("calc-cplx" calc-argument calc-complex-notation calc-i-notation
1021 calc-im calc-j-notation calc-polar calc-polar-mode calc-re)
1022
1023  ("calc-embed" calc-embedded-copy-formula-as-kill
1024 calc-embedded-duplicate calc-embedded-edit calc-embedded-forget
1025 calc-embedded-kill-formula calc-embedded-mark-formula
1026 calc-embedded-new-formula calc-embedded-next calc-embedded-previous
1027 calc-embedded-select calc-embedded-update-formula calc-embedded-word
1028 calc-find-globals calc-show-plain)
1029
1030  ("calc-fin" calc-convert-percent calc-fin-ddb calc-fin-fv
1031 calc-fin-irr calc-fin-nper calc-fin-npv calc-fin-pmt calc-fin-pv
1032 calc-fin-rate calc-fin-sln calc-fin-syd calc-percent-change)
1033
1034  ("calc-forms" calc-business-days-minus calc-business-days-plus
1035 calc-convert-time-zones calc-date calc-date-notation calc-date-part
1036 calc-from-hms calc-hms-mode calc-hms-notation calc-inc-month
1037 calc-julian calc-new-month calc-new-week calc-new-year calc-now
1038 calc-time calc-time-zone calc-to-hms calc-unix-time)
1039
1040  ("calc-frac" calc-fdiv calc-frac-mode calc-fraction
1041 calc-over-notation calc-slash-notation)
1042
1043  ("calc-funcs" calc-bernoulli-number calc-bessel-J calc-bessel-Y
1044 calc-beta calc-erf calc-erfc calc-euler-number calc-inc-beta
1045 calc-inc-gamma calc-stirling-number calc-utpb calc-utpc calc-utpf
1046 calc-utpn calc-utpp calc-utpt)
1047
1048  ("calc-graph" calc-graph-add calc-graph-add-3d calc-graph-border
1049 calc-graph-clear calc-graph-command calc-graph-delete
1050 calc-graph-device calc-graph-display calc-graph-fast
1051 calc-graph-fast-3d calc-graph-geometry calc-graph-grid
1052 calc-graph-header calc-graph-hide calc-graph-juggle calc-graph-key
1053 calc-graph-kill calc-graph-line-style calc-graph-log-x
1054 calc-graph-log-y calc-graph-log-z calc-graph-name
1055 calc-graph-num-points calc-graph-output calc-graph-plot
1056 calc-graph-point-style calc-graph-print calc-graph-quit
1057 calc-graph-range-x calc-graph-range-y calc-graph-range-z
1058 calc-graph-show-dumb calc-graph-title-x calc-graph-title-y
1059 calc-graph-title-z calc-graph-view-commands calc-graph-view-trail
1060 calc-graph-zero-x calc-graph-zero-y)
1061
1062  ("calc-help" calc-a-prefix-help calc-b-prefix-help calc-c-prefix-help
1063 calc-d-prefix-help calc-describe-function calc-describe-key
1064 calc-describe-key-briefly calc-describe-variable calc-f-prefix-help
1065 calc-full-help calc-g-prefix-help calc-help-prefix
1066 calc-hyperbolic-prefix-help calc-inv-hyp-prefix-help calc-option-prefix-help
1067 calc-inverse-prefix-help calc-j-prefix-help calc-k-prefix-help
1068 calc-m-prefix-help calc-r-prefix-help calc-s-prefix-help
1069 calc-t-prefix-help calc-u-prefix-help calc-l-prefix-help
1070 calc-v-prefix-help)
1071
1072  ("calc-incom" calc-begin-complex calc-begin-vector calc-comma
1073 calc-dots calc-end-complex calc-end-vector calc-semi)
1074
1075  ("calc-keypd" calc-keypad-menu calc-keypad-menu-back
1076 calc-keypad-press)
1077
1078  ("calc-lang" calc-big-language calc-c-language calc-eqn-language
1079 calc-flat-language calc-fortran-language calc-maple-language
1080 calc-yacas-language calc-maxima-language calc-giac-language
1081 calc-mathematica-language calc-normal-language calc-pascal-language
1082 calc-tex-language calc-latex-language calc-unformatted-language)
1083
1084  ("calc-map" calc-accumulate calc-apply calc-inner-product calc-map
1085 calc-map-equation calc-map-stack calc-outer-product calc-reduce)
1086
1087  ("calc-mtx" calc-mdet calc-mlud calc-mtrace)
1088
1089  ("calc-math" calc-arccos calc-arccosh calc-arcsin calc-arcsinh
1090 calc-arctan calc-arctan2 calc-arctanh calc-conj calc-cos calc-cosh
1091 calc-cot calc-coth calc-csc calc-csch
1092 calc-degrees-mode calc-exp calc-expm1 calc-hypot calc-ilog
1093 calc-imaginary calc-isqrt calc-ln calc-lnp1 calc-log calc-log10
1094 calc-pi calc-radians-mode calc-sec calc-sech
1095 calc-sin calc-sincos calc-sinh calc-sqrt
1096 calc-tan calc-tanh calc-to-degrees calc-to-radians)
1097
1098  ("calc-mode" calc-alg-simplify-mode calc-algebraic-mode
1099 calc-always-load-extensions calc-auto-recompute calc-auto-why
1100 calc-basic-simplify-mode calc-bin-simplify-mode calc-break-vectors
1101 calc-center-justify calc-default-simplify-mode calc-display-raw
1102 calc-eng-notation calc-ext-simplify-mode calc-fix-notation
1103 calc-full-trail-vectors calc-full-vectors calc-get-modes calc-group-char
1104 calc-group-digits calc-infinite-mode calc-left-justify calc-left-label
1105 calc-line-breaking calc-line-numbering calc-matrix-brackets
1106 calc-matrix-center-justify calc-matrix-left-justify calc-matrix-mode
1107 calc-matrix-right-justify calc-mode-record-mode calc-no-simplify-mode
1108 calc-normal-notation calc-num-simplify-mode calc-point-char
1109 calc-right-justify calc-right-label calc-save-modes calc-sci-notation
1110 calc-settings-file-name calc-shift-prefix calc-symbolic-mode
1111 calc-total-algebraic-mode calc-truncate-down calc-truncate-stack
1112 calc-truncate-up calc-units-simplify-mode calc-vector-braces
1113 calc-vector-brackets calc-vector-commas calc-vector-parens
1114 calc-working)
1115
1116  ("calc-prog" calc-call-last-kbd-macro calc-edit-user-syntax
1117 calc-equal-to calc-get-user-defn calc-greater-equal calc-greater-than
1118 calc-in-set calc-kbd-break calc-kbd-else calc-kbd-else-if
1119 calc-kbd-end-for calc-kbd-end-if calc-kbd-end-loop calc-kbd-end-repeat
1120 calc-kbd-for calc-kbd-if calc-kbd-loop calc-kbd-pop calc-kbd-push
1121 calc-kbd-query calc-kbd-repeat calc-kbd-report calc-less-equal
1122 calc-less-than calc-logical-and calc-logical-if calc-logical-not
1123 calc-logical-or calc-not-equal-to calc-pass-errors calc-remove-equal
1124 calc-timing calc-user-define calc-user-define-composition
1125 calc-user-define-edit calc-user-define-formula
1126 calc-user-define-invocation calc-user-define-kbd-macro
1127 calc-user-define-permanent calc-user-undefine)
1128
1129  ("calc-rewr" calc-match calc-rewrite calc-rewrite-selection)
1130
1131  ("calc-sel" calc-break-selections calc-clear-selections
1132 calc-copy-selection calc-del-selection calc-edit-selection
1133 calc-enable-selections calc-enter-selection calc-sel-add-both-sides
1134 calc-sel-div-both-sides calc-sel-evaluate calc-sel-expand-formula
1135 calc-sel-mult-both-sides calc-sel-sub-both-sides
1136 calc-select-additional calc-select-here calc-select-here-maybe
1137 calc-select-less calc-select-more calc-select-next calc-select-once
1138 calc-select-once-maybe calc-select-part calc-select-previous
1139 calc-show-selections calc-unselect)
1140
1141  ("calcsel2" calc-commute-left calc-commute-right calc-sel-commute
1142 calc-sel-distribute calc-sel-invert calc-sel-isolate
1143 calc-sel-jump-equals calc-sel-merge calc-sel-negate calc-sel-unpack)
1144
1145  ("calc-stat" calc-vector-correlation calc-vector-count
1146 calc-vector-covariance calc-vector-geometric-mean
1147 calc-vector-harmonic-mean calc-vector-max calc-vector-mean
1148 calc-vector-mean-error calc-vector-median calc-vector-min
1149 calc-vector-pop-covariance calc-vector-pop-sdev
1150 calc-vector-pop-variance calc-vector-product calc-vector-rms
1151 calc-vector-sdev calc-vector-sum calc-vector-variance)
1152
1153  ("calc-store" calc-assign calc-copy-special-constant
1154 calc-copy-variable calc-declare-variable
1155 calc-edit-AlgSimpRules calc-edit-Decls calc-edit-EvalRules
1156 calc-edit-ExtSimpRules calc-edit-FitRules calc-edit-GenCount
1157 calc-edit-Holidays calc-edit-IntegLimit calc-edit-LineStyles
1158 calc-edit-PlotRejects calc-edit-PointStyles calc-edit-TimeZone
1159 calc-edit-Units calc-edit-variable calc-evalto calc-insert-variables
1160 calc-let calc-permanent-variable calc-recall calc-recall-quick
1161 calc-store calc-store-concat calc-store-decr calc-store-div
1162 calc-store-exchange calc-store-incr calc-store-into
1163 calc-store-into-quick calc-store-inv calc-store-map calc-store-minus
1164 calc-store-neg calc-store-plus calc-store-power calc-store-quick
1165 calc-store-times calc-subscript calc-unstore)
1166
1167  ("calc-stuff" calc-clean calc-clean-num calc-flush-caches
1168 calc-less-recursion-depth calc-more-recursion-depth calc-num-prefix
1169 calc-why)
1170
1171  ("calc-trail" calc-trail-backward calc-trail-first calc-trail-forward
1172 calc-trail-in calc-trail-isearch-backward calc-trail-isearch-forward
1173 calc-trail-kill calc-trail-last calc-trail-marker calc-trail-next
1174 calc-trail-out calc-trail-previous calc-trail-scroll-left
1175 calc-trail-scroll-right calc-trail-yank)
1176
1177  ("calc-undo" calc-last-args calc-redo)
1178
1179  ("calc-units" calc-autorange-units calc-base-units
1180 calc-convert-temperature calc-convert-units
1181 calc-convert-exact-units calc-define-unit
1182 calc-enter-units-table calc-explain-units calc-extract-units
1183 calc-get-unit-definition calc-permanent-units calc-quick-units
1184 calc-remove-units calc-simplify-units calc-undefine-unit
1185 calc-view-units-table calc-lu-quant calc-db
1186 calc-np calc-lu-plus calc-lu-minus
1187 calc-lu-times calc-lu-divide calc-spn calc-midi
1188 calc-freq)
1189
1190  ("calc-vec" calc-arrange-vector calc-build-vector calc-cnorm
1191 calc-conj-transpose calc-cons calc-cross calc-kron calc-diag
1192 calc-display-strings calc-expand-vector calc-grade calc-head
1193 calc-histogram calc-ident calc-index calc-mask-vector calc-mcol
1194 calc-mrow calc-pack calc-pack-bits calc-remove-duplicates
1195 calc-reverse-vector calc-rnorm calc-set-cardinality
1196 calc-set-complement calc-set-difference calc-set-enumerate
1197 calc-set-floor calc-set-intersect calc-set-span calc-set-union
1198 calc-set-xor calc-sort calc-subvector calc-tail calc-transpose
1199 calc-unpack calc-unpack-bits calc-vector-find calc-vlength)
1200
1201  ("calc-yank" calc-copy-as-kill calc-copy-region-as-kill
1202 calc-copy-to-buffer calc-edit calc-edit-cancel calc-edit-mode
1203 calc-kill calc-kill-region calc-yank))))
1204
1205 (defun calc-init-prefixes ()
1206   (if calc-shift-prefix
1207       (progn
1208         (define-key calc-mode-map "A" (lookup-key calc-mode-map "a"))
1209         (define-key calc-mode-map "B" (lookup-key calc-mode-map "b"))
1210         (define-key calc-mode-map "C" (lookup-key calc-mode-map "c"))
1211         (define-key calc-mode-map "D" (lookup-key calc-mode-map "d"))
1212         (define-key calc-mode-map "F" (lookup-key calc-mode-map "f"))
1213         (define-key calc-mode-map "G" (lookup-key calc-mode-map "g"))
1214         (define-key calc-mode-map "J" (lookup-key calc-mode-map "j"))
1215         (define-key calc-mode-map "K" (lookup-key calc-mode-map "k"))
1216         (define-key calc-mode-map "M" (lookup-key calc-mode-map "m"))
1217         (define-key calc-mode-map "S" (lookup-key calc-mode-map "s"))
1218         (define-key calc-mode-map "T" (lookup-key calc-mode-map "t"))
1219         (define-key calc-mode-map "U" (lookup-key calc-mode-map "u")))
1220     (define-key calc-mode-map "A" 'calc-abs)
1221     (define-key calc-mode-map "B" 'calc-log)
1222     (define-key calc-mode-map "C" 'calc-cos)
1223     (define-key calc-mode-map "D" 'calc-redo)
1224     (define-key calc-mode-map "F" 'calc-floor)
1225     (define-key calc-mode-map "G" 'calc-argument)
1226     (define-key calc-mode-map "J" 'calc-conj)
1227     (define-key calc-mode-map "K" 'calc-keep-args)
1228     (define-key calc-mode-map "M" 'calc-more-recursion-depth)
1229     (define-key calc-mode-map "S" 'calc-sin)
1230     (define-key calc-mode-map "T" 'calc-tan)
1231     (define-key calc-mode-map "U" 'calc-undo)))
1232
1233 (calc-init-extensions)
1234
1235
1236
1237
1238 ;;;; Miscellaneous.
1239
1240 ;; calc-command-flags is declared in calc.el
1241 (defvar calc-command-flags)
1242
1243 (defun calc-clear-command-flag (f)
1244   (setq calc-command-flags (delq f calc-command-flags)))
1245
1246
1247 (defun calc-record-message (tag &rest args)
1248   (let ((msg (apply #'format-message args)))
1249     (message "%s" msg)
1250     (calc-record msg tag))
1251   (calc-clear-command-flag 'clear-message))
1252
1253
1254 (defun calc-normalize-fancy (val)
1255   (let ((simp (if (consp calc-simplify-mode)
1256                   (car calc-simplify-mode)
1257                 calc-simplify-mode)))
1258     (cond ((eq simp 'binary)
1259            (let ((s (math-normalize val)))
1260              (if (math-realp s)
1261                  (math-clip (math-round s))
1262                s)))
1263           ((eq simp 'alg)
1264            (math-simplify val))
1265           ((eq simp 'ext)
1266            (math-simplify-extended val))
1267           ((eq simp 'units)
1268            (math-simplify-units val))
1269           (t  ; nil, none, num
1270            (math-normalize val)))))
1271
1272
1273 (defvar calc-help-map nil)
1274
1275 (if calc-help-map
1276     nil
1277   (setq calc-help-map (make-keymap))
1278   (define-key calc-help-map "b" 'calc-describe-bindings)
1279   (define-key calc-help-map "c" 'calc-describe-key-briefly)
1280   (define-key calc-help-map "f" 'calc-describe-function)
1281   (define-key calc-help-map "h" 'calc-full-help)
1282   (define-key calc-help-map "i" 'calc-info)
1283   (define-key calc-help-map "k" 'calc-describe-key)
1284   (define-key calc-help-map "n" 'calc-view-news)
1285   (define-key calc-help-map "s" 'calc-info-summary)
1286   (define-key calc-help-map "t" 'calc-tutorial)
1287   (define-key calc-help-map "v" 'calc-describe-variable)
1288   (define-key calc-help-map "\C-c" 'calc-describe-copying)
1289   (define-key calc-help-map "\C-d" 'calc-describe-distribution)
1290   (define-key calc-help-map "\C-n" 'calc-view-news)
1291   (define-key calc-help-map "\C-w" 'calc-describe-no-warranty)
1292   (define-key calc-help-map "?" 'calc-help-for-help)
1293   (define-key calc-help-map "\C-h" 'calc-help-for-help))
1294
1295 (defvar calc-prefix-help-retry nil)
1296 (defvar calc-prefix-help-phase 0)
1297 (defun calc-do-prefix-help (msgs group key)
1298   (if calc-full-help-flag
1299       (list msgs group key)
1300     (if (cdr msgs)
1301         (progn
1302           (setq calc-prefix-help-phase
1303                 (if calc-prefix-help-retry
1304                     (% (1+ calc-prefix-help-phase) (1+ (length msgs)))
1305                   0))
1306           (let ((msg (nth calc-prefix-help-phase msgs)))
1307             (message "%s" (if msg
1308                               (concat group ": " msg ":"
1309                                       (make-string
1310                                        (- (apply 'max (mapcar 'length msgs))
1311                                           (length msg)) 32)
1312                                       "  [MORE]"
1313                                       (if key
1314                                           (concat "  " (char-to-string key)
1315                                                   "-")
1316                                         ""))
1317                             (if key (format "%c-" key) "")))))
1318       (setq calc-prefix-help-phase 0)
1319       (if key
1320           (if msgs
1321               (message "%s: %s: %c-" group (car msgs) key)
1322             (message "%s: (none)  %c-" group key))
1323         (message "%s: %s" group (car msgs))))
1324     (let* ((chr (read-char))
1325            (bnd (local-key-binding (if key (string key chr) (string chr)))))
1326       (setq calc-prefix-help-retry (= chr ??))
1327       (if bnd
1328           (call-interactively bnd)
1329         (message "%s is undefined"
1330                  (key-description (if key (vector key chr) (vector chr))))))))
1331
1332 ;;;; Commands.
1333
1334
1335 ;;; General.
1336
1337 (defun calc-reset (arg)
1338   (interactive "P")
1339   (setq arg (if arg (prefix-numeric-value arg) nil))
1340   (cond
1341    ((and
1342      calc-embedded-info
1343      (equal (aref calc-embedded-info 0) (current-buffer))
1344      (<= (point) (aref calc-embedded-info 5))
1345      (>= (point) (aref calc-embedded-info 4)))
1346     (let ((cbuf (aref calc-embedded-info 1))
1347           (calc-embedded-quiet t))
1348       (save-window-excursion
1349         (calc-embedded nil)
1350         (set-buffer cbuf)
1351         (calc-reset arg))
1352       (calc-embedded nil)))
1353    ((eq major-mode 'calc-mode)
1354     (save-excursion
1355       (unless (and arg (> (abs arg) 0))
1356         (setq calc-stack nil))
1357       (setq calc-undo-list nil
1358             calc-redo-list nil)
1359       (let (calc-stack calc-user-parse-tables calc-standard-date-formats
1360                        calc-invocation-macro)
1361         (mapc (function (lambda (v) (set v nil))) calc-local-var-list)
1362         (if (and arg (<= arg 0))
1363             (calc-mode-var-list-restore-default-values)
1364           (calc-mode-var-list-restore-saved-values)))
1365       (calc-set-language nil nil t)
1366       (calc-mode)
1367       (calc-flush-caches t)
1368       (run-hooks 'calc-reset-hook))
1369     (calc-wrapper
1370      (let ((win (get-buffer-window (current-buffer))))
1371        (calc-realign 0)
1372        ;; Adjust the window height if the window is visible, but doesn't
1373        ;; take up the whole height of the frame.
1374        (if (and
1375             win
1376             (not (window-full-height-p)))
1377            (let ((height (- (window-height win) 2)))
1378              (set-window-point win (point))
1379              (or (= height calc-window-height)
1380                  (let ((swin (selected-window)))
1381                    (select-window win)
1382                    (enlarge-window (- calc-window-height height))
1383                    (select-window swin)))))))
1384     (message "(Calculator reset)"))
1385    (t
1386     (message "(Not inside a Calc buffer)"))))
1387
1388 ;; What a pain; scroll-left behaves differently when called non-interactively.
1389 (defun calc-scroll-left (n)
1390   (interactive "P")
1391   (setq prefix-arg (or n (/ (window-width) 2)))
1392   (call-interactively #'scroll-left))
1393
1394 (defun calc-scroll-right (n)
1395   (interactive "P")
1396   (setq prefix-arg (or n (/ (window-width) 2)))
1397   (call-interactively #'scroll-right))
1398
1399 (defun calc-scroll-up (n)
1400   (interactive "P")
1401   (condition-case err
1402       (scroll-up (or n (/ (window-height) 2)))
1403     (error nil))
1404   (if (pos-visible-in-window-p (max 1 (- (point-max) 2)))
1405       (if (eq major-mode 'calc-mode)
1406           (calc-realign)
1407         (goto-char (point-max))
1408         (set-window-start (selected-window)
1409                           (save-excursion
1410                             (forward-line (- (1- (window-height))))
1411                             (point)))
1412         (forward-line -1))))
1413
1414 (defun calc-scroll-down (n)
1415   (interactive "P")
1416   (or (pos-visible-in-window-p 1)
1417       (scroll-down (or n (/ (window-height) 2)))))
1418
1419
1420 (defun calc-precision (n)
1421   (interactive "NPrecision: ")
1422   (calc-wrapper
1423    (if (< (prefix-numeric-value n) 3)
1424        (error "Precision must be at least 3 digits")
1425      (calc-change-mode 'calc-internal-prec (prefix-numeric-value n)
1426                        (and (memq (car calc-float-format) '(float sci eng))
1427                             (< (nth 1 calc-float-format)
1428                                 (if (= calc-number-radix 10) 0 1))))
1429      (calc-record calc-internal-prec "prec"))
1430    (message "Floating-point precision is %d digits" calc-internal-prec)))
1431
1432
1433 (defun calc-inverse (&optional n)
1434   (interactive "P")
1435   (let* ((hyp-flag (if (or
1436                         (eq major-mode 'calc-keypad-mode)
1437                         (eq major-mode 'calc-trail-mode))
1438                        (with-current-buffer calc-main-buffer
1439                          calc-hyperbolic-flag)
1440                      calc-hyperbolic-flag))
1441          (opt-flag (if (or
1442                         (eq major-mode 'calc-keypad-mode)
1443                         (eq major-mode 'calc-trail-mode))
1444                        (with-current-buffer calc-main-buffer
1445                          calc-option-flag)
1446                      calc-option-flag))
1447          (msg
1448           (cond
1449            ((and opt-flag hyp-flag) "Option Inverse Hyperbolic...")
1450            (hyp-flag "Inverse Hyperbolic...")
1451            (opt-flag "Option Inverse...")
1452            (t "Inverse..."))))
1453     (calc-fancy-prefix 'calc-inverse-flag msg n)))
1454
1455 (defconst calc-fancy-prefix-map
1456   (let ((map (make-sparse-keymap)))
1457     (define-key map [t] 'calc-fancy-prefix-other-key)
1458     (define-key map (vector meta-prefix-char t) 'calc-fancy-prefix-other-key)
1459     (define-key map [switch-frame] nil)
1460     (define-key map [?\C-u] 'universal-argument)
1461     (define-key map [?0] 'digit-argument)
1462     (define-key map [?1] 'digit-argument)
1463     (define-key map [?2] 'digit-argument)
1464     (define-key map [?3] 'digit-argument)
1465     (define-key map [?4] 'digit-argument)
1466     (define-key map [?5] 'digit-argument)
1467     (define-key map [?6] 'digit-argument)
1468     (define-key map [?7] 'digit-argument)
1469     (define-key map [?8] 'digit-argument)
1470     (define-key map [?9] 'digit-argument)
1471     map)
1472   "Keymap used while processing calc-fancy-prefix.")
1473
1474 (defvar calc-is-keypad-press nil)
1475 (defun calc-fancy-prefix (flag msg n)
1476   (let (prefix)
1477     (calc-wrapper
1478      (calc-set-command-flag 'keep-flags)
1479      (calc-set-command-flag 'no-align)
1480      (setq prefix (set flag (not (symbol-value flag)))
1481            prefix-arg n)
1482      (message "%s" (if prefix msg "")))
1483     (and prefix
1484          (not calc-is-keypad-press)
1485          (if (boundp 'overriding-terminal-local-map)
1486              (setq overriding-terminal-local-map calc-fancy-prefix-map)
1487            (let ((event (calc-read-key t)))
1488              (if (eq (setq last-command-event (car event)) ?\C-u)
1489                  (universal-argument)
1490                (if (or (not (integerp last-command-event))
1491                        (and (>= last-command-event 0) (< last-command-event ? )
1492                             (not (memq last-command-event '(?\e)))))
1493                    (calc-wrapper))  ; clear flags if not a Calc command.
1494                (setq last-command-event (cdr event))
1495                (if (or (not (integerp last-command-event))
1496                        (eq last-command-event ?-))
1497                    (calc-unread-command)
1498                  (digit-argument n))))))))
1499
1500 (defun calc-fancy-prefix-other-key (arg)
1501   (interactive "P")
1502   (if (and
1503        (not (eq last-command-event 'tab))
1504        (not (eq last-command-event 'M-tab))
1505        (or (not (integerp last-command-event))
1506            (and (>= last-command-event 0) (< last-command-event ? )
1507                 (not (eq last-command-event meta-prefix-char)))))
1508      (calc-wrapper))  ; clear flags if not a Calc command.
1509   (setq prefix-arg arg)
1510   (calc-unread-command)
1511   (setq overriding-terminal-local-map nil))
1512
1513 (defun calc-invert-func ()
1514   (save-excursion
1515     (calc-select-buffer)
1516     (setq calc-inverse-flag (not (calc-is-inverse))
1517           calc-hyperbolic-flag (calc-is-hyperbolic)
1518           current-prefix-arg nil)))
1519
1520 (defun calc-is-inverse ()
1521   calc-inverse-flag)
1522
1523 (defun calc-hyperbolic (&optional n)
1524   (interactive "P")
1525   (let* ((inv-flag (if (or
1526                         (eq major-mode 'calc-keypad-mode)
1527                         (eq major-mode 'calc-trail-mode))
1528                        (with-current-buffer calc-main-buffer
1529                          calc-inverse-flag)
1530                      calc-inverse-flag))
1531          (opt-flag (if (or
1532                         (eq major-mode 'calc-keypad-mode)
1533                         (eq major-mode 'calc-trail-mode))
1534                        (with-current-buffer calc-main-buffer
1535                          calc-option-flag)
1536                      calc-option-flag))
1537          (msg
1538           (cond
1539            ((and opt-flag inv-flag) "Option Inverse Hyperbolic...")
1540            (opt-flag "Option Hyperbolic...")
1541            (inv-flag "Inverse Hyperbolic...")
1542            (t "Hyperbolic..."))))
1543     (calc-fancy-prefix 'calc-hyperbolic-flag msg n)))
1544
1545 (defun calc-hyperbolic-func ()
1546   (save-excursion
1547     (calc-select-buffer)
1548     (setq calc-inverse-flag (calc-is-inverse)
1549           calc-hyperbolic-flag (not (calc-is-hyperbolic))
1550           current-prefix-arg nil)))
1551
1552 (defun calc-is-hyperbolic ()
1553   calc-hyperbolic-flag)
1554
1555 (defun calc-option (&optional n)
1556   (interactive "P")
1557   (let* ((inv-flag (if (or
1558                         (eq major-mode 'calc-keypad-mode)
1559                         (eq major-mode 'calc-trail-mode))
1560                        (with-current-buffer calc-main-buffer
1561                          calc-inverse-flag)
1562                      calc-inverse-flag))
1563          (hyp-flag (if (or
1564                         (eq major-mode 'calc-keypad-mode)
1565                         (eq major-mode 'calc-trail-mode))
1566                        (with-current-buffer calc-main-buffer
1567                          calc-hyperbolic-flag)
1568                      calc-hyperbolic-flag))
1569          (msg
1570           (cond
1571            ((and hyp-flag inv-flag) "Option Inverse Hyperbolic...")
1572            (hyp-flag "Option Hyperbolic...")
1573            (inv-flag "Option Inverse...")
1574            (t "Option..."))))
1575     (calc-fancy-prefix 'calc-option-flag msg n)))
1576
1577 (defun calc-is-option ()
1578   calc-option-flag)
1579
1580 (defun calc-keep-args (&optional n)
1581   (interactive "P")
1582   (calc-fancy-prefix 'calc-keep-args-flag "Keep args..." n))
1583
1584
1585 (defun calc-change-mode (var value &optional refresh option)
1586   (if option
1587       (setq value (if value
1588                       (> (prefix-numeric-value value) 0)
1589                     (not (symbol-value var)))))
1590   (or (consp var) (setq var (list var) value (list value)))
1591   (if calc-inverse-flag
1592       (let ((old nil))
1593         (or refresh (error "Not a display-mode command"))
1594         (calc-check-stack 1)
1595         (unwind-protect
1596             (let ((v var))
1597               (while v
1598                 (setq old (cons (symbol-value (car v)) old))
1599                 (set (car v) (car value))
1600                 (setq v (cdr v)
1601                       value (cdr value)))
1602               (calc-refresh-top 1)
1603               (calc-refresh-evaltos)
1604               (symbol-value (car var)))
1605           (let ((v var))
1606             (setq old (nreverse old))
1607             (while v
1608               (set (car v) (car old))
1609               (setq v (cdr v)
1610                     old (cdr old)))
1611             (if (eq (car var) 'calc-language)
1612                 (calc-set-language calc-language calc-language-option t)))))
1613     (let ((chg nil)
1614           (v var))
1615       (while v
1616         (or (equal (symbol-value (car v)) (car value))
1617             (progn
1618               (set (car v) (car value))
1619               (if (eq (car v) 'calc-float-format)
1620                   (setq calc-full-float-format
1621                         (list (if (eq (car (car value)) 'fix)
1622                                   'float
1623                                 (car (car value)))
1624                               0)))
1625               (setq chg t)))
1626         (setq v (cdr v)
1627               value (cdr value)))
1628       (if chg
1629           (progn
1630             (or (and refresh (calc-do-refresh))
1631                 (calc-refresh-evaltos))
1632             (and (eq calc-mode-save-mode 'save)
1633                  (not (equal var '(calc-mode-save-mode)))
1634                  (calc-save-modes))))
1635       (if calc-embedded-info (calc-embedded-modes-change var))
1636       (symbol-value (car var)))))
1637
1638 (defun calc-toggle-banner ()
1639   "Toggle display of the friendly greeting calc normally shows above the stack."
1640   (interactive)
1641   (setq calc-show-banner (not calc-show-banner))
1642   (calc-refresh))
1643
1644 (defun calc-refresh-top (n)
1645   (interactive "p")
1646   (calc-wrapper
1647    (cond ((< n 0)
1648           (setq n (- n))
1649           (let ((entry (calc-top n 'entry))
1650                 (calc-undo-list nil) (calc-redo-list nil))
1651             (calc-pop-stack 1 n t)
1652             (calc-push-list (list (car entry)) n (list (nth 2 entry)))))
1653          ((= n 0)
1654           (calc-refresh))
1655          (t
1656           (let ((entries (calc-top-list n 1 'entry))
1657                 (calc-undo-list nil) (calc-redo-list nil))
1658             (calc-pop-stack n 1 t)
1659             (calc-push-list (mapcar 'car entries)
1660                             1
1661                             (mapcar (function (lambda (x) (nth 2 x)))
1662                                     entries)))))))
1663
1664 (defvar calc-refreshing-evaltos nil)
1665 (defvar calc-no-refresh-evaltos nil)
1666 (defun calc-refresh-evaltos (&optional which-var)
1667   (and calc-any-evaltos calc-auto-recompute (not calc-no-refresh-evaltos)
1668        (let ((calc-refreshing-evaltos t)
1669              (num (calc-stack-size))
1670              (calc-undo-list nil) (calc-redo-list nil)
1671              value new-val)
1672          (while (> num 0)
1673            (setq value (calc-top num 'entry))
1674            (if (and (not (nth 2 value))
1675                     (setq value (car value))
1676                     (or (eq (car-safe value) 'calcFunc-evalto)
1677                         (and (eq (car-safe value) 'vec)
1678                              (eq (car-safe (nth 1 value)) 'calcFunc-evalto))))
1679                (progn
1680                  (setq new-val (math-normalize value))
1681                  (or (equal new-val value)
1682                      (progn
1683                        (calc-push-list (list new-val) num)
1684                        (calc-pop-stack 1 (1+ num) t)))))
1685            (setq num (1- num)))))
1686   (and calc-embedded-active which-var
1687        (calc-embedded-var-change which-var)))
1688
1689 (defun calc-push (&rest vals)
1690   (calc-push-list vals))
1691
1692 (defun calc-pop-push (n &rest vals)
1693   (calc-pop-push-list n vals))
1694
1695 (defun calc-pop-push-record (n prefix &rest vals)
1696   (calc-pop-push-record-list n prefix vals))
1697
1698
1699 (defun calc-evaluate (n)
1700   (interactive "p")
1701   (calc-slow-wrapper
1702    (if (= n 0)
1703        (setq n (calc-stack-size)))
1704    (calc-with-default-simplification
1705     (if (< n 0)
1706         (calc-pop-push-record-list 1 "eval"
1707                                    (math-evaluate-expr (calc-top (- n)))
1708                                    (- n))
1709       (calc-pop-push-record-list n "eval" (mapcar 'math-evaluate-expr
1710                                                   (calc-top-list n)))))
1711    (calc-handle-whys)))
1712
1713
1714 (defun calc-eval-num (n)
1715   (interactive "P")
1716   (calc-slow-wrapper
1717    (let* ((nn (prefix-numeric-value n))
1718           (calc-internal-prec (cond ((>= nn 3) nn)
1719                                     ((< nn 0) (max (+ calc-internal-prec nn)
1720                                                    3))
1721                                     (t calc-internal-prec)))
1722           (calc-symbolic-mode nil))
1723      (calc-with-default-simplification
1724       (calc-pop-push-record 1 "num" (math-evaluate-expr (calc-top 1)))))
1725    (calc-handle-whys)))
1726
1727
1728 (defvar calc-extended-command-history nil
1729   "The history list for calc-execute-extended-command.")
1730
1731 (defun calc-execute-extended-command (n)
1732   (interactive "P")
1733   (let* ((prompt (concat (calc-num-prefix-name n) "M-x "))
1734          (cmd (intern
1735                (completing-read prompt obarray 'commandp t "calc-"
1736                                 'calc-extended-command-history))))
1737     (setq prefix-arg n)
1738     (command-execute cmd)))
1739
1740
1741 (defun calc-realign (&optional num)
1742   (interactive "P")
1743   (if (and num (eq major-mode 'calc-mode))
1744       (progn
1745         (calc-check-stack num)
1746         (calc-cursor-stack-index num)
1747         (and calc-line-numbering
1748              (forward-char 4)))
1749     (if (and calc-embedded-info
1750              (eq (current-buffer) (aref calc-embedded-info 0)))
1751         (progn
1752           (goto-char (aref calc-embedded-info 2))
1753           (if (with-current-buffer (aref calc-embedded-info 1)
1754                 calc-show-plain)
1755               (forward-line 1)))
1756       (calc-wrapper
1757        (if (get-buffer-window (current-buffer))
1758            (set-window-hscroll (get-buffer-window (current-buffer)) 0))))))
1759
1760 (defvar math-cache-list nil)
1761
1762 (defun calc-var-value (v)
1763   (and (symbolp v)
1764        (boundp v)
1765        (symbol-value v)
1766        (if (symbolp (symbol-value v))
1767            (set v (funcall (symbol-value v)))
1768          (if (stringp (symbol-value v))
1769              (let ((val (math-read-expr (symbol-value v))))
1770                (if (eq (car-safe val) 'error)
1771                    (error "Bad format in variable contents: %s" (nth 2 val))
1772                  (set v val)))
1773            (symbol-value v)))))
1774
1775 ;;; In the following table, ( OP LOPS ROPS ) means that if an OP
1776 ;;; term appears as the first argument to any LOPS term, or as the
1777 ;;; second argument to any ROPS term, then they should be treated
1778 ;;; as one large term for purposes of associative selection.
1779 (defconst calc-assoc-ops '( ( + ( + - ) ( + ) )
1780                             ( - ( + - ) ( + ) )
1781                             ( * ( * )   ( * ) )
1782                             ( / ( / )   (   ) )
1783                             ( | ( | )   ( | ) )
1784                             ( calcFunc-land ( calcFunc-land )
1785                                             ( calcFunc-land ) )
1786                             ( calcFunc-lor ( calcFunc-lor )
1787                                            ( calcFunc-lor ) ) ))
1788
1789
1790 (defvar var-CommuteRules 'calc-CommuteRules)
1791 (defvar var-JumpRules    'calc-JumpRules)
1792 (defvar var-DistribRules 'calc-DistribRules)
1793 (defvar var-MergeRules   'calc-MergeRules)
1794 (defvar var-NegateRules  'calc-NegateRules)
1795 (defvar var-InvertRules  'calc-InvertRules)
1796
1797
1798 (defconst calc-tweak-eqn-table '( ( calcFunc-eq  calcFunc-eq  calcFunc-neq )
1799                                   ( calcFunc-neq calcFunc-neq calcFunc-eq  )
1800                                   ( calcFunc-lt  calcFunc-gt  calcFunc-geq )
1801                                   ( calcFunc-gt  calcFunc-lt  calcFunc-leq )
1802                                   ( calcFunc-leq calcFunc-geq calcFunc-gt  )
1803                                   ( calcFunc-geq calcFunc-leq calcFunc-lt  ) ))
1804
1805
1806
1807
1808 (defun calc-float (arg)
1809   (interactive "P")
1810   (calc-slow-wrapper
1811    (calc-unary-op "flt"
1812                   (if (calc-is-hyperbolic) 'calcFunc-float 'calcFunc-pfloat)
1813                   arg)))
1814
1815
1816 (defvar calc-gnuplot-process nil)
1817 (defvar calc-gnuplot-input)
1818 (defvar calc-gnuplot-buffer)
1819
1820 (defun calc-gnuplot-alive ()
1821   (and calc-gnuplot-process
1822        calc-gnuplot-buffer
1823        (buffer-name calc-gnuplot-buffer)
1824        calc-gnuplot-input
1825        (buffer-name calc-gnuplot-input)
1826        (memq (process-status calc-gnuplot-process) '(run stop))))
1827
1828
1829
1830
1831
1832 (defun calc-load-everything ()
1833   (interactive)
1834   (require 'calc-aent)
1835   (require 'calc-alg)
1836   (require 'calc-arith)
1837   (require 'calc-bin)
1838   (require 'calc-comb)
1839   (require 'calc-cplx)
1840   (require 'calc-embed)
1841   (require 'calc-fin)
1842   (require 'calc-forms)
1843   (require 'calc-frac)
1844   (require 'calc-funcs)
1845   (require 'calc-graph)
1846   (require 'calc-help)
1847   (require 'calc-incom)
1848   (require 'calc-keypd)
1849   (require 'calc-lang)
1850   (require 'calc-macs)
1851   (require 'calc-map)
1852   (require 'calc-math)
1853   (require 'calc-misc)
1854   (require 'calc-mode)
1855   (require 'calc-mtx)
1856   (require 'calc-poly)
1857   (require 'calc-prog)
1858   (require 'calc-rewr)
1859   (require 'calc-rules)
1860   (require 'calc-sel)
1861   (require 'calc-stat)
1862   (require 'calc-store)
1863   (require 'calc-stuff)
1864   (require 'calc-trail)
1865   (require 'calc-undo)
1866   (require 'calc-units)
1867   (require 'calc-vec)
1868   (require 'calc-yank)
1869   (require 'calcalg2)
1870   (require 'calcalg3)
1871   (require 'calccomp)
1872   (require 'calcsel2)
1873
1874   (message "All parts of Calc are now loaded"))
1875
1876
1877 ;;; Vector commands.
1878
1879 (defun calc-concat (arg)
1880   (interactive "P")
1881   (calc-wrapper
1882    (if (calc-is-inverse)
1883        (if (calc-is-hyperbolic)
1884            (calc-enter-result 2 "apnd" (list 'calcFunc-append
1885                                           (calc-top 1) (calc-top 2)))
1886          (calc-enter-result 2 "|" (list 'calcFunc-vconcat
1887                                         (calc-top 1) (calc-top 2))))
1888      (if (calc-is-hyperbolic)
1889          (calc-binary-op "apnd" 'calcFunc-append arg '(vec))
1890        (calc-binary-op "|" 'calcFunc-vconcat arg '(vec) nil '|)))))
1891
1892 (defun calc-append (arg)
1893   (interactive "P")
1894   (calc-hyperbolic-func)
1895   (calc-concat arg))
1896
1897
1898 (defconst calc-arg-values '( ( var ArgA var-ArgA ) ( var ArgB var-ArgB )
1899                              ( var ArgC var-ArgC ) ( var ArgD var-ArgD )
1900                              ( var ArgE var-ArgE ) ( var ArgF var-ArgF )
1901                              ( var ArgG var-ArgG ) ( var ArgH var-ArgH )
1902                              ( var ArgI var-ArgI ) ( var ArgJ var-ArgJ )
1903 ))
1904
1905 (defun calc-invent-args (n)
1906   (nreverse (nthcdr (- (length calc-arg-values) n) (reverse calc-arg-values))))
1907
1908
1909
1910
1911 ;;; User menu.
1912
1913 (defun calc-user-key-map ()
1914   (if (featurep 'xemacs)
1915       (error "User-defined keys are not supported in XEmacs"))
1916   (let ((res (cdr (lookup-key calc-mode-map "z"))))
1917     (if (eq (car (car res)) 27)
1918         (cdr res)
1919       res)))
1920
1921 (defvar calc-z-prefix-buf nil)
1922 (defvar calc-z-prefix-msgs nil)
1923
1924 (defun calc-z-prefix-help ()
1925   (interactive)
1926   (let* ((calc-z-prefix-msgs nil)
1927          (calc-z-prefix-buf "")
1928          (kmap (sort (copy-sequence (calc-user-key-map))
1929                      (function (lambda (x y) (< (car x) (car y))))))
1930          (flags (apply 'logior
1931                        (mapcar (function
1932                                 (lambda (k)
1933                                   (calc-user-function-classify (car k))))
1934                                kmap))))
1935     (if (= (logand flags 8) 0)
1936         (calc-user-function-list kmap 7)
1937       (calc-user-function-list kmap 1)
1938       (setq calc-z-prefix-msgs (cons calc-z-prefix-buf calc-z-prefix-msgs)
1939             calc-z-prefix-buf "")
1940       (calc-user-function-list kmap 6))
1941     (if (/= flags 0)
1942         (setq calc-z-prefix-msgs (cons calc-z-prefix-buf calc-z-prefix-msgs)))
1943     (calc-do-prefix-help (nreverse calc-z-prefix-msgs) "user" ?z)))
1944
1945 (defun calc-user-function-classify (key)
1946   (cond ((/= key (downcase key))    ; upper-case
1947          (if (assq (downcase key) (calc-user-key-map)) 9 1))
1948         ((/= key (upcase key)) 2)   ; lower-case
1949         ((= key ??) 0)
1950         (t 4)))   ; other
1951
1952 (defun calc-user-function-list (map flags)
1953   (and map
1954        (let* ((key (car (car map)))
1955               (kind (calc-user-function-classify key))
1956               (func (cdr (car map))))
1957          (if (or (= (logand kind flags) 0)
1958                  (not (symbolp func)))
1959              ()
1960            (let* ((name (symbol-name func))
1961                   (name (if (string-match "\\`calc-" name)
1962                             (substring name 5) name))
1963                   (pos (string-match (char-to-string key) name))
1964                   (desc
1965                    (if (symbolp func)
1966                        (if (= (logand kind 3) 0)
1967                            (format-message "`%c' = %s" key name)
1968                          (if pos
1969                              (format "%s%c%s"
1970                                      (downcase (substring name 0 pos))
1971                                      (upcase key)
1972                                      (downcase (substring name (1+ pos))))
1973                            (format "%c = %s"
1974                                    (upcase key)
1975                                    (downcase name))))
1976                      (char-to-string (upcase key)))))
1977              (if (= (length calc-z-prefix-buf) 0)
1978                  (setq calc-z-prefix-buf (concat (if (= flags 1) "SHIFT + " "")
1979                                    desc))
1980                (if (> (+ (length calc-z-prefix-buf) (length desc)) 58)
1981                    (setq calc-z-prefix-msgs
1982                          (cons calc-z-prefix-buf calc-z-prefix-msgs)
1983                          calc-z-prefix-buf (concat (if (= flags 1) "SHIFT + " "")
1984                                      desc))
1985                  (setq calc-z-prefix-buf (concat calc-z-prefix-buf ", " desc))))))
1986          (calc-user-function-list (cdr map) flags))))
1987
1988
1989
1990 (defun calc-shift-Z-prefix-help ()
1991   (interactive)
1992   (calc-do-prefix-help
1993    '("Define, Undefine, Formula, Kbd-macro, Edit, Get-defn"
1994      "Composition, Syntax; Invocation; Permanent; Timing"
1995      "kbd-macros: [ (if), : (else), | (else-if), ] (end-if)"
1996      "kbd-macros: < > (repeat), ( ) (for), { } (loop)"
1997      "kbd-macros: / (break)"
1998      "kbd-macros: \\=` (save), \\=' (restore)")
1999    "user" ?Z))
2000
2001
2002 ;;;; Caches.
2003
2004 (defmacro math-defcache (name init form)
2005   (let ((cache-prec (intern (concat (symbol-name name) "-cache-prec")))
2006         (cache-val (intern (concat (symbol-name name) "-cache")))
2007         (last-prec (intern (concat (symbol-name name) "-last-prec")))
2008         (last-val (intern (concat (symbol-name name) "-last"))))
2009     `(progn
2010 ;      (defvar ,cache-prec ,(if init (math-numdigs (nth 1 init)) -100))
2011        (defvar ,cache-prec (cond
2012                             ((consp ,init) (math-numdigs (nth 1 ,init)))
2013                             (,init
2014                              (nth 1 (math-numdigs (eval ,init))))
2015                             (t
2016                              -100)))
2017        (defvar ,cache-val (cond ((consp ,init) ,init)
2018                                 (,init (eval ,init))
2019                                 (t ,init)))
2020        (defvar ,last-prec -100)
2021        (defvar ,last-val nil)
2022        (setq math-cache-list
2023              (cons ',cache-prec
2024                    (cons ',last-prec
2025                          math-cache-list)))
2026        (defun ,name ()
2027          (or (= ,last-prec calc-internal-prec)
2028              (setq ,last-val
2029                    (math-normalize
2030                     (progn (or (>= ,cache-prec calc-internal-prec)
2031                                (setq ,cache-val
2032                                      (let ((calc-internal-prec
2033                                             (+ calc-internal-prec 4)))
2034                                        ,form)
2035                                      ,cache-prec (+ calc-internal-prec 2)))
2036                            ,cache-val))
2037                    ,last-prec calc-internal-prec))
2038          ,last-val))))
2039 (put 'math-defcache 'lisp-indent-hook 2)
2040
2041 ;;; Betcha didn't know that pi = 16 atan(1/5) - 4 atan(1/239).   [F] [Public]
2042 (defconst math-approx-pi
2043   (math-read-number-simple "3.141592653589793238463")
2044   "An approximation for pi.")
2045
2046 (math-defcache math-pi math-approx-pi
2047   (math-add-float (math-mul-float '(float 16 0)
2048                                   (math-arctan-raw '(float 2 -1)))
2049                   (math-mul-float '(float -4 0)
2050                                   (math-arctan-raw
2051                                    (math-float '(frac 1 239))))))
2052
2053 (math-defcache math-two-pi nil
2054   (math-mul-float (math-pi) '(float 2 0)))
2055
2056 (math-defcache math-pi-over-2 nil
2057   (math-mul-float (math-pi) '(float 5 -1)))
2058
2059 (math-defcache math-pi-over-4 nil
2060   (math-mul-float (math-pi) '(float 25 -2)))
2061
2062 (math-defcache math-pi-over-180 nil
2063   (math-div-float (math-pi) '(float 18 1)))
2064
2065 (math-defcache math-sqrt-pi nil
2066   (math-sqrt-float (math-pi)))
2067
2068 (math-defcache math-sqrt-2 nil
2069   (math-sqrt-float '(float 2 0)))
2070
2071 (math-defcache math-sqrt-12 nil
2072   (math-sqrt-float '(float 12 0)))
2073
2074 (math-defcache math-sqrt-two-pi nil
2075   (math-sqrt-float (math-two-pi)))
2076
2077 (defconst math-approx-sqrt-e
2078   (math-read-number-simple "1.648721270700128146849")
2079   "An approximation for sqrt(3).")
2080
2081 (math-defcache math-sqrt-e math-approx-sqrt-e
2082   (math-add-float '(float 1 0) (math-exp-minus-1-raw '(float 5 -1))))
2083
2084 (math-defcache math-e nil
2085   (math-pow (math-sqrt-e) 2))
2086
2087 (math-defcache math-phi nil
2088   (math-mul-float (math-add-float (math-sqrt-raw '(float 5 0)) '(float 1 0))
2089                   '(float 5 -1)))
2090
2091 (defconst math-approx-gamma-const
2092   (math-read-number-simple
2093    "0.5772156649015328606065120900824024310421593359399235988057672348848677267776646709369470632917467495")
2094   "An approximation for gamma.")
2095
2096 (math-defcache math-gamma-const nil
2097   math-approx-gamma-const)
2098
2099 (defun math-half-circle (symb)
2100   (if (eq calc-angle-mode 'rad)
2101       (if symb
2102           '(var pi var-pi)
2103         (math-pi))
2104     180))
2105
2106 (defun math-full-circle (symb)
2107   (math-mul 2 (math-half-circle symb)))
2108
2109 (defun math-quarter-circle (symb)
2110   (math-div (math-half-circle symb) 2))
2111
2112 (defvar math-expand-formulas nil)
2113
2114 ;;;; Miscellaneous math routines.
2115
2116 ;;; True if A is an odd integer.  [P R R] [Public]
2117 (defun math-oddp (a)
2118   (if (consp a)
2119       (and (memq (car a) '(bigpos bigneg))
2120            (= (% (nth 1 a) 2) 1))
2121     (/= (% a 2) 0)))
2122
2123 ;;; True if A is a small or big integer.  [P x] [Public]
2124 (defun math-integerp (a)
2125   (or (integerp a)
2126       (memq (car-safe a) '(bigpos bigneg))))
2127
2128 ;;; True if A is (numerically) a non-negative integer.  [P N] [Public]
2129 (defun math-natnump (a)
2130   (or (natnump a)
2131       (eq (car-safe a) 'bigpos)))
2132
2133 ;;; True if A is a rational (or integer).  [P x] [Public]
2134 (defun math-ratp (a)
2135   (or (integerp a)
2136       (memq (car-safe a) '(bigpos bigneg frac))))
2137
2138 ;;; True if A is a real (or rational).  [P x] [Public]
2139 (defun math-realp (a)
2140   (or (integerp a)
2141       (memq (car-safe a) '(bigpos bigneg frac float))))
2142
2143 ;;; True if A is a real or HMS form.  [P x] [Public]
2144 (defun math-anglep (a)
2145   (or (integerp a)
2146       (memq (car-safe a) '(bigpos bigneg frac float hms))))
2147
2148 ;;; True if A is a number of any kind.  [P x] [Public]
2149 (defun math-numberp (a)
2150   (or (integerp a)
2151       (memq (car-safe a) '(bigpos bigneg frac float cplx polar))))
2152
2153 ;;; True if A is a complex number or angle.  [P x] [Public]
2154 (defun math-scalarp (a)
2155   (or (integerp a)
2156       (memq (car-safe a) '(bigpos bigneg frac float cplx polar hms))))
2157
2158 ;;; True if A is a vector.  [P x] [Public]
2159 (defun math-vectorp (a)
2160   (eq (car-safe a) 'vec))
2161
2162 ;;; True if A is any vector or scalar data object.  [P x]
2163 (defun math-objvecp (a)    ;  [Public]
2164   (or (integerp a)
2165       (memq (car-safe a) '(bigpos bigneg frac float cplx polar
2166                                   hms date sdev intv mod vec incomplete))))
2167
2168 ;;; True if A is an object not composed of sub-formulas .  [P x] [Public]
2169 (defun math-primp (a)
2170   (or (integerp a)
2171       (memq (car-safe a) '(bigpos bigneg frac float cplx polar
2172                                   hms date mod var))))
2173
2174 ;;; True if A is numerically (but not literally) an integer.  [P x] [Public]
2175 (defun math-messy-integerp (a)
2176   (cond
2177    ((eq (car-safe a) 'float) (>= (nth 2 a) 0))
2178    ((eq (car-safe a) 'frac) (Math-integerp (math-normalize a)))))
2179
2180 ;;; True if A is numerically an integer.  [P x] [Public]
2181 (defun math-num-integerp (a)
2182   (or (Math-integerp a)
2183       (Math-messy-integerp a)))
2184
2185 ;;; True if A is (numerically) a non-negative integer.  [P N] [Public]
2186 (defun math-num-natnump (a)
2187   (or (natnump a)
2188       (eq (car-safe a) 'bigpos)
2189       (and (eq (car-safe a) 'float)
2190            (Math-natnump (nth 1 a))
2191            (>= (nth 2 a) 0))))
2192
2193 ;;; True if A is an integer or will evaluate to an integer.  [P x] [Public]
2194 (defun math-provably-integerp (a)
2195   (or (Math-integerp a)
2196       (and (memq (car-safe a) '(calcFunc-trunc
2197                                 calcFunc-round
2198                                 calcFunc-rounde
2199                                 calcFunc-roundu
2200                                 calcFunc-floor
2201                                 calcFunc-ceil))
2202            (= (length a) 2))))
2203
2204 ;;; True if A is a real or will evaluate to a real.  [P x] [Public]
2205 (defun math-provably-realp (a)
2206   (or (Math-realp a)
2207       (math-provably-integerp a)
2208       (memq (car-safe a) '(abs arg))))
2209
2210 ;;; True if A is a non-real, complex number.  [P x] [Public]
2211 (defun math-complexp (a)
2212   (memq (car-safe a) '(cplx polar)))
2213
2214 ;;; True if A is a non-real, rectangular complex number.  [P x] [Public]
2215 (defun math-rect-complexp (a)
2216   (eq (car-safe a) 'cplx))
2217
2218 ;;; True if A is a non-real, polar complex number.  [P x] [Public]
2219 (defun math-polar-complexp (a)
2220   (eq (car-safe a) 'polar))
2221
2222 ;;; True if A is a matrix.  [P x] [Public]
2223 (defun math-matrixp (a)
2224   (and (Math-vectorp a)
2225        (Math-vectorp (nth 1 a))
2226        (cdr (nth 1 a))
2227        (let ((len (length (nth 1 a))))
2228          (setq a (cdr a))
2229          (while (and (setq a (cdr a))
2230                      (Math-vectorp (car a))
2231                      (= (length (car a)) len)))
2232          (null a))))
2233
2234 (defun math-matrixp-step (a len)   ; [P L]
2235   (or (null a)
2236       (and (Math-vectorp (car a))
2237            (= (length (car a)) len)
2238            (math-matrixp-step (cdr a) len))))
2239
2240 ;;; True if A is a square matrix.  [P V] [Public]
2241 (defun math-square-matrixp (a)
2242   (let ((dims (math-mat-dimens a)))
2243     (and (cdr dims)
2244          (= (car dims) (nth 1 dims)))))
2245
2246 ;;; True if MAT is an identity matrix.
2247 (defun math-identity-matrix-p (mat &optional mul)
2248   (if (math-square-matrixp mat)
2249       (let ((a (if mul
2250                    (nth 1 (nth 1 mat))
2251                  1))
2252             (n (1- (length mat)))
2253             (i 1))
2254         (while (and (<= i n)
2255                     (math-ident-row-p (nth i mat) i a))
2256           (setq i (1+ i)))
2257         (if (> i n)
2258             a
2259           nil))))
2260
2261 (defun math-ident-row-p (row n &optional a)
2262   (unless a
2263     (setq a 1))
2264   (and
2265    (not (memq nil (mapcar
2266                    (lambda (x) (eq x 0))
2267                    (nthcdr (1+ n) row))))
2268    (not (memq nil (mapcar
2269                    (lambda (x) (eq x 0))
2270                    (butlast
2271                     (cdr row)
2272                     (- (length row) n)))))
2273    (eq (elt row n) a)))
2274
2275 ;;; True if A is any scalar data object.  [P x]
2276 (defun math-objectp (a)    ;  [Public]
2277   (or (integerp a)
2278       (memq (car-safe a) '(bigpos bigneg frac float cplx
2279                                   polar hms date sdev intv mod))))
2280
2281 ;;; Verify that A is an integer and return A in integer form.  [I N; - x]
2282 (defun math-check-integer (a)   ;  [Public]
2283   (cond ((integerp a) a)  ; for speed
2284         ((math-integerp a) a)
2285         ((math-messy-integerp a)
2286          (math-trunc a))
2287         (t (math-reject-arg a 'integerp))))
2288
2289 ;;; Verify that A is a small integer and return A in integer form.  [S N; - x]
2290 (defun math-check-fixnum (a &optional allow-inf)   ;  [Public]
2291   (cond ((integerp a) a)  ; for speed
2292         ((Math-num-integerp a)
2293          (let ((a (math-trunc a)))
2294            (if (integerp a)
2295                a
2296              (if (or (Math-lessp (lsh -1 -1) a)
2297                      (Math-lessp a (- (lsh -1 -1))))
2298                  (math-reject-arg a 'fixnump)
2299                (math-fixnum a)))))
2300         ((and allow-inf (equal a '(var inf var-inf)))
2301          (lsh -1 -1))
2302         ((and allow-inf (equal a '(neg (var inf var-inf))))
2303          (- (lsh -1 -1)))
2304         (t (math-reject-arg a 'fixnump))))
2305
2306 ;;; Verify that A is an integer >= 0 and return A in integer form.  [I N; - x]
2307 (defun math-check-natnum (a)    ;  [Public]
2308   (cond ((natnump a) a)
2309         ((and (not (math-negp a))
2310               (Math-num-integerp a))
2311          (math-trunc a))
2312         (t (math-reject-arg a 'natnump))))
2313
2314 ;;; Verify that A is in floating-point form, or force it to be a float.  [F N]
2315 (defun math-check-float (a)    ; [Public]
2316   (cond ((eq (car-safe a) 'float) a)
2317         ((Math-vectorp a) (math-map-vec 'math-check-float a))
2318         ((Math-objectp a) (math-float a))
2319         (t a)))
2320
2321 ;;; Verify that A is a constant.
2322 (defun math-check-const (a &optional exp-ok)
2323   (if (or (math-constp a)
2324           (and exp-ok math-expand-formulas))
2325       a
2326     (math-reject-arg a 'constp)))
2327
2328 ;;; Some functions for working with error forms.
2329 (defun math-get-value (x)
2330   "Get the mean value of the error form X.
2331 If X is not an error form, return X."
2332   (if (eq (car-safe x) 'sdev)
2333       (nth 1 x)
2334     x))
2335
2336 (defun math-get-sdev (x &optional one)
2337   "Get the standard deviation of the error form X.
2338 If X is not an error form, return 1."
2339   (if (eq (car-safe x) 'sdev)
2340       (nth 2 x)
2341     (if one 1 0)))
2342
2343 (defun math-contains-sdev-p (ls)
2344   "Non-nil if the list LS contains an error form."
2345   (let ((ls (if (eq (car-safe ls) 'vec) (cdr ls) ls)))
2346     (memq t (mapcar (lambda (x) (eq (car-safe x) 'sdev)) ls))))
2347
2348 ;;; Coerce integer A to be a small integer.  [S I]
2349 (defun math-fixnum (a)
2350   (if (consp a)
2351       (if (cdr a)
2352           (if (eq (car a) 'bigneg)
2353               (- (math-fixnum-big (cdr a)))
2354             (math-fixnum-big (cdr a)))
2355         0)
2356     a))
2357
2358 (defun math-fixnum-big (a)
2359   (if (cdr a)
2360       (+ (car a) (* (math-fixnum-big (cdr a)) math-bignum-digit-size))
2361     (car a)))
2362
2363 (defvar math-simplify-only nil)
2364
2365 (defun math-normalize-fancy (a)
2366   (cond ((eq (car a) 'frac)
2367          (math-make-frac (math-normalize (nth 1 a))
2368                          (math-normalize (nth 2 a))))
2369         ((eq (car a) 'cplx)
2370          (let ((real (math-normalize (nth 1 a)))
2371                (imag (math-normalize (nth 2 a))))
2372            (if (and (math-zerop imag)
2373                     (not math-simplify-only))   ; oh, what a kludge!
2374                real
2375              (list 'cplx real imag))))
2376         ((eq (car a) 'polar)
2377          (math-normalize-polar a))
2378         ((eq (car a) 'hms)
2379          (math-normalize-hms a))
2380         ((eq (car a) 'date)
2381          (list 'date (math-normalize (nth 1 a))))
2382         ((eq (car a) 'mod)
2383          (math-normalize-mod a))
2384         ((eq (car a) 'sdev)
2385          (let ((x (math-normalize (nth 1 a)))
2386                (s (math-normalize (nth 2 a))))
2387            (if (or (and (Math-objectp x) (not (Math-scalarp x)))
2388                    (and (Math-objectp s) (not (Math-scalarp s))))
2389                (list 'calcFunc-sdev x s)
2390              (math-make-sdev x s))))
2391         ((eq (car a) 'intv)
2392          (let ((mask (math-normalize (nth 1 a)))
2393                (lo (math-normalize (nth 2 a)))
2394                (hi (math-normalize (nth 3 a))))
2395            (if (if (eq (car-safe lo) 'date)
2396                    (not (eq (car-safe hi) 'date))
2397                  (or (and (Math-objectp lo) (not (Math-anglep lo)))
2398                      (and (Math-objectp hi) (not (Math-anglep hi)))))
2399                (list 'calcFunc-intv mask lo hi)
2400              (math-make-intv mask lo hi))))
2401         ((eq (car a) 'vec)
2402          (cons 'vec (mapcar 'math-normalize (cdr a))))
2403         ((eq (car a) 'quote)
2404          (math-normalize (nth 1 a)))
2405         ((eq (car a) 'special-const)
2406          (calc-with-default-simplification
2407           (math-normalize (nth 1 a))))
2408         ((eq (car a) 'var)
2409          (cons 'var (cdr a)))   ; need to re-cons for selection routines
2410         ((eq (car a) 'calcFunc-if)
2411          (math-normalize-logical-op a))
2412         ((memq (car a) '(calcFunc-lambda calcFunc-quote calcFunc-condition))
2413          (let ((calc-simplify-mode 'none))
2414            (cons (car a) (mapcar 'math-normalize (cdr a)))))
2415         ((eq (car a) 'calcFunc-evalto)
2416          (setq a (or (nth 1 a) 0))
2417          (or calc-refreshing-evaltos
2418              (setq a (let ((calc-simplify-mode 'none)) (math-normalize a))))
2419          (let ((b (if (and (eq (car-safe a) 'calcFunc-assign)
2420                            (= (length a) 3))
2421                       (nth 2 a)
2422                     a)))
2423            (list 'calcFunc-evalto
2424                  a
2425                  (if (eq calc-simplify-mode 'none)
2426                      (math-normalize b)
2427                    (calc-with-default-simplification
2428                     (math-evaluate-expr b))))))
2429         ((or (integerp (car a)) (consp (car a)))
2430          (if (null (cdr a))
2431              (math-normalize (car a))
2432            (error "Can't use multi-valued function in an expression")))))
2433
2434 ;; The variable math-normalize-a is local to math-normalize in calc.el,
2435 ;; but is used by math-normalize-nonstandard, which is called by
2436 ;; math-normalize.
2437 (defvar math-normalize-a)
2438
2439 (defun math-normalize-nonstandard ()
2440   (if (consp calc-simplify-mode)
2441       (progn
2442         (setq calc-simplify-mode 'none
2443               math-simplify-only (car-safe (cdr-safe math-normalize-a)))
2444         nil)
2445     (and (symbolp (car math-normalize-a))
2446          (or (eq calc-simplify-mode 'none)
2447              (and (eq calc-simplify-mode 'num)
2448                   (let ((aptr (setq math-normalize-a
2449                                     (cons
2450                                      (car math-normalize-a)
2451                                      (mapcar 'math-normalize
2452                                              (cdr math-normalize-a))))))
2453                     (while (and aptr (math-constp (car aptr)))
2454                       (setq aptr (cdr aptr)))
2455                     aptr)))
2456          (cons (car math-normalize-a)
2457                (mapcar 'math-normalize (cdr math-normalize-a))))))
2458
2459
2460 ;;; Normalize a bignum digit list by trimming high-end zeros.  [L l]
2461 (defun math-norm-bignum (a)
2462   (let ((digs a) (last nil))
2463     (while digs
2464       (or (eq (car digs) 0) (setq last digs))
2465       (setq digs (cdr digs)))
2466     (and last
2467          (progn
2468            (setcdr last nil)
2469            a))))
2470
2471 (defun math-bignum-test (a)   ; [B N; B s; b b]
2472   (if (consp a)
2473       a
2474     (math-bignum a)))
2475
2476
2477 ;;; Return 0 for zero, -1 for negative, 1 for positive.  [S n] [Public]
2478 (defun calcFunc-sign (a &optional x)
2479   (let ((signs (math-possible-signs a)))
2480     (cond ((eq signs 4) (or x 1))
2481           ((eq signs 2) 0)
2482           ((eq signs 1) (if x (math-neg x) -1))
2483           ((math-looks-negp a) (math-neg (calcFunc-sign (math-neg a))))
2484           (t (calc-record-why 'realp a)
2485              (if x
2486                  (list 'calcFunc-sign a x)
2487                (list 'calcFunc-sign a))))))
2488
2489 ;;; Return 0 if A is numerically equal to B, <0 if less, >0 if more.
2490 ;;; Arguments must be normalized!  [S N N]
2491 (defun math-compare (a b)
2492   (cond ((equal a b)
2493          (if (and (consp a)
2494                   (memq (car a) '(var neg * /))
2495                   (math-infinitep a))
2496              2
2497            0))
2498         ((and (integerp a) (Math-integerp b))
2499          (if (consp b)
2500              (if (eq (car b) 'bigpos) -1 1)
2501            (if (< a b) -1 1)))
2502         ((and (eq (car-safe a) 'bigpos) (Math-integerp b))
2503          (if (eq (car-safe b) 'bigpos)
2504              (math-compare-bignum (cdr a) (cdr b))
2505            1))
2506         ((and (eq (car-safe a) 'bigneg) (Math-integerp b))
2507          (if (eq (car-safe b) 'bigneg)
2508              (math-compare-bignum (cdr b) (cdr a))
2509            -1))
2510         ((eq (car-safe a) 'frac)
2511          (if (eq (car-safe b) 'frac)
2512              (math-compare (math-mul (nth 1 a) (nth 2 b))
2513                            (math-mul (nth 1 b) (nth 2 a)))
2514            (math-compare (nth 1 a) (math-mul b (nth 2 a)))))
2515         ((eq (car-safe b) 'frac)
2516          (math-compare (math-mul a (nth 2 b)) (nth 1 b)))
2517         ((and (eq (car-safe a) 'float) (eq (car-safe b) 'float))
2518          (if (math-lessp-float a b) -1 1))
2519         ((and (eq (car-safe a) 'date) (eq (car-safe b) 'date))
2520          (math-compare (nth 1 a) (nth 1 b)))
2521         ((and (or (Math-anglep a)
2522                   (and (eq (car a) 'cplx) (eq (nth 2 a) 0)))
2523               (or (Math-anglep b)
2524                   (and (eq (car b) 'cplx) (eq (nth 2 b) 0))))
2525          (calcFunc-sign (math-add a (math-neg b))))
2526         ((and (eq (car-safe a) 'intv)
2527               (or (Math-anglep b) (eq (car-safe b) 'date)))
2528          (let ((res (math-compare (nth 2 a) b)))
2529            (cond ((eq res 1) 1)
2530                  ((and (eq res 0) (memq (nth 1 a) '(0 1))) 1)
2531                  ((eq (setq res (math-compare (nth 3 a) b)) -1) -1)
2532                  ((and (eq res 0) (memq (nth 1 a) '(0 2))) -1)
2533                  (t 2))))
2534         ((and (eq (car-safe b) 'intv)
2535               (or (Math-anglep a) (eq (car-safe a) 'date)))
2536          (let ((res (math-compare a (nth 2 b))))
2537            (cond ((eq res -1) -1)
2538                  ((and (eq res 0) (memq (nth 1 b) '(0 1))) -1)
2539                  ((eq (setq res (math-compare a (nth 3 b))) 1) 1)
2540                  ((and (eq res 0) (memq (nth 1 b) '(0 2))) 1)
2541                  (t 2))))
2542         ((and (eq (car-safe a) 'intv) (eq (car-safe b) 'intv))
2543          (let ((res (math-compare (nth 3 a) (nth 2 b))))
2544            (cond ((eq res -1) -1)
2545                  ((and (eq res 0) (or (memq (nth 1 a) '(0 2))
2546                                       (memq (nth 1 b) '(0 1)))) -1)
2547                  ((eq (setq res (math-compare (nth 2 a) (nth 3 b))) 1) 1)
2548                  ((and (eq res 0) (or (memq (nth 1 a) '(0 1))
2549                                       (memq (nth 1 b) '(0 2)))) 1)
2550                  (t 2))))
2551         ((math-infinitep a)
2552          (if (or (equal a '(var uinf var-uinf))
2553                  (equal a '(var nan var-nan)))
2554              2
2555            (let ((dira (math-infinite-dir a)))
2556              (if (math-infinitep b)
2557                  (if (or (equal b '(var uinf var-uinf))
2558                          (equal b '(var nan var-nan)))
2559                      2
2560                    (let ((dirb (math-infinite-dir b)))
2561                      (cond ((and (eq dira 1) (eq dirb -1)) 1)
2562                            ((and (eq dira -1) (eq dirb 1)) -1)
2563                            (t 2))))
2564                (cond ((eq dira 1) 1)
2565                      ((eq dira -1) -1)
2566                      (t 2))))))
2567         ((math-infinitep b)
2568          (if (or (equal b '(var uinf var-uinf))
2569                  (equal b '(var nan var-nan)))
2570              2
2571            (let ((dirb (math-infinite-dir b)))
2572              (cond ((eq dirb 1) -1)
2573                    ((eq dirb -1) 1)
2574                    (t 2)))))
2575         ((and (eq (car-safe a) 'calcFunc-exp)
2576               (eq (car-safe b) '^)
2577               (equal (nth 1 b) '(var e var-e)))
2578          (math-compare (nth 1 a) (nth 2 b)))
2579         ((and (eq (car-safe b) 'calcFunc-exp)
2580               (eq (car-safe a) '^)
2581               (equal (nth 1 a) '(var e var-e)))
2582          (math-compare (nth 2 a) (nth 1 b)))
2583         ((or (and (eq (car-safe a) 'calcFunc-sqrt)
2584                   (eq (car-safe b) '^)
2585                   (or (equal (nth 2 b) '(frac 1 2))
2586                       (equal (nth 2 b) '(float 5 -1))))
2587              (and (eq (car-safe b) 'calcFunc-sqrt)
2588                   (eq (car-safe a) '^)
2589                   (or (equal (nth 2 a) '(frac 1 2))
2590                       (equal (nth 2 a) '(float 5 -1)))))
2591          (math-compare (nth 1 a) (nth 1 b)))
2592         ((eq (car-safe a) 'var)
2593          2)
2594         (t
2595          (if (and (consp a) (consp b)
2596                   (eq (car a) (car b))
2597                   (math-compare-lists (cdr a) (cdr b)))
2598              0
2599            2))))
2600
2601 ;;; Compare two bignum digit lists, return -1 for A<B, 0 for A=B, 1 for A>B.
2602 (defun math-compare-bignum (a b)   ; [S l l]
2603   (let ((res 0))
2604     (while (and a b)
2605       (if (< (car a) (car b))
2606           (setq res -1)
2607         (if (> (car a) (car b))
2608             (setq res 1)))
2609       (setq a (cdr a)
2610             b (cdr b)))
2611     (if a
2612         (progn
2613           (while (eq (car a) 0) (setq a (cdr a)))
2614           (if a 1 res))
2615       (while (eq (car b) 0) (setq b (cdr b)))
2616       (if b -1 res))))
2617
2618 (defun math-compare-lists (a b)
2619   (cond ((null a) (null b))
2620         ((null b) nil)
2621         (t (and (Math-equal (car a) (car b))
2622                 (math-compare-lists (cdr a) (cdr b))))))
2623
2624 (defun math-lessp-float (a b)   ; [P F F]
2625   (let ((ediff (- (nth 2 a) (nth 2 b))))
2626     (if (>= ediff 0)
2627         (if (>= ediff (+ calc-internal-prec calc-internal-prec))
2628             (if (eq (nth 1 a) 0)
2629                 (Math-integer-posp (nth 1 b))
2630               (Math-integer-negp (nth 1 a)))
2631           (Math-lessp (math-scale-int (nth 1 a) ediff)
2632                       (nth 1 b)))
2633       (if (>= (setq ediff (- ediff))
2634               (+ calc-internal-prec calc-internal-prec))
2635           (if (eq (nth 1 b) 0)
2636               (Math-integer-negp (nth 1 a))
2637             (Math-integer-posp (nth 1 b)))
2638         (Math-lessp (nth 1 a)
2639                     (math-scale-int (nth 1 b) ediff))))))
2640
2641 ;;; True if A is numerically equal to B.  [P N N] [Public]
2642 (defun math-equal (a b)
2643   (= (math-compare a b) 0))
2644
2645 ;;; True if A is numerically less than B.  [P R R] [Public]
2646 (defun math-lessp (a b)
2647   (= (math-compare a b) -1))
2648
2649 ;;; True if A is numerically equal to the integer B.  [P N S] [Public]
2650 ;;; B must not be a multiple of 10.
2651 (defun math-equal-int (a b)
2652   (or (eq a b)
2653       (and (eq (car-safe a) 'float)
2654            (eq (nth 1 a) b)
2655            (= (nth 2 a) 0))))
2656
2657
2658
2659
2660 ;;; Return the dimensions of a matrix as a list.  [l x] [Public]
2661 (defun math-mat-dimens (m)
2662   (if (math-vectorp m)
2663       (if (math-matrixp m)
2664           (cons (1- (length m))
2665                 (math-mat-dimens (nth 1 m)))
2666         (list (1- (length m))))
2667     nil))
2668
2669
2670
2671 (defun calc-binary-op-fancy (name func arg ident unary)
2672   (let ((n (prefix-numeric-value arg)))
2673     (cond ((> n 1)
2674            (calc-enter-result n
2675                               name
2676                               (list 'calcFunc-reduce
2677                                     (math-calcFunc-to-var func)
2678                                     (cons 'vec (calc-top-list-n n)))))
2679           ((= n 1)
2680            (if unary
2681                (calc-enter-result 1 name (list unary (calc-top-n 1)))))
2682           ((= n 0)
2683            (if ident
2684                (calc-enter-result 0 name ident)
2685              (error "Argument must be nonzero")))
2686           (t
2687            (let ((rhs (calc-top-n 1)))
2688              (calc-enter-result (- 1 n)
2689                                 name
2690                                 (mapcar (function
2691                                          (lambda (x)
2692                                            (list func x rhs)))
2693                                         (calc-top-list-n (- n) 2))))))))
2694
2695 (defun calc-unary-op-fancy (name func arg)
2696   (let ((n (prefix-numeric-value arg)))
2697     (if (= n 0) (setq n (calc-stack-size)))
2698     (cond ((> n 0)
2699            (calc-enter-result n
2700                               name
2701                               (mapcar (function
2702                                        (lambda (x)
2703                                          (list func x)))
2704                                       (calc-top-list-n n))))
2705           ((< n 0)
2706            (calc-enter-result 1
2707                               name
2708                               (list func (calc-top-n (- n)))
2709                               (- n))))))
2710
2711 (defvar var-Holidays '(vec (var sat var-sat) (var sun var-sun)))
2712 (defvar var-Decls (list 'vec))
2713
2714
2715 (defun math-inexact-result ()
2716   (and calc-symbolic-mode
2717        (signal 'inexact-result nil)))
2718
2719 (defun math-overflow (&optional exp)
2720   (if (and exp (math-negp exp))
2721       (math-underflow)
2722     (signal 'math-overflow nil)))
2723
2724 (defun math-underflow ()
2725   (signal 'math-underflow nil))
2726
2727 ;;; Compute the greatest common divisor of A and B.   [I I I] [Public]
2728 (defun math-gcd (a b)
2729   (cond ((not (or (consp a) (consp b)))
2730          (if (< a 0) (setq a (- a)))
2731          (if (< b 0) (setq b (- b)))
2732          (let (c)
2733            (if (< a b)
2734                (setq c b b a a c))
2735            (while (> b 0)
2736              (setq c b
2737                    b (% a b)
2738                    a c))
2739            a))
2740         ((eq a 0) b)
2741         ((eq b 0) a)
2742         (t
2743          (if (Math-integer-negp a) (setq a (math-neg a)))
2744          (if (Math-integer-negp b) (setq b (math-neg b)))
2745          (let (c)
2746            (if (Math-natnum-lessp a b)
2747                (setq c b b a a c))
2748            (while (and (consp a) (not (eq b 0)))
2749              (setq c b
2750                    b (math-imod a b)
2751                    a c))
2752            (while (> b 0)
2753              (setq c b
2754                    b (% a b)
2755                    a c))
2756            a))))
2757
2758
2759 ;;;; Algebra.
2760
2761 ;;; Evaluate variables in an expression.
2762 (defun math-evaluate-expr (x)  ; [Public]
2763   (if calc-embedded-info
2764       (calc-embedded-evaluate-expr x)
2765     (calc-normalize (math-evaluate-expr-rec x))))
2766
2767 (defalias 'calcFunc-evalv 'math-evaluate-expr)
2768
2769 (defun calcFunc-evalvn (x &optional prec)
2770   (if prec
2771       (progn
2772         (or (math-num-integerp prec)
2773             (if (and (math-vectorp prec)
2774                      (= (length prec) 2)
2775                      (math-num-integerp (nth 1 prec)))
2776                 (setq prec (math-add (nth 1 prec) calc-internal-prec))
2777               (math-reject-arg prec 'integerp)))
2778         (setq prec (math-trunc prec))
2779         (if (< prec 3) (setq prec 3))
2780         (if (> prec calc-internal-prec)
2781             (math-normalize
2782              (let ((calc-internal-prec prec))
2783                (calcFunc-evalvn x)))
2784           (let ((calc-internal-prec prec))
2785             (calcFunc-evalvn x))))
2786     (let ((calc-symbolic-mode nil))
2787       (math-evaluate-expr x))))
2788
2789 (defun math-evaluate-expr-rec (x)
2790   (if (consp x)
2791       (if (memq (car x) '(calcFunc-quote calcFunc-condition
2792                                          calcFunc-evalto calcFunc-assign))
2793           (if (and (eq (car x) 'calcFunc-assign)
2794                    (= (length x) 3))
2795               (list (car x) (nth 1 x) (math-evaluate-expr-rec (nth 2 x)))
2796             x)
2797         (if (eq (car x) 'var)
2798             (if (and (calc-var-value (nth 2 x))
2799                      (not (eq (car-safe (symbol-value (nth 2 x)))
2800                               'incomplete)))
2801                 (let ((val (symbol-value (nth 2 x))))
2802                   (if (eq (car-safe val) 'special-const)
2803                       (if calc-symbolic-mode
2804                           x
2805                         val)
2806                     val))
2807               x)
2808           (if (Math-primp x)
2809               x
2810             (cons (car x) (mapcar 'math-evaluate-expr-rec (cdr x))))))
2811     x))
2812
2813 (defun math-any-floats (expr)
2814   (if (Math-primp expr)
2815       (math-floatp expr)
2816     (while (and (setq expr (cdr expr)) (not (math-any-floats (car expr)))))
2817     expr))
2818
2819 (defvar var-FactorRules 'calc-FactorRules)
2820
2821 (defvar math-mt-many nil)
2822 (defvar math-mt-func nil)
2823
2824 (defun math-map-tree (math-mt-func mmt-expr &optional math-mt-many)
2825   (or math-mt-many (setq math-mt-many 1000000))
2826   (math-map-tree-rec mmt-expr))
2827
2828 (defun math-map-tree-rec (mmt-expr)
2829   (or (= math-mt-many 0)
2830       (let ((mmt-done nil)
2831             mmt-nextval)
2832         (while (not mmt-done)
2833           (while (and (/= math-mt-many 0)
2834                       (setq mmt-nextval (funcall math-mt-func mmt-expr))
2835                       (not (equal mmt-expr mmt-nextval)))
2836             (setq mmt-expr mmt-nextval
2837                   math-mt-many (if (> math-mt-many 0)
2838                                    (1- math-mt-many)
2839                                  (1+ math-mt-many))))
2840           (if (or (Math-primp mmt-expr)
2841                   (<= math-mt-many 0))
2842               (setq mmt-done t)
2843             (setq mmt-nextval (cons (car mmt-expr)
2844                                     (mapcar 'math-map-tree-rec
2845                                             (cdr mmt-expr))))
2846             (if (equal mmt-nextval mmt-expr)
2847                 (setq mmt-done t)
2848               (setq mmt-expr mmt-nextval))))))
2849   mmt-expr)
2850
2851 (defun math-is-true (expr)
2852   (if (Math-numberp expr)
2853       (not (Math-zerop expr))
2854     (math-known-nonzerop expr)))
2855
2856 (defun math-const-var (expr)
2857   (and (consp expr)
2858        (eq (car expr) 'var)
2859        (or (and (symbolp (nth 2 expr))
2860                 (boundp (nth 2 expr))
2861                 (eq (car-safe (symbol-value (nth 2 expr))) 'special-const))
2862            (memq (nth 2 expr) '(var-inf var-uinf var-nan)))))
2863
2864 ;; The variable math-integral-cache is originally declared in calcalg2.el,
2865 ;; but is set by math-defintegral and math-defintegral-2.
2866 (defvar math-integral-cache)
2867
2868 (defmacro math-defintegral (funcs &rest code)
2869   (setq math-integral-cache nil)
2870   (cons 'progn
2871         (mapcar #'(lambda (func)
2872                     `(put ',func 'math-integral
2873                           (nconc
2874                            (get ',func 'math-integral)
2875                            (list
2876                             #'(lambda (u) ,@code)))))
2877                 (if (symbolp funcs) (list funcs) funcs))))
2878 (put 'math-defintegral 'lisp-indent-hook 1)
2879
2880 (defmacro math-defintegral-2 (funcs &rest code)
2881   (setq math-integral-cache nil)
2882   (cons 'progn
2883         (mapcar #'(lambda (func)
2884                     `(put ',func 'math-integral-2
2885                           (nconc
2886                             (get ',func 'math-integral-2)
2887                             (list #'(lambda (u v) ,@code)))))
2888                 (if (symbolp funcs) (list funcs) funcs))))
2889 (put 'math-defintegral-2 'lisp-indent-hook 1)
2890
2891 (defvar var-IntegAfterRules 'calc-IntegAfterRules)
2892
2893 (defvar var-FitRules 'calc-FitRules)
2894
2895 (defvar math-poly-base-variable nil)
2896 (defvar math-poly-neg-powers nil)
2897 (defvar math-poly-mult-powers 1)
2898 (defvar math-poly-frac-powers nil)
2899 (defvar math-poly-exp-base nil)
2900
2901 (defun math-build-var-name (name)
2902   (if (stringp name)
2903       (setq name (intern name)))
2904   (if (string-match "\\`var-." (symbol-name name))
2905       (list 'var (intern (substring (symbol-name name) 4)) name)
2906     (list 'var name (intern (concat "var-" (symbol-name name))))))
2907
2908 (defvar math-simplifying-units nil)
2909 (defvar math-combining-units t)
2910
2911 ;;; Nontrivial number parsing.
2912
2913 (defun math-read-number-fancy (s)
2914   (cond
2915
2916    ;; Integer+fractions
2917    ((string-match "^\\([0-9]*\\)[:/]\\([0-9]*\\)[:/]\\([0-9]*\\)$" s)
2918     (let ((int (math-match-substring s 1))
2919           (num (math-match-substring s 2))
2920           (den (math-match-substring s 3)))
2921       (let ((int (if (> (length int) 0) (math-read-number int) 0))
2922             (num (if (> (length num) 0) (math-read-number num) 1))
2923             (den (if (> (length num) 0) (math-read-number den) 1)))
2924         (and int num den
2925              (math-integerp int) (math-integerp num) (math-integerp den)
2926              (not (math-zerop den))
2927              (list 'frac (math-add num (math-mul int den)) den)))))
2928
2929    ;; Fractions
2930    ((string-match "^\\([0-9]*\\)[:/]\\([0-9]*\\)$" s)
2931     (let ((num (math-match-substring s 1))
2932           (den (math-match-substring s 2)))
2933       (let ((num (if (> (length num) 0) (math-read-number num) 1))
2934             (den (if (> (length num) 0) (math-read-number den) 1)))
2935         (and num den (math-integerp num) (math-integerp den)
2936              (not (math-zerop den))
2937              (list 'frac num den)))))
2938
2939    ;; Modulo forms
2940    ((string-match "^\\(.*\\) *mod *\\(.*\\)$" s)
2941     (let* ((n (math-match-substring s 1))
2942            (m (math-match-substring s 2))
2943            (n (math-read-number n))
2944            (m (math-read-number m)))
2945       (and n m (math-anglep n) (math-anglep m)
2946            (list 'mod n m))))
2947
2948    ;; Error forms
2949    ((string-match "^\\(.*\\) *\\+/- *\\(.*\\)$" s)
2950     (let* ((x (math-match-substring s 1))
2951            (sigma (math-match-substring s 2))
2952            (x (math-read-number x))
2953            (sigma (math-read-number sigma)))
2954       (and x sigma (math-scalarp x) (math-anglep sigma)
2955            (list 'sdev x sigma))))
2956
2957    ;; Integer+fraction with explicit radix
2958    ((string-match "^\\([0-9]+\\)\\(#\\|\\^\\^\\)\\([0-9a-zA-Z]*\\)[:/]\\([0-9a-zA-Z]*\\)[:/]\\([0-9a-zA-Z]\\)$" s)
2959     (let ((radix (string-to-number (math-match-substring s 1)))
2960           (int (math-match-substring s 3))
2961           (num (math-match-substring s 4))
2962           (den (math-match-substring s 5)))
2963       (let ((int (if (> (length int) 0) (math-read-radix int radix) 0))
2964             (num (if (> (length num) 0) (math-read-radix num radix) 1))
2965             (den (if (> (length den) 0) (math-read-radix den radix) 1)))
2966         (and int num den (not (math-zerop den))
2967              (list 'frac
2968                    (math-add num (math-mul int den))
2969                    den)))))
2970
2971    ;; Fraction with explicit radix
2972    ((string-match "^\\([0-9]+\\)\\(#\\|\\^\\^\\)\\([0-9a-zA-Z]*\\)[:/]\\([0-9a-zA-Z]*\\)$" s)
2973     (let ((radix (string-to-number (math-match-substring s 1)))
2974           (num (math-match-substring s 3))
2975           (den (math-match-substring s 4)))
2976       (let ((num (if (> (length num) 0) (math-read-radix num radix) 1))
2977             (den (if (> (length den) 0) (math-read-radix den radix) 1)))
2978         (and num den (not (math-zerop den)) (list 'frac num den)))))
2979
2980    ;; Float with explicit radix and exponent
2981    ((or (string-match "^0*\\(\\([2-9]\\|1[0-4]\\)\\(#\\|\\^\\^\\)[0-9a-dA-D.]+\\)[eE]\\([-+]?[0-9]+\\)$" s)
2982         (string-match "^\\(\\([0-9]+\\)\\(#\\|\\^\\^\\)[0-9a-zA-Z.]+\\) *\\* *\\2\\.? *\\^ *\\([-+]?[0-9]+\\)$" s))
2983     (let ((radix (string-to-number (math-match-substring s 2)))
2984           (mant (math-match-substring s 1))
2985           (exp (math-match-substring s 4)))
2986       (let ((mant (math-read-number mant))
2987             (exp (math-read-number exp)))
2988         (and mant exp
2989              (math-mul mant (math-pow (math-float radix) exp))))))
2990
2991    ;; Float with explicit radix, no exponent
2992    ((string-match "^\\([0-9]+\\)\\(#\\|\\^\\^\\)\\([0-9a-zA-Z]*\\)\\.\\([0-9a-zA-Z]*\\)$" s)
2993     (let ((radix (string-to-number (math-match-substring s 1)))
2994           (int (math-match-substring s 3))
2995           (fracs (math-match-substring s 4)))
2996       (let ((int (if (> (length int) 0) (math-read-radix int radix) 0))
2997             (frac (if (> (length fracs) 0) (math-read-radix fracs radix) 0))
2998             (calc-prefer-frac nil))
2999         (and int frac
3000              (math-add int (math-div frac (math-pow radix (length fracs))))))))
3001
3002    ;; Integer with explicit radix
3003    ((string-match "^\\([0-9]+\\)\\(#&?\\|\\^\\^\\)\\([0-9a-zA-Z]+\\)$" s)
3004     (math-read-radix (math-match-substring s 3)
3005                      (string-to-number (math-match-substring s 1))))
3006
3007    ;; Two's complement with explicit radix
3008    ((string-match "^\\([0-9]+\\)\\(##\\)\\([0-9a-zA-Z]+\\)$" s)
3009     (let ((num (math-read-radix (math-match-substring s 3)
3010                                 (string-to-number (math-match-substring s 1)))))
3011       (if (and
3012            (Math-lessp num math-2-word-size)
3013            (<= (math-compare math-half-2-word-size num) 0))
3014           (math-sub num math-2-word-size)
3015         num)))
3016
3017    ;; C language hexadecimal notation
3018    ((and (eq calc-language 'c)
3019          (string-match "^0[xX]\\([0-9a-fA-F]+\\)$" s))
3020     (let ((digs (math-match-substring s 1)))
3021       (math-read-radix digs 16)))
3022
3023    ;; Pascal language hexadecimal notation
3024    ((and (eq calc-language 'pascal)
3025          (string-match "^\\$\\([0-9a-fA-F]+\\)$" s))
3026     (let ((digs (math-match-substring s 1)))
3027       (math-read-radix digs 16)))
3028
3029    ;; Hours (or degrees)
3030    ((or (string-match "^\\([^#^]+\\)[@oOhH]\\(.*\\)$" s)
3031         (string-match "^\\([^#^]+\\)[dD][eE]?[gG]?\\(.*\\)$" s))
3032     (let* ((hours (math-match-substring s 1))
3033            (minsec (math-match-substring s 2))
3034            (hours (math-read-number hours))
3035            (minsec (if (> (length minsec) 0) (math-read-number minsec) 0)))
3036       (and hours minsec
3037            (math-num-integerp hours)
3038            (not (math-negp hours)) (not (math-negp minsec))
3039            (cond ((math-num-integerp minsec)
3040                   (and (Math-lessp minsec 60)
3041                        (list 'hms hours minsec 0)))
3042                  ((and (eq (car-safe minsec) 'hms)
3043                        (math-zerop (nth 1 minsec)))
3044                   (math-add (list 'hms hours 0 0) minsec))
3045                  (t nil)))))
3046
3047    ;; Minutes
3048    ((string-match "^\\([^'#^]+\\)[mM']\\(.*\\)$" s)
3049     (let* ((minutes (math-match-substring s 1))
3050            (seconds (math-match-substring s 2))
3051            (minutes (math-read-number minutes))
3052            (seconds (if (> (length seconds) 0) (math-read-number seconds) 0)))
3053       (and minutes seconds
3054            (math-num-integerp minutes)
3055            (not (math-negp minutes)) (not (math-negp seconds))
3056            (cond ((math-realp seconds)
3057                   (and (Math-lessp minutes 60)
3058                        (list 'hms 0 minutes seconds)))
3059                  ((and (eq (car-safe seconds) 'hms)
3060                        (math-zerop (nth 1 seconds))
3061                        (math-zerop (nth 2 seconds)))
3062                   (math-add (list 'hms 0 minutes 0) seconds))
3063                  (t nil)))))
3064
3065    ;; Seconds
3066    ((string-match "^\\([^\"#^]+\\)[sS\"]$" s)
3067     (let ((seconds (math-read-number (math-match-substring s 1))))
3068       (and seconds (math-realp seconds)
3069            (not (math-negp seconds))
3070            (Math-lessp seconds 60)
3071            (list 'hms 0 0 seconds))))
3072
3073    ;; Fraction using "/" instead of ":"
3074    ((string-match "^\\([0-9]+\\)/\\([0-9/]+\\)$" s)
3075     (math-read-number (concat (math-match-substring s 1) ":"
3076                               (math-match-substring s 2))))
3077
3078    ;; Syntax error!
3079    (t nil)))
3080
3081 (defun math-read-radix (s r)   ; [I X D]
3082   (setq s (upcase s))
3083   (let ((i 0)
3084         (res 0)
3085         dig)
3086     (while (and (< i (length s))
3087                 (setq dig (math-read-radix-digit (elt s i)))
3088                 (< dig r))
3089       (setq res (math-add (math-mul res r) dig)
3090             i (1+ i)))
3091     (and (= i (length s))
3092          res)))
3093
3094
3095
3096 ;;; Expression parsing.
3097
3098 (defvar math-expr-data)
3099
3100 (defun math-read-expr (math-exp-str)
3101   (let ((math-exp-pos 0)
3102         (math-exp-old-pos 0)
3103         (math-exp-keep-spaces nil)
3104         math-exp-token math-expr-data)
3105     (setq math-exp-str (math-read-preprocess-string math-exp-str))
3106     (while (setq math-exp-token (string-match "\\.\\.\\([^.]\\|.[^.]\\)" math-exp-str))
3107       (setq math-exp-str (concat (substring math-exp-str 0 math-exp-token) "\\dots"
3108                             (substring math-exp-str (+ math-exp-token 2)))))
3109     (math-build-parse-table)
3110     (math-read-token)
3111     (let ((val (catch 'syntax (math-read-expr-level 0))))
3112       (if (stringp val)
3113           (list 'error math-exp-old-pos val)
3114         (if (equal math-exp-token 'end)
3115             val
3116           (list 'error math-exp-old-pos "Syntax error"))))))
3117
3118 (defun math-read-plain-expr (exp-str &optional error-check)
3119   (let* ((calc-language nil)
3120          (math-expr-opers (math-standard-ops))
3121          (val (math-read-expr exp-str)))
3122     (and error-check
3123          (eq (car-safe val) 'error)
3124          (error "%s: %s" (nth 2 val) exp-str))
3125     val))
3126
3127
3128 (defun math-read-string ()
3129   (let ((str (read-from-string (concat math-expr-data "\""))))
3130     (or (and (= (cdr str) (1+ (length math-expr-data)))
3131              (stringp (car str)))
3132         (throw 'syntax "Error in string constant"))
3133     (math-read-token)
3134     (append '(vec) (car str) nil)))
3135
3136
3137
3138 ;;; They said it couldn't be done...
3139
3140 (defun math-read-big-expr (str)
3141   (and (> (length calc-left-label) 0)
3142        (string-match (concat "^" (regexp-quote calc-left-label)) str)
3143        (setq str (concat (substring str 0 (match-beginning 0))
3144                          (substring str (match-end 0)))))
3145   (and (> (length calc-right-label) 0)
3146        (string-match (concat (regexp-quote calc-right-label) " *$") str)
3147        (setq str (concat (substring str 0 (match-beginning 0))
3148                          (substring str (match-end 0)))))
3149   (if (string-match "\\\\[^ \n|]" str)
3150       (if (eq calc-language 'latex)
3151           (math-read-expr str)
3152         (let ((calc-language 'latex)
3153               (calc-language-option nil)
3154               (math-expr-opers (get 'latex 'math-oper-table))
3155               (math-expr-function-mapping (get 'latex 'math-function-table))
3156               (math-expr-variable-mapping (get 'latex 'math-variable-table)))
3157           (math-read-expr str)))
3158     (let ((math-read-big-lines nil)
3159           (pos 0)
3160           (width 0)
3161           (math-read-big-err-msg nil)
3162           math-read-big-baseline math-read-big-h2
3163           new-pos p)
3164       (while (setq new-pos (string-match "\n" str pos))
3165         (setq math-read-big-lines
3166               (cons (substring str pos new-pos) math-read-big-lines)
3167               pos (1+ new-pos)))
3168       (setq math-read-big-lines
3169             (nreverse (cons (substring str pos) math-read-big-lines))
3170             p math-read-big-lines)
3171       (while p
3172         (setq width (max width (length (car p)))
3173               p (cdr p)))
3174       (if (math-read-big-bigp math-read-big-lines)
3175           (or (catch 'syntax
3176                 (math-read-big-rec 0 0 width (length math-read-big-lines)))
3177               math-read-big-err-msg
3178               '(error 0 "Syntax error"))
3179         (math-read-expr str)))))
3180
3181 (defun math-read-big-bigp (math-read-big-lines)
3182   (and (cdr math-read-big-lines)
3183        (let ((matrix nil)
3184              (v 0)
3185              (height (if (> (length (car math-read-big-lines)) 0) 1 0)))
3186          (while (and (cdr math-read-big-lines)
3187                      (let* ((i 0)
3188                             j
3189                             (l1 (car math-read-big-lines))
3190                             (l2 (nth 1 math-read-big-lines))
3191                             (len (min (length l1) (length l2))))
3192                        (if (> (length l2) 0)
3193                            (setq height (1+ height)))
3194                        (while (and (< i len)
3195                                    (or (memq (aref l1 i) '(?\  ?\- ?\_))
3196                                        (memq (aref l2 i) '(?\  ?\-))
3197                                        (and (memq (aref l1 i) '(?\| ?\,))
3198                                             (= (aref l2 i) (aref l1 i)))
3199                                        (and (eq (aref l1 i) ?\[)
3200                                             (eq (aref l2 i) ?\[)
3201                                             (let ((math-rb-h2 (length l1)))
3202                                               (setq j (math-read-big-balance
3203                                                        (1+ i) v "[")))
3204                                             (setq i (1- j)))))
3205                          (setq i (1+ i)))
3206                        (or (= i len)
3207                            (and (eq (aref l1 i) ?\[)
3208                                 (eq (aref l2 i) ?\[)
3209                                 (setq matrix t)
3210                                 nil))))
3211            (setq math-read-big-lines (cdr math-read-big-lines)
3212                  v (1+ v)))
3213          (or (and (> height 1)
3214                   (not (cdr math-read-big-lines)))
3215              matrix))))
3216
3217 ;;; Nontrivial "flat" formatting.
3218
3219 (defvar math-format-hash-args nil)
3220 (defvar calc-can-abbrev-vectors nil)
3221
3222 (defun math-format-flat-expr-fancy (a prec)
3223   (cond
3224    ((eq (car a) 'incomplete)
3225     (format "<incomplete %s>" (nth 1 a)))
3226    ((eq (car a) 'vec)
3227     (if (or calc-full-trail-vectors (not calc-can-abbrev-vectors)
3228             (< (length a) 7))
3229         (concat "[" (math-format-flat-vector (cdr a) ", "
3230                                              (if (cdr (cdr a)) 0 1000)) "]")
3231       (concat "["
3232               (math-format-flat-expr (nth 1 a) 0) ", "
3233               (math-format-flat-expr (nth 2 a) 0) ", "
3234               (math-format-flat-expr (nth 3 a) 0) ", ..., "
3235               (math-format-flat-expr (nth (1- (length a)) a) 0) "]")))
3236    ((eq (car a) 'intv)
3237     (concat (if (memq (nth 1 a) '(0 1)) "(" "[")
3238             (math-format-flat-expr (nth 2 a) 1000)
3239             " .. "
3240             (math-format-flat-expr (nth 3 a) 1000)
3241             (if (memq (nth 1 a) '(0 2)) ")" "]")))
3242    ((eq (car a) 'date)
3243     (concat "<" (math-format-date a) ">"))
3244    ((and (eq (car a) 'calcFunc-lambda) (> (length a) 2))
3245     (let ((p (cdr a))
3246           (ap calc-arg-values)
3247           (math-format-hash-args (if (= (length a) 3) 1 t)))
3248       (while (and (cdr p) (equal (car p) (car ap)))
3249         (setq p (cdr p) ap (cdr ap)))
3250       (concat "<"
3251               (if (cdr p)
3252                   (concat (math-format-flat-vector
3253                            (nreverse (cdr (reverse (cdr a)))) ", " 0)
3254                           " : ")
3255                 "")
3256               (math-format-flat-expr (nth (1- (length a)) a) 0)
3257               ">")))
3258    ((eq (car a) 'var)
3259     (or (and math-format-hash-args
3260              (let ((p calc-arg-values) (v 1))
3261                (while (and p (not (equal (car p) a)))
3262                  (setq p (and (eq math-format-hash-args t) (cdr p))
3263                        v (1+ v)))
3264                (and p
3265                     (if (eq math-format-hash-args 1)
3266                         "#"
3267                       (format "#%d" v)))))
3268         (symbol-name (nth 1 a))))
3269    ((and (memq (car a) '(calcFunc-string calcFunc-bstring))
3270          (= (length a) 2)
3271          (math-vectorp (nth 1 a))
3272          (math-vector-is-string (nth 1 a)))
3273     (concat (substring (symbol-name (car a)) 9)
3274             "(" (math-vector-to-string (nth 1 a) t) ")"))
3275    (t
3276     (let ((op (math-assq2 (car a) (math-standard-ops))))
3277       (cond ((and op (= (length a) 3))
3278              (if (> prec (min (nth 2 op) (nth 3 op)))
3279                  (concat "(" (math-format-flat-expr a 0) ")")
3280                (let ((lhs (math-format-flat-expr (nth 1 a) (nth 2 op)))
3281                      (rhs (math-format-flat-expr (nth 2 a) (nth 3 op))))
3282                  (setq op (car op))
3283                  (if (or (equal op "^") (equal op "_"))
3284                      (if (= (aref lhs 0) ?-)
3285                          (setq lhs (concat "(" lhs ")")))
3286                    (setq op (concat " " op " ")))
3287                  (concat lhs op rhs))))
3288             ((eq (car a) 'neg)
3289              (concat "-" (math-format-flat-expr (nth 1 a) 1000)))
3290             (t
3291              (concat (math-remove-dashes
3292                       (if (string-match "\\`calcFunc-\\([a-zA-Zα-ωΑ-Ω0-9']+\\)\\'"
3293                                         (symbol-name (car a)))
3294                           (math-match-substring (symbol-name (car a)) 1)
3295                         (symbol-name (car a))))
3296                      "("
3297                      (math-format-flat-vector (cdr a) ", " 0)
3298                      ")")))))))
3299
3300 (defun math-format-flat-vector (vec sep prec)
3301   (if vec
3302       (let ((buf (math-format-flat-expr (car vec) prec)))
3303         (while (setq vec (cdr vec))
3304           (setq buf (concat buf sep (math-format-flat-expr (car vec) prec))))
3305         buf)
3306     ""))
3307
3308 (defun math-format-nice-expr (x w)
3309   (cond ((and (eq (car-safe x) 'vec)
3310               (cdr (cdr x))
3311               (let ((ops '(vec calcFunc-assign calcFunc-condition
3312                                calcFunc-schedule calcFunc-iterations
3313                                calcFunc-phase)))
3314                 (or (memq (car-safe (nth 1 x)) ops)
3315                     (memq (car-safe (nth 2 x)) ops)
3316                     (memq (car-safe (nth 3 x)) ops)
3317                     calc-break-vectors)))
3318          (concat "[ " (math-format-flat-vector (cdr x) ",\n  " 0) " ]"))
3319         (t
3320          (let ((str (math-format-flat-expr x 0))
3321                (pos 0) p)
3322            (or (string-match "\"" str)
3323                (while (<= (setq p (+ pos w)) (length str))
3324                  (while (and (> (setq p (1- p)) pos)
3325                              (not (= (aref str p) ? ))))
3326                  (if (> p (+ pos 5))
3327                      (setq str (concat (substring str 0 p)
3328                                        "\n "
3329                                        (substring str p))
3330                            pos (1+ p))
3331                    (setq pos (+ pos w)))))
3332            str))))
3333
3334 (defun math-assq2 (v a)
3335   (while (and a (not (eq v (nth 1 (car a)))))
3336     (setq a (cdr a)))
3337   (car a))
3338
3339 (defun math-format-number-fancy (a prec)
3340   (cond
3341    ((eq (car a) 'float)    ; non-decimal radix
3342     (if (Math-integer-negp (nth 1 a))
3343         (concat "-" (math-format-number (math-neg a)))
3344       (let ((str (if (and calc-radix-formatter
3345                           (not (memq calc-language '(c pascal))))
3346                      (funcall calc-radix-formatter
3347                               calc-number-radix
3348                               (math-format-radix-float a prec))
3349                    (format "%d#%s" calc-number-radix
3350                            (math-format-radix-float a prec)))))
3351         (if (and prec (> prec 191) (string-match "\\*" str))
3352             (concat "(" str ")")
3353           str))))
3354    ((eq (car a) 'frac)
3355     (setq a (math-adjust-fraction a))
3356     (if (> (length (car calc-frac-format)) 1)
3357         (if (Math-integer-negp (nth 1 a))
3358             (concat "-" (math-format-number (math-neg a)))
3359           (let ((q (math-idivmod (nth 1 a) (nth 2 a))))
3360             (concat (let ((calc-frac-format nil))
3361                       (math-format-number (car q)))
3362                     (substring (car calc-frac-format) 0 1)
3363                     (let ((math-radix-explicit-format nil)
3364                           (calc-frac-format nil))
3365                       (math-format-number (cdr q)))
3366                     (substring (car calc-frac-format) 1 2)
3367                     (let ((math-radix-explicit-format nil)
3368                           (calc-frac-format nil))
3369                       (math-format-number (nth 2 a))))))
3370       (concat (let ((calc-frac-format nil))
3371                 (math-format-number (nth 1 a)))
3372               (car calc-frac-format)
3373               (let ((math-radix-explicit-format nil)
3374                     (calc-frac-format nil))
3375                 (math-format-number (nth 2 a))))))
3376    ((eq (car a) 'cplx)
3377     (if (math-zerop (nth 2 a))
3378         (math-format-number (nth 1 a))
3379       (if (null calc-complex-format)
3380           (concat "(" (math-format-number (nth 1 a))
3381                   ", " (math-format-number (nth 2 a)) ")")
3382         (if (math-zerop (nth 1 a))
3383             (if (math-equal-int (nth 2 a) 1)
3384                 (symbol-name calc-complex-format)
3385               (if (math-equal-int (nth 2 a) -1)
3386                   (concat "-" (symbol-name calc-complex-format))
3387                 (if prec
3388                     (math-compose-expr (list '* (nth 2 a) '(cplx 0 1)) prec)
3389                   (concat (math-format-number (nth 2 a)) " "
3390                           (symbol-name calc-complex-format)))))
3391           (if prec
3392               (math-compose-expr (list (if (math-negp (nth 2 a)) '- '+)
3393                                        (nth 1 a)
3394                                        (list 'cplx 0 (math-abs (nth 2 a))))
3395                                  prec)
3396             (concat (math-format-number (nth 1 a))
3397                     (if (math-negp (nth 2 a)) " - " " + ")
3398                     (math-format-number
3399                      (list 'cplx 0 (math-abs (nth 2 a))))))))))
3400    ((eq (car a) 'polar)
3401     (concat "(" (math-format-number (nth 1 a))
3402             "; " (math-format-number (nth 2 a)) ")"))
3403    ((eq (car a) 'hms)
3404     (if (math-negp a)
3405         (concat "-" (math-format-number (math-neg a)))
3406       (let ((calc-number-radix 10)
3407             (calc-twos-complement-mode nil)
3408             (calc-leading-zeros nil)
3409             (calc-group-digits nil))
3410         (format calc-hms-format
3411                 (let ((calc-frac-format '(":" nil)))
3412                   (math-format-number (nth 1 a)))
3413                 (let ((calc-frac-format '(":" nil)))
3414                   (math-format-number (nth 2 a)))
3415                 (math-format-number (nth 3 a))))))
3416    ((eq (car a) 'intv)
3417     (concat (if (memq (nth 1 a) '(0 1)) "(" "[")
3418             (math-format-number (nth 2 a))
3419             " .. "
3420             (math-format-number (nth 3 a))
3421             (if (memq (nth 1 a) '(0 2)) ")" "]")))
3422    ((eq (car a) 'sdev)
3423     (concat (math-format-number (nth 1 a))
3424             " +/- "
3425             (math-format-number (nth 2 a))))
3426    ((eq (car a) 'vec)
3427     (math-format-flat-expr a 0))
3428    (t (format "%s" a))))
3429
3430 (defun math-adjust-fraction (a)
3431   (if (nth 1 calc-frac-format)
3432       (progn
3433         (if (Math-integerp a) (setq a (list 'frac a 1)))
3434         (let ((g (math-quotient (nth 1 calc-frac-format)
3435                                 (math-gcd (nth 2 a)
3436                                           (nth 1 calc-frac-format)))))
3437           (list 'frac (math-mul (nth 1 a) g) (math-mul (nth 2 a) g))))
3438     a))
3439
3440 (defun math-format-bignum-fancy (a)   ; [X L]
3441   (let ((str (cond ((= calc-number-radix 10)
3442                     (math-format-bignum-decimal a))
3443                    ((= calc-number-radix 2)
3444                     (math-format-bignum-binary a))
3445                    ((= calc-number-radix 8)
3446                     (math-format-bignum-octal a))
3447                    ((= calc-number-radix 16)
3448                     (math-format-bignum-hex a))
3449                    (t (math-format-bignum-radix a)))))
3450     (if calc-leading-zeros
3451         (let* ((calc-internal-prec 6)
3452                (digs (math-compute-max-digits (math-abs calc-word-size)
3453                                               calc-number-radix))
3454                (len (length str)))
3455           (if (< len digs)
3456               (setq str (concat (make-string (- digs len) ?0) str)))))
3457     (if calc-group-digits
3458         (let ((i (length str))
3459               (g (if (integerp calc-group-digits)
3460                      (math-abs calc-group-digits)
3461                    (if (memq calc-number-radix '(2 16)) 4 3))))
3462           (while (> i g)
3463             (setq i (- i g)
3464                   str (concat (substring str 0 i)
3465                               calc-group-char
3466                               (substring str i))))
3467           str))
3468     (if (and (/= calc-number-radix 10)
3469              math-radix-explicit-format)
3470         (if calc-radix-formatter
3471             (funcall calc-radix-formatter calc-number-radix str)
3472           (format "%d#%s" calc-number-radix str))
3473       str)))
3474
3475
3476 (defun math-group-float (str)   ; [X X]
3477   (let* ((pt (or (string-match "[^0-9a-zA-Z]" str) (length str)))
3478          (g (if (integerp calc-group-digits) (math-abs calc-group-digits)
3479               (if (memq calc-number-radix '(2 16)) 4 3)))
3480          (i pt))
3481     (if (and (integerp calc-group-digits) (< calc-group-digits 0))
3482         (while (< (setq i (+ (1+ i) g)) (length str))
3483           (setq str (concat (substring str 0 i)
3484                             calc-group-char
3485                             (substring str i))
3486                 i (+ i (1- (length calc-group-char))))))
3487     (setq i pt)
3488     (while (> i g)
3489       (setq i (- i g)
3490             str (concat (substring str 0 i)
3491                         calc-group-char
3492                         (substring str i))))
3493     str))
3494
3495 ;;; Users can redefine this in their init files.
3496 (defvar calc-keypad-user-menu nil
3497   "If non-nil, this describes an additional menu for calc-keypad.
3498 It should contain a list of three rows.
3499 Each row should be a list of six keys.
3500 Each key should be a list of a label string, plus a Calc command name spec.
3501 A command spec is a command name symbol, a keyboard macro string, a
3502 list containing a numeric entry string, or nil.
3503 A key may contain additional specs for Inverse, Hyperbolic, and Inv+Hyp.")
3504
3505 (run-hooks 'calc-ext-load-hook)
3506
3507 (provide 'calc-ext)
3508
3509 ;;; calc-ext.el ends here