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

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