| Current Path : /usr/share/emacs/24.3/lisp/calc/ |
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/calc/calc-prog.elc |
;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:10:45 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/calc/calc-prog.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!\210\300\302!\207" [require calc-ext calc-macs] 2)
(defalias 'calc-equal-to #[(arg) "\300\301!\207" [calc-do #[nil "\250\203 \301V\203 \302\303\304\305!B#\207\306\303\304#\207" [arg 2 calc-enter-result "eq" calcFunc-eq calc-top-list-n calc-binary-op] 6]] 2 nil "P"])
(defalias 'calc-remove-equal #[(arg) "\300\301!\207" [calc-do #[nil "\301\302\303#\207" [arg calc-unary-op "rmeq" calcFunc-rmeq] 4]] 2 nil "P"])
(defalias 'calc-not-equal-to #[(arg) "\300\301!\207" [calc-do #[nil "\250\203 \301V\203 \302\303\304\305!B#\207\306\303\304#\207" [arg 2 calc-enter-result "neq" calcFunc-neq calc-top-list-n calc-binary-op] 6]] 2 nil "P"])
(defalias 'calc-less-than #[(arg) "\300\301!\207" [calc-do #[nil "\301\302\303#\207" [arg calc-binary-op "lt" calcFunc-lt] 4]] 2 nil "P"])
(defalias 'calc-greater-than #[(arg) "\300\301!\207" [calc-do #[nil "\301\302\303#\207" [arg calc-binary-op "gt" calcFunc-gt] 4]] 2 nil "P"])
(defalias 'calc-less-equal #[(arg) "\300\301!\207" [calc-do #[nil "\301\302\303#\207" [arg calc-binary-op "leq" calcFunc-leq] 4]] 2 nil "P"])
(defalias 'calc-greater-equal #[(arg) "\300\301!\207" [calc-do #[nil "\301\302\303#\207" [arg calc-binary-op "geq" calcFunc-geq] 4]] 2 nil "P"])
(defalias 'calc-in-set #[(arg) "\300\301!\207" [calc-do #[nil "\301\302\303#\207" [arg calc-binary-op "in" calcFunc-in] 4]] 2 nil "P"])
(defalias 'calc-logical-and #[(arg) "\300\301!\207" [calc-do #[nil "\301\302\303\304$\207" [arg calc-binary-op "land" calcFunc-land 1] 5]] 2 nil "P"])
(defalias 'calc-logical-or #[(arg) "\300\301!\207" [calc-do #[nil "\301\302\303\304$\207" [arg calc-binary-op "lor" calcFunc-lor 0] 5]] 2 nil "P"])
(defalias 'calc-logical-not #[(arg) "\300\301!\207" [calc-do #[nil "\301\302\303#\207" [arg calc-unary-op "lnot" calcFunc-lnot] 4]] 2 nil "P"])
(defalias 'calc-logical-if #[nil "\300\301!\207" [calc-do #[nil "\300\301\302\303\304\301!B#\207" [calc-enter-result 3 "if" calcFunc-if calc-top-list-n] 6]] 2 nil nil])
(defalias 'calc-timing #[(n) "\300\301!\207" [calc-do #[nil "\302\301\303\304$\210\305 \203 \306\202 \307!\207" [n calc-timing calc-change-mode nil t message "Reporting timing of slow commands in Trail" "Not reporting timing of commands"] 5]] 2 nil "P"])
(defalias 'calc-pass-errors #[nil "\300\301\302\217\207" [err (byte-code "\301\211\302K88\303H\211\242\242\304>\204 \301\211\302K88\305H@@\306>\204& \307\310!\210@\311\240)\207" [place 2 calc-do 15 (error xxxerror) 27 (error xxxerror) error "foo" xxxerror] 4) ((error (error "The calc-do function has been modified; unable to patch")))] 3 nil nil])
(defalias 'calc-user-define #[nil "\305\306!\210\307 \310!\311U\203 \312\313!\210\314\315\316\317!\320Q \321\322\323%!\324 \236\211 \2033 \f\n\241\202; \nB AB\241,\207" [key obarray func kmap old message "Define user key: z-" read-char calc-user-function-classify 0 error "Can't redefine \"?\" key" intern completing-read "Set key z " char-to-string " to command: " commandp t "calc-" calc-user-key-map] 8 nil nil])
(defalias 'calc-user-undefine #[nil "\302\303!\210\304 \305!\306U\203 \307\310!\210\311 \312 \236\206. \226 \236\206. \227 \236\206. \307\313! \"*\207" [key kmap message "Undefine user key: z-" read-char calc-user-function-classify 0 error "Can't undefine \"?\" key" calc-user-key-map delq "No such user key is defined"] 3 nil nil])
(defalias 'calc-user-define-formula #[nil "\300\301!\207" [calc-do #[nil "\306\307!\310\242\311=\205 G\312Y\310\211 \310\211 @\310\211 A B\310\211 C D\310 E\n\203A \313\314\315A!A\237\"GS8\202J \316!\210\317 \320\"\321\322!\210\323 \324\f!\325U\203] \326\327!\210\f\330>?\205e \f\211\205\230 \331\fX\203v \f\332X\204\216 \333\fX\203\202 \f\334X\204\216 \335\fX\203\224 \f\336X\203\224 \337\f!\202\230 \340\341\f\"\f\342 \236
\204\254 \340\343\344\345 \346\246!\"\347
PB\350\351B\352QF\353\310 \203\314 A9\203\314 \354 A!\202\315 \355%\211@\356\230\204\335 @\355\230\203\342 \357
P@\360\361@\"\205\357 \362@\307\"A\363@!\211@\203 \364@!\203 \203 \365@\366N\203\367\354@!\370Q\202\371!\203\254 A\2039\360\372A\"\2034\373A\374\310OP\202<A\202<\373
PB\375\350\376B\352Q\313\377\201M \375F\"\"\201N \310$P\211C\375\230\203f\363\375BP!\202j\363C!\211C\203\231\364C!\203\231\364@!\204\231 \203\231\365C\366N\203\224\367\354C!\370Q\202\225\371!\203 C\204\275\363\201O
\206\271@\203\262\354@!\206\271\340\343\345 \346\246\"P!C\n\203\307 D\202\366\201P \201Q \203\331\201R !\202\334\201S G\201T $D\201U D \"\204\366\365\201V !\203\307D\205C\205\365\201W !E\313\201X D\"D@\203k\201Y \201Z !\210@\201[ \310\201\\ \201] \201^ DG\354C\2067@! H\360\201_ H\"\205I\362H\307\")\201` \201a CD\201b DGDEFDFM\210\201c @\366\201T #\210\201d \201e !D IC\201f \201[ DDE\205\215\313\201g D\"IC#M\210)\201c C\366#\210\310J\f\203\310\342 K\fK\236\211 L\203\273L@\241\210\202\307K\f@BKAB\241\210*.\f\321\356!\207" [form math-arglist is-lambda odef key keyname calc-top 1 nil calcFunc-lambda 2 mapcar #[(x) "A@\207" [x] 1] reverse calc-default-formula-arglist sort string-lessp message "Define user key: z-" read-char calc-user-function-classify 0 error "Can't redefine \"?\" key" (13 32) 48 57 97 122 65 90 char-to-string format "%03d" calc-user-key-map "%05d" abs random 10000 "User-" completing-read "Define M-x command name (default calc-" "): " commandp symbol-name "calc-" "" "calc-User-" string-match "\\`calc-\\(.+\\)\\'" math-match-substring intern fboundp y-or-n-p calc-user-defn "Replace previous definition for " "? " "That name conflicts with a built-in Emacs function. Replace this function? " "\\`User-.+" "User" 5 "calcFunc-" "Define algebraic function name (default " #[(x) "\301\302O\207" [x 9 nil] 3] cmd cmd-base cmd-base-default func calc-user-formula-alist is-symb obarray minibuffer-local-map name body math-integral-cache-state kmap old all-completions #[(x) "\301\302\303P!!\207" [x fboundp intern "calcFunc-"] 4] "calcFunc-User" read-from-minibuffer "Function argument list: " prin1-to-string "()" t calc-subsetp "Okay for arguments that don't appear in formula to be ignored? " "Leave it symbolic for non-constant arguments? " #[(x) "\301\236A\206 \207" [x ((nil . arg-nil) (t . arg-t))] 2] require calc-macs lambda (interactive) calc-wrapper calc-enter-result "\\([^-][^-]?[^-]?[^-]?\\)[^-]*\\'" cons quote calc-top-list-n put math-normalize calc-fix-user-formula append #[(v) "\301\302E\207" [v math-check-const t] 3]] 13]] 2 nil nil])
(defalias 'calc-default-formula-arglist #[(form) ":\205' @\302=\203# A@ >\206 \303!?\205' A@ B\211\207\304A!\207" [form math-arglist var math-const-var calc-default-formula-arglist-step] 2])
(defalias 'calc-default-formula-arglist-step #[(l) "\205
\301@!\210\302A!\207" [l calc-default-formula-arglist calc-default-formula-arglist-step] 2])
(defalias 'calc-subsetp #[(a b) "?\206 @ >\205 \302A \"\207" [a b calc-subsetp] 3])
(defalias 'calc-fix-user-formula #[(f) ":\203\221 \303@\304=\203% A@\305\236A\206 A@\211\n>\203% \202\217 \306!\2042 @\304=\2038 \307D\202\217 @\310=\203S G\311U\203S \312\313\314\315A@!DE\202\217 @\316=\203k G\311U\203k \317\315A@!D\202\217 @\320=\203\203 G\311U\203\203 \321\315A@!D\202\217 \322\307@D\323\315A\"BB)\207\207" [f temp calc-user-formula-alist nil var ((nil . arg-nil) (t . arg-t)) math-constp quote calcFunc-eval 2 let ((calc-simplify-mode nil)) math-normalize calc-fix-user-formula calcFunc-evalsimp math-simplify calcFunc-evalextsimp math-simplify-extended list mapcar] 5])
(defalias 'calc-user-define-composition #[nil "\300\301!\207" [calc-do #[nil "\306=\203\n \307\310!\210\311\312!\313\314\315\316\317\320\321\314\n\"\"\322#P!\211\323N \324\211 '\324\211 ( )\325 !\203G \f\236\211\203\255 \326 \323\327
\f\"#\210\202\255 \330 !\210\331(\332\"(\333\334(\203` \335(!\202a \336*\337$)\340)(\"\204v \341\342!\204R \f\236\211\204\211 \326 \323C\211\fB#\210)G
A\236\211'\204\242
)GC\211'
AB\241\210'\343)\344 !E\241\210\345\312!\210\346 .\207" [calc-language comp obarray func comps entry unform error "Can't define formats for unformatted mode" calc-top 1 intern "calcFunc-" completing-read "Define format for which function: " mapcar #[(x) "\301\302O\207" [x 9 nil] 3] all-completions #[(x) "\301\302\303P!!\207" [x fboundp intern "calcFunc-"] 4] math-compose-forms nil math-zerop put delq calc-default-formula-arglist sort string-lessp read-from-minibuffer "Composition argument list: " prin1-to-string "()" t calc-subsetp y-or-n-p "Okay for arguments that don't appear in formula to be invisible? " lambda calc-fix-user-formula calc-pop-stack calc-do-refresh entry2 math-arglist calc-user-formula-alist minibuffer-local-map] 10]] 2 nil nil])
(defalias 'calc-user-define-kbd-macro #[(arg) "\204 \306\307!\210\310\311!\210\312 \313 !\314U\203 \306\315!\210\316\317\320\n\321\322\323 \324Y\203. \325X\204F \326Y\203: \327X\204F \330Y\203L \331X\203L \332 !\202P \333\334 \"P%!\335 !\203v K\211 ;\206m \f:\205m \336\f8\242\337=)\204v \306\340 \"\210\341 \342\343#\210 \344
!\314W\203\211 \202\232 \345\346\347\337\350\351!\"\305\333\352 \"FFM\210\353 , ,\236\211 -\203\261 - \241\202\273 , B,AB\241,\207" [last-kbd-macro key obarray cmd f arg error "No keyboard macro defined" message "Define last kbd macro on user key: z-" read-char calc-user-function-classify 0 "Can't redefine \"?\" key" intern completing-read "Full name for new command: " commandp nil "calc-User-" 97 122 65 90 48 57 char-to-string format "%03d" fboundp 3 calc-execute-kbd-macro "Function %s is already defined and not a keyboard macro" put calc-user-defn t prefix-numeric-value lambda (arg) (interactive "P") vector key-description "z%c" calc-user-key-map kmap old] 11 nil "P"])
(defalias 'calc-edit-user-syntax #[nil "\300\301!\210\302 \207" [calc-do #[nil "\303\304\305 DD\306\307\310 \204 \311\202, \312=\203 \313\202, \314=\203' \315\202, \316\317 !!\"#\210\320 \n\236A \")\207" [calc-language lang calc-user-parse-tables calc-edit-mode calc-finish-user-syntax-edit quote t format "Editing %s-Mode Syntax Table. " "Normal" tex "TeX" latex "LaTeX" capitalize symbol-name calc-write-parse-table] 8] calc-show-edit-buffer] 2 nil nil])
(defalias 'calc-finish-user-syntax-edit #[(lang) "\305 \" \n\236\211 \203 \206 C\nB\211@\f\241\210\202' \203' \306 \n\"*\307!\207" [calc-original-buffer lang calc-user-parse-tables entry tab calc-read-parse-table delq switch-to-buffer] 4])
(defalias 'calc-write-parse-table #[(tab calc-lang) "\211\205\" \303 @@!\210\304\305\306 @A\307\")\310\261\210 A\211\204 \311)\207" [tab p math-format-hash-args calc-write-parse-table-part ":= " t math-format-flat-expr 0 "\n" nil] 5])
(defalias 'calc-write-parse-table-part #[(p) "\205\273 @;\203N @\303\304 \"\203! \n\305>\204! \306 \307\310OP\303\311 \"\203/ \303\312 \"\204; \313 \314\"\203E A\204E \315 !\316\261\210\202J \316\261\210)\202\263 @\250\203l \317c\210@\320U\204f \321\322@!\261\210\316c\210\202\263 @@\323=\203\212 \324@8@\325\232\203\212 @A@@\316\261\210\202\263 \326c\210\327@A@!\210\330\331@@!\261\210\324@8\203\260 \327\324@8@C!\210\202\263 \316c\210A\211\204 \310\207" [p s calc-lang string-match "\\`\\\\dots\\>" (tex latex) ".." 5 nil "[a-zA-Z0-9\"{}]\\|\\`:=\\'\\|\\`#\\|\\`%%" "[^a-zA-Z0-9\\]" assoc ((")") ("]") (">")) prin1-to-string " " "#" 0 "/" int-to-string \? 2 "$$" "{ " calc-write-parse-table-part "}" symbol-name] 5])
(defalias 'calc-read-parse-table #[(calc-buf calc-lang) "\306\307\306w\210m\204\210 \310\311!\203 \306\210\202 `\312\313\314\" @;\2047 @\250\2030 A@;\2047 \nb\210\315\316!\210`\306\210 `{ r
q\210\306\211\317 \320 \321\322\323\f\"\203a \f\320\211\224O\202b \f!-\211 \242\315=\203| A@\\b\210\315\3248!\210 BC\244-\202 )\207" [tab p pt pos str calc-buf nil "\n " looking-at "%%" calc-read-parse-table-part ":=[\n ]+" ":=" error "Malformed syntax rule" math-standard-ops 0 math-read-expr string-match ",[ ]*\\'" 2 calc-hashes-used math-expr-opers calc-language calc-user-parse-tables exp] 5])
(defalias 'calc-fix-token-name #[(name &optional unquoted) "\303\304\"\203 \305\306\307OP\207\310\232\203 \311>\203 \312\207\313\232\203* \314>\203* \315\207\316\232\2038 \317>\2038 \320\207\321\232\203F \322\321!\210\323\324!\207\n\203U \303\321\"\203U \323\325!\207\303\326\"\204f \322\327\307\330#\210\323\331!\207\207" [name calc-lang unquoted string-match "\\`\\.\\." "\\dots" 2 nil "{" (tex latex eqn) "(" "}" (tex latex eqn) ")" "&" (tex latex) "," "#" search-backward error "Token '#' is reserved" "Tokens containing '#' must be quoted" "[^ ]" "\"" t "Blank tokens are not allowed"] 4])
(defalias 'calc-read-parse-table-part #[(term eterm) "\306\211\307\306w\210m\203 \310\311\n\"\210\312 !\204\312\313!\203# \306\210\202 \312\314!\203\246 \315u\210\316\317\211\" \312\320!\204; \310\321!\210\322``T{! \323u\210\312\324!\210`\325\225{ )\325\225b\210
\326=\203s )G\325V\203s )\327\232\204s )\330\232\204s \310\331!\210\332\333)\"\203\201 \334)!))G\325V\203\217 \335)!)
\f)G\325V\205\236 )\fBEC\244+\202 \312\317!\203\263 \310\336!\210\202 \312\337!\203\307 \335\340p!! C\244\202 \312\341!\203\354 \323\224\323\225U\203\332 \325\202\342 \342\323\224T\323\225{!C\244\325\225b\210\202 \312\343!\203\371 \310\344!\210\202 \312\324!\210\325\225 * \335`*{\345\"C\244*b\210)\202 \325\225b\210 G ++\323V\203M+S\211+ \233 ,\346,@\347\"\205I,@=?\205I,\326,@C\350E\240)\204 ) *\207" [quoted part eterm term p sym nil "\n " error "Expected '%s'" looking-at "%%" "{[\n ]" 2 calc-read-parse-table-part "}" "[+*?]" "Expected '+', '*', or '?'" intern 1 "[^\n ]*" 0 \? "$" "." "Separator not allowed with { ... }?" string-match "\\`\"" read-from-string calc-fix-token-name "Too many }'s" "\"" read "#\\(\\(/[0-9]+\\)?\\)[\n ]" string-to-number ":=[\n ]" "Misplaced ':='" t assoc ((")") ("]") (">")) ("$$") sep end len last] 5])
(defalias 'calc-user-define-invocation #[nil "\204 \302\303!\210\304\305!\207" [last-kbd-macro calc-invocation-macro error "No keyboard macro defined" message "Use `C-x * Z' to invoke this macro"] 2 nil nil])
(defalias 'calc-user-define-edit #[nil "\306\307!\210\310\311 \211\312 \236\206# \226\312 \236\206# \227\312 \236\206# \313\314!\211A\2119\2033 \315 ! K ;\204F :\203~ \316 8\242\317=\203~ \316 8A@\320\234 \321\f\322\" \316\211 88 '\323\324'E\322\325\326'\316 8A@\327\234$#\210
\330\261\210\331 \210\332 +\202\325 \333 !\211 (\205\221 (9\205\221 (\334N )\335\336\n@!P '\315\nA! *(\203\260 \315(!\337\310O\202\261 \340 +)\203\321 \341(!\203\321 \342)\343 \" ,\344\345!\210\332 )\202\324 \313\346!-,\207" [cmdname key def cmd mac str message "Edit definition of command: z-" nil read-char calc-user-key-map error "No command defined for that key" symbol-name 3 calc-execute-kbd-macro 1 edmacro-format-keys t calc-edit-mode calc-edit-macro-finish-edit format "Editing keyboard macro (%s, bound to %s).\nOriginal keys: %s \n" 0 "\n" calc-edit-format-macro-buffer calc-show-edit-buffer calc-stack-command-p calc-user-defn "z" char-to-string 9 "" calc-valid-formula-func math-format-nice-expr frame-width calc-do #[nil "\306\307\310DD\311\312\313 \n \f%#\210
\f)\314\261\207" [func intcmd algcmd kys niceexpr calc-full-float-format calc-edit-mode calc-finish-formula-edit quote nil format "Editing formula (%s, %s, bound to %s).\nOriginal formula: %s\n" "\n" calc-float-format] 9] "That command's definition cannot be edited" kys func defn intcmd algcmd niceexpr] 10 nil nil])
(defalias 'calc-edit-macro-repeats #[nil "b\210\303\304\305\306#\2054 \307\310\311!!`\312 {\313 b\210\314\311!\210\n\315V\2030 \316\261\210\nS\211\202 *\202 \207" [calc-edit-top line num re-search-forward "^\\([0-9]+\\)\\*" nil t string-to-number match-string 1 line-end-position line-beginning-position kill-line 0 "\n"] 5])
(defalias 'calc-edit-macro-adjust-buffer #[nil "\301 \210b\210\302\303\304\305#\203 \306\307!\210\202 b\210\302\310\304\305#\205. `dU?\205. \306\307!\210\202 \207" [calc-edit-top calc-edit-macro-repeats re-search-forward "^RET$" nil t delete-char 1 "^$"] 4])
#@72 Return the command on the current line in a Calc macro editing buffer.
(defalias 'calc-edit-macro-command #[nil "\302 \212\303\304\305 \306#\203 \307u\210\310\311x\210`)\211{*\207" [end beg line-beginning-position search-forward ";;" line-end-position 1 -2 " " nil] 6 (#$ . 16799)])
#@80 Return the type of command on the current line in a Calc macro editing buffer.
(defalias 'calc-edit-macro-command-type #[nil "\212\302\303\304 \305#\205 \306\307w\210`)\212\304 b\210\306\307x\210`)\211\203' {\202( \310*\207" [end beg search-forward ";;" line-end-position t " " nil ""] 5 (#$ . 17093)])
#@49 Put an entire algebraic entry on a single line.
(defalias 'calc-edit-macro-combine-alg-ent #[nil "\304 \305 \306\211\307 b\210\310\311!\210\304 \211\2037 \312\230\2047 \313\314 \"\211\2047 P\310\311!\210\304 \211\204 \203F \310\311!\210 \315OP\316\317\320\316\321\322 ##\211\323\261\210i\324V\203_ \325\326!\210\327\n\330\261\210\205k \331c,\207" [match curline type line calc-edit-macro-command calc-edit-macro-command-type nil line-beginning-position kill-line 1 "RET" string-match "<return>" 0 replace-regexp-in-string "SPC" " SPC " " " "" " " 24 delete-char -1 ";; " "\n" "RET ;; calc-enter\n"] 8 (#$ . 17408)])
#@50 Put an entire extended command on a single line.
(defalias 'calc-edit-macro-combine-ext-command #[nil "\305 \306\307 \310\211 \311 b\210\312\313!\210\305 \211\2039 \314\230\2049 \315\316 \"\211\2049 P\312\313!\210\305 \211\204 \203H \312\313!\210 \317OP\320\321\306 #\f\321 \322\261\210i\323V\203_ \324\325!\210\326\n\327\261\210\205k \330c-\207" [match curline type line cmdbeg calc-edit-macro-command "" calc-edit-macro-command-type nil line-beginning-position kill-line 1 "RET" string-match "<return>" 0 replace-regexp-in-string " " " " 24 delete-char -1 ";; " "\n" "RET ;; calc-enter\n"] 6 (#$ . 18054)])
#@47 Put an entire variable name on a single line.
(defalias 'calc-edit-macro-combine-var-name #[nil "\303 \304\211\305 b\210\306\307!\210\n\310\235\203 \n\311\261\202n \303 \211\203A \312\230\204A \313\314 \"\211\204A \n P\306\307!\210\303 \211\204# \203P \306\307!\210\n \315OP\316\317\320\n#\211\321\261\210i\322V\203e \323\324!\210\325c\210\205n \326c+\207" [match curline line calc-edit-macro-command nil line-beginning-position kill-line 1 ("0" "1" "2" "3" "4" "5" "6" "7" "8" "9") " ;; calc quick variable\n" "RET" string-match "<return>" 0 replace-regexp-in-string " " "" " " 24 delete-char -1 ";; calc variable\n" "RET ;; calc-enter\n"] 5 (#$ . 18693)])
#@52 Put an entire sequence of digits on a single line.
(defalias 'calc-edit-macro-combine-digits #[nil "\302 \303\304 b\210\305\306!\210\307 \310\230\203 \302 P\305\306!\210\202
\311\261\210i\312V\203/ \313\314!\210\315c*\207" [curline line calc-edit-macro-command nil line-beginning-position kill-line 1 calc-edit-macro-command-type "calcDigit-start" " " 24 delete-char -1 ";; calc digits\n"] 2 (#$ . 19379)])
#@40 Rewrite the Calc macro editing buffer.
(defalias 'calc-edit-format-macro-buffer #[nil "\302 \210b\210\303 \211\304\230\204\320 \305\230\204 \306\230\203! \307 \210\202\311 \310\230\203- \311 \210\202\311 \312\230\2039 \313 \210\202\311 \314\230\204\237 \315\230\204\237 \316\230\204\237 \317\230\204\237 \320\230\204\237 \321\230\204\237 \322\230\204\237 \323\230\204\237 \324\230\204\237 \325\230\204\237 \326\230\204\237 \327\230\204\237 \330\230\204\237 \331\230\204\237 \332\230\204\237 \333\230\204\237 \334\230\203\250 \335y\210\336 \210\202\311 \337\230\204\272 \340\230\204\272 \341\230\203\306 \335y\210\336 \210\336 \210\202\311 \335y\210\303 \211\202\n )b\207" [calc-edit-top type calc-edit-macro-adjust-buffer calc-edit-macro-command-type "" "calc-algebraic-entry" "calc-auto-algebraic-entry" calc-edit-macro-combine-alg-ent "calc-execute-extended-command" calc-edit-macro-combine-ext-command "calcDigit-start" calc-edit-macro-combine-digits "calc-store" "calc-store-into" "calc-store-neg" "calc-store-plus" "calc-store-minus" "calc-store-div" "calc-store-times" "calc-store-power" "calc-store-concat" "calc-store-inv" "calc-store-dec" "calc-store-incr" "calc-store-exchange" "calc-unstore" "calc-recall" "calc-let" "calc-permanent-variable" 1 calc-edit-macro-combine-var-name "calc-copy-variable" "calc-copy-special-constant" "calc-declare-variable"] 3 (#$ . 19802)])
(defalias 'calc-edit-macro-pre-finish-edit #[nil "b\210\301\302\303\304#\205 \305\306!\210\307\310!\210\311c\210\202 \207" [calc-edit-top re-search-forward "\\(^\\| \\)RET\\($\\| \\| \\)" nil t search-backward "RET" delete-char 3 "<return>"] 4])
#@66 Finish editing a Calc macro.
Redefine the corresponding command.
(defalias 'calc-edit-macro-finish-edit #[(cmdname key) "\306!\307 \210\nd{\310 \311\"\211 G\312U\203 \313 !\202- \314\315\316\317\320\321\f!\f\"\322
FFM+\207" [cmdname cmd calc-edit-top str mac key intern calc-edit-macro-pre-finish-edit edmacro-parse-keys t 0 fmakunbound lambda (arg) (interactive "P") calc-execute-kbd-macro vector key-description arg] 9 (#$ . 21467) nil])
(defalias 'calc-finish-formula-edit #[(func) "pd{`\306 !
q\210\307\f!\211 \242\310=\203.
q\210 A@\\b\210\310\3118!\210\nA KA@ \312!)\240\210\313 \314#-\207" [calc-edit-top func body start str buf calc-valid-formula-func math-read-expr error 2 calc-fix-user-formula put calc-user-defn calc-original-buffer val calc-user-formula-alist] 6])
(defalias 'calc-valid-formula-func #[(func) "K\211:\205( @\302=\205( AA\211\203& @@\303=\204& A\211\204 @)\207" [func def lambda math-normalize] 3])
(defalias 'calc-get-user-defn #[nil "\300\301!\207" [calc-do #[nil "\305\306!\210\307 \211\310 \236\206! \226\310 \236\206! \227\310 \236\206! \311\312!\211A\2119\203- \nK\n;\2039 \305\313\n\"\202m \314\n!\211\205I 9\205I \315N\211 \203i \316 !\203a \317\320\321\322 KA@\"\fC#\323\324\325\f#\202l \311\326!*+\207" [key def cmd func defn message "Get definition of command: z-" read-char calc-user-key-map error "No command defined for that key" "Keyboard macro: %s" calc-stack-command-p calc-user-defn calc-valid-formula-func append (calcFunc-lambda) mapcar math-build-var-name calc-enter-result 0 "gdef" "That command is not defined by a formula"] 6]] 2 nil nil])
(defalias 'calc-user-define-permanent #[nil "\300\301!\207" [calc-do #[nil "\306\307\"\210\310 \211\311 \236\206W \226\311 \236\206W \227\311 \236\206W \312=\203= \313\314\315\316\317\320\"\321\322\323\315\n\"\"\324\325$P!B\206W \326=\203T \313\314\316\317\327\"\n\330\313\331%!B\206W \332\333!\334\335!!q\210db\210 A\211 \205p \f9\205p \fK \313 @` A\336 B\313\211 C D\313 E\337\340 \341\f9\203\222 \342\f!\202\226 \317\343 \"\344\261\210
\203\243
\242\345=\203\243\f\346N\203\243` A\347
8\242\350=\203\341 \351\347
8A@!\203\341 \330\352!\203\313 \352\313!\210\330\353!\203\341 \325\211E\203\341 \347
8A@\354\313I\210\355\356\f
ABB!\211D\357\261\210\360\361D\"\203\375 E\203\362A`\"\210\363A`\364#\210A\211T|\210\365\342\f!\366\355\f\346N!\367\261\210\370\f!\211@\2050@9\2050@K` A\211 F\203\237F\242\345=\203\237@\346N\203\237\355\356@FABB!\211D\357\261\210\360\361D\"\203fE\203l\362A`\"\210\363A`\364#\210A\211T|\210`A\371\342@!\366\355@\346N!\367\261\210\362A`\"\210\363A`\364#\210A\211T|\210+\202\264
;\203\264\372\355\f!\373\355
!\367\261\210@\204\313\f\205\311\f9\205\311\330\f!\205\311\f@@\374N\203\370` A\371\342\f!\375\355@\374N!\367\261\210\362A`\"\210\363A`\364#\210A\211T|\210) @\203\376\355\377\201G !P!\201H \355\f!\367\261\210.\201I c\210\201J *\207" [calc-settings-file key obarray def cmd fcmd message "Record in %s the command: z-" read-char calc-user-key-map 39 nil intern "calcFunc-" completing-read format "Record in %s the algebraic function: " mapcar #[(x) "\301\302O\207" [x 9 nil] 3] all-completions #[(x) "\301\302\303P!!\207" [x fboundp intern "calcFunc-"] 4] t 134217848 "Record in %s the command: " fboundp "calc-" error "No command defined for that key" find-file-noselect substitute-in-file-name 70 "\n;;; Definition stored by Calc on " current-time-string "\n(put 'calc-define '" symbol-name "key%d" " '(progn\n" lambda calc-user-defn 3 calc-execute-kbd-macro vectorp edit-kbd-macro edmacro-parse-keys 1 prin1-to-string defun "\n" string-match "\"" fill-region indent-rigidly 2 " (put '" " 'calc-user-defn '" ")\n" calc-stack-command-p "(put '" " (fset '" " " math-compose-forms " 'math-compose-forms '" " (define-key calc-mode-map " "z" func pt fill-column fill-prefix str q-ok ffunc char-to-string " '" "))\n" save-buffer] 11]] 2 nil nil])
(defalias 'calc-stack-command-p #[(cmd) "\203 9\203 \301!\205Q \302K!\207:\205Q @\303=\205Q \304\236\206) \305\236\211\205Q \306\236\211\205Q \3078@\310>\205Q \3078A@@\311=\205Q \3078A@A@\207" [cmd fboundp calc-stack-command-p lambda calc-wrapper calc-slow-wrapper calc-enter-result 3 (cons list) quote] 2])
(defalias 'calc-call-last-kbd-macro #[(arg) "\203 \303\304!\210 \204 \303\305!\210\306 \n\"\207" [defining-kbd-macro last-kbd-macro arg error "Can't execute anonymous macro while defining one" "No kbd macro has been defined" calc-execute-kbd-macro] 3 nil "P"])
(defalias 'calc-execute-kbd-macro #[(mac arg &rest prefix) "\203 \304 \210\305 !\2034 G\306V\2034 \306H;\2034 \307H\2063 \307\310\311!\203- \311\312!\210\313 \306H!I\314\n!\306W\203D \315 \314\n![\"\207 \203M \315 \n\"\207\316\317`\"\207" [calc-keep-args-flag mac arg calc-executing-macro calc-keep-args vectorp 0 1 fboundp edit-kbd-macro nil edmacro-parse-keys prefix-numeric-value execute-kbd-macro calc-do #[nil "\306! \307 \n \n\310\216 \f\311
\".\207" [calc-stack calc-stack-top calc-refresh-count old-refresh-count old-buffer-size old-stack-top copy-sequence buffer-size ((byte-code "\306 \210\307!\307 ! \203$ \n\203$ @\n@\232\203$ A\nA\202 \f\310\232\204B \311 G\312V\2039 \313\314 \"\202: \315\f@\206@ \316\"\210\317\320\321
E!\210\n\203W \317\322\312\313\314\n\"E!\210 \323 \324\nG!\210* \325 U\203\231 U\203\231 \326 `d|\210 \203\222 \317\327\312D!\210\330 @!\331\261\210 A\211\204} \332 \210)\202\255 \203\252 \317\327\312D!\210 A\211\204\235 \333 \210\317\320\321\323E!\210*\326\207" [calc-stack old-stack-whole old-stack new-stack prefix old-stack-top calc-select-buffer reverse (nil) calc-record-list 1 mapcar car ("") "kmac" calc-record-undo set saved-stack-top pop 0 calc-cursor-stack-index buffer-size nil push math-format-stack-value "\n" calc-renumber-stack calc-refresh calc-stack-top old-buffer-size old-refresh-count calc-refresh-count buffer-read-only] 7)) execute-kbd-macro old-stack-whole mac calc-executing-macro arg] 4]] 5])
(defalias 'calc-push-list-in-macro #[(vals m sels) "@\306 @E\n\206 \306 \\ \f\306V\203& \f\307Z\233
\fS\233B\241\202-
B\211*\207" [vals sels m calc-stack-top mm entry 1 2 calc-stack] 4])
(defalias 'calc-pop-stack-in-macro #[(n mm) "\303V\203 \304Z \233\305\n\306# \233\241\207\n \233\211\207" [mm calc-stack n 1 2 + -1] 5])
(defalias 'calc-kbd-if #[nil "\300\301!\207" [calc-do #[nil "\302\303!\304\303!\210\305!\203 \205# \306\307!\202# \203 \306\310!\210\311\312!)\207" [cond defining-kbd-macro calc-top-n 1 calc-pop-stack math-is-true message "If true..." "Condition is false; skipping to Z: or Z] ..." calc-kbd-skip-to-else-if t] 2]] 2 nil nil])
(defalias 'calc-kbd-else-if #[nil "\300 \207" [calc-kbd-if] 1 nil nil])
(defalias 'calc-kbd-skip-to-else-if #[(else-okay) "\304\305 \304Y\203\\ \306 \211\307U\203 \310\311!\210\312U\203 \306 \211\313U\203- T\211\202 \314U\203: S\211\202 \315U\203P \304U\203 \n\203 \307\211\202 \316=\203 \317 \210\202 \205o \315U\203l \320\321!\202o \320\322!*\207" [ch count else-okay defining-kbd-macro 0 nil read-char -1 error "Unterminated Z[ in keyboard macro" 90 91 93 58 7 keyboard-quit message "Else..." "End-if..."] 3])
(defalias 'calc-kbd-end-if #[nil "\205 \301\302!\207" [defining-kbd-macro message "End-if..."] 2 nil nil])
(defalias 'calc-kbd-else #[nil "\203 \301\302!\210\303\304!\207" [defining-kbd-macro message "Else; skipping to Z] ..." calc-kbd-skip-to-else-if nil] 2 nil nil])
(defalias 'calc-kbd-repeat #[nil "\301\302\303!\210\304!)\207" [count nil calc-do #[nil "\302\303\304!!\211\211:?\206 @\305>)\204 \306\307!\210\211:\203( @\310=\202+ \311W)\2031 \311\250\2048 \312\313\304!\207" [count a math-trunc calc-top-n 1 (bigpos bigneg) error "Count must be an integer" bigneg 0 1000000 calc-pop-stack] 4] calc-kbd-loop] 2 nil nil])
(defalias 'calc-kbd-for #[(dir) "\303\211\304\305!\210\306\303 \n\205 \307\n!$*\207" [final init dir nil calc-do #[nil "\302\303!\302\304!\305!\203 \305 !\204 \306\307!\210\310\303!\207" [init final calc-top-n 2 1 math-anglep error "Initial and final values must be real numbers" calc-pop-stack] 2] calc-kbd-loop prefix-numeric-value] 6 nil "P"])
(defalias 'calc-kbd-loop #[(rpt-count &optional initial final dir) "\203\n \306!\202 \307\310\311\312\f # $\311 %&\204$ \313\314!\210 \310Y\203\233 \315 \211%\316U\2039 \317\320
\"\210%\321U\203\221 \315 % \322\323%!Q%\324>\203Z T\211\202% %\325>\203h S\211\202% %\326U\203\204 \310U\203\204 \n \310\327O\330PC\244\312\202$ %\331=\203$ \332 \210\202$ \323%!P\202$ %
\333\236AU\204\254 \317\334
%#\210&\204\265 \313\335!\210 \310\327O\330P&\204\326 \307U\203\326 \n\204\326 $\204\326 \313\336!\210\310#\203\350 '\204\350 \337(#\"'\340\341!\210&\206\364 \313\342!.\207" [rpt-count count parts body last-command-event open prefix-numeric-value 1000000 0 nil "" message "Reading loop body..." read-char -1 error "Unterminated Z%c in keyboard macro" 90 "Z" char-to-string (60 40 123) (62 41 125) 47 -2 "Z]" 7 keyboard-quit ((60 . 62) (40 . 41) (123 . 125)) "Mismatched Z%c and Z%c in keyboard macro" "Looping..." "Warning: Infinite loop! Not executing" math-compare calc-do #[nil "\306V\205\254 \203] \f\306=\203$
\307\"\306U*\202Q \f\310=\203<
\307\"\311U*\202Q \f\311=\203Y
\307\"\311U*\203Y \306\202] \312 !\210\n\203\203 \306V\203\203 \313\n@!\210\314\315\310!!\203y \306\202| \nA\316\310!\210\202] \306V\203\250 \313!\210 \203\245 \315\310! \316\310!\210\317 \")\202\250 S)\202 \207" [rpt-count parts part counter dir final 0 math-compare 1 -1 calc-push execute-kbd-macro math-is-true calc-top-n calc-pop-stack calcFunc-add b a body step] 3] "Looping...done" initial counter ch executing-kbd-macro dir final] 5 nil "P"])
(defalias 'calc-kbd-end-repeat #[nil "\300\301!\207" [error "Unbalanced Z> in keyboard macro"] 2 nil nil])
(defalias 'calc-kbd-end-for #[nil "\300\301!\207" [error "Unbalanced Z) in keyboard macro"] 2 nil nil])
(defalias 'calc-kbd-end-loop #[nil "\300\301!\207" [error "Unbalanced Z} in keyboard macro"] 2 nil nil])
(defalias 'calc-kbd-break #[nil "\300\301!\207" [calc-do #[nil "\301\302!\303\302!\210\304!\205 \305\306!)\207" [cond calc-top-n 1 calc-pop-stack math-is-true error "Keyboard macro aborted"] 2]] 2 nil nil])
(defvar calc-kbd-push-level 0)
(defvar var-q0 nil)
(defvar var-q1 nil)
(defvar var-q2 nil)
(defvar var-q3 nil)
(defvar var-q4 nil)
(defvar var-q5 nil)
(defvar var-q6 nil)
(defvar var-q7 nil)
(defvar var-q8 nil)
(defvar var-q9 nil)
(defalias 'calc-kbd-push #[(arg) "\300\301!\207" [calc-do #[nil "\205 \306!\307V\n \f
! !\" \"# #$ $ \2032 \310\2024 % % \203> \311\202@ & & \203J \312\202L ' ' ?\205U ( (?\205^ ) )?\205g * * ?\205p + + ?\205y , , ?\205\202 - - ?\205\213 . . ?\205\224 / /\307 0\313 1\314 23\204\251 4\203,4\203\262 \315\316!\2100\307Y\203\317 \2112\320U\203\307 \321\322!\2102\323U\203 \317 21\324\3252!Q12\326=\203\354 0T\2110\202\264 2\327=\203\374 0S\2110\202\264 2\330=\203\262 \331 \210\202\262 1\3252!P1\202\262 4\203 \315\332!\210\307 5\3331\307\334O!)\20285T 5\315\335!\210\336 ).\207" [arg defs var-q0 var-q1 var-q2 var-q3 prefix-numeric-value 0 12 32 deg "" nil message "Reading body..." read-char -1 error "Unterminated Z` in keyboard macro" 90 "Z" char-to-string 96 39 7 keyboard-quit "Reading body...done" execute-kbd-macro -2 "Saving modes; type Z' to restore" recursive-edit var-q4 var-q5 var-q6 var-q7 var-q8 var-q9 calc-internal-prec calc-word-size calc-angle-mode calc-simplify-mode calc-algebraic-mode calc-incomplete-algebraic-mode calc-symbolic-mode calc-matrix-mode calc-prefer-frac calc-complex-mode calc-infinite-mode count body ch executing-kbd-macro defining-kbd-macro calc-kbd-push-level] 5]] 2 nil "P"])
(defalias 'calc-kbd-pop #[nil "\301V\203
\302\303!\210\304 \207\305\306!\207" [calc-kbd-push-level 0 message "Mode settings restored" exit-recursive-edit error "Unbalanced Z' in keyboard macro"] 2 nil nil])
(defalias 'calc-kbd-query #[nil "\303\211\304\305!\242\306=\204 \307\310!\202 \311!\312\313!+\207" [msg executing-kbd-macro defining-kbd-macro nil calc-top 1 vec error "No prompt string provided" math-vector-to-string calc-do #[nil "\301\302!\210\303\304\305\232?\205 \"\207" [msg calc-pop-stack 1 calc-alg-entry nil ""] 4]] 4 nil nil])
(defalias 'calcFunc-eq #[(a b &rest more) "\203j \n\306!BB\307 \310
A\203R \f\311=\204R
A\211\203K \f\311=\204K \312
@@\"\211\307=\203!
\313@
A\"\241\210\202!
A\211\202 \f\311=\203\\ \311\202h A\203g \314 B\202h \307,\207\312 \n\"\206\226 \315 !\204} \316 !\203\222 \315\n!\204\211 \316\n!\203\222 \314\317 !\317\n!E\207\314 \nE\207" [more a b args res p copy-sequence 1 nil 0 math-two-eq delq calcFunc-eq math-looks-negp math-zerop math-neg p2] 5])
(defalias 'calcFunc-neq #[(a b &rest more) "\203e \nBB\306 \307 \310 A\203N \f\311=\204N A\211\203E \f\311=\204E \312@@\"\211\204$ \310\202$ A\211\202 \f\311=\203X \306\202c
\203` \311\202c \313 B-\207\312 \n\"\314\236A\206\224 \315 !\204{ \316 !\203\220 \315\n!\204\207 \316\n!\203\220 \313\317 !\317\n!E\207\313 \nE\207" [more a b args res all 0 t nil 1 math-two-eq calcFunc-neq ((0 . 1) (1 . 0)) math-looks-negp math-zerop math-neg p p2] 5])
(defalias 'math-two-eq #[(a b) "\242\303=\203] \242\303=\203K G GU\203I \304A A\211\203F \n\305=\204F \n\2036 \306@ @\"\202 \306@ @\"\305=\203 \305\202 \n)\207\305\207 \211:?\206W @\307>)\205\\ \305\207 \242\303=\203v \211:?\206p @\307>)\205\257 \305\207\310 \"\211\305U\203\205 \304\202\256 \n\311U\205\251 \211:?\206\227 @\312>)\205\250 \211:?\206\247 @\312>)??\205\256 \305)\207" [a b res vec 1 0 math-two-eq (bigpos bigneg frac float cplx polar hms date sdev intv mod) math-compare 2 (bigpos bigneg frac float cplx polar hms)] 4])
(defalias 'calcFunc-lt #[(a b) "\303 \"\211\304U\203 \305\202@ \n\306U\203? \307!\204! \310!\2038 \307 !\204- \310 !\2038 \311\312!\312 !E\202@ \313 E\202@ \314)\207" [a b res math-compare -1 1 2 math-looks-negp math-zerop calcFunc-gt math-neg calcFunc-lt 0] 5])
(defalias 'calcFunc-gt #[(a b) "\303 \"\211\304U\203 \304\202@ \n\305U\203? \306!\204! \307!\2038 \306 !\204- \307 !\2038 \310\311!\311 !E\202@ \312 E\202@ \313)\207" [a b res math-compare 1 2 math-looks-negp math-zerop calcFunc-lt math-neg calcFunc-gt 0] 5])
(defalias 'calcFunc-leq #[(a b) "\303 \"\211\304U\203 \305\202@ \n\306U\203? \307!\204! \310!\2038 \307 !\204- \310 !\2038 \311\312!\312 !E\202@ \313 E\202@ \304)\207" [a b res math-compare 1 0 2 math-looks-negp math-zerop calcFunc-geq math-neg calcFunc-leq] 5])
(defalias 'calcFunc-geq #[(a b) "\303 \"\211\304U\203 \305\202@ \n\306U\203? \307!\204! \310!\2038 \307 !\204- \310 !\2038 \311\312!\312 !E\202@ \313 E\202@ \314)\207" [a b res math-compare -1 0 2 math-looks-negp math-zerop calcFunc-leq math-neg calcFunc-geq 1] 5])
(defalias 'calcFunc-rmeq #[(a) "\302!\203 \303\304\"\207\242 \236\203+ \3058\242\306=\203' \307A@!\203' A@\207\3058\207\242\310=\2036 \3058\207\242\311=\203A A@\207\304D\207" [a calc-tweak-eqn-table math-vectorp math-map-vec calcFunc-rmeq 2 var math-objectp calcFunc-assign calcFunc-evalto] 3])
(defalias 'calcFunc-land #[(a b) "\211:\203$ @\302>?\205' @\303=\203 A@\304=\202' \305!\202' \304=)\203- \207 \211:\203Q @\302>?\205T @\303=\203K A@\304=\202T \305!\202T \304=)\203Z \207\306!\203b \207\306 !\203j \207\307 E\207" [a b (bigpos bigneg) float 0 math-zerop math-is-true calcFunc-land] 4])
(defalias 'calcFunc-lor #[(a b) "\211:\203$ @\302>?\205' @\303=\203 A@\304=\202' \305!\202' \304=)\203- \207 \211:\203Q @\302>?\205T @\303=\203K A@\304=\202T \305!\202T \304=)\203Z \207\306!\203b \207\306 !\203j \207\307 E\207" [a b (bigpos bigneg) float 0 math-zerop math-is-true calcFunc-lor] 4])
(defalias 'calcFunc-lnot #[(a) "\211:\203$ @\303>?\205' @\304=\203 A@\305=\202' \306!\202' \305=)\203- \307\207\310!\2035 \305\207G\311U\205@ @ \236\211\203N \312\n8AB\202Q \313D)\207" [a calc-tweak-eqn-table op (bigpos bigneg) float 0 math-zerop 1 math-is-true 3 2 calcFunc-lnot] 3])
(defalias 'calcFunc-if #[(c e1 e2) "\211:\203$ @\306>?\205' @\307=\203 A@\310=\202' \311 !\202' \310=)\203- \n\207\312!\203D \211:\205> @\313=)\204D \207\211:\205O @\313=)\203\271 \314!\203\271 \211:\205d @\313=)\203| G GU\203u A\202~ \315\316 \"\202~ C\n\211:\205\211 @\313=)\203\241 G\nGU\203\232 \nA\202\243 \315\316\n\"\202\243 \nC \211 \205\265 \f\205\265 \313\317A
\f#B*\206\276 \320 \nF\207" [c a e2 e1 ee2 ee1 (bigpos bigneg) float 0 math-zerop math-is-true vec math-constp calc-record-why "*Dimension error" math-if-vector calcFunc-if] 6])
(defalias 'math-if-vector #[(c e1 e2) "\205H @\211:\203) @\304>?\205, @\305=\203# A@\306=\202, \307 !\202, \306=)\2035 \n@\2027 @\310A A\206@ \nA\206F \n#B\207" [c a e2 e1 (bigpos bigneg) float 0 math-zerop math-if-vector] 6])
(defalias 'math-normalize-logical-op #[(a) "@\303=\203\236 G\304U\203\236 \305A@!\211\211:\2038 @\306>?\205; @\307=\2032 A@\310=\202; \311!\202; \310=)\203G \305\3128!\202\232 \211:?\206S @\313>)\203_ \305\3148!\202\232 A@\211:\205l @\315=)\203\212 \316A@!\203\212 \303A@\305\3148!\305\3128!#\202\232 \317\303 \305\3148!\305\3128!F))\206\237 \207" [a a1 calc-simplify-mode calcFunc-if 4 math-normalize (bigpos bigneg) float 0 math-zerop 3 (bigpos bigneg frac float cplx polar) 2 vec math-constp none] 7])
(defalias 'calcFunc-in #[(a b) "\242\305=\203J A\211\2031 @\242\306>\203\" \307\n @\"\310=\202. \n @\311\n\"\312U*\203 \2039 \310\202F \313\n!\205F \313 !\205F \312)\206\242\314=\203\356 \311\n\3158\"\316\211 \317U\203d \312\202\352 \f\312U\203\224 A@\315U\203\204 \3158\3208\311\n\"\317U*\203\224 A@\321>\203\220 \310\202\352 \312\202\352 \311\n\3208\"\211\310U\203\245 \312\202\352 \312U\203\325 A@\310U\203\305 \3158\3208\311\n\"\317U*\203\325 A@\322>\203\321 \310\202\352 \312\202\352 \f\310U\204\337 \316\202\352 \317U\204\351 \316\202\352 \310*\206\n\311\n\"\312U*\203\376 \310\207\313\n!\203\f\313!\203\f\312\207\307\nE\207" [b bb a res2 res vec (vec intv) calcFunc-in 1 math-compare 0 math-constp intv 2 nil -1 3 (2 3) (1 3)] 5])
(defalias 'calcFunc-typeof #[(a) "\211:?\206\f @\301>)\203 \302\207@\303=\203 \304\207@\305=\203$ \306\207@\307=\203- \310\207@\311=\2036 \312\207@\313=\203? \314\207@\315=\203H \316\207@\317=\203Q \320\207@\321=\203Z \322\207@\323=\203w A@\211:?\206o @\301>)\203u \324\207\325\207@\326=\203\212 \3048\327>\203\210 \330\207\331\207@\332=\203\233 \333!\203\231 \334\207\335\207\336@!\207" [a (bigpos bigneg) 1 frac 2 float 3 hms 4 cplx 5 polar 6 sdev 7 intv 8 mod 9 date 10 11 var (var-inf var-uinf var-nan) 12 100 vec math-matrixp 102 101 math-calcFunc-to-var] 3])
(defalias 'calcFunc-integer #[(a) "\211:?\206\f @\301>)\203 \302\207\211:?\206 @\303>)\203$ \304\207\305D\207" [a (bigpos bigneg) 1 (bigpos bigneg frac float cplx polar hms date sdev intv mod vec) 0 calcFunc-integer] 3])
(defalias 'calcFunc-real #[(a) "\211:?\206\f @\301>)\203 \302\207\211:?\206 @\303>)\203$ \304\207\305D\207" [a (bigpos bigneg frac float) 1 (bigpos bigneg frac float cplx polar hms date sdev intv mod vec) 0 calcFunc-real] 3])
(defalias 'calcFunc-constant #[(a) "\301!\203 \302\207\211:?\206 @\303>)\203 \304\207\305D\207" [a math-constp 1 (bigpos bigneg frac float cplx polar hms date sdev intv mod vec) 0 calcFunc-constant] 3])
(defalias 'calcFunc-refers #[(a b) "\302 \"\203 \303\207\242\304=\203 \305 E\207\306\207" [a b math-expr-contains 1 var calcFunc-refers 0] 3])
(defalias 'calcFunc-negative #[(a) "\301!\203 \302\207\303!\204 \304!\203 \305\207\306D\207" [a math-looks-negp 1 math-zerop math-posp 0 calcFunc-negative] 2])
(defalias 'calcFunc-variable #[(a) "\242\301=\203 \302\207\211:?\206 @\303>)\203 \304\207\305D\207" [a var 1 (bigpos bigneg frac float cplx polar hms date sdev intv mod vec) 0 calcFunc-variable] 3])
(defalias 'calcFunc-nonvar #[(a) "\242\301=\203 \302D\207\303\207" [a var calcFunc-nonvar 1] 2])
(defalias 'calcFunc-istrue #[(a) "\301!\203 \302\207\303\207" [a math-is-true 1 0] 2])
(defalias 'math-do-defmath #[(func args body) "\306\307!\210\310\311\312!P!\n@;\205 \n@C\nA\313\314\f\" \n@:\2051 \n@@\315=\2051 \n@\nA )\316\n
\"\317)\205')G\320V\204N )A@\250\203\321\211 * +)A@;\203\207 )A@\322\232\203k \323+\202\202 )A@\324\232\203z \323*\202\202 \325\326)A@\"\210)A))A@\250\204\223 \325\327!\210\330\310\331\312!P!+\204\245 *\205\246 \332\333 \315+\204\263 *\205\264 \334B\335\333*\205\310 \336\337\340\337\341)A@FEC\342*\203\322 \337\202\326 )A@\320)8+\203\361 \333\343 CD\344)A@D\345BBB\202\346\343 D\344*\203\377 \337\202)A@DEFC\"BD\"*BBB\202'\330\310\331\312!P!
\333 )\347\nBD\"BBB\330
\333 \350\f\321\211#\n#BBBE,\207" [func fname body doc args clargs require calc-macs intern "calcFunc-" symbol-name mapcar math-clean-arg interactive math-define-function-body progn 2 nil "p" t "m" error "Can't handle interactive code string \"%s\"" "Expected an integer in interactive specification" defun "calc-" (&optional n) append ("P") calc-slow-wrapper setq n if (prefix-numeric-value n) calc-enter-result quote calc-top-list-n ((and n (list (math-normalize (prefix-numeric-value n))))) cons calc-wrapper math-do-arg-list-check inter hasmulti hasprefix] 17])
(defalias 'math-clean-arg #[(arg) ":\203 \301A@!\207\207" [arg math-clean-arg] 2])
(defalias 'math-do-arg-check #[(arg var is-opt is-rest) "\203 \306 \n\307\211$\310\n A\203 \311 BC\202 )BBC\207 :\205\353 \306 A@\n\f$ @ \"\312\"! #\313\314#P!\315 !\203b \316
\f\203W \317\n\320\321 D\nEEC\202^ \317\n \nDEC\"\202\352 \315\313\322#P!\211!\203\236 \316
\f\203\215 \320\323\324\325\326 \327B\330\331\321\"DEEED\nEC\202\232 \326 \nD\330\n\321\"DEEC\"\202\352 \332\333#\"\203\345 \315\313\322\334#\335\"P!\211!\203\345 \316
\f\203\324 \320\323\324\336\310 \337B\330\331\321\"DEEED\nEC\202\341 \310 \nD\330\n\321\"DEEC\"\202\352 \340\341#\",\207" [is-opt arg var chk is-rest rest math-do-arg-check nil and progn symbol-name intern "math-check-" fboundp append setq mapcar quote "math-" function lambda (x) or (x) math-reject-arg x string-match "\\`not-\\(.*\\)\\'" math-match-substring 1 (x) (x) error "Unknown qualifier `%s'" qual qual-name] 12])
(defalias 'math-do-arg-list-check #[(args is-opt is-rest) "\204 \303\207@:\203 \304\305@\306@! \n$\307A \n#\"\207@\310=\203- \307A\311\303#\207@\312=\203; \307A\303\311#\207\307A \n#\207" [args is-opt is-rest nil append math-do-arg-check math-clean-arg math-do-arg-list-check &optional t &rest] 6])
(defconst math-prim-funcs '((~= . math-nearly-equal) (% . math-mod) (lsh . calcFunc-lsh) (ash . calcFunc-ash) (logand . calcFunc-and) (logandc2 . calcFunc-diff) (logior . calcFunc-or) (logxor . calcFunc-xor) (lognot . calcFunc-not) (equal . equal) (eq . eq) (and . and) (or . or) (if . if) (^ . math-pow) (expt . math-pow)))
(defconst math-prim-vars '((nil) (t . t) (&optional . &optional) (&rest . &rest)))
(defalias 'math-define-function-body #[(body env) "\302 \"\303\304\"\203 \305\306BBC\202 )\207" [body env math-define-body math-body-refers-to math-return catch 'math-return] 3])
(defalias 'math-define-body #[(body math-exp-env) "\301!\207" [body math-define-list] 2])
(defalias 'math-define-list #[(body &optional quote) "\204 \304\207@\305=\203( A@;\203( \306\307A@\306\"\310\n!*\311AA!B\207 \203B @:\203: \311A\306\"\202< @\311A!B\207\310@!\311A!B\207" [body math-read-expr-quotes exp quote nil : t math-read-plain-expr math-define-exp math-define-list] 3])
(defalias 'math-define-exp #[(exp) ":\203m@\211\306>\203- A@:\203) A@@\307=\203) \310\311A@\n\"B\202k\202k \312>\203c A@AA \313>\204O \314\236A\f@<\204O \fC\315 \316\f!\317 \320\f!\n\244\"BB!*\202k \321>\203\213 \322A!\203\213 G\323V\203\200 \324\325A!B\202k\326A@\3278\"\202k \330=\203\244 A@\317AAA@\nB\"BB\202k \331=\203\263 \332A!B\202k :\203\310 @\310=\203\310 \333A!B\202k 9\203e\333A!
\236 @ A@\203\346 @AAB\202a \334=\203\365 \335A@\336E\202a \337=\203\340\341\342A@AA$\202a \343=\203*AG\344U\203 \345AB\202a\340\346\342A@AA$\202a \347=\203=\340\350\344A@AA$\202a \351=\203P\340\352\344A@AA$\202a \353=\203c\340\354\342A@AA$\202a \355=\203v\340\356\342A@AA$\202a \357=\203\235\360AA@!\203\226\361AA@!\203\226\362A@D\202a\363AB\202a \364=\203\311\360AA@!\203\275\361AA@!\203\275\365A@D\202a\363AA@A@E\202a \366=\203\367\367\360AA@!\203\352\361AA@!\203\352\365A@D\202\363\363AA@A@ED\202a \370=\203 \367\360AA@!\203\361AA@!\203\362A@D\202 \363ABD\202a \371=\203a\360AA@!\203@\361AA@!\203@\361A@D\202aAA@\250\203ZAA@\372\246\342U\204Z\373AB\202a\374AB\202a \375=\203\244\367\360AA@!\203\202\361AA@!\203\202\361A@D\202\240AA@\250\203\234AA@\372\246\342U\204\234\373AB\202\240\374ABD\202a \376=\203\263\341A@\344E\202a \377=\203\304\341A@\201F E\202a \367=\203\341A\242 =\203\332AA@@\202a AB\202a \201G =\203\375AAA\203\375\201H A@AA\"\202a\315\201I ! B\201J \201K BP! C\201J \201L BP! D\201M C!\203.CAB\202_\201M D!\203?DAB\202_\201M !\204S\201N \201O B\"\203Z AB\202_CAB+!*\202k \333A!B)\2079\203\257E\236\201I ! B\211 @\203\211@A\202\255\n>\203\223\202\255\201N \201P B\"\203\243\202\255\201J \201Q BP!*\207\250\203\316\201R X\204\304\201S Y\203\314\310\201T !D\207\207\207" [exp func math-exp-env body head math-prim-funcs 'function lambda quote math-define-lambda (let let* for foreach) (let let*) ((for . math-for) (foreach . math-foreach)) macroexpand math-define-let math-define-body math-define-let-env (setq setf) math-complicated-lhs 3 progn math-define-setf-list math-define-setf 2 condition-case cond math-define-cond math-define-list floatp eq 'float + math-define-binop math-add 0 - 1 math-neg math-sub * math-mul / math-div min math-min max math-max < math-numberp math-zerop math-negp math-lessp > math-posp <= not >= = 10 math-equal-int math-equal /= 1+ 1- prim args name cfunc mfunc math-prim-vars -1 elt math-define-elt symbol-name intern "calcFunc-" "math-" fboundp string-match "\\`calcFunc-.*" "-" "var-" -1000000 1000000 math-normalize] 8])
(defalias 'math-define-cond #[(forms) "\205
\301@!\302A!B\207" [forms math-define-list math-define-cond] 3])
(defalias 'math-complicated-lhs #[(body) "\205 @9?\206 \301AA!\207" [body math-complicated-lhs] 2])
(defalias 'math-define-setf-list #[(body) "\205 \301@A@\"\302AA!B\207" [body math-define-setf math-define-setf-list] 3])
(defalias 'math-define-setf #[(place value) "\302!\302 !9\203 \303 E\207\242\304=\203% \305\306A@\3078E E\207\242\310=\2038 \305\306\3078A@E E\207\242\311=\203F \305A@ E\207\242\312=\203T \313A@ E\207\314\315\"\207" [place value math-define-exp setq nth setcar nthcdr 2 elt car cdr setcdr error "Bad place form for setf: %s"] 5])
(defalias 'math-define-binop #[(op ident arg1 rest) "\203 \304 \n @EA$\207 \206 \n\207" [rest op ident arg1 math-define-binop] 6])
(defalias 'math-define-let #[(vlist) "\205 @:\203 @@\301@A!B\202 @\302A!B\207" [vlist math-define-list math-define-let] 3])
(defalias 'math-define-let-env #[(vlist) "\205 @:\203 @@\202 @\301A!B\207" [vlist math-define-let-env] 3])
(defalias 'math-define-lambda #[(exp exp-env) "@A@D\302AA\303A@ \"\"\244\207" [exp exp-env math-define-function-body append] 6])
(defalias 'math-define-elt #[(seq idx) "\203 \302\303 @EA\"\207 \207" [idx seq math-define-elt elt] 4])
(defalias 'math-while '(macro . #[(head &rest body) "\302 BB\303 \304\"\203 \305\306 CBB\202 )\207" [head body while math-body-refers-to math-break catch 'math-break] 3]))
(defalias 'math-for '(macro . #[(head &rest body) "\203 \302 \"\202 \303\304 BB\305 \306\"\203! \307\310 CBB\202\" )\207" [head body math-handle-for while t math-body-refers-to math-break catch 'math-break] 3]))
(defalias 'math-handle-for #[(head body) "@@@A@\306@8\307@8\206 \310 A\203% \311A
\"C\202&
\n\250\2053 \250\2053 \f\250 \250\206F \242\312=\205F \313 A@! \f\250\206Y \f\242\312=\205Y \313\fA@! \203d \202g \314\315! \203r \f\202u \314\316! \317\320 ?\205\204 DC ?\205\217 \fDC \nDC#\321 \203\260 \f\322V\203\250 \323 E\202\344 \324 E\202\344 \325 \203\323 \326\f!\204\303 \326\f\243!\203\313 \327 E\202\343 \327 E\202\343 \330\326 D\327 E\327 EFD\320
\331 \203\361 \332\202\362 \333 EEC\".\nBBCBB\207" [head var init limit step body 2 3 1 math-handle-for quote math-realp make-symbol "<limit>" "<step>" let append while 0 <= >= not math-posp math-lessp if setq + math-add all-ints const-limit const-step save-limit save-step] 11])
(defalias 'math-foreach '(macro . #[(head &rest body) "\302 \"\303 \304\"\203 \305\306 CBB\202 )\207" [head body math-handle-foreach math-body-refers-to math-break catch 'math-break] 3]))
(defalias 'math-handle-foreach #[(head body) "@@@A@A\203 \304A \"C\202 \305 \nDC\306 \307 \310 \311 DEC\"+BBCBB\207" [head body data var math-handle-foreach let while append setq cdr] 10])
(defalias 'math-body-refers-to #[(body thing) " \232\206 :\205 \302@ \"\206 \302A \"\207" [body thing math-body-refers-to] 3])
(defalias 'math-break #[(&optional value) "\301\302\"\207" [value throw math-break] 3])
(defalias 'math-return #[(&optional value) "\301\302\"\207" [value throw math-return] 3])
(defalias 'math-composite-inequalities #[(x op) "A@\302>\203 @A@=\203 \303 \304\3058!C\"\207\306\307\310\"\207\311\312 8A@\313>\203a @\314>\203Z \315 @\316=\203? \312\202@ \317A@\316=\203L \320\202M \317\\ A@\304\3058!#\202\223 \306\307\310\"\202\223 @\321>\203\217 \315A@\322=\203u \312\202v \317 @\322=\203\201 \320\202\202 \317\\\304\3058! A@#\202\223 \306\307\310\"E\207" [op x (calcFunc-eq calcFunc-neq) append math-read-expr-level 3 throw syntax "Syntax error" calcFunc-in 2 (calcFunc-lt calcFunc-leq) (calcFunc-lt calcFunc-leq) math-make-intv calcFunc-leq 0 1 (calcFunc-gt calcFunc-geq) calcFunc-geq] 8])
(provide 'calc-prog)