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

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