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