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

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