| Current Path : /usr/share/emacs/24.3/lisp/ |
Linux gator3171.hostgator.com 4.19.286-203.ELK.el7.x86_64 #1 SMP Wed Jun 14 04:33:55 CDT 2023 x86_64 |
| Current File : //usr/share/emacs/24.3/lisp/calculator.elc |
;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:06:12 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/calculator.el
;;; in Emacs version 24.3.1
;;; 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\302\315\316\317\310\301&\210\313\320\321\322\316\317\310\301&\210\313\323\302\324\316\317\310\301&\210\313\325\326\327\316\330\310\301&\210\313\331\332\333\316\334\310\301&\210\313\335\336\337\316\340\310\301&\210\313\341\321\342\316\317\310\301&\210\313\343\344\345\316\340\310\301&\210\313\346\347\350\316\334\310\301&\210\313\351\321\352\316\353\310\301&\210\313\354\355\356\310\301%\210\313\357\360\361\316\362\310\301&\210\313\363\321\364\316\317\310\301&\210\313\365\302\366\316\317\310\301&\210\313\367\302\370\316\317\310\301&\210\313\371\302\372\316\373\310\301&\210\313\374\302\375\316\376\377\201@ \310\301& \210\313\201A \302\201B \316\201C \310\301&\207" [custom-declare-group calculator nil "Simple Emacs calculator." :prefix "calculator" :version "21.1" :group tools applications custom-declare-variable calculator-electric-mode "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 t "Make `calculator' create a menu.\nNote that this requires easymenu. Must be set before loading." calculator-bind-escape "If non-nil, set escape to exit the calculator." calculator-unary-style 'postfix "Value is either 'prefix or 'postfix.\nThis determines the default behavior of unary operators." (choice (const prefix) (const postfix)) calculator-prompt "Calc=%s> " "The prompt used by the Emacs calculator.\nIt should contain a \"%s\" somewhere that will indicate the i/o radices;\nthis will be a two-character string as described in the documentation\nfor `calculator-mode'." string calculator-number-digits 3 "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 "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 4 "The number of digits used for grouping display in radix modes.\nSee `calculator-radix-grouping-mode'." calculator-radix-grouping-separator "'" "The separator used in radix grouping display.\nSee `calculator-radix-grouping-mode'." calculator-remove-zeros "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 and if it is nil, nothing is removed.\nUsed by the `calculator-remove-zeros' function." (choice (const t) (const leave-decimal) (const nil)) calculator-displayer '(std 110) "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) where C is a\ncharacter, in this case the `calculator-standard-displayer' function\nwill be used with this character for a format string." calculator-displayers '(((std 110) "Standard display, decimal point or scientific") (calculator-eng-display "Eng display") ((std 102) "Standard display, decimal point") ((std 101) "Standard display, scientific") ("%S" "Emacs printer")) "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 display\nof result values not values in expressions. A displayer specification\nis the same as the values that can be stored in `calculator-displayer'.\n\n`calculator-rotate-displayer' rotates this list." sexp calculator-paste-decimals "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." calculator-copy-displayer "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 "If non-nil, show negative numbers in 2s complement in radix modes.\nOtherwise show as a negative number." calculator-mode-hook "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 "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 #[(_ val) "\303\301!\203 \304 \"\211\207" [val calculator-registers calculator-user-registers boundp append] 3] calculator-user-operators "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 very simple, X for an argument (Y the\n second in case of a binary operator), TX is a truncated version of X\n and F does a recursive call, Here is a [very inefficient] Fibonacci\n number calculation:\n\n (add-to-list 'calculator-user-operators\n '(\"F\" fib (if (<= TX 1)\n 1\n (+ (F (- TX 1)) (F (- TX 2)))) 0))\n\n Note that this will be either postfix or prefix, according to\n `calculator-unary-style'." (repeat (list string symbol sexp integer integer))] 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)) (#$ . 7709))
#@1235 The calculator operators, each a list with:
1. The key that is bound to for this operation (usually a string);
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, non-number =>
postfix/prefix as determined by `calculator-unary-style' (the
default);
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 useful for predefined
keys.
Use `calculator-user-operators' to add operators to this list, see its
documentation for an example.
(defvar calculator-operators nil (#$ . 8945))
#@43 Stack contents - operations and operands.
(defvar calculator-stack nil (#$ . 10231))
#@45 Current number being entered (as a string).
(defvar calculator-curnum nil (#$ . 10322))
#@50 Cons of the stack and its string representation.
(defvar calculator-stack-display nil (#$ . 10416))
#@69 A table to convert input characters to corresponding radix symbols.
(defvar calculator-char-radix '((68) (66 . bin) (79 . oct) (72 . hex) (88 . hex)) (#$ . 10522))
#@66 The mode for display, one of: nil (decimal), 'bin, 'oct or 'hex.
(defvar calculator-output-radix nil (#$ . 10692))
#@64 The mode for input, one of: nil (decimal), 'bin, 'oct or 'hex.
(defvar calculator-input-radix nil (#$ . 10813))
#@66 Non-nil if trig functions operate on degrees instead of radians.
(defvar calculator-deg nil (#$ . 10931))
#@35 A list of saved values collected.
(defvar calculator-saved-list nil (#$ . 11043))
#@42 The pointer to the current saved number.
(defvar calculator-saved-ptr 0 (#$ . 11131))
#@60 Bound to t when a value should be added to the saved-list.
(defvar calculator-add-saved nil (#$ . 11223))
#@68 When non-nil, we see something that the next digit should replace.
(defvar calculator-display-fragile nil (#$ . 11335))
#@32 The current calculator buffer.
(defvar calculator-buffer nil (#$ . 11461))
#@50 Internal value used by `calculator-eng-display'.
(defvar calculator-eng-extra nil (#$ . 11542))
#@50 Internal value used by `calculator-eng-display'.
(defvar calculator-eng-tmp-show nil (#$ . 11644))
#@98 The last binary operation and its arguments.
Used for repeating operations in calculator-repR/L.
(defvar calculator-last-opXY nil (#$ . 11749))
#@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) (#$ . 11899))
#@23 Saved global key map.
(defvar calculator-saved-global-map nil (#$ . 12102))
#@57 Used to hack restarting with the electric mode changed.
(defvar calculator-restart-other-mode nil (#$ . 12184))
#@25 The calculator key map.
(defvar calculator-mode-map (byte-code "\306 \307\310\"\210\311\312\313#\210\311\314\313#\210\315 @@\316 @A!\n\2032 \311\n@ #\210\nA\211\204$ * A\211\204 )\f\203N \311\317\320#\210\311\321\320#\210\202T \311\322\320#\210
\204^ \311\323\324#\210@\203n\325\326!\204n\327\330\331\"\332 A B\333\313!\210\334\326\335\336\337\340\341\342\340\343\344\340\345A\346\347\"A\350\351\"\352A\353\354\"A\355\356\"A\357\360\"A\361\362\"\363A\364\365\"A\366\367\"A\370\371\"A\372\373\"A\374\375\"A\376\377\"\201D A\201E \201F \"A\201G \201H \"A\201I \201J \"A\201K \201L \"\257\201M \201N \201O \201P \201Q \201R \340A\201S \201T \"A\201U \201V \"\257 \201W \201X \201Y \201Z \340\201[ \327\201\\ B\"\201] \201[ \327\201^ B\"\201_ \327\201` B\"#BC\"BBBB\201a \201[ \327\201b C\"\201c \"B\201d BBBBBBBBBBBBBB$\210*)\207" [map p keys func calculator-bind-escape window-system make-sparse-keymap suppress-keymap t define-key "i" nil "o" ((calculator-open-paren "[") (calculator-close-paren "]") (calculator-op-or-exp "+" "-" [kp-add] [kp-subtract]) (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-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" "iD" "iH" "iX" "iO" "iB") (calculator-radix-output-mode "od" "oh" "ox" "oo" "ob" "oD" "oH" "oX" "oO" "oB") (calculator-rotate-displayer "'") (calculator-rotate-displayer-back "\"") (calculator-displayer-prev "{") (calculator-displayer-next "}") (calculator-saved-up [up] [16]) (calculator-saved-down [down] [14]) (calculator-quit "q" [7]) (calculator-enter [enter] [linefeed] [kp-enter] [return] [13] [10]) (calculator-save-on-list " " [space]) (calculator-clear-saved [3] [(control delete)]) (calculator-save-and-quit [(control return)] [(control kp-enter)]) (calculator-paste [insert] [(shift insert)] [paste] [mouse-2] [25]) (calculator-clear [delete] [127] [4]) (calculator-help [104] [63] [f1] [help]) (calculator-copy [(control insert)] [copy]) (calculator-backspace [backspace])) reverse [27] calculator-quit [escape] [27 27 27] [8] calculator-backspace boundp calculator-menu mapcar #[(x) "\301@\302\3038D\304\305\306\3038\307\310\311\312\313A@DE\311\314\313A@DEE&\301@\315P\316\3038D\306\317\3038\227P\304\305\307\311\312\313A@DE&\301@\320P\321\3038D\306\322\3038\227P\304\305\307\311\314\313A@DE&E\207" [x 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"] 14] (("Decimal" nil "D") ("Binary" bin "B") ("Octal" oct "O") ("Hexadecimal" hex "H")) #[(name key) "\302\303 D\304 $\207" [name key vector calculator-op :keys] 5] (lambda (#1=#:def-tmp-var) (defvar calculator-menu #1# #2="Calculator menu.")) 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" calculator-use-menu op radix-selectors calculator-displayers "------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 (and (or calculator-input-radix calculator-output-radix) (calculator-radix-mode "D")) (and calculator-deg (calculator-dec/deg-mode))) :keys "D" :style radio :selected (not (or calculator-input-radix calculator-output-radix calculator-deg))] ["Degrees" (progn (and (or calculator-input-radix calculator-output-radix) (calculator-radix-mode "D")) (or 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" #[(x) "A@\207" [x] 1] ("---") #[(x) "\3018\207" [x 2] 2] "Decimal Display" #[(d) "\302\211A@)\303\304DD\"\207" [d x vector calculator-rotate-displayer quote] 6] ("---" ["Change Prev Display" calculator-displayer-prev] ["Change Next Display" calculator-displayer-next]) ("---" ["Copy+Quit" calculator-save-and-quit] ["Quit" calculator-quit])] 36) (#$ . 12302))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\305\306!\204 \302\306\307\310#\210\300\207" [calculator-mode-hook variable-documentation put purecopy "Hook run when 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] 5)
(defvar calculator-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\305\306!\204 \302\306\307\310#\210\300\207" [calculator-mode-map variable-documentation put purecopy "Keymap for `calculator-mode'." boundp calculator-mode-syntax-table definition-name calculator-mode] 5)
(defvar calculator-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\302\305\306\307#\207" [calculator-mode-syntax-table variable-documentation put purecopy "Syntax table for `calculator-mode'." calculator-mode-abbrev-table definition-name calculator-mode] 5)
(defvar calculator-mode-abbrev-table (progn (define-abbrev-table 'calculator-mode-abbrev-table nil) calculator-mode-abbrev-table))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\302\305\306\307#\207" [calculator-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `calculator-mode'." calculator-mode derived-mode-parent nil] 5)
#@4828 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). If the result of a calculation is too
large (out of range for Emacs), the value of "inf" is returned.
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 reminder
* `_' `;' 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 (`X' is shortcut for `H'):
* `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:
* "D=": degrees mode;
* "?=": (? is B/O/H) this is the radix for both input and output;
* "=?": (? is B/O/H) the display radix (when input is decimal);
* "??": (? 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 step
during initialization.
(defalias 'calculator-mode #[nil "\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 (#$ . 19019) nil])
#@93 Run the Emacs calculator.
See the documentation for `calculator-mode' for more information.
(defalias 'calculator #[nil "\203 ?\n\203 \306\n!\210\307\306 !\210\310\311! \203k \312 \313\216\314\315!\210\316\307!\210\307\211\317\307 2 3 4 5\320\321 \f\"\210\322\321 !\210\323 \210\324 \210\325 4\326 5\326 6\327\307!\210\3307!\210\331\332!\210\333\216\334\335\215\210.\2024\336\f!\204\337 8\322\340\341\342!\203\343\342\344!\345\" 9\342\346! :\343:\345\" ;9\250\203\244 ;\250\203\244 ;9W\206\265 ;\247\205\265 ;\250?\205\265 ;\347W?\2059\250\203\315 ;\250\203\315 ;9V\206;\247\203\340 ;\250\204\340 ;\347V\206\343:\350\" <\343<\351\" =<\205\375 =?\206\375 =\317V*\206\343\342\346!\352\"+\203\353\202\354!!\210\355\f!\210)\202'p\f=\204'\322\336\f!!\210\356 \210\357>\323 \210\316\360!\210\205> \205>\361 \207" [calculator-restart-other-mode calculator-electric-mode calculator-initial-operators calculator-user-operators calculator-buffer #1=#:wconfig calculator-add-operators nil get-buffer-create "*calculator*" current-window-configuration ((set-window-configuration #1#)) require electric message 0 set-window-buffer minibuffer-window select-window calculator-reset calculator-update-display current-local-map current-global-map use-local-map use-global-map run-hooks calculator-mode-hook ((byte-code "\203 \303\304\215\210\305 !\210\306\n!\207" [calculator-buffer old-l-map old-g-map calculator-done (calculator-quit) use-local-map use-global-map] 2)) calculator-done (byte-code "\300\301\302\303\304$\207" [Electric-command-loop calculator-done #[nil "\300\207" [noprompt] 1] nil #[(x y) "\300 \207" [calculator-update-display] 1]] 5) get-buffer-window 2 split-window-below fboundp face-attr-construct plist-get default :height mode-line 1 :box :line-width :overline -3 -2 switch-to-buffer calculator-mode t "Hit `?' For a quick help screen." calculator garbage-collection-messages echo-keystrokes old-l-map old-g-map calculator-saved-global-map calculator-mode-map window-min-height dh mf mh bx lh buffer-read-only] 5 (#$ . 24264) nil])
#@57 Same as `message', but special handle of electric mode.
(defalias 'calculator-message #[(string &rest arguments) "\303\304 #\210\n\205 \305\306!\210\304\307!\207" [string arguments calculator-electric-mode apply message sit-for 1 nil] 4 (#$ . 26369)])
#@33 Return OP's arity, 2, +1 or -1.
(defalias 'calculator-op-arity #[(op) "\3038\206 \304\211\247\203 \202 \n\305=\203 \306\202 \307)\207" [op arity calculator-unary-style 3 x postfix 1 -1] 3 (#$ . 26629)])
#@83 Return OP's precedence for reducing when inserting into the stack.
Defaults to 1.
(defalias 'calculator-op-prec #[(op) "\3018\206 \302\207" [op 4 1] 2 (#$ . 26846)])
#@173 This function handles operator addition.
Adds MORE-OPS to `calculator-operator', called initially to handle
`calculator-initial-operators' and `calculator-user-operators'.
(defalias 'calculator-add-operators #[(more-ops) "\306 \203] @@\307=\204C \310 @@ T\211\nGW\203< \311\312\f\n\313 TO\"!\204 \314\f\n\313 TO\306#\210\nG\211\202 \314\f\n\315#\210* @@\307=\203Q @A\202S @B A\211\204 \316\237
\"\211)\207" [added-ops more-ops key i calculator-mode-map calculator-operators nil nobind -1 keymapp lookup-key 0 define-key calculator-op append] 7 (#$ . 27021)])
#@29 Reset calculator variables.
(defalias 'calculator-reset #[nil "\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 (#$ . 27602)])
#@79 Return a string to display.
The string is set not to exceed the screen width.
(defalias 'calculator-get-prompt #[nil "\306 \204\n \n\2036 \n=\203 \307\310 \"@!\311P\202? \n\203* \307\310\n \"@!\202+ \311\307\310 \"@!P\202? \f\203> \312\202? \313\"\211
A\203P \314P\202b G\315U\203a \203a \316\202b \317Q\211 G\320 SZ\211 \321X\203x \202\203 G\\\316OP+\207" [calculator-prompt calculator-output-radix calculator-input-radix calculator-char-radix calculator-deg calculator-stack-display format char-to-string rassq "=" "D=" "==" "_" 1 nil "?" window-width 0 calculator-curnum calculator-stack calculator-display-fragile prompt trim] 8 (#$ . 27881)])
#@88 Convert the given STR to a number, according to the value of
`calculator-input-radix'.
(defalias 'calculator-string-to-number #[(str) "\203\231 \306\236A\307\310\211 T\211
GW\203\226
H\226\211 \311W\203) \312\202Q \313X\2037 \311Z\202Q \314W\203B \312\202Q \315X\203P \316Z\202Q \312\211 \203n \310 X\203n \fW\203n \f\n_\\\202y \317\320 \"\210\321\322!\210\n*\211\310W\203\207 \n\310V\202\212 \n\310W\203\221 \317\323!\210 \202 \n,\207\324
\325\232\203\244 \326\202\325 \327\330
\"\203\261
\331P\202\325 \327\332
\"\203\274
\202\325 \327\333
\"\203\311
\331P\202\325
;\203\324
\334P\202\325 \326!@\207" [calculator-input-radix new-value value i radix str ((bin . 2) (oct . 8) (hex . 16)) -1 0 48 nil 57 65 90 55 calculator-message "Warning: Ignoring bad input character `%c'." sit-for 1 "Warning: Overflow in input." read-from-string "." "0.0" string-match "[eE][+-]?$" "0" "\\.[0-9]\\|[eE]" "\\." ".0" ch n] 5 (#$ . 28559)])
#@66 Get the numeric value of the displayed number string as a float.
(defalias 'calculator-curnum-value #[nil "\301!\207" [calculator-curnum calculator-string-to-number] 2 (#$ . 29526)])
#@207 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.
(defalias 'calculator-rotate-displayer #[(&optional new-disp) "\203 ?\306\307 \203 \310\202 \311\"\210\202R \n\203@ \n >\203@ \312 @\n=\2046 @\fB A\211\202$ \f\237\244\211)\202F A @C\244\306\313 @\211 A@)\"\210\314 \207" [calculator-output-radix calculator-radix-grouping-mode new-disp calculator-displayers tmp x calculator-message "Digit grouping mode %s." "ON" "OFF" nil "Using %s." calculator-enter] 4 (#$ . 29717) nil])
#@116 Like `calculator-rotate-displayer', but rotates modes back.
If radix output mode is active, toggle digit grouping.
(defalias 'calculator-rotate-displayer-back #[nil "\301\302!@!\207" [calculator-displayers calculator-rotate-displayer last] 3 (#$ . 30369) nil])
#@207 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 #[nil "\203\n T\305 \207\n@\2057 \n\211@@)\211 9\203! \f\306!\2026 \f:\2056 \f@\307=\2056 \310\306\f\211A@)\")\207" [calculator-output-radix calculator-radix-grouping-digits calculator-displayers x disp calculator-enter left std calculator-standard-displayer] 4 (#$ . 30638) nil])
#@208 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 #[nil "\203\f \305 S]\306 \207\n@\2059 \n\211@@)\211 9\203# \f\307!\2028 \f:\2058 \f@\310=\2058 \311\307\f\211A@)\")\207" [calculator-output-radix calculator-radix-grouping-digits calculator-displayers x disp 2 calculator-enter right std calculator-standard-displayer] 4 (#$ . 31174) nil])
#@132 Get a number string NUMSTR and remove unnecessary zeros.
The behavior of this function is controlled by
`calculator-remove-zeros'.
(defalias 'calculator-remove-zeros #[(numstr) "\302=\203# \303\304 \"\203# \305\224\203 \306\211\224O\307\305 \"P\207 \306\211\224O\207\203D \303\310 \"\203D \311\224\203> \306\312\224O\307\311 \"P\207 \306\312\224O\207 \207" [calculator-remove-zeros numstr t string-match "\\.0+\\([eE][+-]?[0-9]*\\)?$" 1 0 match-string "\\..\\([0-9]*[1-9]\\)?\\(0+\\)\\([eE][+-]?[0-9]*\\)?$" 3 2] 4 (#$ . 31719)])
#@503 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.
The special 'left and 'right symbols will make it change the current
number of digits displayed (`calculator-number-digits').
It will also remove redundant zeros from the result.
(defalias 'calculator-standard-displayer #[(num char) "9\203' \305=\203 \306V\205& S\211\205& \307 \207\310=\205` T\307 \207\311!\2031 \312\202[ \313\314\315 !\n\316=\203U \317!\211\320W\204L \321V\203P \322\202Q \323)\202X \324\n!Q\" \325\f!)\207" [num calculator-number-digits char n str left 0 calculator-enter right zerop "0" format "%." number-to-string 110 abs 0.001 100000000.0 "e" "f" string calculator-remove-zeros] 6 (#$ . 32261)])
#@220 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.
(defalias 'calculator-eng-display #[(num) "9\2033 \306=\203 \203 T\202 \307\310\311 )\207\312=\205\274 \203+ S\202, \313\310\311 )\207\314\314U\204\230 \315!\316W\203N \317_ \320Z\202; \315!\321V\203a \322\245 \320\\\202N \n\203\230 \314U\204\230 \211 \314V\203\202 \323_ \320Z\fS\211\202n \f\314W\203\227 \324\245 \320\\\fT\211\202\203 )\n\204\236 \325\326\327\330
!\331Q\" \205\257 \332 \333 !)\334\330 !Q*\207" [num calculator-eng-extra calculator-eng-tmp-show exp i calculator-number-digits left 1 t calculator-enter right -1 0 abs 1.0 1000.0 3 999.0 1000.0 1000.0 1000.0 nil format "%." number-to-string "f" x calculator-remove-zeros "e" str] 5 (#$ . 33226)])
#@38 Convert NUM to a displayable string.
(defalias 'calculator-number-to-string #[(num) "\247\203\246 \203\246 \306 \307=\203 \310\202 \311\312\n\203 \202! \313!!\" \314=\203O \315\316
T\211 GW\203D \f
H\317\236AP\202. \320\321\f\"\210\322\323\f\"* \203\222 G \245 G \246 S\211 \324 !\203s \323\202t \325Y\203\221 _\\ \325
O!
\326OQ)\202b *\n\204\242 \325W\203\242 \327 P\202\243 \226)\207\247\203\361 \"\203\361 \";\203\274 \306\"\"\207\"9\203\307 \"!\207\":\203\341 \"@\330=\203\341 \331\"\211 #A@)\"\207\"<\203\354 \332\"!\207\333\334\"\207\333A@\334\"\207" [num calculator-output-radix calculator-2s-complement str s i format hex "%x" "%o" calculator-truncate abs bin -1 "" ((48 . "000") (49 . "001") (50 . "010") (51 . "011") (52 . "100") (53 . "101") (54 . "110") (55 . "111")) string-match "^0*\\(.+\\)" match-string 1 zerop 0 nil "-" std calculator-standard-displayer eval prin1-to-string t calculator-radix-grouping-mode calculator-radix-grouping-digits r d calculator-radix-grouping-separator calculator-displayer x] 6 (#$ . 34157)])
#@89 Update the display.
If optional argument FORCE is non-nil, don't use the cached string.
(defalias 'calculator-update-display #[(&optional force) "q\210 \204 \n@ =\204l \211\203i \f\203' G\306U\203' \f\211 @@)\202) \307\310\311 !\312#)\312\205e \205e @8U\205e \313U\203Y \314\315G\"\202e \314\316GZG#Q\202j \317B\320 \321 \210\322 c\210)\323\324!\210\203\206 GTb\207`Sb\207" [calculator-buffer force calculator-stack-display calculator-stack calculator-displayers x 1 mapconcat calculator-number-to-string reverse " " 0 format "[%s]" "[%s/%s]" "" t erase-buffer calculator-get-prompt set-buffer-modified-p nil calculator-displayer calculator-display-fragile calculator-saved-list calculator-saved-ptr inhibit-read-only calculator-prompt] 8 (#$ . 35256)])
#@103 Reduce the stack using top operator.
PREC is a precedence - reduce everything with higher precedence.
(defalias 'calculator-reduce-stack #[(prec) "AA\2039 @:\2039 A@\247\2039 \3028:\2039 @A@\303=\2039 \3028A@\304=\2039 A@\305\233B\211\202 AA\203| @\247\203| A@:\203| \3028\247\203| \306A@!\302U\203| \307A@!X\203| \310\302A@8\3028@#\305\233B\211\202 G\302Y\203\266 @\247\203\266 A@:\203\266 \306A@!\311U\203\266 \307A@!X\203\266 \310\302A@8@\"AAB\211\202 A\203\354 @:\203\354 A@\247\203\354 \306@!\312U\203\354 \307@!X\203\354 \310\302@8A@\"AAB\211\202 \203
@:\203
\306@!\313U\203
\310\302@8!AB\211\202 A\203'@\247\203'A@\247\203'\211AA\241\202(\314\205.\202 \207" [calculator-stack prec 2 \) \( 3 calculator-op-arity calculator-op-prec calculator-funcall -1 1 0 nil] 5 (#$ . 36050)])
#@115 If F is a symbol, evaluate (F X Y).
Otherwise, it should be a list, evaluate it with X, Y bound to the
arguments.
(defalias 'calculator-funcall #[(f &optional X Y) "\203 \nE\304\305\306\217\207" [Y f X calculator-last-opXY nil (byte-code "9\203 \203 \n\203 \n\"\207 \203 !\207 \207\306 ! \n\205* \306\n! \2039 _\307\245\202: \310\311!\211 \205K \311K \310\312!\211 \205X \312K \311\313M\210\312\314M\210\315\216\316!.\n\207" [f X Y __f__ TX TY calculator-truncate 180 fboundp F D #[(&optional x y) "\303 \n#\207" [__f__ x y calculator-funcall] 4] #[(x) "\203\n \303_\n\245\207 \207" [calculator-deg x float-pi 180] 2] ((byte-code "\203 \304 M\210\202 \305\304!\210\n\203 \306 M\210\202 \305\306!\210\304\207" [Fbound Fsave Dbound Dsave F fmakunbound D] 2)) eval calculator-deg pi DX calculator-saved-list L Fbound Fsave Dbound Dsave] 4) ((error 0))] 3 (#$ . 36907)])
#@126 Last char (or event or event sequence) that was read.
Optional string argument KEYS will force using it as the keys entered.
(defalias 'calculator-last-input #[(&optional keys) "\206 \305 \211;\204 \306 !\204 \202a \307\310 G\311\"\312 \nT\211 GW\203_ \nH\313\314!\203J \314\f!\203J \313\315!\203J \315\f!\203J \315\f!\f9\203W \f\316N\206V \311 \n\fI\210\202 +)\207" [keys inp i converted-str k this-command-keys arrayp -1 make-string 32 nil fboundp key-press-event-p event-key ascii-character] 4 (#$ . 37824)])
#@112 Clear the fragile flag if it was set, then maybe reset all.
OP is the operator (if any) that caused this call.
(defalias 'calculator-clear-fragile #[(&optional op) "\203 \203 \302 !\303U\204 \302 !\304U\203 \305 \210\306\211\207" [calculator-display-fragile op calculator-op-arity -1 0 calculator-reset nil] 2 (#$ . 38358)])
#@23 Enter a single digit.
(defalias 'calculator-digit #[nil "\306 \307H \204 \n@\247?\205Q \204 \310X\2023 \311=\203& \312X\2023 \313=\2032 \314X\2023 \315\205Q \316 \210\317!\226
\320\232\203F \321
\206K \322\fP)\323 )\207" [inp calculator-display-fragile calculator-stack calculator-input-radix digit calculator-curnum calculator-last-input 0 57 bin 49 oct 55 t calculator-clear-fragile char-to-string "0" nil "" calculator-update-display] 2 (#$ . 38696) nil])
#@25 Enter a decimal period.
(defalias 'calculator-decimal #[nil "?\205) \204 \n@\247?\205) \205 \304\305 \"?\205) \306 \210 \206$ \307\310P\311 \207" [calculator-input-radix calculator-display-fragile calculator-stack calculator-curnum string-match "[.eE]" calculator-clear-fragile "0" "." calculator-update-display] 3 (#$ . 39174) nil])
#@64 Enter an `E' exponent character, or a digit in hex input mode.
(defalias 'calculator-exp #[nil "\203 \304 \207 \204 \n@\247?\205+ \205 \305\306 \"?\205+ \307 \210 \206& \310\311P\312 \207" [calculator-input-radix calculator-display-fragile calculator-stack calculator-curnum calculator-digit string-match "[eE]" calculator-clear-fragile "1" "e" calculator-update-display] 3 (#$ . 39520) nil])
#@136 Enter an operator on the stack, doing all necessary reductions.
Optional string argument KEYS will force using it as the keys entered.
(defalias 'calculator-op #[(&optional keys) "\300\301\215\207" [op-error (byte-code "\306!\307 \n\"\310 !\210\f\203 \311 !\312U\204 \313
B\314\311 !\315U\203c
\2032
@\247\204c \n @@\232\204F A \2025 \307 A\"\211\203Y \311 !\316U\204b \317\320!\210\321\322\314\"\210)\323 A@\324=\203p \325\202 A@\326=\203| \312\202 \327 !!\210\311 !\316U\203\217
@\247\204\245 \311 !\316U\204\256 \311 !\312U\204\256
@\247\204\256 \317\330!\210\321\322\314\"\210
B\323\327 !!\210
G\331U\203\364
@\247\203\364 \332\211 \203\364 \203\364 \312U\203\342
@ B \202\364 S \233\211 !
@!AB\241\210)\333 *\207" [keys last-inp calculator-operators op calculator-curnum calculator-stack calculator-last-input assoc calculator-clear-fragile calculator-op-arity 0 calculator-curnum-value nil 2 -1 calculator-message "Binary operator without a first operand" throw op-error calculator-reduce-stack \( 10 \) calculator-op-prec "Unterminated expression" 1 t calculator-update-display rest-ops calculator-display-fragile calculator-add-saved calculator-saved-ptr calculator-saved-list p] 4)] 2 (#$ . 39926) 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 #[nil "\204 \203 \302\303 \"\203 \304 \207\305 \207" [calculator-display-fragile calculator-curnum string-match "[eE]$" calculator-digit calculator-op] 3 (#$ . 41186) nil])
#@68 Set decimal mode for display & input, if decimal, toggle deg mode.
(defalias 'calculator-dec/deg-mode #[nil "\203 \305 B\306\n\204 \203 \306\211\202 \f?\307\310!\207" [calculator-curnum calculator-stack calculator-input-radix calculator-output-radix calculator-deg calculator-curnum-value nil calculator-update-display t] 3 (#$ . 41586) nil])
#@107 Set input and display radix modes.
Optional string argument KEYS will force using it as the keys entered.
(defalias 'calculator-radix-mode #[(&optional keys) "\301!\210\302!\207" [keys calculator-radix-input-mode calculator-radix-output-mode] 2 (#$ . 41948) nil])
#@95 Set input radix modes.
Optional string argument KEYS will force using it as the keys entered.
(defalias 'calculator-radix-input-mode #[(&optional keys) "\203 \306 B\307\310\n!\211\211GSH\226\f\236A)\311 \207" [calculator-curnum calculator-stack keys inp calculator-char-radix calculator-input-radix calculator-curnum-value nil calculator-last-input calculator-update-display] 3 (#$ . 42220) nil])
#@97 Set display radix modes.
Optional string argument KEYS will force using it as the keys entered.
(defalias 'calculator-radix-output-mode #[(&optional keys) "\203 \306 B\307\310\n!\211\211GSH\226\f\236A)\311\312!\207" [calculator-curnum calculator-stack keys inp calculator-char-radix calculator-output-radix calculator-curnum-value nil calculator-last-input calculator-update-display t] 3 (#$ . 42630) nil])
#@67 Evaluate current expression, put result on the saved values list.
(defalias 'calculator-save-on-list #[nil "\301\302 )\207" [calculator-add-saved t calculator-enter] 1 (#$ . 43050) nil])
#@60 Clear the list of saved values in `calculator-saved-list'.
(defalias 'calculator-clear-saved #[nil "\302\303\304\305!\207" [calculator-saved-list calculator-saved-ptr nil 0 calculator-update-display t] 2 (#$ . 43244) nil])
#@44 Go N elements up the list of saved values.
(defalias 'calculator-saved-move #[(n) "\205* \203\f \n\205* \f\\G^\305]\2118\203% \f8C\306\202( \307 \210\310 \207" [calculator-saved-list calculator-stack calculator-display-fragile n calculator-saved-ptr 0 t calculator-reset calculator-update-display] 3 (#$ . 43475) nil])
#@33 Go up the list of saved values.
(defalias 'calculator-saved-up #[nil "\300\301!\207" [calculator-saved-move 1] 2 (#$ . 43809) nil])
#@35 Go down the list of saved values.
(defalias 'calculator-saved-down #[nil "\300\301!\207" [calculator-saved-move -1] 2 (#$ . 43947) nil])
#@30 Equivalents of `(' use this.
(defalias 'calculator-open-paren #[nil "\300\301!\207" [calculator-op "("] 2 (#$ . 44090) nil])
#@30 Equivalents of `)' use this.
(defalias 'calculator-close-paren #[nil "\300\301!\207" [calculator-op ")"] 2 (#$ . 44221) nil])
#@30 Evaluate current expression.
(defalias 'calculator-enter #[nil "\300\301!\207" [calculator-op "="] 2 (#$ . 44353) nil])
#@52 Backward delete a single digit or a stack element.
(defalias 'calculator-backspace #[nil "\203 G\302V\205 \303GSO\202 A\304 \207" [calculator-curnum calculator-stack 1 0 calculator-update-display] 3 (#$ . 44479) nil])
#@23 Clear current number.
(defalias 'calculator-clear #[nil "\306 \203@ \n\203@ @\f\n8U\203@ \f\307U\203 \nA\202. \fS\n\233\211 \211AA\241\210\fS)\n\203: \f\n8C\202O \310 \210\202O \204L \n =\203O \310 \210\311 \207" [calculator-curnum calculator-display-fragile calculator-saved-list calculator-stack calculator-saved-ptr p nil 0 calculator-reset calculator-update-display last-command this-command] 4 (#$ . 44713) nil])
#@41 Copy current number to the `kill-ring'.
(defalias 'calculator-copy #[nil "\206 ?\205 \n\305 \210 A\211 \205* \306\307\f\"\205* \310\311\f\"\211\205* \312\f!+\207" [calculator-copy-displayer calculator-displayer calculator-displayers calculator-stack-display s calculator-enter string-match "^\\([^ ]+\\) *\\(\\[[0-9/]+\\]\\)? *$" match-string 1 kill-new] 4 (#$ . 45146) nil])
#@31 Set a register value for REG.
(defalias 'calculator-set-register #[(reg) " \236\305 \210 @ \n\203 \n\f\241\210\202 \fB B\306\307\f#*\207" [reg calculator-registers as calculator-stack val calculator-enter calculator-message "[%c] := %S"] 4 (#$ . 45536) "cRegister to store into: "])
#@73 Paste VAL as if entered.
Used by `calculator-paste' and `get-register'.
(defalias 'calculator-put-value #[(val) "\247\205 \204 \n@\247?\205 \305 \210\306\307!)\310 \207" [val calculator-display-fragile calculator-stack calculator-displayer calculator-curnum calculator-clear-fragile "%S" calculator-number-to-string calculator-update-display] 2 (#$ . 45832)])
#@37 Paste a value from the `kill-ring'.
(defalias 'calculator-paste #[nil "\303\304\305\306\307\310!# \204G \n\203G \311\312\"\203G \313\314\"\204- \313\315\"\204- \313\316\"\203G \313\314\"\2065 \317\313\315\"\206= \320\313\316\"\206E \321Q\322\323\324\217)!\207" [str calculator-input-radix calculator-paste-decimals calculator-put-value replace-regexp-in-string "^ *\\(.+[^ ]\\) *$" "\\1" current-kill 0 string-match "\\([0-9]+\\)\\(\\.[0-9]+\\)?\\(e[0-9]+\\)?" match-string 1 2 3 "0" ".0" "" nil (calculator-string-to-number str) ((error))] 6 (#$ . 46206) nil])
#@34 Get a value from a register REG.
(defalias 'calculator-get-register #[(reg) "\302 \236A!\207" [reg calculator-registers calculator-put-value] 3 (#$ . 46783) "cRegister to get value from: "])
#@976 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 inverses 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 (X is a shortcut for H)
* 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 #[nil "\306=\203; \307\310\311 \312 \313\314!\210
\203 \315&!\210
\204' \316 \210\202* \317 \210
\2032 \315\n!\210\320 !\210\321\322!,\207\323\324!\312 \325\326! ' (\327 )\330\216* +r\325\326!q\210p\331 \210+*\322\211,-\324\211.\324 / 0\332 \210\333\334!\210+\211 1 2\335\336\306!!\210\3371!\210+(\203\224 \340\341'!!\210\321\342\343 \"\210\320 !\210\344\345!\210*\320 !+\207" [last-command win g-map major-mode mode-name calculator-electric-mode calculator-help "Calculator" calculator-mode current-global-map selected-window require ehelp use-global-map describe-mode electric-describe-mode select-window message nil one-window-p t get-buffer-create "*Help*" current-window-configuration ((set-window-configuration #1=#:wconfig)) 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, any other key continues normally." calculator-last-input sit-for 360 calculator-saved-global-map help-buf one #1# default-directory #2=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #3=#:buf standard-output] 5 (#$ . 46982) nil])
#@18 Quit calculator.
(defalias 'calculator-quit #[nil "q\210\303\304 \210)\n\204 \305\306\307\217\210\310!\210\305\311\312!\210\n\205$ \313\314\305\"\207" [calculator-buffer inhibit-read-only calculator-electric-mode t erase-buffer nil (byte-code "\301!\203 \302\301!!\210\202 \301\207" [calculator-buffer get-buffer-window delete-window] 3) ((error)) kill-buffer message "Calculator done." throw calculator-done] 3 (#$ . 49233) nil])
#@60 Quit the calculator, saving the result on the `kill-ring'.
(defalias 'calculator-save-and-quit #[nil "\300 \210\301 \210\302 \207" [calculator-enter calculator-copy calculator-quit] 1 (#$ . 49679) nil])
#@134 Repeat the last binary operation with its second argument and X.
To use this, apply a binary operator (evaluate it), then call this.
(defalias 'calculator-repR #[(x) "\203 \302@ \3038#)\207 \207" [calculator-last-opXY x calculator-funcall 2] 5 (#$ . 49889)])
#@133 Repeat the last binary operation with its first argument and X.
To use this, apply a binary operator (evaluate it), then call this.
(defalias 'calculator-repL #[(x) "\203 \302@A@ #)\207 \207" [calculator-last-opXY x calculator-funcall] 4 (#$ . 50161)])
#@38 Non-nil if X is equal to an integer.
(defalias 'calculator-integer-p #[(x) "\300\301\302\217\207" [nil (byte-code "\301!U\207" [x ftruncate] 3) ((error))] 3 (#$ . 50426)])
#@49 Compute X^Y, dealing with errors appropriately.
(defalias 'calculator-expt #[(x y) "\300\301\302\217\207" [nil (expt x y) ((domain-error 0.0e+NaN) (range-error (byte-code "\302W\203 \303V\203 \304\207\305V\203 \306W\203 \307\207\310V\203* \311V\203* \312\207 \313W\2032 \314\207\315\316 !\317\"\317=\203? \320\207\321\207" [x y 1.0 -1.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0e+INF 0.0 0.0 logand truncate 1 -1.0e+INF 1.0e+INF] 3)) (error 0.0e+NaN))] 3 (#$ . 50606)])
#@24 Simple factorial of X.
(defalias 'calculator-fact #[(x) "\302Y\203= \303!\203= \304\305\245\"\306U\203 \307\207\310X\203# \311\202$ \312\302V\2038 \313!_S\211\202& \314 \\)\207\315U\203E \207\316\207" [x r 0 calculator-integer-p calculator-expt 3.0 1.0e+INF 1.0e+INF 10 1 1.0 truncate 0.0 1.0e+INF 0.0e+NaN] 4 (#$ . 51078)])
#@43 Truncate N, return 0 in case of overflow.
(defalias 'calculator-truncate #[(n) "\300\301\302\217\207" [nil (truncate n) ((error 0))] 3 (#$ . 51424)])
(provide 'calculator)