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