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