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