lisp/calc/calc-ext.el

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