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

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