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