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