Current File : //usr/local/share/emacs/27.2/lisp/calculator.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301\302\303\304\305\306\307\310\311\310\312& \210\313\314\315\316\317DD\320\321\322\310\301&\210\313\323\315\316\324DD\325\321\322\310\301&\210\313\326\315\316\327DD\330\321\322\310\301&\210\313\331\315\316\332DD\333\321\334\310\301&\210\313\335\315\316\336DD\337\321\340\310\301&\210\313\341\315\316\342DD\343\321\344\310\301&\210\313\345\315\316\346DD\347\321\322\310\301&\210\313\350\315\316\351DD\352\321\344\310\301&\210\313\353\315\316\354DD\355\321\340\310\301&\210\313\356\315\316\357DD\360\321\361\310\301&\210\313\362\315\316\363DD\364\321\365\310\301&\210\313\366\315\316\367DD\370\321\371\310\301&\210\313\372\315\316\373DD\374\321\322\310\301&\210\375\372\376\377#\210\313\201@ \315\316\201A DD\201B \321\322\310\301&\210\313\201C \315\316\201D DD\201E \321\322\310\301&\210\313\201F \315\316\201G DD\201H \321\201I \310\301&\210\313\201J \315\316\201K DD\201L \321\201M \201N \201O \310\301& \210\313\201P \315\316\201Q DD\201R \321\201S \310\301&\210\201T \201U !\207" [custom-declare-group calculator nil "Simple Emacs calculator." :prefix "calculator" :version "21.1" :group tools applications custom-declare-variable calculator-electric-mode funcall function #[0 "\300\207" [nil] 1] "Run `calculator' electrically, in the echo area.\nElectric mode saves some place but changes the way you interact with the\ncalculator." :type boolean calculator-use-menu #[0 "\300\207" [t] 1] "Make `calculator' create a menu.\nNote that this requires easymenu. Must be set before loading." calculator-bind-escape #[0 "\300\207" [nil] 1] "If non-nil, set escape to exit the calculator." calculator-unary-style #[0 "\300\207" [postfix] 1] "Value is either `prefix' or `postfix'.\nThis determines the default behavior of unary operators." (choice (const prefix) (const postfix)) calculator-prompt #[0 "\300\207" [#1="Calc=%s> "] 1 #1#] "The prompt used by the Emacs calculator.\nIt should contain a \"%s\" somewhere that will indicate the i/o radixes;\nthis will be a two-character string as described in the documentation\nfor `calculator-mode'." string calculator-number-digits #[0 "\300\207" [3] 1] "The calculator's number of digits used for standard display.\nUsed by the `calculator-standard-display' function - it will use the\nformat string \"%.NC\" where this number is N and C is a character given\nat runtime." integer calculator-radix-grouping-mode #[0 "\300\207" [t] 1] "Use digit grouping in radix output mode.\nIf this is set, chunks of `calculator-radix-grouping-digits' characters\nwill be separated by `calculator-radix-grouping-separator' when in radix\noutput mode is active (determined by `calculator-output-radix')." calculator-radix-grouping-digits #[0 "\300\207" [4] 1] "The number of digits used for grouping display in radix modes.\nSee `calculator-radix-grouping-mode'." calculator-radix-grouping-separator #[0 "\300\207" [#2="'"] 1 #2#] "The separator used in radix grouping display.\nSee `calculator-radix-grouping-mode'." calculator-remove-zeros #[0 "\300\207" [t] 1] "Non-nil value means delete all redundant zero decimal digits.\nIf this value is not t and not nil, redundant zeros are removed except\nfor one.\nUsed by the `calculator-remove-zeros' function." (choice (const t) (const leave-decimal) (const nil)) calculator-displayer #[0 "\300\207" [(std 110)] 1] "A displayer specification for numerical values.\nThis is the displayer used to show all numbers in an expression. Result\nvalues will be displayed according to the first element of\n`calculator-displayers'.\n\nThe displayer is a symbol, a string or an expression. A symbol should\nbe the name of a one-argument function, a string is used with a single\nargument and an expression will be evaluated with the variable `num'\nbound to whatever should be displayed. If it is a function symbol, it\nshould be able to handle special symbol arguments, currently `left' and\n`right' which will be sent by special keys to modify display parameters\nassociated with the displayer function (for example to change the number\nof digits displayed).\n\nAn exception to the above is the case of the list (std C [G]) where C is\na character and G is an optional boolean, in this case the\n`calculator-standard-displayer' function will be used with these as\narguments." (choice (function) (string) (sexp) (list (const std) character) (list (const std) character boolean)) calculator-displayers #[0 "\300\207" [(((std 110) "Standard display, decimal point or scientific") (calculator-eng-display "Eng display") ((std 102 t) "Standard display, decimal point with grouping") ((std 101) "Standard display, scientific") ("%S" "Emacs printer"))] 1] "A list of displayers.\nEach element is a list of a displayer and a description string. The\nfirst element is the one which is currently used, this is for the\ndisplay of result values not values in expressions. A displayer\nspecification is the same as the values that can be stored in\n`calculator-displayer'.\n\n`calculator-rotate-displayer' rotates this list." sexp calculator-paste-decimals #[0 "\300\207" [t] 1] "If non-nil, convert pasted integers so they have a decimal point.\nThis makes it possible to paste big integers since they will be read as\nfloats, otherwise the Emacs reader will fail on them." make-obsolete-variable "it is no longer used." "26.1" calculator-copy-displayer #[0 "\300\207" [nil] 1] "If non-nil, this is any value that can be used for\n`calculator-displayer', to format a string before copying it with\n`calculator-copy'. If nil, then `calculator-displayer's normal value is\nused." calculator-2s-complement #[0 "\300\207" [nil] 1] "If non-nil, show negative numbers in 2s complement in radix modes.\nOtherwise show as a negative number." calculator-mode-hook #[0 "\300\207" [nil] 1] "List of hook functions for `calculator-mode' to run.\nNote: if `calculator-electric-mode' is on, then this hook will get\nactivated in the minibuffer -- in that case it should not do much more\nthan local key settings and other effects that will change things\noutside the scope of calculator related code." hook calculator-user-registers #[0 "\300\207" [nil] 1] "An association list of user-defined register bindings.\nEach element in this list is a list of a character and a number that\nwill be stored in that character's register.\n\nFor example, use this to define the golden ratio number:\n (setq calculator-user-registers \\='((?g . 1.61803398875)))\nbefore you load calculator." (repeat (cons character number)) :set #[514 "\302\300!\203 \303\"\211\211\207" [calculator-registers calculator-user-registers boundp append] 5 "\n\n(fn _ VAL)"] calculator-user-operators #[0 "\300\207" [nil] 1] "A list of additional operators.\nThis is a list in the same format as specified in the documentation for\n`calculator-operators', that you can use to bind additional calculator\noperators. It is probably not a good idea to modify this value with\n`customize' since it is too complex...\n\nExamples:\n\n* A very simple one, adding a postfix \"x-to-y\" conversion keys, using\n t as a prefix key:\n\n (setq calculator-user-operators\n \\='((\"tf\" cl-to-fr (+ 32 (/ (* X 9) 5)) 1)\n (\"tc\" fr-to-cl (/ (* (- X 32) 5) 9) 1)\n (\"tp\" kg-to-lb (/ X 0.453592) 1)\n (\"tk\" lb-to-kg (* X 0.453592) 1)\n (\"tF\" mt-to-ft (/ X 0.3048) 1)\n (\"tM\" ft-to-mt (* X 0.3048) 1)))\n\n* Using a function-like form is simple: use `X' for the argument (`Y'\n for a second one in case of a binary operator), `TX' is a truncated\n version of `X' and `F' for a recursive call. Here is a [very\n inefficient] Fibonacci number operator:\n\n (add-to-list \\='calculator-user-operators\n \\='(\"F\" fib\n (if (<= TX 1) 1 (+ (F (- TX 1)) (F (- TX 2))))))\n\n Note that this will be either postfix or prefix, according to\n `calculator-unary-style'." (repeat (list string symbol sexp integer integer)) require cl-lib] 12)
#@418 A list of initial operators.
This is a list in the same format as `calculator-operators'. Whenever
`calculator' starts, it looks at the value of this variable, and if it
is not empty, its contents is prepended to `calculator-operators' and
the appropriate key bindings are made.
This variable is then reset to nil. Don't use this if you want to add
user-defined operators, use `calculator-user-operators' instead.
(defvar calculator-initial-operators '(("=" = identity 1 -1) (nobind "+" + + 2 4) (nobind "-" - - 2 4) (nobind "+" + + -1 9) (nobind "-" - - -1 9) ("(" \( identity -1 -1) (")" \) identity 1 10) ("|" or (logior TX TY) 2 2) ("#" xor (logxor TX TY) 2 2) ("&" and (logand TX TY) 2 3) ("*" * * 2 5) ("/" / / 2 5) ("\\" div (/ TX TY) 2 5) ("%" rem (% TX TY) 2 5) ("L" log log 2 6) ("S" sin (sin DX) x 6) ("C" cos (cos DX) x 6) ("T" tan (tan DX) x 6) ("IS" asin (D (asin X)) x 6) ("IC" acos (D (acos X)) x 6) ("IT" atan (D (atan X)) x 6) ("Q" sqrt sqrt x 7) ("^" ^ calculator-expt 2 7) ("!" ! calculator-fact x 7) (";" 1/ (/ 1 X) 1 7) ("_" - - 1 8) ("~" ~ (lognot TX) x 8) (">" repR calculator-repR 1 8) ("<" repL calculator-repL 1 8) ("v" avg (/ (apply '+ L) (length L)) 0 8) ("l" tot (apply '+ L) 0 8)) (#$ . 8419))
#@1344 The calculator operators, each a list with:
1. The key(s) that is bound to for this operation, a string that is
used with `kbd';
2. The displayed symbol for this function;
3. The function symbol, or a form that uses the variables `X' and `Y',
(if it is a binary operator), `TX' and `TY' (truncated integer
versions), `DX' (converted to radians if degrees mode is on), `D'
(function for converting radians to degrees if deg mode is on), `L'
(list of saved values), `F' (function for recursive iteration calls)
and evaluates to the function value -- these variables are capital;
4. The function's arity, optional, one of: 2 => binary, -1 => prefix
unary, +1 => postfix unary, 0 => a 0-arg operator func (note that
using such a function replaces the currently entered number, if any),
non-number (the default) => postfix or prefix as determined by
`calculator-unary-style';
5. The function's precedence -- should be in the range of 1 (lowest) to
9 (highest) (optional, defaults to 1);
It it possible have a unary prefix version of a binary operator if it
comes later in this list. If the list begins with the symbol `nobind',
then no key binding will take place -- this is only used for predefined
keys.
Use `calculator-user-operators' to add operators to this list, see its
documentation for an example.
(defvar calculator-operators nil (#$ . 9655))
#@44 Stack contents -- operations and operands.
(defvar calculator-stack nil (#$ . 11050))
#@45 Current number being entered (as a string).
(defvar calculator-curnum nil (#$ . 11142))
#@50 Cons of the stack and its string representation.
(defvar calculator-stack-display nil (#$ . 11236))
#@69 A table to convert input characters to corresponding radix symbols.
(defvar calculator-char-radix '((68) (66 . bin) (79 . oct) (72 . hex) (88 . hex)) (#$ . 11342))
#@69 The mode for display, one of: nil (decimal), `bin', `oct' or `hex'.
(defvar calculator-output-radix nil (#$ . 11512))
#@67 The mode for input, one of: nil (decimal), `bin', `oct' or `hex'.
(defvar calculator-input-radix nil (#$ . 11636))
#@66 Non-nil if trig functions operate on degrees instead of radians.
(defvar calculator-deg nil (#$ . 11757))
#@35 A list of saved values collected.
(defvar calculator-saved-list nil (#$ . 11869))
#@42 The pointer to the current saved number.
(defvar calculator-saved-ptr 0 (#$ . 11957))
#@60 Bound to t when a value should be added to the saved-list.
(defvar calculator-add-saved nil (#$ . 12049))
#@68 When non-nil, we see something that the next digit should replace.
(defvar calculator-display-fragile nil (#$ . 12161))
#@32 The current calculator buffer.
(defvar calculator-buffer nil (#$ . 12287))
#@50 Internal value used by `calculator-eng-display'.
(defvar calculator-eng-extra nil (#$ . 12368))
#@50 Internal value used by `calculator-eng-display'.
(defvar calculator-eng-tmp-show nil (#$ . 12470))
#@98 The last binary operation and its arguments.
Used for repeating operations in calculator-repR/L.
(defvar calculator-last-opXY nil (#$ . 12575))
#@53 The association list of calculator register values.
(defvar calculator-registers (byte-code "\303\304 B\305\nBD\"\207" [calculator-user-registers float-e float-pi append 101 112] 5) (#$ . 12725))
#@57 Used to hack restarting with the electric mode changed.
(defvar calculator-restart-other-mode nil (#$ . 12928))
#@20
(fn KEY CMD MAP)
(defalias 'calculator-define-key #[771 ";\203 \300!\202\f \301!\302#\210\211\204( \303 \262\304\305\"\210\306\"\210\211CG\307\211W\205\205 \211H\310!\311\242\"\312\nGSU\203\\ \313!\204| \211$\210\202| \313!\203j \240\210\202| \303 $\210\240\266\266\211T\262\202- \266\202\262\207" [kbd keymap-parent define-key make-sparse-keymap suppress-keymap t set-keymap-parent 0 vector lookup-key #[1028 "\300\242#\210\301!\2051 \302X\203 \303X\204% \304X\2051 \305X\2051 \300\242\306\307\310\"!#\207" [define-key characterp 65 90 97 122 vector logxor 32] 10 "\n\n(fn M C K X)"] keymapp] 19 (#$ . 13046)])
#@25 The calculator key map.
(defvar calculator-mode-map (byte-code "\304 \305\306\"\210\307\211\203/ \211@\310A!\211\203' \211@\311@#\210A\266\202\202 \210A\266\202\202 \210\203C \311\312\313#\210\311\314\313#\210\202I \311\315\313#\210 \204S \311\316\317#\210\n\203U\320\321!\204U\322\323\324\"\325\326\327!\210\330\321\331\332\333\334\335\336\334\337\340\334\341\342\343\"\344\345\"\346\347\350\"\351\352\"\353\354\"\355\356\"\357\360\361\"\362\363\"\364\365\"\366\367\"\370\371\"\372\373\"\374 \375\376\" \377\201@ \" \201A \201B \" \201C \201D \"\257\201E \201F \201G \201H \201I \201J \334\201K \201L \"\201M \201N \"\257 \201O \201P \201Q \201R \334\201S \322\201T \"\201U \201S \322\201V \"\201W \322\201X \"#BC\"BBBB\201Y \201S \322\201Z \"\201[ \"B\201\\ BBBBBBBBBBBBBB$\266\211\207" [calculator-bind-escape window-system calculator-use-menu calculator-displayers make-sparse-keymap suppress-keymap t ((calculator-digit "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "a" "b" "c" "d" "f" "<kp-0>" "<kp-1>" "<kp-2>" "<kp-3>" "<kp-4>" "<kp-5>" "<kp-6>" "<kp-7>" "<kp-8>" "<kp-9>") (calculator-open-paren "[") (calculator-close-paren "]") (calculator-op-or-exp "+" "-" "<kp-add>" "<kp-subtract>") (calculator-op "<kp-divide>" "<kp-multiply>") (calculator-decimal "." "<kp-decimal>") (calculator-exp "e") (calculator-dec/deg-mode "D") (calculator-set-register "s") (calculator-get-register "g") (calculator-radix-mode "H" "X" "O" "B") (calculator-radix-input-mode "iD" "iH" "iX" "iO" "iB") (calculator-radix-output-mode "oD" "oH" "oX" "oO" "oB") (calculator-rotate-displayer "'") (calculator-rotate-displayer-back "\"") (calculator-displayer-prev "{") (calculator-displayer-next "}") (calculator-saved-up "<up>" "C-p") (calculator-saved-down "<down>" "C-n") (calculator-quit "q" "C-g") (calculator-enter "<enter>" "<linefeed>" "<kp-enter>" "<return>" "RET" "LFD") (calculator-save-on-list "SPC" "<space>") (calculator-clear-saved "C-c" "<C-delete>") (calculator-save-and-quit "<C-return>" "<C-kp-enter>") (calculator-paste "<insert>" "<S-insert>" "<paste>" "<mouse-2>" "C-y") (calculator-clear "<delete>" "DEL" "C-d") (calculator-help "h" "?" "<f1>" "<help>") (calculator-copy "<C-insert>" "<copy>") (calculator-backspace "<backspace>")) reverse calculator-define-key "ESC" calculator-quit "<escape>" "ESC ESC ESC" "C-h" calculator-backspace boundp calculator-menu mapcar #[257 "\300@\301\3028D\303\304\305\3028\306\307\310\311\312\fA@DE\310\313\312
A@DEE&\300@\314P\315\3028D\305\316\3028\227P\303\304\306\310\311\312\fA@DE&\300@\317P\320\3028D\305\321\3028\227P\303\304\306\310\313\312
A@DE&E\207" [vector calculator-radix-mode 2 :style radio :keys :selected and eq calculator-input-radix quote calculator-output-radix " Input" calculator-radix-input-mode "i" " Output" calculator-radix-output-mode "o"] 15 "\n\n(fn X)"] (("Decimal" nil "D") ("Binary" bin "B") ("Octal" oct "O") ("Hexadecimal" hex "H")) #[514 "\300\301D\302$\207" [vector calculator-op :keys] 7 "\n\n(fn NAME KEY)"] (lambda (#1=#:def-tmp-var) (defvar calculator-menu #1# #2="Calculator menu.")) nil easy-menu-do-define #2# "Calculator" ["Help" (let ((last-command 'calculator-help)) (calculator-help)) :keys "?"] "---" ["Copy" calculator-copy] ["Paste" calculator-paste] ["Electric mode" (progn (calculator-quit) (setq calculator-restart-other-mode t) (run-with-timer 0.1 nil (lambda nil (message nil))) (calculator)) :active (not calculator-electric-mode)] ["Normal mode" (progn (setq calculator-restart-other-mode t) (calculator-quit)) :active calculator-electric-mode] "Functions" "Repeat-right" ">" "Repeat-left" "<" "------General------" "Reciprocal" ";" "Log" "L" "Square-root" "Q" "Factorial" "!" "------Trigonometric------" "Sinus" "S" "Cosine" "C" "Tangent" "T" "Inv-Sinus" "IS" "Inv-Cosine" "IC" "Inv-Tangent" "IT" "------Bitwise------" "Or" "|" "Xor" "#" "And" "&" "Not" "~" "Saved List" ["Eval+Save" calculator-save-on-list] ["Prev number" calculator-saved-up] ["Next number" calculator-saved-down] ["Delete current" calculator-clear :active (and calculator-display-fragile calculator-saved-list (= (car calculator-stack) (nth calculator-saved-ptr calculator-saved-list)))] ["Delete all" calculator-clear-saved] "List-total" "l" "List-average" "v" ("Registers" ["Get register" calculator-get-register] ["Set register" calculator-set-register]) "Modes" ["Radians" (progn (when (or calculator-input-radix calculator-output-radix) (calculator-radix-mode "D")) (when calculator-deg (calculator-dec/deg-mode))) :keys "D" :style radio :selected (not (or calculator-input-radix calculator-output-radix calculator-deg))] ["Degrees" (progn (when (or calculator-input-radix calculator-output-radix) (calculator-radix-mode "D")) (unless calculator-deg (calculator-dec/deg-mode))) :keys "D" :style radio :selected (and calculator-deg (not (or calculator-input-radix calculator-output-radix)))] append car "Separate I/O" #[257 "\211A@\207" [] 2 "\n\n(fn X)"] ("---") #[257 "\3008\207" [2] 3 "\n\n(fn X)"] "Decimal Display" #[257 "\300A@\301\302DD\"\207" [vector calculator-rotate-displayer quote] 6 "\n\n(fn D)"] ("---" ["Change Prev Display" calculator-displayer-prev] ["Change Next Display" calculator-displayer-next]) ("---" ["Copy+Quit" calculator-save-and-quit] ["Quit" calculator-quit])] 38) (#$ . 13728))
(defvar calculator-mode-hook nil)
(byte-code "\300\301N\204\f \302\300\301\303#\210\304\305!\204 \302\305\306\307#\210\300\207" [calculator-mode-hook variable-documentation put "Hook run after entering Calculator mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp calculator-mode-map definition-name calculator-mode] 4)
(defvar calculator-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204 \303\301\302\304\305!#\210\306\307!\204 \303\307\310\311#\210\312\313 !\210\307\302N\204- \303\307\302\304\314!#\210\306\300!\204B \303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P \303\300\302\304\320!#\210\303\311\321\317#\207" [calculator-mode-abbrev-table calculator-mode-map variable-documentation put purecopy "Keymap for `calculator-mode'." boundp calculator-mode-syntax-table definition-name calculator-mode (lambda (#1=#:def-tmp-var) (defvar calculator-mode-syntax-table #1#)) make-syntax-table "Syntax table for `calculator-mode'." (lambda (#1#) (defvar calculator-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `calculator-mode'." derived-mode-parent] 5)
#@4783 A [not so] simple calculator for Emacs.
This calculator is used in the same way as other popular calculators
like xcalc or calc.exe -- but using an Emacs interface.
Expressions are entered using normal infix notation, parens are used as
normal. Unary functions are usually postfix, but some depends on the
value of `calculator-unary-style' (if the style for an operator below is
specified, then it is fixed, otherwise it depends on this variable).
`+' and `-' can be used as either binary operators or prefix unary
operators. Numbers can be entered with exponential notation using `e',
except when using a non-decimal radix mode for input (in this case `e'
will be the hexadecimal digit).
Here are the editing keys:
* `RET' `=' evaluate the current expression
* `C-insert' copy the whole current expression to the `kill-ring'
* `C-return' evaluate, save result the `kill-ring' and exit
* `insert' paste a number if the one was copied (normally)
* `delete' `C-d' clear last argument or whole expression (hit twice)
* `backspace' delete a digit or a previous expression element
* `h' `?' pop-up a quick reference help
* `ESC' `q' exit (`ESC' can be used if `calculator-bind-escape' is
non-nil, otherwise use three consecutive `ESC's)
These operators are pre-defined:
* `+' `-' `*' `/' the common binary operators
* `\' `%' integer division and remainder
* `_' `;' postfix unary negation and reciprocal
* `^' `L' binary operators for x^y and log(x) in base y
* `Q' `!' unary square root and factorial
* `S' `C' `T' unary trigonometric operators: sin, cos and tan
* `|' `#' `&' `~' bitwise operators: or, xor, and, not
The trigonometric functions can be inverted if prefixed with an `I', see
below for the way to use degrees instead of the default radians.
Two special postfix unary operators are `>' and `<': whenever a binary
operator is performed, it is remembered along with its arguments; then
`>' (`<') will apply the same operator with the same right (left)
argument.
hex/oct/bin modes can be set for input and for display separately.
Another toggle-able mode is for using degrees instead of radians for
trigonometric functions.
The keys to switch modes are (both `H' and `X' are for hex):
* `D' switch to all-decimal mode, or toggle degrees/radians
* `B' `O' `H' `X' binary/octal/hexadecimal modes for input & display
* `i' `o' followed by one of `D' `B' `O' `H' `X' (case
insensitive) sets only the input or display radix mode
The prompt indicates the current modes:
* "==": decimal mode (using radians);
* "D=": decimal mode using degrees;
* "?=": ? is B/O/H, the radix for both input and output;
* "=?": ? is B/O/H, the display radix (with decimal input);
* "??": ? is D/B/O/H, 1st char for input radix, 2nd for display.
Also, the quote key can be used to switch display modes for decimal
numbers (double-quote rotates back), and the two brace characters
("{" and "}" change display parameters that these displayers use,
if they handle such). If output is using any radix mode, then these
keys toggle digit grouping mode and the chunk size.
Values can be saved for future reference in either a list of saved
values, or in registers.
The list of saved values is useful for statistics operations on some
collected data. It is possible to navigate in this list, and if the
value shown is the current one on the list, an indication is displayed
as "[N]" if this is the last number and there are N numbers, or
"[M/N]" if the M-th value is shown.
* `SPC' evaluate the current value as usual, but also adds
the result to the list of saved values
* `l' `v' computes total / average of saved values
* `up' `C-p' browse to the previous value in the list
* `down' `C-n' browse to the next value in the list
* `delete' `C-d' remove current value from the list (if it is on it)
* `C-delete' `C-c' delete the whole list
Registers are variable-like place-holders for values:
* `s' followed by a character attach the current value to that character
* `g' followed by a character fetches the attached value
There are many variables that can be used to customize the calculator.
Some interesting customization variables are:
* `calculator-electric-mode' use only the echo-area electrically.
* `calculator-unary-style' set most unary ops to pre/postfix style.
* `calculator-user-registers' to define user-preset registers.
* `calculator-user-operators' to add user-defined operators.
See the documentation for these variables, and "calculator.el" for
more information.
\{calculator-mode-map}
This mode runs the hook `calculator-mode-hook', as the final or penultimate step
during initialization.
(defalias 'calculator-mode #[0 "\306\300!\210\307\310 \210\311\312\313 !\210\314\f!\210
)\315\316!\207" [delay-mode-hooks major-mode mode-name calculator-mode-map calculator-mode-syntax-table calculator-mode-abbrev-table make-local-variable t kill-all-local-variables calculator-mode "Calculator" use-local-map set-syntax-table run-mode-hooks calculator-mode-hook local-abbrev-table] 2 (#$ . 20282) nil])
#@93 Run the Emacs calculator.
See the documentation for `calculator-mode' for more information.
(defalias 'calculator #[0 "\203 ?\n\203 \306\n!\210\307\306 !\210\310\311! \203u \312 \313\314\315\316\317!\320\"\321$\216\322\323!\210\324\307!\210\325\326 !\314\307 /\327\326 \f\"\210\330\326 !\210\331 \210\332 \210\3330!\210\334\335!\210\313\314\336\316\317!\337\"\340$\216\3412m \342\341\343\307\344$0\210+\210)\210\202\256 \345\f!\204\225 \321 1\330\346\347 \203\211 \350\202\212 \351!!\210\352\f!\210)\202\241 p\f=\204\241 \330\345\f!!\210\353 \210\3542\331 \210\324\355!\210\205\270 \205\270 \356 \207" [calculator-restart-other-mode calculator-electric-mode calculator-initial-operators calculator-user-operators calculator-buffer garbage-collection-messages calculator-add-operators nil get-buffer-create "*calculator*" current-window-configuration make-byte-code 0 "\301\300!\207" vconcat vector [set-window-configuration] 2 require electric message window-buffer minibuffer-window set-window-buffer select-window calculator-reset calculator-update-display use-local-map run-hooks calculator-mode-hook "\302\303 \300\"\210\304 !\207" [calculator-buffer set-window-buffer minibuffer-window kill-buffer] 3 calculator-done Electric-command-loop #[0 "\300\207" [noprompt] 1] #[514 "\300 \207" [calculator-update-display] 3 "\n\n(fn X Y)"] get-buffer-window split-window-below calculator-need-3-lines -3 -2 switch-to-buffer calculator-mode t "Hit `?' For a quick help screen." calculator echo-keystrokes calculator-mode-map window-min-height buffer-read-only] 8 (#$ . 25480) nil])
(defalias 'calculator-need-3-lines #[0 "\300\301\302\"\300\303\302\"\250\203 \211\250\203 \211W\206& \211\247\205& \211\250?\205& \211\304W?\205j \250\203: \211\250\203: \211V\206j \211\247\203J \211\250\204J \211\304V\206j \300\303\305\"\306\307\"\205^ \211?\206^ \211\310V\266\202\206j \300\303\311\"\312>?\207" [face-attribute default :height mode-line 1 :box plist-get :line-width 0 :overline (nil unspecified)] 6])
#@80 Same as `message', but also handle electric mode.
(fn STRING &rest ARGUMENTS)
(defalias 'calculator-message #[385 "\301\302#\210\205 \303\304!\210\302\305!\207" [calculator-electric-mode apply message sit-for 1 nil] 6 (#$ . 27506)])
#@111 Return OP's arity.
Current results are one of 2 (binary), +1 (postfix), -1 (prefix), or
0 (nullary).
(fn OP)
(defalias 'calculator-op-arity #[257 "\3018\211\247\203\f \211\202 \302=\203 \303\202 \304\207" [calculator-unary-style 3 postfix 1 -1] 4 (#$ . 27751)])
#@92 Return OP's precedence for reducing when inserting into the stack.
Defaults to 1.
(fn OP)
(defalias 'calculator-op-prec #[257 "\3008\206 \301\207" [4 1] 3 (#$ . 28025)])
#@188 This function handles operator addition.
Adds MORE-OPS to `calculator-operator', called initially to handle
`calculator-initial-operators' and `calculator-user-operators'.
(fn MORE-OPS)
(defalias 'calculator-add-operators #[257 "\302\211\203. \211@\211@\303=\204 \304@\305#\210\211@\303=\203\" \211A\202# \211B\262A\266\202\202 \210\306\237 \"\211\207" [calculator-mode-map calculator-operators nil nobind calculator-define-key calculator-op append] 8 (#$ . 28205)])
#@29 Reset calculator variables.
(defalias 'calculator-reset #[0 "\204\f \305\211\305\211\305\306 \207" [calculator-restart-other-mode calculator-stack calculator-curnum calculator-stack-display calculator-display-fragile nil calculator-update-display] 2 (#$ . 28689)])
#@76 Return a string to display.
The result should not exceed the screen width.
(defalias 'calculator-get-display #[0 "\205 \306\307 \"@!\n\205 \306\307\n \"@!\310 \204 \2038 \206% \311\232\203/ \311\2024 \2064 \312P\202A \f\203@ \313\202A \314\"
A\203P \315P\202b G\316U\203a \203a \317\202b \320P\321GG\316\322 [$\323X\203x \202| \324\"P\207" [calculator-input-radix calculator-char-radix calculator-output-radix calculator-prompt calculator-deg calculator-stack-display char-to-string rassq format "=" "D" "D=" "==" "_" 1 nil "?" + window-width 0 substring calculator-curnum calculator-stack calculator-display-fragile] 9 (#$ . 28966)])
#@98 Convert the given STR to a number, according to the value of
`calculator-input-radix'.
(fn STR)
(defalias 'calculator-string-to-number #[257 "\203
\301\302\236A@\"\207\303\304\305#\303\306\307#\301!\207" [calculator-input-radix string-to-number ((bin 2) (oct 8) (hex 16)) replace-regexp-in-string "\\.\\([^0-9].*\\)?$" ".0\\1" "[eE][+-]?\\([^0-9].*\\)?$" "e0\\1"] 6 (#$ . 29633)])
#@62 Push the numeric value of the displayed number to the stack.
(defalias 'calculator-push-curnum #[0 "\205
\302! B\303\211\207" [calculator-curnum calculator-stack calculator-string-to-number nil] 2 (#$ . 30028)])
#@232 Switch to the next displayer on the `calculator-displayers' list.
Can be called with an optional argument NEW-DISP to force rotation to
that argument.
If radix output mode is active, toggle digit grouping.
(fn &optional NEW-DISP)
(defalias 'calculator-rotate-displayer #[256 "\203 ?\303\304 \203 \305\202 \306\"\210\202O \211\203@ \211\n>\203@ \307\n@=\2045 \n\211A\242B\262\202\" \n\237\244\211\262\202F \nA\n@C\244\303\310\n@A@\"\210\311 \207" [calculator-output-radix calculator-radix-grouping-mode calculator-displayers calculator-message "Digit grouping mode %s." "ON" "OFF" nil "Using %s." calculator-enter] 4 (#$ . 30252) nil])
#@116 Like `calculator-rotate-displayer', but rotates modes back.
If radix output mode is active, toggle digit grouping.
(defalias 'calculator-rotate-displayer-back #[0 "\301\302!@!\207" [calculator-displayers calculator-rotate-displayer last] 3 (#$ . 30909) nil])
#@208 Send the current displayer function a `left' argument.
This is used to modify display arguments (if the current displayer
function supports this).
If radix output mode is active, increase the grouping size.
(defalias 'calculator-displayer-prev #[0 "\203\n T\303 \207\n@\205. \n@@\2119\203 \211\304!\202, \211:\205, \211@\305=\205, \306\304!\262\207" [calculator-output-radix calculator-radix-grouping-digits calculator-displayers calculator-enter left std calculator-standard-displayer] 3 (#$ . 31176) nil])
#@209 Send the current displayer function a `right' argument.
This is used to modify display arguments (if the current displayer
function supports this).
If radix output mode is active, decrease the grouping size.
(defalias 'calculator-displayer-next #[0 "\203\f \303 S]\304 \207\n@\2050 \n@@\2119\203 \211\305!\202. \211:\205. \211@\306=\205. \307\305!\262\207" [calculator-output-radix calculator-radix-grouping-digits calculator-displayers 2 calculator-enter right std calculator-standard-displayer] 3 (#$ . 31696) nil])
#@145 Get a number string NUMSTR and remove unnecessary zeros.
The behavior of this function is controlled by
`calculator-remove-zeros'.
(fn NUMSTR)
(defalias 'calculator-remove-zeros #[257 "\301=\204\n \211\202 \302\303\304#\204 \211\202 \302\305\306#\207" [calculator-remove-zeros t replace-regexp-in-string "\\.0+\\([eE].*\\)?$" "\\1" "\\(\\..[0-9]*?\\)0+\\([eE].*\\)?$" "\\1\\2"] 6 (#$ . 32225)])
#@184 Return the input string STR with occurrences of SEP that separate
every N characters starting from the right, or from the left if
FROMLEFT is true.
(fn STR N SEP &optional FROMLEFT)
(defalias 'calculator-groupize-number #[1027 "G\211\245\246?\206 \211\300U?\205 \301Z\"C\300V\203E _\203. \211\2021 \211\\\301\n Z#B\266\203S\262\202 \204Y \300V\203Y \301\300#B\262\302\303#\207" [0 substring mapconcat identity] 14 (#$ . 32635)])
#@579 Standard display function, used to display NUM.
Its behavior is determined by `calculator-number-digits' and the given
CHAR argument (both will be used to compose a format string). If the
char is "n" then this function will choose one between %f or %e, this
is a work around %g jumping to exponential notation too fast.
It will also split digit sequences into comma-separated groups
and/or remove redundant zeros.
The special `left' and `right' symbols will make it change the current
number of digits displayed (`calculator-number-digits').
(fn NUM &optional CHAR GROUP-P)
(defalias 'calculator-standard-displayer #[769 "9\203 \302\267\202 \303V\205 S\304 \207T\304 \207\305\207\306=\203D \307!\303W\2034 \211\310W\204: \311W\203> \312\202? \313\262\202E \314\315#\316\314\"!\203e \317\305\320\321#)\266\203\203i \211\202~ \322\323\324\325\326\327\330!\331\"\332\333%\305\211\334&\207" [calculator-number-digits inhibit-changing-match-data #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (left 11 right 23)) 0 calculator-enter nil 110 abs 0.001 100000000.0 101 102 format "%%.%s%c" calculator-remove-zeros "[eE]" t string-match replace-regexp-in-string "\\([0-9]+\\)\\(?:\\..*\\|$\\)" make-byte-code 257 "\301\302\303\300\"\304\305#\207" vconcat vector [calculator-groupize-number match-string 1 3 ","] 5 "\n\n(fn _)" 1] 14 (#$ . 33107)])
#@232 Display NUM in engineering notation.
The number of decimal digits used is controlled by
`calculator-number-digits', so to change it at runtime you have to use
the `left' or `right' when one of the standard modes is used.
(fn NUM)
(defalias 'calculator-eng-display #[257 "\2119\203/ \211\304\267\202- \203 T\202 \305\306\307 )\207\203% S\202& \310\306\307 )\207\311\207\312\312U\204\232 \313!\314W\203K \315_\262\211\316Z\262\2026 \313!\317V\203` \320\245\262\211\316\\\262\202K \203\232 \312U\204\232 \211\312V\203\202 \321_\262\316Z\262\211S\262\202k \211\312W\203\231 \322\245\262\316\\\262\211T\262\202\202 \210 \204\240 \311\323\211\324\n\"\" \205\254 \325\303!)\326\327!Q\262\207" [calculator-eng-extra calculator-eng-tmp-show calculator-number-digits calculator-remove-zeros #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (left 11 right 28)) 1 t calculator-enter -1 nil 0 abs 1.0 1000.0 3 999.0 1000.0 1000.0 1000.0 format "%%.%sf" x "e" number-to-string] 7 (#$ . 34526)])
#@48 Convert NUM to a displayable string.
(fn NUM)
(defalias 'calculator-number-to-string #[257 "\211\247\204\f \306A@\307\"\207\310!\203 \311!\203 \312\207\313X\203\" \314\207\211\315X\203* \316\207\203\216 \317=\2038 \320\2029 \321 \203A \202D \322!\323\324!\"\325\326=\204U \202m \327\330\331\332\333\334\335\336\337\340\341 !\342\"\343\344%\"\"#\n\204u \211\202z \345 \f# \204\205 \346Y\203\211 \211\202\214 \347P\226\207
;\203\230 \323
\"\207
9\203\241
!\207
\242\350=\203\257 \332\351
A#\207
<\203\301 \352\353\354\355DDC
E\307\"\207\306\307\"\207" [calculator-output-radix calculator-2s-complement calculator-radix-grouping-mode calculator-radix-grouping-digits calculator-radix-grouping-separator calculator-displayer prin1-to-string t floatp isnan "NaN" 1.0e+INF "Inf" -1.0e+INF "-Inf" hex "%x" "%o" abs format truncate ((48 "000") (49 "001") (50 "010") (51 "011") (52 "100") (53 "101") (54 "110") (55 "111")) bin replace-regexp-in-string "^0+\\(.\\)" "\\1" apply concat mapcar make-byte-code 257 "\211\300\236A@\207" vconcat vector [] 3 "\n\n(fn C)" calculator-groupize-number 0 "-" std calculator-standard-displayer eval let num quote] 17 (#$ . 35588)])
#@111 Update the display.
If optional argument FORCE is non-nil, don't use the cached string.
(fn &optional FORCE)
(defalias 'calculator-update-display #[256 "q\210\211\204 @\n=\204f \n\211\203c \203$ \nG\306U\203$ @@\202% \f \307\310\311\n!\312#)\312
\205_ \205_ \n@8=\205_ \313U\203S \314\315G\"\202_ \314\316GZG#Q\202d \317B\320 \321 \210\322 c\210)\323\324!\210
\203\200 GT\202\202 `Sb\207" [calculator-buffer calculator-stack-display calculator-stack calculator-displayers calculator-displayer calculator-display-fragile 1 mapconcat calculator-number-to-string reverse " " 0 format "[%s]" "[%s/%s]" "" t erase-buffer calculator-get-display set-buffer-modified-p nil calculator-saved-list calculator-saved-ptr inhibit-read-only calculator-prompt] 8 (#$ . 36783)])
#@50 Worker for `calculator-reduce-stack'.
(fn PREC)
(defalias 'calculator-reduce-stack-once #[257 "\301\302\303\304\305:\205\205@\211:\203V\211A\211:\203\336\211@\211\306=\203aA\211:\203F\211@\211\247\203*A\211:\203\367 \211@\211:\203\304 \211A\211:\203\217 \211@\211\307=\203Z A\211\211B\266\202\262\202\212
\310 #\203r
\f$\202\212
\311 #\203\211 \n
#\202\212 \312\262\202\277 \f\310\n#\203\247 \f $\202\277 \f\311\n#\203\276 \f\n#\202\277 \312\262\202\362
\310 #\203\333 \n$\202\362
\311 #\203\361 #\202\362 \312\262\202%\n\f\310#\203\n $\202%\n\f\311#\203$\n#\202%\312\262\202A \311#\203@ #\202A\312\262\202\\\n\311#\203[#\202\\\312\262\202\331 \310#\203\300A\211:\203\245\211@\211\247\203\211A\n $\262\202\240 \311#\203\237 #\202\240\312\262\202\273\n\311#\203\272#\202\273\312\262\202\331 \311#\203\330A#\262\202\331\312\262\202Q\310#\2039A\211:\203 \211@\211\247\203A $\262\202\n\311#\203#\202\312\262\2024 \311#\2033#\2024\312\262\202Q\311#\203PA#\262\202Q\312\262\202\203\211\247\203A\211:\203\373\211@ \313#\203A\211:\203\n\211@\211\247\203\222A\211
#B\266\204\262\202 \314#\203\250 $\202 \310#\203\335\247\203\303 $\202 \311#\203\331 #\202\312\202 \311#\203\363 #\202\247\203\211B\266\203\202\312\262\202z\n\314#\203 $\202z\n\310#\203T\247\203;$\202z\n\311#\203P#\202z\312\202z\n\311#\203i#\202z\247\203y\211\211B\266\203\202z\312\262\202\366 \314#\203\231A$\262\202\366 \310#\203\316\211\247\203\267A$\262\202\366 \311#\203\312#\202\366\312\202\366 \311#\203\341#\202\366\211\247\203\365A\211\211B\266\203\262\202\366\312\262\202\311#\203#\202\312\262\202\203\310#\203lA\211:\203S\211@\211\247\203:A$\262\202N \311#\203M#\202N\312\262\202g\311#\203f#\202g\312\262\202\203\311#\203\202A#\262\202\203\312\262\266\203\207" [calculator-stack #[771 "\211<\205 \300!X\205 \301!U\207" [calculator-op-prec calculator-op-arity] 6 "\n\n(fn PREC AR OP)"] #[385 "\300\301\3028#\207" [apply calculator-funcall 2] 6 "\n\n(fn OP &rest ARGS)"] #[1028 "\"B\207" #1=[] 7 "\n\n(fn --CL-CALL-- REST O X)"] #[771 "!B\207" #1# 5 "\n\n(fn --CL-CALL-- REST O)"] #[1028 "\"B\207" #1# 7 "\n\n(fn --CL-CALL-- REST X O)"] \) \( 1 0 nil 2 -1] 20 (#$ . 37577)])
#@136 Reduce the stack using top operators as long as possible.
PREC is a precedence -- reduce everything with higher precedence.
(fn PREC)
(defalias 'calculator-reduce-stack #[257 "\301\302!\211\262\205 \211\202 \207" [calculator-stack nil calculator-reduce-stack-once] 4 (#$ . 40320)])
#@137 If F is a symbol, evaluate (F X Y).
Otherwise, it should be a list, evaluate it with X, Y bound to the
arguments.
(fn F &optional X Y)
(defalias 'calculator-funcall #[769 "\211\203 E9\203& \203 \211\203 \"\207\203# !\207 \207\205- \303!\2054 \303!\203B \203B \304_\202C \n\305\306D\307BB\310\311\312\313\314E\315\316ED\317\320\fD\321\fD\322\nD\323
D\324
D\325\306
DD\257
EE\326\"\207" [calculator-last-opXY calculator-deg calculator-saved-list calculator-truncate 0.017453292519943295 calculator-funcall quote (x y) (if calculator-deg (radians-to-degrees x) x) eval cl-flet F (&optional x y) D (x) let X Y DX TX TY L t] 21 (#$ . 40615)])
#@177 Return the last key sequence that was used to invoke this command, or
the input KEYS. Uses the `function-key-map' translate keypad numbers to
plain ones.
(fn &optional KEYS)
(defalias 'calculator-last-input #[256 "\211\206 \301 \302!\203 \211;\204 \303\"\206 \211\211\203R \211;\204R \302!\203R \3042O \211G\305\211W\203K \211\306H!\204C \307\304\310\"\210\210\211T\262\202/ \266\3110\203V \211\202Y \211\260\207" [function-key-map this-command-keys arrayp lookup-key done 0 characterp throw t nil] 9 (#$ . 41297)])
#@131 Clear the fragile flag if it was set, then maybe reset all.
OP is the operator (if any) that caused this call.
(fn &optional OP)
(defalias 'calculator-clear-fragile #[256 "\203 \211\203 \301!\302>\203 \303 \210\304\211\207" [calculator-display-fragile calculator-op-arity (-1 0) calculator-reset nil] 3 (#$ . 41836)])
#@23 Enter a single digit.
(defalias 'calculator-digit #[0 "\304 \305H\204 @\247?\205@ \211\n\204 \306\202' \n\307\267\202& \310\202' \311\202' \312X\205@ \313 \210 \314\232\2038 \315\2029 \226CP\316 \207" [calculator-display-fragile calculator-stack calculator-input-radix calculator-curnum calculator-last-input 0 57 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (bin 30 oct 34)) 49 55 999 calculator-clear-fragile "0" "" calculator-update-display] 4 (#$ . 42167) nil])
#@25 Enter a decimal period.
(defalias 'calculator-decimal #[0 "?\2052 \204 \n@\247?\2052 \205! \305 \306\307 \310#)\266\203?\2052 \311 \210 \206- \312\313P\314 \207" [calculator-input-radix calculator-display-fragile calculator-stack calculator-curnum inhibit-changing-match-data "[.eE]" nil t string-match calculator-clear-fragile "0" "." calculator-update-display] 7 (#$ . 42686) nil])
#@55 Enter an exponent, or an "E" digit in hex input mode.
(defalias 'calculator-exp #[0 "\203 \305 \207 \204 \n@\247?\2054 \205# \306 \307\310 \311#)\266\203?\2054 \312 \210 \206/ \313\314P\315 \207" [calculator-input-radix calculator-display-fragile calculator-stack calculator-curnum inhibit-changing-match-data calculator-digit "[eE]" nil t string-match calculator-clear-fragile "1" "e" calculator-update-display] 7 (#$ . 43084) nil])
#@157 Enter an operator on the stack, doing all necessary reductions.
Optional string argument KEYS will force using it as the keys entered.
(fn &optional KEYS)
(defalias 'calculator-op #[256 "\3062\303 \307!\310\"\311!\210\312 \210\313!\314U\203> @\247\204> \310>A\"\262\211\2035 \313!\315U\204> \316\317!\210\320\306\321\"\210\322A@\323=\203K \324\202Z A@\325=\203W \326\202Z \327!!\210 @\247\313!\211\330\267\202q \202r ?\202r \321\262\262\203\202 \316\331!\210\320\306\321\"\210\211 B\322\327!!\210 G\332U\203\276 @\247\203\276 \333 \203\276 @\f\211\326X\203\261
\233B\202\274 \211S
\233
\233B\241\210\266\334 \266\2020\207" [calculator-operators calculator-stack calculator-display-fragile calculator-add-saved calculator-saved-ptr calculator-saved-list op-error calculator-last-input assoc calculator-clear-fragile calculator-push-curnum calculator-op-arity 2 -1 calculator-message "Binary operator without a first operand" throw nil calculator-reduce-stack \( 10 \) 0 calculator-op-prec #s(hash-table size 3 test eql rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (-1 104 2 108 1 108)) "Incomplete expression" 1 t calculator-update-display] 9 (#$ . 43533) nil])
#@185 Either enter an operator or a digit.
Used with +/- for entering them as digits in numbers like 1e-3 (there is
no need for negative numbers since these are handled by unary
operators).
(defalias 'calculator-op-or-exp #[0 "\204 \204 \n\203 \304\n\305\306\307#)\266\203\203 \310 \207\311 \207" [calculator-input-radix calculator-display-fragile calculator-curnum inhibit-changing-match-data "[eE]$" nil t string-match calculator-digit calculator-op] 7 (#$ . 44744) nil])
#@68 Set decimal mode for display & input, if decimal, toggle deg mode.
(defalias 'calculator-dec/deg-mode #[0 "\303 \210\204 \203 \304\211\202 \n?\305\306!\207" [calculator-input-radix calculator-output-radix calculator-deg calculator-push-curnum nil calculator-update-display t] 3 (#$ . 45228) nil])
#@128 Set input and display radix modes.
Optional string argument KEYS will force using it as the keys entered.
(fn &optional KEYS)
(defalias 'calculator-radix-mode #[256 "\300!\210\301!\207" [calculator-radix-input-mode calculator-radix-output-mode] 3 (#$ . 45540) nil])
#@116 Set input radix modes.
Optional string argument KEYS will force using it as the keys entered.
(fn &optional KEYS)
(defalias 'calculator-radix-input-mode #[256 "\302 \210\303!\211GSH\226\236A\262\304 \207" [calculator-char-radix calculator-input-radix calculator-push-curnum calculator-last-input calculator-update-display] 4 (#$ . 45816) nil])
#@118 Set display radix modes.
Optional string argument KEYS will force using it as the keys entered.
(fn &optional KEYS)
(defalias 'calculator-radix-output-mode #[256 "\302 \210\303!\211GSH\226\236A\262\304\305!\207" [calculator-char-radix calculator-output-radix calculator-push-curnum calculator-last-input calculator-update-display t] 4 (#$ . 46173) nil])
#@67 Evaluate current expression, put result on the saved values list.
(defalias 'calculator-save-on-list #[0 "\301\302 )\207" [calculator-add-saved t calculator-enter] 1 (#$ . 46539) nil])
#@60 Clear the list of saved values in `calculator-saved-list'.
(defalias 'calculator-clear-saved #[0 "\302\303\304\305!\207" [calculator-saved-list calculator-saved-ptr nil 0 calculator-update-display t] 2 (#$ . 46731) nil])
#@52 Go N elements up the list of saved values.
(fn N)
(defalias 'calculator-saved-move #[257 "\205* \203\f \n\205* \211 \\G^\304]\2118\203% 8C\305\202( \306 \210\307 \207" [calculator-saved-list calculator-stack calculator-display-fragile calculator-saved-ptr 0 t calculator-reset calculator-update-display] 4 (#$ . 46960) nil])
#@33 Go up the list of saved values.
(defalias 'calculator-saved-up #[0 "\300\301!\207" [calculator-saved-move 1] 2 (#$ . 47301) nil])
#@35 Go down the list of saved values.
(defalias 'calculator-saved-down #[0 "\300\301!\207" [calculator-saved-move -1] 2 (#$ . 47437) nil])
#@30 Equivalents of `(' use this.
(defalias 'calculator-open-paren #[0 "\300\301!\207" [calculator-op "("] 2 (#$ . 47578) nil])
#@30 Equivalents of `)' use this.
(defalias 'calculator-close-paren #[0 "\300\301!\207" [calculator-op ")"] 2 (#$ . 47707) nil])
#@30 Evaluate current expression.
(defalias 'calculator-enter #[0 "\300\301!\207" [calculator-op "="] 2 (#$ . 47837) nil])
#@52 Backward delete a single digit or a stack element.
(defalias 'calculator-backspace #[0 "\203 G\302V\205 \303\304GS#\202 A\305 \207" [calculator-curnum calculator-stack 1 substring 0 calculator-update-display] 4 (#$ . 47961) nil])
#@23 Clear current number.
(defalias 'calculator-clear #[0 "\306 \203? \n\203? @\f\n8U\203? \f\307U\203 \nA\202- \fS\n\233\211AA\241\210\fS\210\n\2039 \f\n8C\202M \310 \210\202M \204J
\n=\203M \310 \210\311 \207" [calculator-curnum calculator-display-fragile calculator-saved-list calculator-stack calculator-saved-ptr last-command nil 0 calculator-reset calculator-update-display this-command] 3 (#$ . 48207) nil])
#@41 Copy current number to the `kill-ring'.
(defalias 'calculator-copy #[0 "\206 ?\205 \n\304 \210 A\211\205 \305\306\307\310#!\262*\207" [calculator-copy-displayer calculator-displayer calculator-displayers calculator-stack-display calculator-enter kill-new replace-regexp-in-string "^\\([^ ]+\\) *\\(\\[[0-9/]+\\]\\)? *$" "\\1"] 6 (#$ . 48634) nil])
#@83 Paste VAL as if entered.
Used by `calculator-paste' and `get-register'.
(fn VAL)
(defalias 'calculator-put-value #[257 "\211\247\205! \204 @\247?\205! \306 \210\307\310\n \311!+ \312 \207" [calculator-display-fragile calculator-stack calculator-input-radix calculator-output-radix calculator-radix-grouping-mode calculator-displayer calculator-clear-fragile "%S" nil calculator-number-to-string calculator-update-display calculator-curnum] 4 (#$ . 48998)])
#@325 Paste a value from the `kill-ring'.
With a prefix argument, paste the raw string as a sequence of key
presses, which can be used to paste expressions. Note that this
is literal; examples: spaces will store values, pasting "1+2"
will not produce 3 if it's done you're entering a number or after
a multiplication.
(fn ARG)
(defalias 'calculator-paste #[257 "\301\302!\203 \303\304!\"\211\202 \305\306!!\207" [unread-command-events current-kill 0 append listify-key-sequence calculator-put-value calculator-string-to-number] 5 (#$ . 49470) "P"])
#@84 Similar to `register-read-with-preview' but for calculator
registers.
(fn PROMPT)
(defalias 'calculator-register-read-with-preview #[257 "\304\305\306!+\207" [calculator-registers register-preview-function register-preview-delay register-alist 1 #[257 "\300\301\302@!\303A!#\207" [format "%s: %s\n" single-key-description calculator-number-to-string] 6 "\n\n(fn R)"] register-read-with-preview] 4 (#$ . 50029)])
#@41 Set a register value for REG.
(fn REG)
(defalias 'calculator-set-register #[257 "\211\236\302 \210 @\203 \241\210\202 BB\303\304#\207" [calculator-registers calculator-stack calculator-enter calculator-message "[%c] := %S"] 7 (#$ . 50455) (byte-code "\300\301!C\207" [calculator-register-read-with-preview "Register to store value into: "] 2)])
#@44 Get a value from a register REG.
(fn REG)
(defalias 'calculator-get-register #[257 "\301\236A!\207" [calculator-registers calculator-put-value] 4 (#$ . 50819) (byte-code "\300\301!C\207" [calculator-register-read-with-preview "Register to get value from: "] 2)])
#@983 Quick reference:
* numbers/operators/parens/./e - enter expressions
+ - * / \(div) %(rem) _(-X,postfix) ;(1/X,postfix) ^(exp) L(og)
Q(sqrt) !(fact) S(in) C(os) T(an) |(or) #(xor) &(and) ~(not)
* >/< repeats last binary operation with its 2nd (1st) arg as postfix op
* I inverse the next trig function * \='/"/{/} - display/display args
* D - switch to all-decimal, or toggle deg/rad mode
* B/O/H/X - binary/octal/hex mode for i/o (both H and X are for hex)
* i/o - prefix for D/B/O/X - set only input/output modes
* enter/= - evaluate current expr. * s/g - set/get a register
* space - evaluate & save on list * l/v - list total/average
* up/down/C-p/C-n - browse saved * C-delete - clear all saved
* C-insert - copy whole expr. * C-return - evaluate, copy, exit
* insert - paste a number * backspace- delete backwards
* delete - clear argument or list value or whole expression (twice)
* escape/q - exit.
(defalias 'calculator-help #[0 "\306=\203( \307\310\311 \312\313!\210 \204 \314 \210\202 \315 \210\316!\210\317\320!*\207\321\322!\311 \323\324!\325 \326\327\330\331\332!\333\"\334$\216\fr\323\324!q\210p\335 \210\320\211+\322\211,\322 - .\336 \210\337\340!\210+\211 /\341\342\306!!\210\343!\210)\266\203{ \344\345!!\210\317\346\347 \350#\210\316!\210\351\352!\210)\210\316!\207" [last-command major-mode mode-name calculator-electric-mode default-directory buffer-read-only calculator-help "Calculator" calculator-mode selected-window require ehelp describe-mode electric-describe-mode select-window message nil one-window-p t get-buffer-create "*Help*" current-window-configuration make-byte-code 0 "\301\300!\207" vconcat vector [set-window-configuration] 2 kill-all-local-variables erase-buffer run-hooks temp-buffer-setup-hook princ documentation internal-temp-output-buffer-show shrink-window-if-larger-than-buffer get-buffer-window "`%s' again for more help, %s." calculator-last-input "any other key continues normally" sit-for 360 buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only standard-output] 11 (#$ . 51092) nil])
#@18 Quit calculator.
(defalias 'calculator-quit #[0 "q\210\303\304 \210)\n\204) \3051$ \306!\205 \307\306!!\210\202 0\202( \210\202) \210\310!\210\311\312!\210\n\203: \313\314\315\"\207\315\211\207" [calculator-buffer inhibit-read-only calculator-electric-mode t erase-buffer (error) get-buffer-window delete-window kill-buffer message "Calculator done." throw calculator-done nil] 3 (#$ . 53257) nil])
#@60 Quit the calculator, saving the result on the `kill-ring'.
(defalias 'calculator-save-and-quit #[0 "\300 \210\301 \210\302 \207" [calculator-enter calculator-copy calculator-quit] 1 (#$ . 53670) nil])
#@142 Repeat the last binary operation with its second argument and X.
To use this, apply a binary operator (evaluate it), then call this.
(fn X)
(defalias 'calculator-repR #[257 "\203 \301@\3028#)\207\207" [calculator-last-opXY calculator-funcall 2] 6 (#$ . 53878)])
#@141 Repeat the last binary operation with its first argument and X.
To use this, apply a binary operator (evaluate it), then call this.
(fn X)
(defalias 'calculator-repL #[257 "\203 \301@A@#)\207\207" [calculator-last-opXY calculator-funcall] 5 (#$ . 54155)])
#@59 Compute X^Y, dealing with errors appropriately.
(fn X Y)
(defalias 'calculator-expt #[514 "\3001\n \301\"0\207\210\302!\204 \303\304\"\305U\203 \306\207\307\207" [(overflow-error) expt natnump logand 1 0 1.0e+INF -1.0e+INF] 5 (#$ . 54425)])
#@32 Simple factorial of X.
(fn X)
(defalias 'calculator-fact #[257 "\211\300Y\203 \207\301!\203 \302!\204 \211\303W\203 \304\207\305\306\245\"\307Y\203( \310\207\311!\312\303V\203> \211_\262S\262\202, \207" [1.0e+INF floatp isnan 0 0.0e+NaN calculator-expt 3.0 1.0e+INF 1.0e+INF truncate 1.0] 5 (#$ . 54679)])
#@51 Truncate N, return 0 in case of overflow.
(fn N)
(defalias 'calculator-truncate #[257 "\3001 \301!0\207\210\302\207" [(range-error) truncate 0] 3 (#$ . 55006)])
(provide 'calculator)
Mini Shell