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

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