lisp/calculator.el

   1 ;;; calculator.el --- a [not so] simple calculator for Emacs
   2
   3 ;; Copyright (C) 1998, 2000, 2001, 2002, 2003, 2004,  2005, 2006, 2007,
   4 ;;   2008, 2009, 2010 Free Software Foundation, Inc.
   5
   6 ;; Author: Eli Barzilay <eli@barzilay.org>
   7 ;; Keywords: tools, convenience
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software: you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation, either version 3 of the License, or
  14 ;; (at your option) any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 ;;;=====================================================================
  25 ;;; Commentary:
  26 ;;
  27 ;; A calculator for Emacs.
  28 ;; Why should you reach for your mouse to get xcalc (calc.exe, gcalc or
  29 ;; whatever), when you have Emacs running already?
  30 ;;
  31 ;; If this is not part of your Emacs distribution, then simply bind
  32 ;; `calculator' to a key and make it an autoloaded function, e.g.:
  33 ;;   (autoload 'calculator "calculator"
  34 ;;     "Run the Emacs calculator." t)
  35 ;;   (global-set-key [(control return)] 'calculator)
  36 ;;
  37 ;; Written by Eli Barzilay: Maze is Life!  eli@barzilay.org
  38 ;;                                         http://www.barzilay.org/
  39 ;;
  40 ;; For latest version, check
  41 ;;     http://www.barzilay.org/misc/calculator.el
  42 ;;
  43
  44 ;;; History:
  45 ;; I hate history.
  46
  47 (eval-when-compile (require 'cl))
  48
  49 ;;;=====================================================================
  50 ;;; Customization:
  51
  52 (defgroup calculator nil
  53   "Simple Emacs calculator."
  54   :prefix "calculator"
  55   :version "21.1"
  56   :group 'tools
  57   :group 'convenience)
  58
  59 (defcustom calculator-electric-mode nil
  60   "Run `calculator' electrically, in the echo area.
  61 Electric mode saves some place but changes the way you interact with the
  62 calculator."
  63   :type  'boolean
  64   :group 'calculator)
  65
  66 (defcustom calculator-use-menu t
  67   "Make `calculator' create a menu.
  68 Note that this requires easymenu.  Must be set before loading."
  69   :type  'boolean
  70   :group 'calculator)
  71
  72 (defcustom calculator-bind-escape nil
  73   "If non-nil, set escape to exit the calculator."
  74   :type  'boolean
  75   :group 'calculator)
  76
  77 (defcustom calculator-unary-style 'postfix
  78   "Value is either 'prefix or 'postfix.
  79 This determines the default behavior of unary operators."
  80   :type    '(choice (const prefix) (const postfix))
  81   :group   'calculator)
  82
  83 (defcustom calculator-prompt "Calc=%s> "
  84   "The prompt used by the Emacs calculator.
  85 It should contain a \"%s\" somewhere that will indicate the i/o radixes;
  86 this will be a two-character string as described in the documentation
  87 for `calculator-mode'."
  88   :type  'string
  89   :group 'calculator)
  90
  91 (defcustom calculator-number-digits 3
  92   "The calculator's number of digits used for standard display.
  93 Used by the `calculator-standard-display' function - it will use the
  94 format string \"%.NC\" where this number is N and C is a character given
  95 at runtime."
  96   :type  'integer
  97   :group 'calculator)
  98
  99 (defcustom calculator-radix-grouping-mode t
 100   "Use digit grouping in radix output mode.
 101 If this is set, chunks of `calculator-radix-grouping-digits' characters
 102 will be separated by `calculator-radix-grouping-separator' when in radix
 103 output mode is active (determined by `calculator-output-radix')."
 104   :type  'boolean
 105   :group 'calculator)
 106
 107 (defcustom calculator-radix-grouping-digits 4
 108   "The number of digits used for grouping display in radix modes.
 109 See `calculator-radix-grouping-mode'."
 110   :type  'integer
 111   :group 'calculator)
 112
 113 (defcustom calculator-radix-grouping-separator "'"
 114   "The separator used in radix grouping display.
 115 See `calculator-radix-grouping-mode'."
 116   :type  'string
 117   :group 'calculator)
 118
 119 (defcustom calculator-remove-zeros t
 120   "Non-nil value means delete all redundant zero decimal digits.
 121 If this value is not t, and not nil, redundant zeros are removed except
 122 for one and if it is nil, nothing is removed.
 123 Used by the `calculator-remove-zeros' function."
 124   :type  '(choice (const t) (const leave-decimal) (const nil))
 125   :group 'calculator)
 126
 127 (defcustom calculator-displayer '(std ?n)
 128   "A displayer specification for numerical values.
 129 This is the displayer used to show all numbers in an expression.  Result
 130 values will be displayed according to the first element of
 131 `calculator-displayers'.
 132
 133 The displayer is a symbol, a string or an expression.  A symbol should
 134 be the name of a one-argument function, a string is used with a single
 135 argument and an expression will be evaluated with the variable `num'
 136 bound to whatever should be displayed.  If it is a function symbol, it
 137 should be able to handle special symbol arguments, currently 'left and
 138 'right which will be sent by special keys to modify display parameters
 139 associated with the displayer function (for example to change the number
 140 of digits displayed).
 141
 142 An exception to the above is the case of the list (std C) where C is a
 143 character, in this case the `calculator-standard-displayer' function
 144 will be used with this character for a format string."
 145   :group 'calculator)
 146
 147 (defcustom calculator-displayers
 148   '(((std ?n) "Standard display, decimal point or scientific")
 149     (calculator-eng-display "Eng display")
 150     ((std ?f) "Standard display, decimal point")
 151     ((std ?e) "Standard display, scientific")
 152     ("%S"     "Emacs printer"))
 153   "A list of displayers.
 154 Each element is a list of a displayer and a description string.  The
 155 first element is the one which is currently used, this is for the display
 156 of result values not values in expressions.  A displayer specification
 157 is the same as the values that can be stored in `calculator-displayer'.
 158
 159 `calculator-rotate-displayer' rotates this list."
 160   :type  'sexp
 161   :group 'calculator)
 162
 163 (defcustom calculator-paste-decimals t
 164   "If non-nil, convert pasted integers so they have a decimal point.
 165 This makes it possible to paste big integers since they will be read as
 166 floats, otherwise the Emacs reader will fail on them."
 167   :type  'boolean
 168   :group 'calculator)
 169
 170 (defcustom calculator-copy-displayer nil
 171   "If non-nil, this is any value that can be used for
 172 `calculator-displayer', to format a string before copying it with
 173 `calculator-copy'.  If nil, then `calculator-displayer's normal value is
 174 used."
 175   :type  'boolean
 176   :group 'calculator)
 177
 178 (defcustom calculator-2s-complement nil
 179   "If non-nil, show negative numbers in 2s complement in radix modes.
 180 Otherwise show as a negative number."
 181   :type  'boolean
 182   :group 'calculator)
 183
 184 (defcustom calculator-mode-hook nil
 185   "List of hook functions for `calculator-mode' to run.
 186 Note: if `calculator-electric-mode' is on, then this hook will get
 187 activated in the minibuffer - in that case it should not do much more
 188 than local key settings and other effects that will change things
 189 outside the scope of calculator related code."
 190   :type  'hook
 191   :group 'calculator)
 192
 193 (defcustom calculator-user-registers nil
 194   "An association list of user-defined register bindings.
 195 Each element in this list is a list of a character and a number that
 196 will be stored in that character's register.
 197
 198 For example, use this to define the golden ratio number:
 199   (setq calculator-user-registers '((?g .  1.61803398875)))
 200 before you load calculator."
 201   :type  '(repeat (cons character number))
 202   :set   '(lambda (_ val)
 203             (and (boundp 'calculator-registers)
 204                  (setq calculator-registers
 205                        (append val calculator-registers)))
 206             (setq calculator-user-registers val))
 207   :group 'calculator)
 208
 209 (defcustom calculator-user-operators nil
 210   "A list of additional operators.
 211 This is a list in the same format as specified in the documentation for
 212 `calculator-operators', that you can use to bind additional calculator
 213 operators.  It is probably not a good idea to modify this value with
 214 `customize' since it is too complex...
 215
 216 Examples:
 217
 218 * A very simple one, adding a postfix \"x-to-y\" conversion keys, using
 219   t as a prefix key:
 220
 221   (setq calculator-user-operators
 222         '((\"tf\" cl-to-fr (+ 32 (/ (* X 9) 5)) 1)
 223           (\"tc\" fr-to-cl (/ (* (- X 32) 5) 9) 1)
 224           (\"tp\" kg-to-lb (/ X 0.453592)       1)
 225           (\"tk\" lb-to-kg (* X 0.453592)       1)
 226           (\"tF\" mt-to-ft (/ X 0.3048)         1)
 227           (\"tM\" ft-to-mt (* X 0.3048)         1)))
 228
 229 * Using a function-like form is very simple, X for an argument (Y the
 230   second in case of a binary operator), TX is a truncated version of X
 231   and F does a recursive call, Here is a [very inefficient] Fibonacci
 232   number calculation:
 233
 234   (add-to-list 'calculator-user-operators
 235                '(\"F\" fib (if (<= TX 1)
 236                          1
 237                          (+ (F (- TX 1)) (F (- TX 2)))) 0))
 238
 239   Note that this will be either postfix or prefix, according to
 240   `calculator-unary-style'."
 241   :type  '(repeat (list string symbol sexp integer integer))
 242   :group 'calculator)
 243
 244 ;;;=====================================================================
 245 ;;; Code:
 246
 247 ;;;---------------------------------------------------------------------
 248 ;;; Variables
 249
 250 (defvar calculator-initial-operators
 251   '(;; "+"/"-" have keybindings of themselves, not calculator-ops
 252     ("=" =     identity        1 -1)
 253     (nobind "+" +  +           2  4)
 254     (nobind "-" -  -           2  4)
 255     (nobind "+" +  +          -1  9)
 256     (nobind "-" -  -          -1  9)
 257     ("(" \(    identity       -1 -1)
 258     (")" \)    identity       +1 10)
 259     ;; normal keys
 260     ("|"  or   (logior TX TY)  2  2)
 261     ("#"  xor  (logxor TX TY)  2  2)
 262     ("&"  and  (logand TX TY)  2  3)
 263     ("*"  *    *               2  5)
 264     ("/"  /    /               2  5)
 265     ("\\" div  (/ TX TY)       2  5)
 266     ("%"  rem  (% TX TY)       2  5)
 267     ("L"  log  log             2  6)
 268     ("S"  sin  (sin DX)        x  6)
 269     ("C"  cos  (cos DX)        x  6)
 270     ("T"  tan  (tan DX)        x  6)
 271     ("IS" asin (D (asin X))    x  6)
 272     ("IC" acos (D (acos X))    x  6)
 273     ("IT" atan (D (atan X))    x  6)
 274     ("Q"  sqrt sqrt            x  7)
 275     ("^"  ^    calculator-expt 2  7)
 276     ("!"  !    calculator-fact x  7)
 277     (";"  1/   (/ 1 X)         1  7)
 278     ("_"  -    -               1  8)
 279     ("~"  ~    (lognot TX)     x  8)
 280     (">"  repR calculator-repR 1  8)
 281     ("<"  repL calculator-repL 1  8)
 282     ("v"  avg  (/ (apply '+ L) (length L)) 0 8)
 283     ("l"  tot  (apply '+ L)    0 8)
 284     )
 285   "A list of initial operators.
 286 This is a list in the same format as `calculator-operators'.  Whenever
 287 `calculator' starts, it looks at the value of this variable, and if it
 288 is not empty, its contents is prepended to `calculator-operators' and
 289 the appropriate key bindings are made.
 290
 291 This variable is then reset to nil.  Don't use this if you want to add
 292 user-defined operators, use `calculator-user-operators' instead.")
 293
 294 (defvar calculator-operators nil
 295   "The calculator operators, each a list with:
 296
 297 1. The key that is bound to for this operation (usually a string);
 298
 299 2. The displayed symbol for this function;
 300
 301 3. The function symbol, or a form that uses the variables `X' and `Y',
 302    (if it is a binary operator), `TX' and `TY' (truncated integer
 303    versions), `DX' (converted to radians if degrees mode is on), `D'
 304    (function for converting radians to degrees if deg mode is on), `L'
 305    (list of saved values), `F' (function for recursive iteration calls)
 306    and evaluates to the function value - these variables are capital;
 307
 308 4. The function's arity, optional, one of: 2 => binary, -1 => prefix
 309    unary, +1 => postfix unary, 0 => a 0-arg operator func, non-number =>
 310    postfix/prefix as determined by `calculator-unary-style' (the
 311    default);
 312
 313 5. The function's precedence - should be in the range of 1 (lowest) to
 314    9 (highest) (optional, defaults to 1);
 315
 316 It it possible have a unary prefix version of a binary operator if it
 317 comes later in this list.  If the list begins with the symbol 'nobind,
 318 then no key binding will take place - this is only useful for predefined
 319 keys.
 320
 321 Use `calculator-user-operators' to add operators to this list, see its
 322 documentation for an example.")
 323
 324 (defvar calculator-stack nil
 325   "Stack contents - operations and operands.")
 326
 327 (defvar calculator-curnum nil
 328   "Current number being entered (as a string).")
 329
 330 (defvar calculator-stack-display nil
 331   "Cons of the stack and its string representation.")
 332
 333 (defvar calculator-char-radix
 334   '((?D . nil) (?B . bin) (?O . oct) (?H . hex) (?X . hex))
 335   "A table to convert input characters to corresponding radix symbols.")
 336
 337 (defvar calculator-output-radix nil
 338   "The mode for display, one of: nil (decimal), 'bin, 'oct or 'hex.")
 339
 340 (defvar calculator-input-radix nil
 341   "The mode for input, one of: nil (decimal), 'bin, 'oct or 'hex.")
 342
 343 (defvar calculator-deg nil
 344   "Non-nil if trig functions operate on degrees instead of radians.")
 345
 346 (defvar calculator-saved-list nil
 347   "A list of saved values collected.")
 348
 349 (defvar calculator-saved-ptr 0
 350   "The pointer to the current saved number.")
 351
 352 (defvar calculator-add-saved nil
 353   "Bound to t when a value should be added to the saved-list.")
 354
 355 (defvar calculator-display-fragile nil
 356   "When non-nil, we see something that the next digit should replace.")
 357
 358 (defvar calculator-buffer nil
 359   "The current calculator buffer.")
 360
 361 (defvar calculator-eng-extra nil
 362   "Internal value used by `calculator-eng-display'.")
 363
 364 (defvar calculator-eng-tmp-show nil
 365   "Internal value used by `calculator-eng-display'.")
 366
 367 (defvar calculator-last-opXY nil
 368   "The last binary operation and its arguments.
 369 Used for repeating operations in calculator-repR/L.")
 370
 371 (defvar calculator-registers ; use user-bindings first
 372   (append calculator-user-registers
 373           (list (cons ?e float-e) (cons ?p float-pi)))
 374   "The association list of calculator register values.")
 375
 376 (defvar calculator-saved-global-map nil
 377   "Saved global key map.")
 378
 379 (defvar calculator-restart-other-mode nil
 380   "Used to hack restarting with the electric mode changed.")
 381
 382 ;;;---------------------------------------------------------------------
 383 ;;; Key bindings
 384
 385 (defvar calculator-mode-map nil
 386   "The calculator key map.")
 387
 388 (or calculator-mode-map
 389   (let ((map (make-sparse-keymap)))
 390     (suppress-keymap map t)
 391     (define-key map "i" nil)
 392     (define-key map "o" nil)
 393     (let ((p
 394            '((calculator-open-paren  "[")
 395              (calculator-close-paren "]")
 396              (calculator-op-or-exp   "+" "-" [kp-add] [kp-subtract])
 397              (calculator-digit       "0" "1" "2" "3" "4" "5" "6" "7" "8"
 398                                      "9" "a" "b" "c" "d" "f"
 399                                      [kp-0] [kp-1] [kp-2] [kp-3] [kp-4]
 400                                      [kp-5] [kp-6] [kp-7] [kp-8] [kp-9])
 401              (calculator-op          [kp-divide] [kp-multiply])
 402              (calculator-decimal     "." [kp-decimal])
 403              (calculator-exp         "e")
 404              (calculator-dec/deg-mode "D")
 405              (calculator-set-register "s")
 406              (calculator-get-register "g")
 407              (calculator-radix-mode        "H" "X" "O" "B")
 408              (calculator-radix-input-mode  "id" "ih" "ix" "io" "ib"
 409                                            "iD" "iH" "iX" "iO" "iB")
 410              (calculator-radix-output-mode "od" "oh" "ox" "oo" "ob"
 411                                            "oD" "oH" "oX" "oO" "oB")
 412              (calculator-rotate-displayer      "'")
 413              (calculator-rotate-displayer-back "\"")
 414              (calculator-displayer-prev        "{")
 415              (calculator-displayer-next        "}")
 416              (calculator-saved-up      [up] [?\C-p])
 417              (calculator-saved-down    [down] [?\C-n])
 418              (calculator-quit          "q" [?\C-g])
 419              (calculator-enter         [enter] [linefeed] [kp-enter]
 420                                        [return] [?\r] [?\n])
 421              (calculator-save-on-list  " " [space])
 422              (calculator-clear-saved   [?\C-c] [(control delete)])
 423              (calculator-save-and-quit [(control return)]
 424                                        [(control kp-enter)])
 425              (calculator-paste         [insert] [(shift insert)]
 426                                        [paste] [mouse-2] [?\C-y])
 427              (calculator-clear         [delete] [?\C-?] [?\C-d])
 428              (calculator-help          [?h] [??] [f1] [help])
 429              (calculator-copy          [(control insert)] [copy])
 430              (calculator-backspace     [backspace])
 431              )))
 432       (while p
 433         ;; reverse the keys so first defs come last - makes the more
 434         ;; sensible bindings visible in the menu
 435         (let ((func (car (car p))) (keys (reverse (cdr (car p)))))
 436           (while keys
 437             (define-key map (car keys) func)
 438             (setq keys (cdr keys))))
 439         (setq p (cdr p))))
 440     (if calculator-bind-escape
 441       (progn (define-key map [?\e] 'calculator-quit)
 442              (define-key map [escape] 'calculator-quit))
 443       (define-key map [?\e ?\e ?\e] 'calculator-quit))
 444     ;; make C-h work in text-mode
 445     (or window-system (define-key map [?\C-h] 'calculator-backspace))
 446     ;; set up a menu
 447     (if (and calculator-use-menu (not (boundp 'calculator-menu)))
 448       (let ((radix-selectors
 449              (mapcar (lambda (x)
 450                        `([,(nth 0 x)
 451                           (calculator-radix-mode ,(nth 2 x))
 452                           :style radio
 453                           :keys ,(nth 2 x)
 454                           :selected
 455                           (and
 456                            (eq calculator-input-radix ',(nth 1 x))
 457                            (eq calculator-output-radix ',(nth 1 x)))]
 458                          [,(concat (nth 0 x) " Input")
 459                           (calculator-radix-input-mode ,(nth 2 x))
 460                           :keys ,(concat "i" (downcase (nth 2 x)))
 461                           :style radio
 462                           :selected
 463                           (eq calculator-input-radix ',(nth 1 x))]
 464                          [,(concat (nth 0 x) " Output")
 465                           (calculator-radix-output-mode ,(nth 2 x))
 466                           :keys ,(concat "o" (downcase (nth 2 x)))
 467                           :style radio
 468                           :selected
 469                           (eq calculator-output-radix ',(nth 1 x))]))
 470                      '(("Decimal"     nil "D")
 471                        ("Binary"      bin "B")
 472                        ("Octal"       oct "O")
 473                        ("Hexadecimal" hex "H"))))
 474             (op '(lambda (name key)
 475                         `[,name (calculator-op ,key) :keys ,key])))
 476         (easy-menu-define
 477          calculator-menu map "Calculator menu."
 478          `("Calculator"
 479            ["Help"
 480             (let ((last-command 'calculator-help)) (calculator-help))
 481             :keys "?"]
 482            "---"
 483            ["Copy"  calculator-copy]
 484            ["Paste" calculator-paste]
 485            "---"
 486            ["Electric mode"
 487             (progn (calculator-quit)
 488                    (setq calculator-restart-other-mode t)
 489                    (run-with-timer 0.1 nil '(lambda () (message nil)))
 490                    ;; the message from the menu will be visible,
 491                    ;; couldn't make it go away...
 492                    (calculator))
 493             :active (not calculator-electric-mode)]
 494            ["Normal mode"
 495             (progn (setq calculator-restart-other-mode t)
 496                    (calculator-quit))
 497             :active calculator-electric-mode]
 498            "---"
 499            ("Functions"
 500             ,(funcall op "Repeat-right" ">")
 501             ,(funcall op "Repeat-left"  "<")
 502             "------General------"
 503             ,(funcall op "Reciprocal"   ";")
 504             ,(funcall op "Log"          "L")
 505             ,(funcall op "Square-root"  "Q")
 506             ,(funcall op "Factorial"    "!")
 507             "------Trigonometric------"
 508             ,(funcall op "Sinus"        "S")
 509             ,(funcall op "Cosine"       "C")
 510             ,(funcall op "Tangent"      "T")
 511             ,(funcall op "Inv-Sinus"    "IS")
 512             ,(funcall op "Inv-Cosine"   "IC")
 513             ,(funcall op "Inv-Tangent"  "IT")
 514             "------Bitwise------"
 515             ,(funcall op "Or"           "|")
 516             ,(funcall op "Xor"          "#")
 517             ,(funcall op "And"          "&")
 518             ,(funcall op "Not"          "~"))
 519            ("Saved List"
 520             ["Eval+Save"      calculator-save-on-list]
 521             ["Prev number"    calculator-saved-up]
 522             ["Next number"    calculator-saved-down]
 523             ["Delete current" calculator-clear
 524              :active (and calculator-display-fragile
 525                           calculator-saved-list
 526                           (= (car calculator-stack)
 527                              (nth calculator-saved-ptr
 528                                   calculator-saved-list)))]
 529             ["Delete all" calculator-clear-saved]
 530             "---"
 531             ,(funcall op "List-total"   "l")
 532             ,(funcall op "List-average" "v"))
 533            ("Registers"
 534             ["Get register" calculator-get-register]
 535             ["Set register" calculator-set-register])
 536            ("Modes"
 537             ["Radians"
 538              (progn
 539                (and (or calculator-input-radix calculator-output-radix)
 540                     (calculator-radix-mode "D"))
 541                (and calculator-deg (calculator-dec/deg-mode)))
 542              :keys "D"
 543              :style radio
 544              :selected (not (or calculator-input-radix
 545                                 calculator-output-radix
 546                                 calculator-deg))]
 547             ["Degrees"
 548              (progn
 549                (and (or calculator-input-radix calculator-output-radix)
 550                     (calculator-radix-mode "D"))
 551                (or calculator-deg (calculator-dec/deg-mode)))
 552              :keys "D"
 553              :style radio
 554              :selected (and calculator-deg
 555                             (not (or calculator-input-radix
 556                                      calculator-output-radix)))]
 557             "---"
 558             ,@(mapcar 'car radix-selectors)
 559             ("Separate I/O"
 560              ,@(mapcar (lambda (x) (nth 1 x)) radix-selectors)
 561              "---"
 562              ,@(mapcar (lambda (x) (nth 2 x)) radix-selectors)))
 563            ("Decimal Display"
 564             ,@(mapcar (lambda (d)
 565                         (vector (cadr d)
 566                                 ;; Note: inserts actual object here
 567                                 `(calculator-rotate-displayer ',d)))
 568                       calculator-displayers)
 569             "---"
 570             ["Change Prev Display" calculator-displayer-prev]
 571             ["Change Next Display" calculator-displayer-next])
 572            "---"
 573            ["Copy+Quit" calculator-save-and-quit]
 574            ["Quit"      calculator-quit]))))
 575     (setq calculator-mode-map map)))
 576
 577 ;;;---------------------------------------------------------------------
 578 ;;; Startup and mode stuff
 579
 580 (defun calculator-mode ()
 581   ;; this help is also used as the major help screen
 582   "A [not so] simple calculator for Emacs.
 583
 584 This calculator is used in the same way as other popular calculators
 585 like xcalc or calc.exe - but using an Emacs interface.
 586
 587 Expressions are entered using normal infix notation, parens are used as
 588 normal.  Unary functions are usually postfix, but some depends on the
 589 value of `calculator-unary-style' (if the style for an operator below is
 590 specified, then it is fixed, otherwise it depends on this variable).
 591 `+' and `-' can be used as either binary operators or prefix unary
 592 operators.  Numbers can be entered with exponential notation using `e',
 593 except when using a non-decimal radix mode for input (in this case `e'
 594 will be the hexadecimal digit).  If the result of a calculation is too
 595 large (out of range for Emacs), the value of \"inf\" is returned.
 596
 597 Here are the editing keys:
 598 * `RET' `='      evaluate the current expression
 599 * `C-insert'     copy the whole current expression to the `kill-ring'
 600 * `C-return'     evaluate, save result the `kill-ring' and exit
 601 * `insert'       paste a number if the one was copied (normally)
 602 * `delete' `C-d' clear last argument or whole expression (hit twice)
 603 * `backspace'    delete a digit or a previous expression element
 604 * `h' `?'        pop-up a quick reference help
 605 * `ESC' `q'      exit (`ESC' can be used if `calculator-bind-escape' is
 606                  non-nil, otherwise use three consecutive `ESC's)
 607
 608 These operators are pre-defined:
 609 * `+' `-' `*' `/' the common binary operators
 610 * `\\' `%'         integer division and reminder
 611 * `_' `;'         postfix unary negation and reciprocal
 612 * `^' `L'         binary operators for x^y and log(x) in base y
 613 * `Q' `!'         unary square root and factorial
 614 * `S' `C' `T'     unary trigonometric operators - sin, cos and tan
 615 * `|' `#' `&' `~' bitwise operators - or, xor, and, not
 616
 617 The trigonometric functions can be inverted if prefixed with an `I', see
 618 below for the way to use degrees instead of the default radians.
 619
 620 Two special postfix unary operators are `>' and `<': whenever a binary
 621 operator is performed, it is remembered along with its arguments; then
 622 `>' (`<') will apply the same operator with the same right (left)
 623 argument.
 624
 625 hex/oct/bin modes can be set for input and for display separately.
 626 Another toggle-able mode is for using degrees instead of radians for
 627 trigonometric functions.
 628 The keys to switch modes are (`X' is shortcut for `H'):
 629 * `D'             switch to all-decimal mode, or toggle degrees/radians
 630 * `B' `O' `H' `X' binary/octal/hexadecimal modes for input & display
 631 * `i' `o'         followed by one of `D' `B' `O' `H' `X' (case
 632                   insensitive) sets only the input or display radix mode
 633 The prompt indicates the current modes:
 634 * \"D=\": degrees mode;
 635 * \"?=\": (? is B/O/H) this is the radix for both input and output;
 636 * \"=?\": (? is B/O/H) the display radix (when input is decimal);
 637 * \"??\": (? is D/B/O/H) 1st char for input radix, 2nd for display.
 638
 639 Also, the quote key can be used to switch display modes for decimal
 640 numbers (double-quote rotates back), and the two brace characters
 641 \(\"{\" and \"}\" change display parameters that these displayers use (if
 642 they handle such).  If output is using any radix mode, then these keys
 643 toggle digit grouping mode and the chunk size.
 644
 645 Values can be saved for future reference in either a list of saved
 646 values, or in registers.
 647
 648 The list of saved values is useful for statistics operations on some
 649 collected data.  It is possible to navigate in this list, and if the
 650 value shown is the current one on the list, an indication is displayed
 651 as \"[N]\" if this is the last number and there are N numbers, or
 652 \"[M/N]\" if the M-th value is shown.
 653 * `SPC'            evaluate the current value as usual, but also adds
 654                    the result to the list of saved values
 655 * `l' `v'          computes total / average of saved values
 656 * `up' `C-p'       browse to the previous value in the list
 657 * `down' `C-n'     browse to the next value in the list
 658 * `delete' `C-d'   remove current value from the list (if it is on it)
 659 * `C-delete' `C-c' delete the whole list
 660
 661 Registers are variable-like place-holders for values:
 662 * `s' followed by a character attach the current value to that character
 663 * `g' followed by a character fetches the attached value
 664
 665 There are many variables that can be used to customize the calculator.
 666 Some interesting customization variables are:
 667 * `calculator-electric-mode'  use only the echo-area electrically.
 668 * `calculator-unary-style'    set most unary ops to pre/postfix style.
 669 * `calculator-user-registers' to define user-preset registers.
 670 * `calculator-user-operators' to add user-defined operators.
 671 See the documentation for these variables, and \"calculator.el\" for
 672 more information.
 673
 674 \\{calculator-mode-map}"
 675   (interactive)
 676   (kill-all-local-variables)
 677   (setq major-mode 'calculator-mode)
 678   (setq mode-name "Calculator")
 679   (use-local-map calculator-mode-map)
 680   (run-mode-hooks 'calculator-mode-hook))
 681
 682 (eval-when-compile (require 'electric) (require 'ehelp))
 683
 684 ;;;###autoload
 685 (defun calculator ()
 686   "Run the Emacs calculator.
 687 See the documentation for `calculator-mode' for more information."
 688   (interactive)
 689   (if calculator-restart-other-mode
 690     (setq calculator-electric-mode (not calculator-electric-mode)))
 691   (if calculator-initial-operators
 692     (progn (calculator-add-operators calculator-initial-operators)
 693            (setq calculator-initial-operators nil)
 694            ;; don't change this since it is a customization variable,
 695            ;; its set function will add any new operators
 696            (calculator-add-operators calculator-user-operators)))
 697   (setq calculator-buffer (get-buffer-create "*calculator*"))
 698   (if calculator-electric-mode
 699     (save-window-excursion
 700       (progn (require 'electric) (message nil)) ; hide load message
 701       (let (old-g-map old-l-map (echo-keystrokes 0)
 702             (garbage-collection-messages nil)) ; no gc msg when electric
 703         (set-window-buffer (minibuffer-window) calculator-buffer)
 704         (select-window (minibuffer-window))
 705         (calculator-reset)
 706         (calculator-update-display)
 707         (setq old-l-map (current-local-map))
 708         (setq old-g-map (current-global-map))
 709         (setq calculator-saved-global-map (current-global-map))
 710         (use-local-map nil)
 711         (use-global-map calculator-mode-map)
 712         (run-hooks 'calculator-mode-hook)
 713         (unwind-protect
 714             (catch 'calculator-done
 715               (Electric-command-loop
 716                'calculator-done
 717                ;; can't use 'noprompt, bug in electric.el
 718                '(lambda () 'noprompt)
 719                nil
 720                (lambda (x y) (calculator-update-display))))
 721           (and calculator-buffer
 722                (catch 'calculator-done (calculator-quit)))
 723           (use-local-map old-l-map)
 724           (use-global-map old-g-map))))
 725     (progn
 726       (cond
 727         ((not (get-buffer-window calculator-buffer))
 728          (let ((window-min-height 2))
 729            ;; maybe leave two lines for our window because of the normal
 730            ;; `raised' modeline in Emacs 21
 731            (select-window
 732             (split-window-vertically
 733              ;; If the modeline might interfere with the calculator buffer,
 734              ;; use 3 lines instead.
 735              (if (and (fboundp 'face-attr-construct)
 736                       (let* ((dh (plist-get (face-attr-construct 'default) :height))
 737                              (mf (face-attr-construct 'modeline))
 738                              (mh (plist-get mf :height)))
 739                         ;; If the modeline is shorter than the default,
 740                         ;; stick with 2 lines.  (It may be necessary to
 741                         ;; check how much shorter.)
 742                         (and
 743                          (not
 744                           (or (and (integerp dh)
 745                                    (integerp mh)
 746                                    (< mh dh))
 747                               (and (numberp mh)
 748                                    (not (integerp mh))
 749                                    (< mh 1))))
 750                          (or
 751                           ;; If the modeline is taller than the default,
 752                           ;; use 3 lines.
 753                           (and (integerp dh)
 754                                (integerp mh)
 755                                (> mh dh))
 756                           (and (numberp mh)
 757                                (not (integerp mh))
 758                                (> mh 1))
 759                           ;; If the modeline has a box with non-negative line-width,
 760                           ;; use 3 lines.
 761                           (let* ((bx (plist-get mf :box))
 762                                  (lh (plist-get bx :line-width)))
 763                             (and bx
 764                                  (or
 765                                   (not lh)
 766                                   (> lh 0))))
 767                           ;; If the modeline has an overline, use 3 lines.
 768                           (plist-get (face-attr-construct 'modeline) :overline)))))
 769                -3 -2)))
 770            (switch-to-buffer calculator-buffer)))
 771         ((not (eq (current-buffer) calculator-buffer))
 772          (select-window (get-buffer-window calculator-buffer))))
 773       (calculator-mode)
 774       (setq buffer-read-only t)
 775       (calculator-reset)
 776       (message "Hit `?' For a quick help screen.")))
 777   (if (and calculator-restart-other-mode calculator-electric-mode)
 778     (calculator)))
 779
 780 (defun calculator-message (string &rest arguments)
 781   "Same as `message', but special handle of electric mode."
 782   (apply 'message string arguments)
 783   (if calculator-electric-mode
 784     (progn (sit-for 1) (message nil))))
 785
 786 ;;;---------------------------------------------------------------------
 787 ;;; Operators
 788
 789 (defun calculator-op-arity (op)
 790   "Return OP's arity, 2, +1 or -1."
 791   (let ((arity (or (nth 3 op) 'x)))
 792     (if (numberp arity)
 793       arity
 794       (if (eq calculator-unary-style 'postfix) +1 -1))))
 795
 796 (defun calculator-op-prec (op)
 797   "Return OP's precedence for reducing when inserting into the stack.
 798 Defaults to 1."
 799   (or (nth 4 op) 1))
 800
 801 (defun calculator-add-operators (more-ops)
 802   "This function handles operator addition.
 803 Adds MORE-OPS to `calculator-operator', called initially to handle
 804 `calculator-initial-operators' and `calculator-user-operators'."
 805   (let ((added-ops nil))
 806     (while more-ops
 807       (or (eq (car (car more-ops)) 'nobind)
 808           (let ((i -1) (key (car (car more-ops))))
 809             ;; make sure the key is undefined, so it's easy to define
 810             ;; prefix keys
 811             (while (< (setq i (1+ i)) (length key))
 812               (or (keymapp
 813                    (lookup-key calculator-mode-map
 814                                (substring key 0 (1+ i))))
 815                   (progn
 816                     (define-key
 817                       calculator-mode-map (substring key 0 (1+ i)) nil)
 818                     (setq i (length key)))))
 819             (define-key calculator-mode-map key 'calculator-op)))
 820       (setq added-ops (cons (if (eq (car (car more-ops)) 'nobind)
 821                               (cdr (car more-ops))
 822                               (car more-ops))
 823                             added-ops))
 824       (setq more-ops (cdr more-ops)))
 825     ;; added-ops come first, but in correct order
 826     (setq calculator-operators
 827           (append (nreverse added-ops) calculator-operators))))
 828
 829 ;;;---------------------------------------------------------------------
 830 ;;; Display stuff
 831
 832 (defun calculator-reset ()
 833   "Reset calculator variables."
 834   (or calculator-restart-other-mode
 835       (setq calculator-stack           nil
 836             calculator-curnum          nil
 837             calculator-stack-display   nil
 838             calculator-display-fragile nil))
 839   (setq calculator-restart-other-mode nil)
 840   (calculator-update-display))
 841
 842 (defun calculator-get-prompt ()
 843   "Return a string to display.
 844 The string is set not to exceed the screen width."
 845   (let* ((calculator-prompt
 846           (format calculator-prompt
 847                   (cond
 848                     ((or calculator-output-radix calculator-input-radix)
 849                      (if (eq calculator-output-radix
 850                              calculator-input-radix)
 851                        (concat
 852                         (char-to-string
 853                          (car (rassq calculator-output-radix
 854                                      calculator-char-radix)))
 855                         "=")
 856                        (concat
 857                         (if calculator-input-radix
 858                           (char-to-string
 859                            (car (rassq calculator-input-radix
 860                                        calculator-char-radix)))
 861                           "=")
 862                         (char-to-string
 863                          (car (rassq calculator-output-radix
 864                                      calculator-char-radix))))))
 865                     (calculator-deg "D=")
 866                     (t "=="))))
 867          (prompt
 868           (concat calculator-prompt
 869                   (cdr calculator-stack-display)
 870                   (cond (calculator-curnum
 871                          ;; number being typed
 872                          (concat calculator-curnum "_"))
 873                         ((and (= 1 (length calculator-stack))
 874                               calculator-display-fragile)
 875                          ;; only the result is shown, next number will
 876                          ;; restart
 877                          nil)
 878                         (t
 879                          ;; waiting for a number or an operator
 880                          "?"))))
 881          (trim (- (length prompt) (1- (window-width)))))
 882     (if (<= trim 0)
 883       prompt
 884       (concat calculator-prompt
 885               (substring prompt (+ trim (length calculator-prompt)))))))
 886
 887 (defun calculator-string-to-number (str)
 888   "Convert the given STR to a number, according to the value of
 889 `calculator-input-radix'."
 890   (if calculator-input-radix
 891     (let ((radix
 892            (cdr (assq calculator-input-radix
 893                       '((bin . 2) (oct . 8) (hex . 16)))))
 894           (i -1) (value 0) (new-value 0))
 895       ;; assume mostly valid input (e.g., characters in range)
 896       (while (< (setq i (1+ i)) (length str))
 897         (setq new-value
 898               (let* ((ch (upcase (aref str i)))
 899                      (n (cond ((< ch ?0)  nil)
 900                               ((<= ch ?9) (- ch ?0))
 901                               ((< ch ?A)  nil)
 902                               ((<= ch ?Z) (- ch (- ?A 10)))
 903                               (t          nil))))
 904                 (if (and n (<= 0 n) (< n radix))
 905                   (+ n (* radix value))
 906                   (progn
 907                     (calculator-message
 908                      "Warning: Ignoring bad input character `%c'." ch)
 909                     (sit-for 1)
 910                     value))))
 911         (if (if (< new-value 0) (> value 0) (< value 0))
 912           (calculator-message "Warning: Overflow in input."))
 913         (setq value new-value))
 914       value)
 915     (car (read-from-string
 916           (cond ((equal "." str) "0.0")
 917                 ((string-match "[eE][+-]?$" str) (concat str "0"))
 918                 ((string-match "\\.[0-9]\\|[eE]" str) str)
 919                 ((string-match "\\." str)
 920                  ;; do this because Emacs reads "23." as an integer
 921                  (concat str "0"))
 922                 ((stringp str) (concat str ".0"))
 923                 (t "0.0"))))))
 924
 925 (defun calculator-curnum-value ()
 926   "Get the numeric value of the displayed number string as a float."
 927   (calculator-string-to-number calculator-curnum))
 928
 929 (defun calculator-rotate-displayer (&optional new-disp)
 930   "Switch to the next displayer on the `calculator-displayers' list.
 931 Can be called with an optional argument NEW-DISP to force rotation to
 932 that argument.
 933 If radix output mode is active, toggle digit grouping."
 934   (interactive)
 935   (cond
 936     (calculator-output-radix
 937      (setq calculator-radix-grouping-mode
 938            (not calculator-radix-grouping-mode))
 939      (calculator-message
 940       "Digit grouping mode %s."
 941       (if calculator-radix-grouping-mode "ON" "OFF")))
 942     (t
 943      (setq calculator-displayers
 944            (if (and new-disp (memq new-disp calculator-displayers))
 945              (let ((tmp nil))
 946                (while (not (eq (car calculator-displayers) new-disp))
 947                  (setq tmp (cons (car calculator-displayers) tmp))
 948                  (setq calculator-displayers
 949                        (cdr calculator-displayers)))
 950                (setq calculator-displayers
 951                      (nconc calculator-displayers (nreverse tmp))))
 952              (nconc (cdr calculator-displayers)
 953                     (list (car calculator-displayers)))))
 954      (calculator-message
 955       "Using %s." (cadr (car calculator-displayers)))))
 956   (calculator-enter))
 957
 958 (defun calculator-rotate-displayer-back ()
 959   "Like `calculator-rotate-displayer', but rotates modes back.
 960 If radix output mode is active, toggle digit grouping."
 961   (interactive)
 962   (calculator-rotate-displayer (car (last calculator-displayers))))
 963
 964 (defun calculator-displayer-prev ()
 965   "Send the current displayer function a 'left argument.
 966 This is used to modify display arguments (if the current displayer
 967 function supports this).
 968 If radix output mode is active, increase the grouping size."
 969   (interactive)
 970   (if calculator-output-radix
 971     (progn (setq calculator-radix-grouping-digits
 972                  (1+ calculator-radix-grouping-digits))
 973            (calculator-enter))
 974     (and (car calculator-displayers)
 975          (let ((disp (caar calculator-displayers)))
 976            (cond
 977              ((symbolp disp) (funcall disp 'left))
 978              ((and (consp disp) (eq 'std (car disp)))
 979               (calculator-standard-displayer 'left (cadr disp))))))))
 980
 981 (defun calculator-displayer-next ()
 982   "Send the current displayer function a 'right argument.
 983 This is used to modify display arguments (if the current displayer
 984 function supports this).
 985 If radix output mode is active, decrease the grouping size."
 986   (interactive)
 987   (if calculator-output-radix
 988     (progn (setq calculator-radix-grouping-digits
 989                  (max 2 (1- calculator-radix-grouping-digits)))
 990            (calculator-enter))
 991     (and (car calculator-displayers)
 992          (let ((disp (caar calculator-displayers)))
 993            (cond
 994              ((symbolp disp) (funcall disp 'right))
 995              ((and (consp disp) (eq 'std (car disp)))
 996               (calculator-standard-displayer 'right (cadr disp))))))))
 997
 998 (defun calculator-remove-zeros (numstr)
 999   "Get a number string NUMSTR and remove unnecessary zeros.
1000 The behavior of this function is controlled by
1001 `calculator-remove-zeros'."
1002   (cond ((and (eq calculator-remove-zeros t)
1003               (string-match "\\.0+\\([eE][+-]?[0-9]*\\)?$" numstr))
1004          ;; remove all redundant zeros leaving an integer
1005          (if (match-beginning 1)
1006            (concat (substring numstr 0 (match-beginning 0))
1007                    (match-string 1 numstr))
1008            (substring numstr 0 (match-beginning 0))))
1009         ((and calculator-remove-zeros
1010               (string-match
1011                "\\..\\([0-9]*[1-9]\\)?\\(0+\\)\\([eE][+-]?[0-9]*\\)?$"
1012                numstr))
1013          ;; remove zeros, except for first after the "."
1014          (if (match-beginning 3)
1015            (concat (substring numstr 0 (match-beginning 2))
1016                    (match-string 3 numstr))
1017            (substring numstr 0 (match-beginning 2))))
1018         (t numstr)))
1019
1020 (defun calculator-standard-displayer (num char)
1021   "Standard display function, used to display NUM.
1022 Its behavior is determined by `calculator-number-digits' and the given
1023 CHAR argument (both will be used to compose a format string).  If the
1024 char is \"n\" then this function will choose one between %f or %e, this
1025 is a work around %g jumping to exponential notation too fast.
1026
1027 The special 'left and 'right symbols will make it change the current
1028 number of digits displayed (`calculator-number-digits').
1029
1030 It will also remove redundant zeros from the result."
1031   (if (symbolp num)
1032     (cond ((eq num 'left)
1033            (and (> calculator-number-digits 0)
1034                 (setq calculator-number-digits
1035                       (1- calculator-number-digits))
1036                 (calculator-enter)))
1037           ((eq num 'right)
1038            (setq calculator-number-digits
1039                  (1+ calculator-number-digits))
1040            (calculator-enter)))
1041     (let ((str (if (zerop num)
1042                  "0"
1043                  (format
1044                   (concat "%."
1045                           (number-to-string calculator-number-digits)
1046                           (if (eq char ?n)
1047                             (let ((n (abs num)))
1048                               (if (or (< n 0.001) (> n 1e8)) "e" "f"))
1049                             (string char)))
1050                   num))))
1051       (calculator-remove-zeros str))))
1052
1053 (defun calculator-eng-display (num)
1054   "Display NUM in engineering notation.
1055 The number of decimal digits used is controlled by
1056 `calculator-number-digits', so to change it at runtime you have to use
1057 the 'left or 'right when one of the standard modes is used."
1058   (if (symbolp num)
1059     (cond ((eq num 'left)
1060            (setq calculator-eng-extra
1061                  (if calculator-eng-extra
1062                    (1+ calculator-eng-extra)
1063                    1))
1064            (let ((calculator-eng-tmp-show t)) (calculator-enter)))
1065           ((eq num 'right)
1066            (setq calculator-eng-extra
1067                  (if calculator-eng-extra
1068                    (1- calculator-eng-extra)
1069                    -1))
1070            (let ((calculator-eng-tmp-show t)) (calculator-enter))))
1071     (let ((exp 0))
1072       (and (not (= 0 num))
1073            (progn
1074              (while (< (abs num) 1.0)
1075                (setq num (* num 1000.0)) (setq exp (- exp 3)))
1076              (while (> (abs num) 999.0)
1077                (setq num (/ num 1000.0)) (setq exp (+ exp 3)))
1078              (and calculator-eng-tmp-show
1079                   (not (= 0 calculator-eng-extra))
1080                   (let ((i calculator-eng-extra))
1081                     (while (> i 0)
1082                       (setq num (* num 1000.0)) (setq exp (- exp 3))
1083                       (setq i (1- i)))
1084                     (while (< i 0)
1085                       (setq num (/ num 1000.0)) (setq exp (+ exp 3))
1086                       (setq i (1+ i)))))))
1087       (or calculator-eng-tmp-show (setq calculator-eng-extra nil))
1088       (let ((str (format (concat "%." (number-to-string
1089                                        calculator-number-digits)
1090                                  "f")
1091                          num)))
1092         (concat (let ((calculator-remove-zeros
1093                        ;; make sure we don't leave integers
1094                        (and calculator-remove-zeros 'x)))
1095                   (calculator-remove-zeros str))
1096                 "e" (number-to-string exp))))))
1097
1098 (defun calculator-number-to-string (num)
1099   "Convert NUM to a displayable string."
1100   (cond
1101     ((and (numberp num) calculator-output-radix)
1102      ;; print with radix - for binary I convert the octal number
1103      (let ((str (format (if (eq calculator-output-radix 'hex) "%x" "%o")
1104                         (calculator-truncate
1105                          (if calculator-2s-complement num (abs num))))))
1106        (if (eq calculator-output-radix 'bin)
1107          (let ((i -1) (s ""))
1108            (while (< (setq i (1+ i)) (length str))
1109              (setq s
1110                    (concat s
1111                            (cdr (assq (aref str i)
1112                                       '((?0 . "000") (?1 . "001")
1113                                         (?2 . "010") (?3 . "011")
1114                                         (?4 . "100") (?5 . "101")
1115                                         (?6 . "110") (?7 . "111")))))))
1116            (string-match "^0*\\(.+\\)" s)
1117            (setq str (match-string 1 s))))
1118        (if calculator-radix-grouping-mode
1119          (let ((d (/ (length str) calculator-radix-grouping-digits))
1120                (r (% (length str) calculator-radix-grouping-digits)))
1121            (while (>= (setq d (1- d)) (if (zerop r) 1 0))
1122              (let ((i (+ r (* d calculator-radix-grouping-digits))))
1123                (setq str (concat (substring str 0 i)
1124                                  calculator-radix-grouping-separator
1125                                  (substring str i)))))))
1126        (upcase
1127         (if (and (not calculator-2s-complement) (< num 0))
1128           (concat "-" str)
1129           str))))
1130     ((and (numberp num) calculator-displayer)
1131      (cond
1132        ((stringp calculator-displayer)
1133         (format calculator-displayer num))
1134        ((symbolp calculator-displayer)
1135         (funcall calculator-displayer num))
1136        ((and (consp calculator-displayer)
1137              (eq 'std (car calculator-displayer)))
1138         (calculator-standard-displayer num (cadr calculator-displayer)))
1139        ((listp calculator-displayer)
1140         (eval calculator-displayer))
1141        (t (prin1-to-string num t))))
1142     ;; operators are printed here
1143     (t (prin1-to-string (nth 1 num) t))))
1144
1145 (defun calculator-update-display (&optional force)
1146   "Update the display.
1147 If optional argument FORCE is non-nil, don't use the cached string."
1148   (set-buffer calculator-buffer)
1149   ;; update calculator-stack-display
1150   (if (or force
1151           (not (eq (car calculator-stack-display) calculator-stack)))
1152     (setq calculator-stack-display
1153           (cons calculator-stack
1154                 (if calculator-stack
1155                   (concat
1156                    (let ((calculator-displayer
1157                           (if (and calculator-displayers
1158                                    (= 1 (length calculator-stack)))
1159                             ;; customizable display for a single value
1160                             (caar calculator-displayers)
1161                             calculator-displayer)))
1162                      (mapconcat 'calculator-number-to-string
1163                                 (reverse calculator-stack)
1164                                 " "))
1165                    " "
1166                    (and calculator-display-fragile
1167                         calculator-saved-list
1168                         (= (car calculator-stack)
1169                            (nth calculator-saved-ptr
1170                                 calculator-saved-list))
1171                         (if (= 0 calculator-saved-ptr)
1172                           (format "[%s]" (length calculator-saved-list))
1173                           (format "[%s/%s]"
1174                                   (- (length calculator-saved-list)
1175                                      calculator-saved-ptr)
1176                                   (length calculator-saved-list)))))
1177                   ""))))
1178   (let ((inhibit-read-only t))
1179     (erase-buffer)
1180     (insert (calculator-get-prompt)))
1181   (set-buffer-modified-p nil)
1182   (if calculator-display-fragile
1183     (goto-char (1+ (length calculator-prompt)))
1184     (goto-char (1- (point)))))
1185
1186 ;;;---------------------------------------------------------------------
1187 ;;; Stack computations
1188
1189 (defun calculator-reduce-stack (prec)
1190   "Reduce the stack using top operator.
1191 PREC is a precedence - reduce everything with higher precedence."
1192   (while
1193       (cond
1194         ((and (cdr (cdr calculator-stack))         ; have three values
1195               (consp   (nth 0 calculator-stack))   ; two operators & num
1196               (numberp (nth 1 calculator-stack))
1197               (consp   (nth 2 calculator-stack))
1198               (eq '\) (nth 1 (nth 0 calculator-stack)))
1199               (eq '\( (nth 1 (nth 2 calculator-stack))))
1200          ;; reduce "... ( x )" --> "... x"
1201          (setq calculator-stack
1202                (cons (nth 1 calculator-stack)
1203                      (nthcdr 3 calculator-stack)))
1204          ;; another iteration
1205          t)
1206         ((and (cdr (cdr calculator-stack))         ; have three values
1207               (numberp (nth 0 calculator-stack))   ; two nums & operator
1208               (consp   (nth 1 calculator-stack))
1209               (numberp (nth 2 calculator-stack))
1210               (= 2 (calculator-op-arity            ; binary operator
1211                     (nth 1 calculator-stack)))
1212               (<= prec                             ; with higher prec.
1213                   (calculator-op-prec (nth 1 calculator-stack))))
1214          ;; reduce "... x op y" --> "... r", r is the result
1215          (setq calculator-stack
1216                (cons (calculator-funcall
1217                       (nth 2 (nth 1 calculator-stack))
1218                       (nth 2 calculator-stack)
1219                       (nth 0 calculator-stack))
1220                      (nthcdr 3 calculator-stack)))
1221          ;; another iteration
1222          t)
1223         ((and (>= (length calculator-stack) 2)     ; have two values
1224               (numberp (nth 0 calculator-stack))   ; number & operator
1225               (consp   (nth 1 calculator-stack))
1226               (= -1 (calculator-op-arity           ; prefix-unary op
1227                      (nth 1 calculator-stack)))
1228               (<= prec                             ; with higher prec.
1229                   (calculator-op-prec (nth 1 calculator-stack))))
1230          ;; reduce "... op x" --> "... r" for prefix op
1231          (setq calculator-stack
1232                (cons (calculator-funcall
1233                       (nth 2 (nth 1 calculator-stack))
1234                       (nth 0 calculator-stack))
1235                      (nthcdr 2 calculator-stack)))
1236          ;; another iteration
1237          t)
1238         ((and (cdr calculator-stack)               ; have two values
1239               (consp   (nth 0 calculator-stack))   ; operator & number
1240               (numberp (nth 1 calculator-stack))
1241               (= +1 (calculator-op-arity           ; postfix-unary op
1242                      (nth 0 calculator-stack)))
1243               (<= prec                             ; with higher prec.
1244                   (calculator-op-prec (nth 0 calculator-stack))))
1245          ;; reduce "... x op" --> "... r" for postfix op
1246          (setq calculator-stack
1247                (cons (calculator-funcall
1248                       (nth 2 (nth 0 calculator-stack))
1249                       (nth 1 calculator-stack))
1250                      (nthcdr 2 calculator-stack)))
1251          ;; another iteration
1252          t)
1253         ((and calculator-stack                     ; have one value
1254               (consp (nth 0 calculator-stack))     ; an operator
1255               (= 0 (calculator-op-arity            ; 0-ary op
1256                     (nth 0 calculator-stack))))
1257          ;; reduce "... op" --> "... r" for 0-ary op
1258          (setq calculator-stack
1259                (cons (calculator-funcall
1260                       (nth 2 (nth 0 calculator-stack)))
1261                      (nthcdr 1 calculator-stack)))
1262          ;; another iteration
1263          t)
1264         ((and (cdr calculator-stack)               ; have two values
1265               (numberp (nth 0 calculator-stack))   ; both numbers
1266               (numberp (nth 1 calculator-stack)))
1267          ;; get rid of redundant numbers:
1268          ;;   reduce "... y x" --> "... x"
1269          ;; needed for 0-ary ops that puts more values
1270          (setcdr calculator-stack (cdr (cdr calculator-stack))))
1271         (t ;; no more iterations
1272            nil))))
1273
1274 (defun calculator-funcall (f &optional X Y)
1275   "If F is a symbol, evaluate (F X Y).
1276 Otherwise, it should be a list, evaluate it with X, Y bound to the
1277 arguments."
1278   ;; remember binary ops for calculator-repR/L
1279   (if Y (setq calculator-last-opXY (list f X Y)))
1280   (condition-case nil
1281       ;; there used to be code here that returns 0 if the result was
1282       ;; smaller than calculator-epsilon (1e-15).  I don't think this is
1283       ;; necessary now.
1284       (if (symbolp f)
1285         (cond ((and X Y) (funcall f X Y))
1286               (X         (funcall f X))
1287               (t         (funcall f)))
1288         ;; f is an expression
1289         (let* ((__f__ f) ; so we can get this value below...
1290                (TX (calculator-truncate X))
1291                (TY (and Y (calculator-truncate Y)))
1292                (DX (if calculator-deg (/ (* X pi) 180) X))
1293                (L  calculator-saved-list)
1294                (Fbound (fboundp 'F))
1295                (Fsave  (and Fbound (symbol-function 'F)))
1296                (Dbound (fboundp 'D))
1297                (Dsave  (and Dbound (symbol-function 'D))))
1298           ;; a shortened version of flet
1299           (fset 'F (function
1300                     (lambda (&optional x y)
1301                       (calculator-funcall __f__ x y))))
1302           (fset 'D (function
1303                     (lambda (x)
1304                       (if calculator-deg (/ (* x 180) float-pi) x))))
1305           (unwind-protect (eval f)
1306             (if Fbound (fset 'F Fsave) (fmakunbound 'F))
1307             (if Dbound (fset 'D Dsave) (fmakunbound 'D)))))
1308     (error 0)))
1309
1310 ;;;---------------------------------------------------------------------
1311 ;;; Input interaction
1312
1313 (defun calculator-last-input (&optional keys)
1314   "Last char (or event or event sequence) that was read.
1315 Optional string argument KEYS will force using it as the keys entered."
1316   (let ((inp (or keys (this-command-keys))))
1317     (if (or (stringp inp) (not (arrayp inp)))
1318       inp
1319       ;; this translates kp-x to x and [tries to] create a string to
1320       ;; lookup operators
1321       (let* ((i -1) (converted-str (make-string (length inp) ? )) k)
1322         ;; converts an array to a string the ops lookup with keypad
1323         ;; input
1324         (while (< (setq i (1+ i)) (length inp))
1325           (setq k (aref inp i))
1326           ;; if Emacs will someday have a event-key, then this would
1327           ;; probably be modified anyway
1328           (and (if (fboundp 'key-press-event-p) (key-press-event-p k))
1329                (if (fboundp 'event-key)
1330                    (and (event-key k) (setq k (event-key k)))))
1331           ;; assume all symbols are translatable with an ascii-character
1332           (and (symbolp k)
1333                (setq k (or (get k 'ascii-character) ? )))
1334           (aset converted-str i k))
1335         converted-str))))
1336
1337 (defun calculator-clear-fragile (&optional op)
1338   "Clear the fragile flag if it was set, then maybe reset all.
1339 OP is the operator (if any) that caused this call."
1340   (if (and calculator-display-fragile
1341            (or (not op)
1342                (= -1 (calculator-op-arity op))
1343                (= 0 (calculator-op-arity op))))
1344     ;; reset if last calc finished, and now get a num or prefix or 0-ary
1345     ;; op
1346     (calculator-reset))
1347   (setq calculator-display-fragile nil))
1348
1349 (defun calculator-digit ()
1350   "Enter a single digit."
1351   (interactive)
1352   (let ((inp (aref (calculator-last-input) 0)))
1353     (if (and (or calculator-display-fragile
1354                  (not (numberp (car calculator-stack))))
1355              (cond
1356                ((not calculator-input-radix)     (<= inp ?9))
1357                ((eq calculator-input-radix 'bin) (<= inp ?1))
1358                ((eq calculator-input-radix 'oct) (<= inp ?7))
1359                (t t)))
1360       ;; enter digit if starting a new computation or have an op on the
1361       ;; stack
1362       (progn
1363         (calculator-clear-fragile)
1364         (let ((digit (upcase (char-to-string inp))))
1365           (if (equal calculator-curnum "0")
1366             (setq calculator-curnum nil))
1367           (setq calculator-curnum
1368                 (concat (or calculator-curnum "") digit)))
1369         (calculator-update-display)))))
1370
1371 (defun calculator-decimal ()
1372   "Enter a decimal period."
1373   (interactive)
1374   (if (and (not calculator-input-radix)
1375            (or calculator-display-fragile
1376                (not (numberp (car calculator-stack))))
1377            (not (and calculator-curnum
1378                      (string-match "[.eE]" calculator-curnum))))
1379     ;; enter the period on the same condition as a digit, only if no
1380     ;; period or exponent entered yet
1381     (progn
1382       (calculator-clear-fragile)
1383       (setq calculator-curnum (concat (or calculator-curnum "0") "."))
1384       (calculator-update-display))))
1385
1386 (defun calculator-exp ()
1387   "Enter an `E' exponent character, or a digit in hex input mode."
1388   (interactive)
1389   (if calculator-input-radix
1390     (calculator-digit)
1391     (if (and (or calculator-display-fragile
1392                  (not (numberp (car calculator-stack))))
1393              (not (and calculator-curnum
1394                        (string-match "[eE]" calculator-curnum))))
1395       ;; same condition as above, also no E so far
1396       (progn
1397         (calculator-clear-fragile)
1398         (setq calculator-curnum (concat (or calculator-curnum "1") "e"))
1399         (calculator-update-display)))))
1400
1401 (defun calculator-op (&optional keys)
1402   "Enter an operator on the stack, doing all necessary reductions.
1403 Optional string argument KEYS will force using it as the keys entered."
1404   (interactive)
1405   (catch 'op-error
1406     (let* ((last-inp (calculator-last-input keys))
1407            (op (assoc last-inp calculator-operators)))
1408       (calculator-clear-fragile op)
1409       (if (and calculator-curnum (/= (calculator-op-arity op) 0))
1410         (setq calculator-stack
1411               (cons (calculator-curnum-value) calculator-stack)))
1412       (setq calculator-curnum nil)
1413       (if (and (= 2 (calculator-op-arity op))
1414                (not (and calculator-stack
1415                          (numberp (nth 0 calculator-stack)))))
1416         ;; we have a binary operator but no number - search for a prefix
1417         ;; version
1418         (let ((rest-ops calculator-operators))
1419           (while (not (equal last-inp (car (car rest-ops))))
1420             (setq rest-ops (cdr rest-ops)))
1421           (setq op (assoc last-inp (cdr rest-ops)))
1422           (if (not (and op (= -1 (calculator-op-arity op))))
1423             ;;(error "Binary operator without a first operand")
1424             (progn
1425               (calculator-message
1426                "Binary operator without a first operand")
1427               (throw 'op-error nil)))))
1428       (calculator-reduce-stack
1429        (cond ((eq (nth 1 op) '\() 10)
1430              ((eq (nth 1 op) '\)) 0)
1431              (t (calculator-op-prec op))))
1432       (if (or (and (= -1 (calculator-op-arity op))
1433                    (numberp (car calculator-stack)))
1434               (and (/= (calculator-op-arity op) -1)
1435                    (/= (calculator-op-arity op) 0)
1436                    (not (numberp (car calculator-stack)))))
1437         ;;(error "Unterminated expression")
1438         (progn
1439           (calculator-message "Unterminated expression")
1440           (throw 'op-error nil)))
1441       (setq calculator-stack (cons op calculator-stack))
1442       (calculator-reduce-stack (calculator-op-prec op))
1443       (and (= (length calculator-stack) 1)
1444            (numberp (nth 0 calculator-stack))
1445            ;; the display is fragile if it contains only one number
1446            (setq calculator-display-fragile t)
1447            ;; add number to the saved-list
1448            calculator-add-saved
1449            (if (= 0 calculator-saved-ptr)
1450              (setq calculator-saved-list
1451                    (cons (car calculator-stack) calculator-saved-list))
1452              (let ((p (nthcdr (1- calculator-saved-ptr)
1453                               calculator-saved-list)))
1454                (setcdr p (cons (car calculator-stack) (cdr p))))))
1455       (calculator-update-display))))
1456
1457 (defun calculator-op-or-exp ()
1458   "Either enter an operator or a digit.
1459 Used with +/- for entering them as digits in numbers like 1e-3 (there is
1460 no need for negative numbers since these are handled by unary operators)."
1461   (interactive)
1462   (if (and (not calculator-display-fragile)
1463            calculator-curnum
1464            (string-match "[eE]$" calculator-curnum))
1465     (calculator-digit)
1466     (calculator-op)))
1467
1468 ;;;---------------------------------------------------------------------
1469 ;;; Input/output modes (not display)
1470
1471 (defun calculator-dec/deg-mode ()
1472   "Set decimal mode for display & input, if decimal, toggle deg mode."
1473   (interactive)
1474   (if calculator-curnum
1475     (setq calculator-stack
1476           (cons (calculator-curnum-value) calculator-stack)))
1477   (setq calculator-curnum nil)
1478   (if (or calculator-input-radix calculator-output-radix)
1479     (progn (setq calculator-input-radix nil)
1480            (setq calculator-output-radix nil))
1481     ;; already decimal - toggle degrees mode
1482     (setq calculator-deg (not calculator-deg)))
1483   (calculator-update-display t))
1484
1485 (defun calculator-radix-mode (&optional keys)
1486   "Set input and display radix modes.
1487 Optional string argument KEYS will force using it as the keys entered."
1488   (interactive)
1489   (calculator-radix-input-mode keys)
1490   (calculator-radix-output-mode keys))
1491
1492 (defun calculator-radix-input-mode (&optional keys)
1493   "Set input radix modes.
1494 Optional string argument KEYS will force using it as the keys entered."
1495   (interactive)
1496   (if calculator-curnum
1497     (setq calculator-stack
1498           (cons (calculator-curnum-value) calculator-stack)))
1499   (setq calculator-curnum nil)
1500   (setq calculator-input-radix
1501         (let ((inp (calculator-last-input keys)))
1502           (cdr (assq (upcase (aref inp (1- (length inp))))
1503                      calculator-char-radix))))
1504   (calculator-update-display))
1505
1506 (defun calculator-radix-output-mode (&optional keys)
1507   "Set display radix modes.
1508 Optional string argument KEYS will force using it as the keys entered."
1509   (interactive)
1510   (if calculator-curnum
1511     (setq calculator-stack
1512           (cons (calculator-curnum-value) calculator-stack)))
1513   (setq calculator-curnum nil)
1514   (setq calculator-output-radix
1515         (let ((inp (calculator-last-input keys)))
1516           (cdr (assq (upcase (aref inp (1- (length inp))))
1517                      calculator-char-radix))))
1518   (calculator-update-display t))
1519
1520 ;;;---------------------------------------------------------------------
1521 ;;; Saved values list
1522
1523 (defun calculator-save-on-list ()
1524   "Evaluate current expression, put result on the saved values list."
1525   (interactive)
1526   (let ((calculator-add-saved t)) ; marks the result to be added
1527     (calculator-enter)))
1528
1529 (defun calculator-clear-saved ()
1530   "Clear the list of saved values in `calculator-saved-list'."
1531   (interactive)
1532   (setq calculator-saved-list nil)
1533   (setq calculator-saved-ptr 0)
1534   (calculator-update-display t))
1535
1536 (defun calculator-saved-move (n)
1537   "Go N elements up the list of saved values."
1538   (interactive)
1539   (and calculator-saved-list
1540        (or (null calculator-stack) calculator-display-fragile)
1541        (progn
1542          (setq calculator-saved-ptr
1543                (max (min (+ n calculator-saved-ptr)
1544                          (length calculator-saved-list))
1545                     0))
1546          (if (nth calculator-saved-ptr calculator-saved-list)
1547            (setq calculator-stack
1548                  (list (nth calculator-saved-ptr calculator-saved-list))
1549                  calculator-display-fragile t)
1550            (calculator-reset))
1551          (calculator-update-display))))
1552
1553 (defun calculator-saved-up ()
1554   "Go up the list of saved values."
1555   (interactive)
1556   (calculator-saved-move +1))
1557
1558 (defun calculator-saved-down ()
1559   "Go down the list of saved values."
1560   (interactive)
1561   (calculator-saved-move -1))
1562
1563 ;;;---------------------------------------------------------------------
1564 ;;; Misc functions
1565
1566 (defun calculator-open-paren ()
1567   "Equivalents of `(' use this."
1568   (interactive)
1569   (calculator-op "("))
1570
1571 (defun calculator-close-paren ()
1572   "Equivalents of `)' use this."
1573   (interactive)
1574   (calculator-op ")"))
1575
1576 (defun calculator-enter ()
1577   "Evaluate current expression."
1578   (interactive)
1579   (calculator-op "="))
1580
1581 (defun calculator-backspace ()
1582   "Backward delete a single digit or a stack element."
1583   (interactive)
1584   (if calculator-curnum
1585     (setq calculator-curnum
1586           (if (> (length calculator-curnum) 1)
1587             (substring calculator-curnum
1588                        0 (1- (length calculator-curnum)))
1589             nil))
1590     (setq calculator-stack (cdr calculator-stack)))
1591   (calculator-update-display))
1592
1593 (defun calculator-clear ()
1594   "Clear current number."
1595   (interactive)
1596   (setq calculator-curnum nil)
1597   (cond
1598     ;; if the current number is from the saved-list - remove it
1599     ((and calculator-display-fragile
1600           calculator-saved-list
1601           (= (car calculator-stack)
1602              (nth calculator-saved-ptr calculator-saved-list)))
1603      (if (= 0 calculator-saved-ptr)
1604        (setq calculator-saved-list (cdr calculator-saved-list))
1605        (let ((p (nthcdr (1- calculator-saved-ptr)
1606                         calculator-saved-list)))
1607          (setcdr p (cdr (cdr p)))
1608          (setq calculator-saved-ptr (1- calculator-saved-ptr))))
1609      (if calculator-saved-list
1610        (setq calculator-stack
1611              (list (nth calculator-saved-ptr calculator-saved-list)))
1612        (calculator-reset)))
1613     ;; reset if fragile or double clear
1614     ((or calculator-display-fragile (eq last-command this-command))
1615      (calculator-reset)))
1616   (calculator-update-display))
1617
1618 (defun calculator-copy ()
1619   "Copy current number to the `kill-ring'."
1620   (interactive)
1621   (let ((calculator-displayer
1622          (or calculator-copy-displayer calculator-displayer))
1623         (calculator-displayers
1624          (if calculator-copy-displayer nil calculator-displayers)))
1625     (calculator-enter)
1626     ;; remove trailing spaces and an index
1627     (let ((s (cdr calculator-stack-display)))
1628       (and s
1629            (if (string-match "^\\([^ ]+\\) *\\(\\[[0-9/]+\\]\\)? *$" s)
1630              (setq s (match-string 1 s)))
1631            (kill-new s)))))
1632
1633 (defun calculator-set-register (reg)
1634   "Set a register value for REG."
1635   (interactive "cRegister to store into: ")
1636   (let* ((as  (assq reg calculator-registers))
1637          (val (progn (calculator-enter) (car calculator-stack))))
1638     (if as
1639       (setcdr as val)
1640       (setq calculator-registers
1641             (cons (cons reg val) calculator-registers)))
1642     (calculator-message "[%c] := %S" reg val)))
1643
1644 (defun calculator-put-value (val)
1645   "Paste VAL as if entered.
1646 Used by `calculator-paste' and `get-register'."
1647   (if (and (numberp val)
1648            ;; (not calculator-curnum)
1649            (or calculator-display-fragile
1650                (not (numberp (car calculator-stack)))))
1651     (progn
1652       (calculator-clear-fragile)
1653       (setq calculator-curnum (let ((calculator-displayer "%S"))
1654                                 (calculator-number-to-string val)))
1655       (calculator-update-display))))
1656
1657 (defun calculator-paste ()
1658   "Paste a value from the `kill-ring'."
1659   (interactive)
1660   (calculator-put-value
1661    (let ((str (replace-regexp-in-string
1662                "^ *\\(.+[^ ]\\) *$" "\\1" (current-kill 0))))
1663      (and (not calculator-input-radix)
1664           calculator-paste-decimals
1665           (string-match "\\([0-9]+\\)\\(\\.[0-9]+\\)?\\(e[0-9]+\\)?"
1666                         str)
1667           (or (match-string 1 str)
1668               (match-string 2 str)
1669               (match-string 3 str))
1670           (setq str (concat (or (match-string 1 str) "0")
1671                             (or (match-string 2 str) ".0")
1672                             (or (match-string 3 str) ""))))
1673      (condition-case nil (calculator-string-to-number str)
1674        (error nil)))))
1675
1676 (defun calculator-get-register (reg)
1677   "Get a value from a register REG."
1678   (interactive "cRegister to get value from: ")
1679   (calculator-put-value (cdr (assq reg calculator-registers))))
1680
1681 (defun calculator-help ()
1682   ;; this is used as the quick reference screen you get with `h'
1683   "Quick reference:
1684 * numbers/operators/parens/./e - enter expressions
1685   + - * / \\(div) %(rem) _(-X,postfix) ;(1/X,postfix) ^(exp) L(og)
1686   Q(sqrt) !(fact) S(in) C(os) T(an) |(or) #(xor) &(and) ~(not)
1687 * >/< repeats last binary operation with its 2nd (1st) arg as postfix op
1688 * I inverses next trig function        * '/\"/{} - display/display args
1689 * D         - switch to all-decimal, or toggle deg/rad mode
1690 * B/O/H/X   - binary/octal/hex mode for i/o (X is a shortcut for H)
1691 * i/o       - prefix for d/b/o/x - set only input/output modes
1692 * enter/=   - evaluate current expr.   * s/g      - set/get a register
1693 * space     - evaluate & save on list  * l/v      - list total/average
1694 * up/down/C-p/C-n - browse saved       * C-delete - clear all saved
1695 * C-insert  - copy whole expr.         * C-return - evaluate, copy, exit
1696 * insert    - paste a number           * backspace- delete backwards
1697 * delete    - clear argument or list value or whole expression (twice)
1698 * escape/q  - exit."
1699   (interactive)
1700   (if (eq last-command 'calculator-help)
1701     (let ((mode-name "Calculator")
1702           (major-mode 'calculator-mode)
1703           (g-map (current-global-map))
1704           (win (selected-window)))
1705       (require 'ehelp)
1706       (if calculator-electric-mode
1707         (use-global-map calculator-saved-global-map))
1708       (if (or (not calculator-electric-mode)
1709               ;; XEmacs has a problem with electric-describe-mode
1710               (featurep 'xemacs))
1711         (describe-mode)
1712         (electric-describe-mode))
1713       (if calculator-electric-mode
1714         (use-global-map g-map))
1715       (select-window win) ; these are for XEmacs (also below)
1716       (message nil))
1717     (let ((one (one-window-p t))
1718           (win (selected-window))
1719           (help-buf (get-buffer-create "*Help*")))
1720       (save-window-excursion
1721         (with-output-to-temp-buffer "*Help*"
1722           (princ (documentation 'calculator-help)))
1723         (if one
1724           (shrink-window-if-larger-than-buffer
1725            (get-buffer-window help-buf)))
1726         (message
1727          "`%s' again for more help, any other key continues normally."
1728          (calculator-last-input))
1729         (select-window win)
1730         (sit-for 360))
1731       (select-window win))))
1732
1733 (defun calculator-quit ()
1734   "Quit calculator."
1735   (interactive)
1736   (set-buffer calculator-buffer)
1737   (let ((inhibit-read-only t)) (erase-buffer))
1738   (if (not calculator-electric-mode)
1739     (progn
1740       (condition-case nil
1741           (while (get-buffer-window calculator-buffer)
1742             (delete-window (get-buffer-window calculator-buffer)))
1743         (error nil))
1744       (kill-buffer calculator-buffer)))
1745   (setq calculator-buffer nil)
1746   (message "Calculator done.")
1747   (if calculator-electric-mode (throw 'calculator-done nil)))
1748
1749 (defun calculator-save-and-quit ()
1750   "Quit the calculator, saving the result on the `kill-ring'."
1751   (interactive)
1752   (calculator-enter)
1753   (calculator-copy)
1754   (calculator-quit))
1755
1756 (defun calculator-repR (x)
1757   "Repeat the last binary operation with its second argument and X.
1758 To use this, apply a binary operator (evaluate it), then call this."
1759   (if calculator-last-opXY
1760     ;; avoid rebinding calculator-last-opXY
1761     (let ((calculator-last-opXY calculator-last-opXY))
1762       (calculator-funcall
1763        (car calculator-last-opXY) x (nth 2 calculator-last-opXY)))
1764     x))
1765
1766 (defun calculator-repL (x)
1767   "Repeat the last binary operation with its first argument and X.
1768 To use this, apply a binary operator (evaluate it), then call this."
1769   (if calculator-last-opXY
1770     ;; avoid rebinding calculator-last-opXY
1771     (let ((calculator-last-opXY calculator-last-opXY))
1772       (calculator-funcall
1773        (car calculator-last-opXY) (nth 1 calculator-last-opXY) x))
1774     x))
1775
1776 (defun calculator-integer-p (x)
1777   "Non-nil if X is equal to an integer."
1778   (condition-case nil
1779       (= x (ftruncate x))
1780     (error nil)))
1781
1782 (defun calculator-expt (x y)
1783   "Compute X^Y, dealing with errors appropriately."
1784   (condition-case
1785       nil
1786       (expt x y)
1787     (domain-error 0.0e+NaN)
1788     (range-error
1789      (cond
1790       ((and (< x 1.0) (> x -1.0))
1791        ;; For small x, the range error comes from large y.
1792        0.0)
1793       ((and (> x 0.0) (< y 0.0))
1794        ;; For large positive x and negative y, the range error
1795        ;; comes from large negative y.
1796        0.0)
1797       ((and (> x 0.0) (> y 0.0))
1798        ;; For large positive x and positive y, the range error
1799        ;; comes from large y.
1800        1.0e+INF)
1801       ;; For the rest, x must be large and negative.
1802       ;; The range errors come from large integer y.
1803       ((< y 0.0)
1804        0.0)
1805       ((eq (logand (truncate y) 1) 1)   ; expansion of cl `oddp'
1806        ;; If y is odd
1807        -1.0e+INF)
1808       (t
1809        ;;
1810        1.0e+INF)))
1811     (error 0.0e+NaN)))
1812
1813 (defun calculator-fact (x)
1814   "Simple factorial of X."
1815   (if (and (>= x 0)
1816            (calculator-integer-p x))
1817       (if (= (calculator-expt (/ x 3.0) x) 1.0e+INF)
1818           1.0e+INF
1819         (let ((r (if (<= x 10) 1 1.0)))
1820           (while (> x 0)
1821             (setq r (* r (truncate x)))
1822             (setq x (1- x)))
1823           (+ 0.0 r)))
1824     (if (= x 1.0e+INF)
1825         x
1826       0.0e+NaN)))
1827
1828 (defun calculator-truncate (n)
1829   "Truncate N, return 0 in case of overflow."
1830   (condition-case nil (truncate n) (error 0)))
1831
1832
1833 (provide 'calculator)
1834
1835 ;; arch-tag: a1b9766c-af8a-4a74-b466-65ad8eeb0c73
1836 ;;; calculator.el ends here