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

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