;ELC ;;; compiled by amu@mit.edu on Wed Dec 18 01:17:52 1996 ;;; from file /afs/sipb.mit.edu/contrib/emacs/packages/calc-2.02e/calc-alg-2.el ;;; emacs version 19.30.1. ;;; bytecomp version FSF 2.10 ;;; optimization is on. ;;; this file uses opcodes which do not exist in Emacs 18. (if (and (boundp 'emacs-version) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.29"))) (error "`calc-alg-2.el' was compiled for Emacs 19.29 or later")) (byte-code "!!" [require calc-ext calc-macs] 2) (defalias 'calc-Need-calc-alg-2 #[nil "" [nil] 1]) (defalias 'calc-derivative #[(var num) "\"" [calc-do #[nil "W\n! łlj \n ̚* ͚: !! W ! =O A@\" !SYl\n EW #+" [num 0 error "Order of derivative must be positive" calc-is-hyperbolic calcFunc-tderiv calcFunc-deriv nil expr n func var "" "$" 2 calc-top-n 1 math-read-expr "Bad format in expression: %s" calc-enter-result "derv"] 5] 1813] 3 nil "sDifferentiate with respect to: \np"]) (defalias 'calc-integral #[(var) "\"" [calc-do #[nil "\fš!!E#!=+A@\"!E#)" [var "" "$" calc-enter-result 2 "intg" calcFunc-integ calc-top-n 1 math-read-expr error "Bad format in expression: %s"] 8] 2276] 3 nil "sIntegration variable: "]) (defalias 'calc-num-integral #[(&optional varname lowname highname) " &" [calc-tabular-command calcFunc-ninteg "Integration" "nint" nil varname lowname highname] 8 nil "sIntegration variable: "]) (defalias 'calc-summation #[(arg &optional varname lowname highname) "\f &" [calc-tabular-command calcFunc-sum "Summation" "sum" arg varname lowname highname] 8 nil "P\nsSummation variable: "]) (defalias 'calc-alt-summation #[(arg &optional varname lowname highname) "\f &" [calc-tabular-command calcFunc-asum "Summation" "asum" arg varname lowname highname] 8 nil "P\nsSummation variable: "]) (defalias 'calc-product #[(arg &optional varname lowname highname) "\f &" [calc-tabular-command calcFunc-prod "Index" "prod" arg varname lowname highname] 8 nil "P\nsIndex variable: "]) (defalias 'calc-tabulate #[(arg &optional varname lowname highname) "\f &" [calc-tabular-command calcFunc-table "Index" "tabl" arg varname lowname highname] 8 nil "P\nsIndex variable: "]) (defalias 'calc-tabular-command #[(func prompt prefix arg varname lowname highname) "\"" [calc-do #[nil " \n:!\f͚4\fΚ4\fP\f\\!\f\\!\f\\! \f\\T\f;]\f!_\f =p A@\"\fR!͚Κ\f\\!\f\\!\f\\T;!=A@\"\fܰ!͚Κ\f\\!\f\\T;!=A@\"\n:T\fݰ!͚6 Κ@!T !=TA@\"r\n:g!r\nr\n! !  \"\n C\"#." [nil 1 expr num stepnum stepname step high low var arg 0 varname "" "$" calc-top-n 2 3 4 math-read-expr error "Bad format in expression: %s" lowname read-string prompt " variable: " ", from: " highname ", to: " ", step: " prefix-numeric-value calc-enter-result prefix append func] 10] 5462] 3]) (defalias 'calc-solve-for #[(var) "\"" [calc-do #[nil "  ‚ ĂȚ,ɚ<!!E#x\"V\"VQ!Z!=kA@\"!E#))" [calc-is-inverse calc-is-hyperbolic calcFunc-ffinv calcFunc-finv calcFunc-fsolve calcFunc-solve func var "" "$" calc-enter-result 2 "solv" calc-top-n 1 string-match ",\\|[^ ] +[^ ]" "\\[" math-read-expr "[" "]" error "Bad format in expression: %s"] 8] 6205] 3 nil "sVariable to solve for: "]) (defalias 'calc-poly-roots #[(var) "\"" [calc-do #[nil "\fš!!E#\"0\"0Q!3!=BA@\"!E#)" [var "" "$" calc-enter-result 2 "prts" calcFunc-roots calc-top-n 1 string-match ",\\|[^ ] +[^ ]" "\\[" math-read-expr "[" "]" error "Bad format in expression: %s"] 8] 6801] 3 nil "sVariable to solve for: "]) (defalias 'calc-taylor #[(var nterms) "\"" [calc-do #[nil " != A@\"! \n!F#)" [math-read-expr var error "Bad format in expression: %s" calc-enter-result 1 "tylr" calcFunc-taylor calc-top-n prefix-numeric-value nterms] 9] 7193] 3 nil "sTaylor expansion variable: \nNNumber of terms: "]) (defalias 'math-derivative #[(expr) " ‡:B@>B@=B@=DB!B 8 <\fA@>D͇@=XA@!8!\"@=lA@!8!\"@>@A@!8!E@=A@!!@=8A@!\"A@8!\"\"@=A@!8\"A@8!\"8!\"\"@=qA@!8!: @>@=8=!=,8A@8\"E!\"\":R@>Y@=K8=V!V=iA@D!\"\"\"*@=~A@!@=\"@>GU@A@!D@>GUA@!**!͂@*8E)@9;GU)@N,%A@!-:-@>-@=-A@=-!-=-$,A@!-\"))8@N,7,!)/=]!2Y/)Y2!):v@>v@=v@9/\" E:;<=<@!:@=<@!:A@=<@!:!<@!:=@!@;V\fA;!BQ!GUCUGU+DUGEU:FUGGUIHUGIUUJKL=:LKN,K{,{M,A\"/LNN\"LAB)\"\"=*;T;=," [expr deriv-var 1 (bigpos bigneg frac float cplx polar hms) sdev var deriv-total math-const-var math-setup-declarations const 2 math-decls-cache math-decls-all 0 + math-add math-derivative - math-sub (calcFunc-eq calcFunc-neq calcFunc-lt calcFunc-gt calcFunc-leq calcFunc-geq) neg math-neg * math-mul / math-div math-sqr ^ dv du (bigpos bigneg) float math-zerop math-normalize -1 calcFunc-ln % vec math-map-vec (calcFunc-conj calcFunc-re calcFunc-im) (calcFunc-subscr calcFunc-mrow calcFunc-mcol) 3 d math-numberp handler deriv math-derivative-n deriv-symb pre-expand math-expand-formula exp math-deriv (math-derivative expr) (bigpos bigneg frac float cplx polar hms date sdev intv mod vec) throw nil calcFunc-tderiv calcFunc-deriv derv n arg accum intern symbol-name "'" int-to-string "" math-derivative-1 math-derivative-2 4 math-derivative-3 5 math-derivative-4 6 math-derivative-5 prop func apply calc-user-defn] 10]) (defalias 'calcFunc-deriv #[(expr deriv-var &optional deriv-value deriv-symb) "Í=\f\f!\f)(\f #)\f*" [nil deriv-total math-deriv (math-derivative expr) res calcFunc-deriv math-normalize deriv-value math-expr-subst deriv-var] 5]) (defalias 'calcFunc-tderiv #[(expr deriv-var &optional deriv-value deriv-symb) " č=  ! ,+ \n#, *" [math-setup-declarations t deriv-total math-deriv (math-derivative expr) res calcFunc-tderiv math-normalize deriv-value math-expr-subst deriv-var] 5]) (byte-code "#############################" [put calcFunc-inv\' math-derivative-1 #[(u) "\f!\"!" [math-neg math-div 1 math-sqr u] 5] calcFunc-sqrt\' #[(u) " D\"\"" [math-div 1 math-mul 2 calcFunc-sqrt u] 6] calcFunc-deg\' #[(u) " \"" [math-div-float (float 18 1) math-pi] 3] calcFunc-rad\' #[(u) " " [math-pi-over-180] 1] calcFunc-ln\' #[(u) "\n\"" [math-div 1 u] 3] calcFunc-log10\' #[(u) "!\"\f\"" [math-div 1 math-normalize (calcFunc-ln 10) u] 5] calcFunc-lnp1\' #[(u) " \"\"" [math-div 1 math-add u] 5] calcFunc-log\' math-derivative-2 #[(x b) ":\"@>?%@=A@=%!%=?:D! \"\")" [b (bigpos bigneg) float 0 math-zerop math-normalize calcFunc-ln lnv math-div 1 math-mul x] 5] calcFunc-log\'2 #[(x b) " D E\n \"\"!)" [calcFunc-ln b lnv math-neg math-div calcFunc-log x math-mul] 6] calcFunc-exp\' #[(u) "\nD!" [math-normalize calcFunc-exp u] 3] calcFunc-expm1\' #[(u) "\nD!" [math-normalize calcFunc-expm1 u] 3] calcFunc-sin\' #[(u) " D!!" [math-to-radians-2 math-normalize calcFunc-cos u] 4] calcFunc-cos\' #[(u) "\fD!!!" [math-neg math-to-radians-2 math-normalize calcFunc-sin u] 5] calcFunc-tan\' #[(u) "D!!\"!" [math-to-radians-2 math-div 1 math-sqr math-normalize calcFunc-cos u] 7] calcFunc-arcsin\' #[(u) "!\"D!\"!" [math-from-radians-2 math-div 1 math-normalize calcFunc-sqrt math-sub math-sqr u] 9] calcFunc-arccos\' #[(u) "!\"D!\"!" [math-from-radians-2 math-div -1 math-normalize calcFunc-sqrt math-sub 1 math-sqr u] 9] calcFunc-arctan\' #[(u) " !\"\"!" [math-from-radians-2 math-div 1 math-add math-sqr u] 7] calcFunc-sinh\' #[(u) "\nD!" [math-normalize calcFunc-cosh u] 3] calcFunc-cosh\' #[(u) "\nD!" [math-normalize calcFunc-sinh u] 3] calcFunc-tanh\' #[(u) " D!!\"" [math-div 1 math-sqr math-normalize calcFunc-cosh u] 6] calcFunc-arcsinh\' #[(u) "!\"D!\"" [math-div 1 math-normalize calcFunc-sqrt math-add math-sqr u] 7] calcFunc-arccosh\' #[(u) "!\"D!\"" [math-div 1 math-normalize calcFunc-sqrt math-add math-sqr u -1] 7] calcFunc-arctanh\' #[(u) "\f!\"\"" [math-div 1 math-sub math-sqr u] 6] calcFunc-bern\'2 #[(n x) " \" E\"" [math-mul n calcFunc-bern math-add -1 x] 6] calcFunc-euler\'2 #[(n x) " \" E\"" [math-mul n calcFunc-euler math-add -1 x] 6] calcFunc-gammag\'2 #[(a x) " \n#" [math-deriv-gamma a x 1] 4] calcFunc-gammaG\'2 #[(a x) " \n#" [math-deriv-gamma a x -1] 4] calcFunc-gammaP\'2 #[(a x) " \n D!\"#" [math-deriv-gamma a x math-div 1 math-normalize calcFunc-gamma] 8] calcFunc-gammaQ\'2 #[(a x) " \n D!\"#" [math-deriv-gamma a x math-div -1 math-normalize calcFunc-gamma] 8]] 4) (defalias 'math-deriv-gamma #[(a x scale) " \"\" !D\"\"" [math-mul scale math-pow x math-add a -1 calcFunc-exp math-neg] 8]) (byte-code "##" [put calcFunc-betaB\' math-derivative-3 #[(x a b) " \n $" [math-deriv-beta x a b 1] 5] calcFunc-betaI\' #[(x a b) " \n \n E\"$" [math-deriv-beta x a b math-div 1 calcFunc-beta] 9]] 4) (defalias 'math-deriv-beta #[(x a b scale) "\n\f\"\"\n\"\"\"\" \"" [math-mul math-pow x math-add a -1 math-sub 1 b scale] 8]) (byte-code "#########ECC" [put calcFunc-erf\' math-derivative-1 #[(x) " !Dǂ \"\"" [math-div 2 math-mul calcFunc-exp math-sqr x calc-symbolic-mode (calcFunc-sqrt (var pi var-pi)) math-sqrt-pi] 6] calcFunc-erfc\' #[(x) " !Dǂ \"\"" [math-div -2 math-mul calcFunc-exp math-sqr x calc-symbolic-mode (calcFunc-sqrt (var pi var-pi)) math-sqrt-pi] 6] calcFunc-besJ\'2 math-derivative-2 #[(v z) "\f\"E\f\"E\"\"" [math-div math-sub calcFunc-besJ math-add v -1 z 1 2] 7] calcFunc-besY\'2 #[(v z) "\f\"E\f\"E\"\"" [math-div math-sub calcFunc-besY math-add v -1 z 1 2] 7] calcFunc-sum math-derivative-n #[(expr) "\nAAB \"\"\nA@!\nAABB" [math-expr-contains vec expr deriv-var throw math-deriv nil calcFunc-sum math-derivative] 3] calcFunc-prod #[(expr) "\nAAB \"\"\n\nA@!\nA@\"\nAABB\"" [math-expr-contains vec expr deriv-var throw math-deriv nil math-mul calcFunc-sum math-div math-derivative] 6] calcFunc-integ #[(expr) "GU 8 A@A@!8E!GUwA@88#A@88#\n \n8!\" 8!\"\"8 bςuA@!888!\"*" [expr 3 2 deriv-var math-normalize calcFunc-integ math-derivative 5 math-expr-subst 4 upper lower math-add math-sub math-mul 0] 9] calcFunc-if #[(expr) "GUA@8!8!F" [expr 4 calcFunc-if math-derivative 2 3] 6] calcFunc-subscr #[(expr) "GUA@8!E" [expr 3 calcFunc-subscr math-derivative 2] 5] (var X ---) math-integ-var (var Y ---) math-integ-var-2 f math-integ-vars math-integ-var-list math-integ-var-list-list] 5) (defalias 'math-tracing-integral '(macro . #[(&rest parts) "EBɯE" [and trace-buffer save-excursion (set-buffer trace-buffer) (goto-char (point-max)) (bolp) (insert (make-string (- math-integral-limit math-integ-level) 32) (format "%2d " math-integ-depth) (make-string math-integ-level 32)) insert parts (sit-for 0)] 8])) (defalias 'math-integral #[(expr &optional simplify same-as-above) " \f\" T@qdbn2\n Z\" \" \" \"ұ!)xqdbni\n Z\" \" \"A@\"!)8:!qdbn\n Z\" \" \"A@\"ٱ!)8=8/8 Y/ !/܎=! \"\"!A% !砈( %! !\"D\fB(=\\qdbnT\n Z\" \" \"c!) ! qdbn\n Z\" \" \"c!) !qdbn\n Z\" \" \"c!) #! !!(=! ! qdbn\n Z\" \" \"!) #))=.!)A@!FA@H2A@>]AEiA@:iA@qdbn\n Z\" \" \" \"\"ٱ!)," [cur-record simp assoc expr math-integral-cache math-integ-depth cancelled val trace-buffer make-string math-integral-limit math-integ-level 32 format "%2d " "Integrating " math-format-value 1000 "...\n" sit-for 0 "Found " 1 math-replace-integral-parts " => " "\n" math-integral-contains-parts nil ((byte-code "A \n \fŠ" [cur-record val math-enable-subst math-any-substs math-integ-level cancelled] 2)) math-integ-msg calc-display-working-message lots calc-set-command-flag clear-message "Working... Integrating %s" math-format-flat-expr message same-as-above vector busy simplify yes "Simplifying..." math-simplify " no change\n" math-do-integral " simplified\n" math-integral no t "Trying again after " "simplification...\n" vectorp (parts parts2) parts2 var PARTS "Integral of " " is "] 7]) (byte-code "! B! B‡" [boundp math-integral-cache nil current-load-list math-integral-cache-state] 2) (defalias 'math-integral-contains-parts #[(expr) ":\f@> =/A@=/8<A.@! " [expr (bigpos bigneg frac float cplx polar hms date mod var) var PARTS 2 math-integral-contains-parts] 2]) (defalias 'math-replace-integral-parts #[(expr) ":?`@>`A`@: @@=X@A@= @8: @8A@\fA@@\fA@A@\f8\"\fA@8\f8\"E#+\f8>.\f8@\f8A@\fA@\"ɉ\f88\fA@\"E#+\f@=4\fA@ \"<\fA@\"<\f8\"!.\fA@\n\"+\f8 \"X\fA@!.\n\f8\"+\fA@=\fA@A@ \"\fA@8\f8\"!.\n\fA@A@\"+\fA@=\fA@8 \"\fA@A@\f8\"!.\n\fA@8\"+\f8=\f8A@ \"\fA@ɉ\f88\"!.\n\f8A@\"+\f8=ɉ\f88 \"\fA@\f8A@\"!.\nɉ\f88\"+\f8=.\fA@\f8A@!D\"!+\f@=.\fA@ \"w\f8 #b\f\nA@\fA@D!\"\".\f8\fA@D!\"D#+\f8 \".\f8\f8W\fA@\f8[\"E#+\fA@ #\f8\"\fA@ \" \nA@\"\".\f8:\f8@=\f8@=.\f8@>\n\f8A@:\f8A@@=\f8A@W\f8!\f8W.\fA@\f8!\"\"#.\f #j%&\nd&\n@ %\"\"%\"\"&\nA>%T%>&*.\fGU\f@9\f@N\n\n@\fA@!\nA  !\fGU\f@9\f@N\n\n@\fA@\f8\"\nA  !.\f \"\f \"\n\f\n!.+iK\f E./01M0#/1M/0?e/\".Z.G>e.A\";\f;@;8Q D;8%)e/\"?e/-.@A\f@!\"A\f@!\fBC%DE%T%DADD@ CB%CD@ \"BC B? CU@FGC\"HHIPE\"\nJEމOEޔHG\\OP!\fAB)-.KVL\f!.M\f!/-/!)*" [nil t2 t1 math-expr-contains expr math-integ-var math-mul math-div math-sqr 2 + math-integral math-add - math-sub neg math-neg * (+ -) yes t (+ -) / math-equal-int 1 calcFunc-exp ^ math-is-polynomial math-normalize calcFunc-ln 0 math-pow bigneg bigpos (frac float) math-negp 20 n accum 3 math-integral-2 math-ratpoly-p calcFunc-apart has-rules calcFunc-integ calcFunc-integtry part res input math-old-integ ((byte-code " M" [calcFunc-integ math-old-integ] 2)) math-sub-integration math-rewrite (var IntegRules var-IntegRules) math-expr-calls (calcFunc-integsubst) (3 4 5) mapcar #[(x) " 8\f#" [math-expr-subst x 2 part math-integ-var] 4] parts math-integrate-by-substitution calcFunc-integfailed (calcFunc-integtry calcFunc-integfailed) string-match "'" symbol-name bad which p name format "'%d" prime "\\('['0-9]*\\|$\\)" intern math-integ-level math-do-integral-methods math-expand-formula] 9]) (defalias 'math-sub-integration #[(expr &rest rest) " \nW@ = !1 # \nU.\"?0)7 D" [rest math-integ-level math-integral-limit math-integ-var math-integral expr apply math-old-integ res math-expr-calls calcFunc-integ calcFunc-integfailed] 4]) (defalias 'math-do-integral-methods #[(expr) "\f!!! ? @@>? @A@ ? A \" )b!T\" \"D\"\n  @@> @A@  A i )!\" \"D\"\n   @  @@= @A@ # A  ?)AA8!:8!!A@\"\"@!\"!\" \"\"\"\"D\"+8!A@\"\"@!\"&&!| \"\"&!!\"D\" \"\"&!\"D\"+\"!*" [math-integ-var-list-list nil rat-in so-far math-enable-subst math-integ-try-substitutions expr math-integ-try-linear-substitutions math-expr-rational-in p (calcFunc-sin calcFunc-cos calcFunc-tan) math-integ-var math-integ-parts-easy math-integ-try-parts t math-integrate-by-good-substitution calcFunc-tan math-div 2 (calcFunc-sinh calcFunc-cosh calcFunc-tanh calcFunc-exp) calcFunc-tanh t1 calcFunc-sqrt math-is-polynomial t2 math-guess-if-neg math-sqrt math-neg c math-mul -2 d math-add math-sqr a calcFunc-arcsin math-div-thru math-sub aa calcFunc-arccosh calcFunc-arcsinh] 9]) (defalias 'math-integ-parts-easy #[(expr) ":\f@>‡@>#A@![8!@=8A@![8!@=M8![A@!@=ZA@!‡" [expr (bigpos bigneg frac float cplx polar hms date mod var) t (+ - *) math-integ-parts-easy 2 / math-atomic-factorp ^ natnump neg] 3]) (defalias 'math-integ-try-parts #[(expr &optional math-good-parts) " ! ?\n!) @=W A@\") 8 : A@ 8\"S 8 A@\"S ?S A@ 8\") @= A@\" 8\" A@\" A@\") @= A@ 8\"\" A@\"" [calcFunc-expand expr exp math-integral * math-polynomial-p math-integ-var 2 math-prev-parts-v first-bad math-integrate-by-parts / math-expr-contains math-div 1 recip ^ math-pow math-sub] 7]) (defalias 'math-integrate-by-parts #[(u vprime) " \n \"\f\fSƉ Yˎ\fA͠aqdbnM\fZ\"\"\f\"\n\"\"ڱ!)!\n $\"\")\n\"\"\fA@=!\fE\"E&'\"$)?!)," [math-good-parts math-polynomial-p u math-integ-var math-integ-level t nil temp v math-doing-parts 0 ((byte-code "A" [cur-record busy] 2)) cur-record parts trace-buffer make-string math-integral-limit 32 format "%2d " math-integ-depth "Integrating by parts, u = " math-format-value 1000 ", v' = " vprime "\n" sit-for math-integral calcFunc-deriv math-prev-parts-v math-mul yes math-sub calcFunc-expand var PARTS vec var-thing calc-next-why math-solve-for math-simplify-extended] 7]) (defalias 'math-integrate-by-substitution #[(expr u &optional user uinv uinvprime) "VZ]\f %)" [math-integ-level 0 2 math-integrate-by-good-substitution expr u user uinv uinvprime] 6]) (defalias 'math-integrate-by-good-substitution #[(expr u &optional user uinv uinvprime) "  #!  $)\f[\fqdbnLZ\"\"\" \"ױ!) ?$Ɖ \" # ##\" ?$Ɖ # ## \"\"\n #!+" [t nil temp deriv math-living-dangerously uinv math-expr-subst math-integ-var math-integ-var-2 calc-next-why math-solve-for u trace-buffer make-string math-integral-limit math-integ-level 32 format "%2d " math-integ-depth "Integrating by substitution, u = " math-format-value 1000 "\n" sit-for 0 calcFunc-deriv user math-integral math-div expr yes uinvprime math-mul math-simplify-extended] 8]) (defalias 'math-integ-try-linear-substitutions #[(sub-expr) ":?\n@>?x@>a@=#8a\"aA[@\".@ \".@C B  @\".)xAu@!d)" [sub-expr (bigpos bigneg frac float cplx polar hms date mod var) (+ - * / neg) ^ 2 math-expr-contains math-integ-var nil res math-linear-in assoc so-far math-integrate-by-substitution expr math-integ-try-linear-substitutions] 3]) (defalias 'math-integ-try-substitutions #[(sub-expr &optional allow-rat) ":?\n@>? \"? \"@>9@=289ɉ\n>\n\nu\f=u\f\"@=u8u8WuA@8[\"\"C BA@\n\"})" [sub-expr (bigpos bigneg frac float cplx polar hms date mod var) assoc so-far math-expr-contains math-integ-var (+ - * / neg) ^ 2 t allow-rat nil expr math-integrate-by-substitution 0 math-integ-try-substitutions math-pow res] 5]) (defalias 'math-expr-rational-in #[(expr) " ! \")" [nil parts math-expr-rational-in-rec expr mapcar car] 3]) (defalias 'math-expr-rational-in-rec #[(expr) ":\f@>!\nv\f\"?vC\fB@>6@=H8HA@!8v8!@=a8!=aA@D!\f\"?v\n\"vC\fB" [expr (bigpos bigneg frac float cplx polar hms date mod var) math-integ-var assoc parts (+ - * / neg) ^ 2 math-expr-rational-in-rec math-quarter-integer calcFunc-sqrt math-expr-contains] 3]) (defalias 'math-expr-calls #[(expr funcs &optional arg-contains) ":[@ >$@=3 @=38!=31\"[:?=@>?[\nAX@ #\nD\n)" [expr funcs ^ calcFunc-sqrt math-quarter-integer 2 arg-contains math-expr-contains (bigpos bigneg frac float cplx polar hms date mod var) nil res math-expr-calls] 4]) (defalias 'math-fix-const-terms #[(expr except-vars) " \n\" Ç : @> @=- A@\n\" 8\n\"\" @=C A@\n\" 8\n\"\" " [math-expr-depends expr except-vars 0 (bigpos bigneg frac float cplx polar hms date mod var) + math-add math-fix-const-terms 2 - math-sub] 5]) (defalias 'calc-dump-integral-cache #[(&optional arg) "p\n!!!q O @ &\f!\f@\"\fA@9>\fA@!QD\fA@\"ӱ Aeb," [buf ((set-buffer buf)) math-integral-cache nil cur-record p display-buffer get-buffer-create "*Integral Cache*" get-buffer erase-buffer arg math-replace-integral-parts math-format-flat-expr 0 " --> " "(" symbol-name ")" "\n"] 6 nil "P"]) (defalias 'math-try-integral #[(expr) "ĉ! \n \f \"L6ĉ6\"LVLL\"." [math-integral-limit 0 "Working...done" nil t calc-has-rules var-IntegRules has-rules calc-symbolic-mode calc-prefer-frac math-integrating cur-record math-integ-msg math-integ-depth math-integ-level math-integral expr yes math-any-substs math-enable-subst math-max-integral-limit] 10]) (defalias 'calcFunc-integ #[(expr var &optional low high) "=A@\f $8\f $\"=8A@\f $8\f $\"=KA@\f $!=jA@\f\"jA@8\f $\"=8\f\"A@\f $8\"=A@\f\"A@\"A@8\"\f $\"=8\f\"A@\f $8\"=A@=A@A@\f\"A@A@A@88\"\f $\"=9A@=9A@8\f\"9A@8A@A@8\"\f $\"=l8=l8A@\f\"lA@lj88\"\f $8A@\"=8=lj88\f\"A@8A@\"\f $lj88\"=A\"B!!F)! ! #$\f&#'!*+=?++./012*Jp 45*!&*!!*qdb ;!HĂI :U @>YĂZ\\n:n@>rĂs\\U Ԛ \"\":@>!:@=8Y!:@= @=@>A@:A@@=\nA@W\n!\nWT !\"%#!Y T \"'=Q!\"j'=c!\"j!Bt\"S2'B,:@> \":@>@=8Y : @> @= 8Y\" \"\"'%E  ? DC#+" [low (neg (var inf var-inf)) (var inf var-inf) high 1 math-infinitep step math-scan-for-limits expr math-zerop math-reject-arg nonzerop (bigpos bigneg frac float cplx polar hms date sdev intv mod) 0 (var inf var-inf) nil vec count known 2 (var inf var-inf) math-div math-sub math-simplify float math-trunc bigneg bigpos (frac float) math-negp -1 math-tabulate-initial math-working-step math-working-step-2 var-DUMMY math-evaluate-expr math-expr-subst var (var DUMMY var-DUMMY) math-tabulate-function calcFunc-sum math-add calcFunc-prod math-mul (bigpos bigneg) calc-record-why fixnump (bigpos bigneg) integerp append calcFunc-table (neg (var inf var-inf)) (var inf var-inf)] 6]) (byte-code "" [nil math-tabulate-initial math-tabulate-function] 1) (defalias 'math-scan-for-limits #[(x) ":?@>@=A@:A@@=8\"8$ 8A@GS$\f  d !d\fd\f!\f \"U{  \f  \f !\"\f!\",A@!" [x (bigpos bigneg frac float cplx polar hms date mod var) calcFunc-subscr vec math-expr-contains 2 var nil calc-next-why math-solve-for 1 low-val high-val temp math-realp math-compare -1 math-max low math-ceiling math-min high math-floor math-scan-for-limits] 5]) (defalias 'calcFunc-sum #[(expr var &optional low high step) " \n\\  %)\n\n!*" [math-disable-sums math-reject-arg calc-internal-prec 2 math-sum-rec expr var low high step res t math-normalize] 6]) (byte-code "" [nil math-disable-sums] 1) (defalias 'math-sum-rec #[(expr var &optional low high step) " ʼn\n \"<\n \"5\"\"\"?\"!_\n !%?\"!!\n  \"#!  \"!$\n  \"\"#! \"\"!$)? \">=\n #?ڂ?\n #(  !@$ TA \">$ \"\"\"*?\n@>g\nA@  $\n8  $g\"\\\"g\n@E?\n@=\n \"@A  $\"?\n@=\nA@>\nA@A@\n8\"\nA@8\n8\"\nA@@=$  $?\n@=\n8>\nA@\n8A@\"\nA@\n88\"\n8@=$  $?\n@=<\nA@!<\nA@ \"<@A\n8\"  $\"?\n@=i\n8 \"i\nA@A\"  $@\"?\n@=\nA@  $!?\n@=\nA@ \"\n8 #\nA@A@\"55 \"\"5\"\"\nA@@\"\"5\"\")?\n!  $\"!?\n@>\n@\nA@  $D?\n@=?\nGU?\n8 \"??\nA@  $\n8EJ`>@A\n  $*+" [low (neg (var inf var-inf)) (var inf var-inf) high 1 nil val t2 t1 math-expr-contains expr var math-mul math-add math-div math-sub step math-equal-int math-negp math-sum-rec math-neg math-simplify lo math-known-num-integerp math-normalize math-expr-subst 0 math-compare (0 1) math-is-polynomial 20 n poly math-poly-mix math-sum-integer-power math-build-polynomial-expr (0 1) (+ -) 2 math-expr-calls (calcFunc-sum) (calcFunc-sum) * math-sum-const-factors (+ -) math-add-or-sub - (+ -) / math-primp neg ^ math-pow x math-to-exponentials (calcFunc-sum) math-to-exps (calcFunc-ln calcFunc-log10) calcFunc-prod calcFunc-log 3 (var nan var-nan) math-tabulate-initial calcFunc-sum math-tabulate-function calcFunc-table] 10]) (defalias 'calcFunc-asum #[(expr var low &optional high step no-mul-flag) "  x \"x !- \"\n  !&\" \"!!X\n  \"#!  \"!$v\n  \" \"#!  \" \"!$)‚ \" \"\n\" $\"" [high low 1 step math-equal-int math-negp math-mul math-pow -1 calcFunc-asum expr var math-neg t math-simplify math-div lo math-num-integerp math-normalize math-expr-subst math-add 0 math-sub no-mul-flag calcFunc-sum] 9]) (defalias 'math-sum-const-factors #[(expr var) " \n=.\nA@\" \nA@ B&\nA@\fB\n8\n\"=\n BA\n\fB\f|\f@ \fA[\f@ E I ) @d Ax @ E f )B+" [nil expr p not-const const * math-expr-contains var 2 temp 1] 5]) (defalias 'math-sum-integer-power #[(pow) " G\n\fXlʼnD\nS 8A\n  Q@\n\"  \n\"B  \" \nT\nA(\n \"\" C\nT.\f 8*" [t math-sum-int-pow-cache n calc-prefer-frac pow 0 new lin pp 2 p sum nil q math-div math-mul math-add math-sub 1] 7]) (byte-code "C‡" [(0 1) math-sum-int-pow-cache nil] 1) (defalias 'math-to-exponentials #[(expr) ":GUA@\n \n!ł\" @=7 E@=p=P EE  EE EDEEEE@== EE  EE EDEEE@= E DEEE@= E DEEE+" [expr 2 calc-symbolic-mode (var pi var-pi) math-pi (var i var-i) (cplx 0 1) i pi x calcFunc-exp ^ (var e var-e) calcFunc-sin calc-angle-mode rad / * 180 - (var e var-e) (var e var-e) neg calcFunc-cos + (var e var-e) (var e var-e) calcFunc-sinh (var e var-e) (var e var-e) calcFunc-cosh (var e var-e) (var e var-e) nil] 9]) (defalias 'math-to-exps #[(expr) " : @> Ú @=2 A@ƚ2 8D @ A\"B" [calc-symbolic-mode expr (bigpos bigneg frac float cplx polar hms date mod var) (var e var-e) math-e ^ (var e var-e) calcFunc-exp 2 mapcar math-to-exps] 4]) (defalias 'calcFunc-prod #[(expr var &optional low high step) " \n\\  %)\n\n!*" [math-disable-prods math-reject-arg calc-internal-prec 2 math-prod-rec expr var low high step res t math-normalize] 6]) (byte-code "" [nil math-disable-prods] 1) (defalias 'math-prod-rec #[(expr var &optional low high step) " ʼn  \f\"= \"6\"\"\"\\\"!` \f !%\\\"!! \f\f\"#!\f \"!$ \f\f\"\"#!\f \"\"!$)\\ @> A@\f $  8\f $ \"\" @ E\\ @= 8\f\" A@\f $ 8\"\\ @== A@\f\"= A@ 8\f $\"\\ @=W A@\f D!\\ @=x \"\"\" A@\f $\"\\ @= A@\f $D\\ \f# \\ A@\" @\"!  @\"! A@\"< @ \"! @\"!<! !݂T! !.! !. !݂TΉ \"\"\"!D \"DE\"T D\"DET A@\"d\" @\"! \" @\"! A@\"T @ \"\"! @\"\"!T!!!!!T!T!!݂T!!!! !݂T!D\"DETD\"DET!@EEEE!D\"DEET!TD\"DE\\g{:; \f $*," [low (neg (var inf var-inf)) (var inf var-inf) high (var inf var-inf) nil val t3 t2 t1 math-expr-contains expr var math-pow math-add math-div math-sub step 1 math-equal-int math-negp math-prod-rec math-neg math-simplify lo math-known-num-integerp math-normalize math-expr-subst math-mul 0 (* /) 2 math-expr-calls (calcFunc-prod) (calcFunc-prod) ^ calcFunc-sum sqrt calcFunc-sqrt calcFunc-prod neg -1 calcFunc-exp math-is-polynomial math-zerop math-num-integerp math-posp / calcFunc-fact -2 math-integerp math-messy-integerp math-trunc math-evenp calcFunc-dfact * - (var nan var-nan) math-tabulate-initial math-tabulate-function calcFunc-table] 10]) (defalias 'math-try-solve-for #[(lhs rhs &optional sign no-poly) "\f o=j\f!D \nb@ @C A U\n @#A:\nA-\n!,\f\f:{\f@>\f@=\fA@\f8=\f:\f@>\f@=\fA@=\f!\f=\fA@GU\f8GU\fA@@N !\n\"=\n!\fA@A@\n \f8A@#\"\" \f@=,\fA@\f!([#=8 &\f \f$\nA@A GUb\n@ # GUr\n@ # GU\n@ # GU\n@ $\n@ \"2\n@ !#$)\n8=  \n8$\"!\f\"\f \"= \n! \n\"  \n\"!\f #!\f\"\n #\"!\"\f@=[\fA@ \"@\f8\f\fA@\"#\f8 \"?\fA@\f\f8\"#\f@=u\fA@\f8\"\f&$\f@=\fA@@=\f8A=\fA@A=\f8@=\fA@\fA@@B!\f8A@\"D\"\f\"\fA@ \"\f8\fA@\f\"[#\f8 \"?\fA@C\f\f8\"#= \f@D=5\f8 \"5\fA@C\fE\f8!\"\"\f@F=t\f8 \"V\fA@\f8\f\"\"\fA@ \"?\f8\fA@G\f\"\"\"\fGU\f@9\f@N \f!\f@HN\fA@\n!   _ \f\"#\f@9\f@IN \f\f\"\nJ\f! \f#K\f\"+" [nil t3 t2 t1 lhs solve-var sign math-solve-sign solve-full all vec math-evaluate-expr rhs p var newvec math-solve-ranges math-expr-subst math-normalize (bigpos bigneg frac float cplx polar hms date mod var) - 2 (bigpos bigneg) float 0 math-zerop math-inverse (var SOLVEDUM SOLVEDUM) math-expr-contains-count (var SOLVEDUM SOLVEDUM) 1 math-solve-above-dummy math-try-solve-for math-sub neg math-neg t math-try-solve-prod no-poly math-decompose-poly 15 5 apply math-solve-quartic 4 math-solve-cubic 3 math-solve-quadratic math-solve-linear math-poly-all-roots calc-symbolic-mode math-poly-any-root reverse math-solve-prod calc-record-why "*Unable to find a symbolic solution" math-solve-find-root-term math-simplify math-evenp math-pow math-expand-power + math-expr-contains calcFunc-eq calcFunc-sin calcFunc-cos math-quarter-circle math-add % math-solve-get-int calcFunc-log math-div math-inverse-sign math-inverse-n math-expand-formula "*No inverse known"] 12]) (byte-code "" [nil math-solve-ranges] 1) (defalias 'math-try-solve-prod #[nil "@=A@ \"$8A@\" A@\"#8 \"AA@8\" 8\"#:h@>?d@=aA@=l!l=d8\")A@\"\"@=A@ \"8A@\" A@\"#8 \"A@8\" 8\"#A@8\"\"\"d@=cA@ \"8A@E!!\"\"A@D!\"\"\"8 \"?d88Y8!=cA@!cSYZDF!{SY{D!!cA@!\"8!A@8!E\"\"=8:8@>A@!8E!8!!A@ 8! 8\"#A@8:\n8@>'88!\"\"8\"\"A8:8!\"\"\"8\"D!8E!\" a8!a 8\"#" [lhs * math-expr-contains solve-var math-try-solve-for 2 math-div rhs math-solve-sign sign (bigpos bigneg) float 0 math-zerop math-solve-prod math-solve-ranges / math-mul math-sub t1 ^ math-add math-normalize calcFunc-log (var pi var-pi) math-solve-get-int (var i var-i) calcFunc-ln math-integer-log2 t2 solve-full t math-known-realp calcFunc-sqrt math-solve-get-sign math-looks-negp math-neg 1 (bigpos bigneg) calcFunc-nroot math-evenp math-oddp calcFunc-exp (bigpos bigneg frac float) (var pi var-pi) (var i var-i) math-abs (var pi var-pi) (var i var-i) nil] 15]) (defalias 'math-solve-prod #[(lsoln rsoln) " \f\n=A A\"B\n*!E F" [lsoln rsoln solve-full all vec append calcFunc-if calcFunc-gt math-solve-get-sign 1 0] 4]) (defalias 'math-solve-poly-funny-powers #[(sub-rhs) "\n( @\" \f\"\n\f\"\n A\n* 4 \n\"=\")\" !!#)" [lhs t1 math-poly-neg-powers nil fac pp math-pow math-poly-mult-powers 1 math-mul rhs sub-rhs math-sub t calc-prefer-frac math-div math-poly-frac-powers t2 math-is-polynomial math-simplify calcFunc-expand b 50] 6]) (defalias 'math-solve-crunch-poly #[(max-degree) "\n<\n@:,\n@@><\n@@=%\n@A@=0\n@!0\n@=<\nA T\n\nGSV @UU\n\f \fU @C @:@@>@@=@A@=@!@=\fATl\f AB  ,SI @\" \"D \nGSX*)" [0 count t1 (bigpos bigneg) float math-zerop degree scale 1 t3 nil t okay new-t1 n p math-mul t2 max-degree] 5]) (defalias 'calcFunc-poly #[(expr var &optional degree) "!\"$ 5 ʚ.C: B:\")" [degree natnump math-reject-arg fixnatnump 50 math-is-polynomial expr var gen p (0) vec "Expected a polynomial"] 6]) (defalias 'calcFunc-gpoly #[(expr var &optional degree) "!\"  $\n+\nB0\"*" [degree natnump math-reject-arg fixnatnump 50 var math-poly-base-variable math-decompose-poly expr nil d vec "Expected a polynomial"] 6]) (defalias 'math-decompose-poly #[(lhs solve-var degree sub-rhs) "‰\"7\f @\" B,\f A@\"6\f A@\"\"E," [sub-rhs 1 nil t3 t2 t1 rhs math-polynomial-base lhs #[(b) " ?{>  {  #{Қ]>] =] ]@\"ABa !{!{\"{ @\"," [(1) nil 1 t math-poly-exp-base math-poly-frac-powers math-poly-mult-powers math-poly-neg-powers b lhs (+ -) sub-rhs (1 0) t3 t2 math-is-polynomial 50 t1 (1) (nil 1) math-sub rhs math-solve-poly-funny-powers math-solve-crunch-poly degree math-expr-contains solve-var] 4] math-pow vec math-div] 7]) (defalias 'math-solve-linear #[(var sign b a) " \f! \" \"$" [math-try-solve-for var math-div math-neg b a math-solve-sign sign t] 6]) (defalias 'math-solve-quadratic #[(var c b a) " !0 \"!!!\"\"D!!\"\")R ! !!\"\"\"D!!\"\"\"$" [math-try-solve-for var math-looks-evenp b math-div 2 halfb math-add math-neg math-solve-get-sign math-normalize calcFunc-sqrt math-sqr math-mul c a 4 nil t] 15]) (defalias 'math-solve-cubic #[(var d c b a) " \n\"\f\n\"\n\" !  \"\"\f \"\" \"\"\"\"\"\f:c\f@>\f@=\\\fA@=g\f!g\f= \"\"\"!$:@>@=A@=!= \"\" \"\"!\f\"\"$\f\"D\"\"\f\"\"D\"\"&!\"\"\"\"D\"! \"\"$." [math-div b a p c q d r math-sqr psqr math-sub 3 aa math-add math-mul 2 9 27 bb nil m (bigpos bigneg) float 0 math-zerop math-try-solve-for math-pow var math-neg t calcFunc-sqrt -3 math-normalize calcFunc-cos calcFunc-arccos 1 math-solve-get-int math-half-circle calc-symbolic-mode] 18]) (defalias 'math-solve-quartic #[(var d c b a aa) " \n\" \n\"\f\n\" \n\" !  \" ̉ щ \"\" \"\"\f!\" \f\" \"\" !%* \"\"D! \" \"\":@>@=A@=!=! \"\"D\"\"щ \"\"\f\"\" \"\"\"\"\"\"\"D#\"\"#\"!\" \"\"!.$" [math-div a aa b c d math-try-solve-for var math-sqr asqr 4 asqr4 nil calc-next-why solve-full math-solve-cubic solve-var math-sub math-mul math-neg 1 y math-add rsqr calcFunc-sqrt r math-solve-get-sign sign1 3 2 (bigpos bigneg) float 0 math-zerop 8 de math-normalize t] 16]) (defalias 'math-poly-all-roots #[(var p &optional math-factoring) "" [ouch (byte-code "\fGS\f! \n \f\f < @:3 @@>< A # RJ }\"}@\f\"\"!  \"\fB\"A+ VF‰\f!   @: @@> A \" V@#$%& $=$8$A@\"$!$$ B$!$!$ @% A 4 @& %$%\"&\"%A S,!, V‰0123\fGGUf! Ur} U|}3\f#A \", V\f@!\fA@\" B  @! A  E/‰<  @00==!=#=@=$\"A\"* AB A!0=,BCGS#E.*.\n" [calc-symbolic-mode math-symbolic-solve nil roots p deg reverse orig-p math-int-coefs math-int-scale math-double-roots math-int-factors math-int-threshold pp (bigpos bigneg frac) math-factoring throw ouch t apply math-lcm-denoms scale calc-prefer-frac lead math-abs math-mul math-div (float 5 -2) vec 4 copy-sequence def-p (bigpos bigneg frac float cplx polar) 2 math-poly-any-root (float 0 0) x b c cplx math-nearly-zerop calcFunc-re math-numberp math-evaluate-expr math-add 1 (var DUMMY var-DUMMY) all solve-full math-solve-ranges math-solve-sign solve-var append math-solve-quadratic 3 math-solve-cubic math-solve-quartic 0 math-neg math-poly-integer-root res root math-floatp math-try-solve-for var math-normalize calcFunc-subscr math-solve-get-int] 8)] 2]) (byte-code "" [nil math-symbolic-solve] 1) (defalias 'math-lcm-denoms #[(&rest fracs) "\n\n@= \n@8\"\nA )" [1 den fracs frac calcFunc-lcm 2] 5]) (defalias 'math-poly-any-root #[(p x polish) " ! # #A!#@NA\": : @#A!H@N  #\f a\f!a\"\f*" [math-zerop x math-poly-newton-root p (cplx (float 123 -6) (float 1 -4)) 4 newt math-lessp (float 1 -3) polish 30 math-poly-laguerre-root res math-symbolic-solve math-floatp throw ouch nil] 4]) (defalias 'math-poly-newton-root #[(p x iters) "   S V \f =* \" @\fA\fU \"\" \"\f@\"2!)\" \"\f!\" !))= !\" !݂! !\".B" [nil calc-prefer-frac calc-symbolic-mode math-int-coefs try-integer x dx b d iters 0 p pp calc-display-working-message lots math-do-working "newton" math-add math-mul math-zerop math-div math-sub math-abs-approx adx math-lessp math-int-threshold math-poly-integer-root iroot math-nearly-zerop 1] 6]) (defalias 'math-poly-integer-root #[(x) " !!\f\"t t ! !  !  ! \"\" \"!\" @AlB@\"\"L!!CB,s \"\"!\"!  \" \"! \"! @\" A@#! !E&\"'(''&\"&#\"A\"(\"B#(\"\"\"@(!\"\"##!q\"!q\",'O!! !EC&B&!BB,/0,!!\"! !lЂm\")\"). -" [math-lessp calcFunc-xpon math-abs-approx x calc-internal-prec math-int-coefs t calc-prefer-frac calcFunc-re xre calcFunc-im xim math-sqr xresq ximsq calcFunc-scf -1 math-div math-round math-mul math-int-scale rnd icp rem nil newcoef math-add math-zerop math-neg math-int-factors -2 rnd1 sqscale rnd0 rem1 rem0 assoc math-posp math-double-roots found this delq 0 math-sub aa reverse math-negp math-symbolic-solve calc-symbolic-mode math-sqrt 1] 8]) (byte-code "" [nil math-int-coefs] 1) (defalias 'math-poly-laguerre-root #[(p x polish) " GS? \n \f \fTW6\" @!!  @\n \fA\f\" \"\f \"\n\" \n\"@\"\n\n!\"\"OZ\"\n!\"+ !\f!\n!E\" \n\"$$!&&\f\n\"\"\")S)\"&\"\"!+$+\",$+\"-,!-!\"-,,\"\" !!\"\"  #2 2A!U2@ 2A\" 2@#66A!z6@ 2@)) = \".!8  \fX8\"!8\"!;!;!;]@!))8)%![\"\"%A!\fB!.\f" [nil calc-prefer-frac calc-symbolic-mode 0 iters p m polish try-newt tried-newt b d f x1 dx dxold 50 math-reject-arg x "*Laguerre's method failed to converge" math-abs-approx pp abx err math-add math-mul math-lessp calcFunc-scf -2 calc-internal-prec math-zerop math-pow math-neg frac 1 math-div g math-sqr g2 math-sub 2 h math-sqrt sq gp gm calcFunc-abssqr -3 math-poly-newton-root 7 newt t (float 1 -6) 20 newt2 math-nearly-equal cdx 6 calcFunc-xpon digs calc-record-why "*Could not attain full precision" natnump 3 math-normalize math-floatp math-poly-integer-root] 8]) (defalias 'math-solve-above-dummy #[(x) ":?\n@>?3A@šGUA1@!! )" [x (bigpos bigneg frac float cplx polar hms date mod var) (var SOLVEDUM SOLVEDUM) 2 nil res math-solve-above-dummy] 2]) (defalias 'math-solve-find-root-term #[(x neg) " !\f\n  >. A@\n\". 8 @=,\n?-\n\"" [math-solve-find-root-in-prod x neg t3 t1 (+ -) math-solve-find-root-term 2 -] 4]) (defalias 'math-solve-find-root-in-prod #[(x) ":p\n\"p@=ĉp@=I8!>0ĉp8=Iĉ88=Iʉp@>pA@\n\"a8!p8\n\"?pA@!" [x math-expr-contains solve-var calcFunc-sqrt 2 t2 ^ math-quarter-integer (1 2 3) frac 3 (* /) math-solve-find-root-in-prod] 3]) (defalias 'math-solve-system #[(exprs solve-vars solve-full) "\n:\n@=\nA\nC\"\f:(\f@=(\fA*\fC\n\f#)@\n\f#)" [mapcar list exprs vec solve-vars nil math-solve-simplifying math-solve-system-rec t] 4]) (defalias 'math-solve-system-rec #[(eqn-list var-list solns) " @ \f= \fA@@ \n  u @\n=E N @\f$ u @\n=f Ai C\nB A 7 \n@ !\"\" @!\"\"\f\n\"BB*#?+A%\n+ A\f\n*\"=\" \"B!! \"  \"B!" [var-list nil res v vv eqn-list e calcFunc-elim elim res2 eprev e2 math-solve-for 0 solve-full all math-solve-system-rec mapcar math-solve-system-subst delq copy-sequence #[(x) "@A!B" [x math-solve-system-subst] 3] solns s math-solve-simplifying apply append sort #[(x y) "@ @\n>>?" [x y solve-vars] 3] math-transpose math-normalize vec #[(x) " AB" [vec x] 2] #[(x) " B" [vec x] 2] #[(x) " B" [calcFunc-eq x] 2] car] 8]) (defalias 'math-solve-system-subst #[(x) " \f \n@\"\fA\nA *" [nil res res2 accum x mapcar #[(r) " @\f #! @\f #" [math-solve-simplifying math-simplify math-expr-subst x vv r] 5]] 4]) (defalias 'math-get-from-counter #[(name) " \nATB B\nA)" [name calc-command-flags ctr 1] 3]) (defalias 'math-solve-get-sign #[(val) " !=& A@: A@@>& A@ 8!E =H 8=H A@A@ A@8\"E! ! :a @=e Y = D \" \" !!P!P!E =EB \"*! " [math-simplify val * (bigpos bigneg frac float cplx polar) math-solve-get-sign 2 calcFunc-sqrt 1 ^ math-normalize math-div solve-full calc-var-value var-GenCount bigpos 0 all math-mul calcFunc-as math-add calc-refresh-evaltos "s" math-get-from-counter solve-sign var intern "var-" var2 -1 math-solve-ranges calc-record-why "*Choosing positive solution"] 7]) (defalias 'math-solve-get-int #[(val &optional range first) "n!3\n:\n@=\nY3=3\nD\"\n\"!!P!P!Ef=f^\"ABB\"*!ć" [solve-full calc-var-value var-GenCount bigpos 0 all math-mul val calcFunc-an math-add 1 calc-refresh-evaltos "n" math-get-from-counter solve-int var intern "var-" var2 range calcFunc-index first math-solve-ranges calc-record-why "*Choosing 0 for arbitrary integer in solution"] 5]) (defalias 'math-solve-sign #[(sign expr) "\n!> >[)" [sign math-possible-signs expr s1 (4 6) (1 3)] 3]) (defalias 'math-looks-evenp #[(expr) ":\f@>!@>A@!" [expr (bigpos bigneg) math-evenp (* /) math-looks-evenp] 2]) (defalias 'math-solve-for #[(lhs rhs solve-var solve-full &optional sign) " \n\" \"\n$ \n\"p \\ \n  #=l\n!lG\"\"GWkUa؂iZ\"!*+!" [math-expr-contains rhs solve-var math-solve-for math-sub lhs 0 solve-full math-normalize calc-internal-prec 1 math-poly-base-variable math-try-solve-for sign res all math-known-realp nil new-len old-len delq mapcar #[(x) ">? " [x (cplx polar)] 2] calc-record-why "*All solutions were complex" format "*Omitted %d complex solutions"] 7]) (defalias 'math-solve-eqn #[(expr var full) ">YAB @=?% W\n=0@  EW\n=@@ EW@=K!@>W  E) $ k  E)" [expr (calcFunc-neq calcFunc-lt calcFunc-gt calcFunc-leq calcFunc-geq) math-solve-for - 0 var full calcFunc-neq 1 res math-solve-sign -1 calc-record-why "*Can't determine direction of inequality" (calcFunc-neq calcFunc-lt calcFunc-gt) calcFunc-eq] 8]) (defalias 'math-reject-solution #[(expr var func) " \n\" @Ě! \nE" [math-expr-contains expr var calc-next-why (* "Unable to find a symbolic solution") calc-record-why "*Unable to find a solution" func] 3]) (defalias 'calcFunc-solve #[(expr var) ":\f@=\n: \n@= \n#%\n#-\n#" [expr vec var math-solve-system nil math-solve-eqn math-reject-solution calcFunc-solve] 4]) (defalias 'calcFunc-fsolve #[(expr var) ":\f@=\n: \n@= \n#%\n#-\n#" [expr vec var math-solve-system t math-solve-eqn math-reject-solution calcFunc-fsolve] 4]) (defalias 'calcFunc-roots #[(expr var) "\n:\n@=\f:\"\f@=\"\n\f#(\n\f$0\n\f#)" [nil math-solve-ranges expr vec var math-solve-system all math-solve-for 0 math-reject-solution calcFunc-roots] 5]) (defalias 'calcFunc-finv #[(expr var) " \n $ \n #! #)" [math-solve-for expr math-integ-var var nil res math-normalize math-expr-subst math-reject-solution calcFunc-finv] 6]) (defalias 'calcFunc-ffinv #[(expr var) " \n $ \n #! #)" [math-solve-for expr math-integ-var var t res math-normalize math-expr-subst math-reject-solution calcFunc-finv] 6]) (byte-code "###################################" [put calcFunc-inv math-inverse #[(x) "\n\"" [math-div 1 x] 3] math-inverse-sign -1 calcFunc-sqrt #[(x) " !" [math-sqr x] 2] calcFunc-conj #[(x) " D" [calcFunc-conj x] 2] calcFunc-abs #[(x) " !" [math-solve-get-sign x] 2] calcFunc-deg #[(x) " D" [calcFunc-rad x] 2] 1 calcFunc-rad #[(x) " D" [calcFunc-deg x] 2] calcFunc-ln #[(x) " D" [calcFunc-exp x] 2] calcFunc-log10 #[(x) " D" [calcFunc-exp10 x] 2] calcFunc-lnp1 #[(x) " D" [calcFunc-expm1 x] 2] calcFunc-exp #[(x) " D!!\"\"\"" [math-add math-normalize calcFunc-ln x math-mul 2 (var pi var-pi) math-solve-get-int (var i var-i)] 8] calcFunc-expm1 #[(x) " D!!\"\"\"" [math-add math-normalize calcFunc-lnp1 x math-mul 2 (var pi var-pi) math-solve-get-int (var i var-i)] 8] calcFunc-sin #[(x) "!D!\n\"\"!\n\"\")" [math-solve-get-int 1 n math-add math-mul math-normalize calcFunc-arcsin x math-pow -1 math-half-circle t] 6] calcFunc-cos #[(x) "\fD!!!!\"" [math-add math-solve-get-sign math-normalize calcFunc-arccos x math-solve-get-int math-full-circle t] 5] calcFunc-tan #[(x) " D!!!\"" [math-add math-normalize calcFunc-arctan x math-solve-get-int math-half-circle t] 5] calcFunc-arcsin #[(x) "\nD!" [math-normalize calcFunc-sin x] 3] calcFunc-arccos #[(x) "\nD!" [math-normalize calcFunc-cos x] 3] calcFunc-arctan #[(x) "\nD!" [math-normalize calcFunc-tan x] 3] calcFunc-sinh #[(x) "!D!\n\"\"!\n\"\"\")" [math-solve-get-int 1 n math-add math-mul math-normalize calcFunc-arcsinh x math-pow -1 math-half-circle t (var i var-i)] 7] calcFunc-cosh #[(x) "\fD!!!!\"\"" [math-add math-solve-get-sign math-normalize calcFunc-arccosh x math-mul math-full-circle t math-solve-get-int (var i var-i)] 6] calcFunc-tanh #[(x) " D!!!\"\"" [math-add math-normalize calcFunc-arctanh x math-mul math-half-circle t math-solve-get-int (var i var-i)] 6] calcFunc-arcsinh #[(x) "\nD!" [math-normalize calcFunc-sinh x] 3] calcFunc-arccosh #[(x) "\nD!" [math-normalize calcFunc-cosh x] 3] calcFunc-arctanh #[(x) "\nD!" [math-normalize calcFunc-tanh x] 3]] 4) (defalias 'calcFunc-taylor #[(expr var num) "  >\" @= 8! 8 A@\n= \n\" ! \n # @=L ABM  T X\n$!\"\"\n #\"\"\"[!-  F*" [0 var v x0 (+ - calcFunc-eq) + math-neg 2 math-expr-contains expr natnump num math-expr-subst calcFunc-eq - 1 fprime nfac n var2 accum calcFunc-deriv nil t math-simplify math-mul math-add math-div math-pow math-normalize calcFunc-taylor] 9])