restart; IntMaplet := module() ############################################################ ############################################################ export iniMathML, addMathML, addMathML2, addMathML3, runIntMaplet, startRule, applyRule, applyOtherRule, applyMathFuncRule, getHint, applyHint, getFinalAnswer, showAllSteps, clearSteps, applyRuleParts, applyRuleSplit, applyRuleRewrite, applyRuleChange, changeUnderstoodRules, forgetUnderstoodRule, aboutRule, aboutDefRule, helpStr, partsStr, rewriteStr, changeStr, getLastMath, getLastString, getRMISingle2, getRMISingle3: local steps, mlSteps, iniMlStr, save_settingsTB, save_settingsML, save_RMISingle2, save_RMISingle3: steps:=[]: mlSteps:=[]: iniMlStr := "": ############################################################ getLastMath:= proc() save_settingsML; end proc: ############################################################ getLastString:= proc() save_settingsTB; end proc: ############################################################ getRMISingle2:= proc(value) save_RMISingle2:=value; end proc: ############################################################ getRMISingle3:= proc(value) save_RMISingle3:=value; end proc: ############################################################ helpStr := "This maplet guides you through a integration problem step-by-step. You can apply integration rules one at a time to a function f and see the resulting expression. At any step of the problem, you can request a hint for the next rule to apply. You can a lso specify in advance that you already understand a certain set of rules, in which case those rules are automatically applied (when possible) at any step of the problem. Instructions To start, enter a function with its independent variable, and press the 'Start' button. This will clear the problem history and begin a new one. Integration rules can be applied by pressing the corresponding buttons or selecting rules from the menus. To show all steps in the solution, you can press the 'All Steps' button. You can also go directly to the final answer by pressing the 'Final Ans' button, or by selecting 'Get the Final Answer' in Menu/File. When a rule is applied, the display of the problem will be updated with the result of the applied rule. If you select a rule that is not applicable to the problem in its current state, the message box will say so. You may ask for a hint by pressing the 'Obtain a Hint' button or by selecting 'Receive a Hint' in Menu/File. Pressing the 'Apply the Hint' button or selecting 'Apply the Hint' in Menu/File applies the hint to the problem (this should always work unless th e problem is done). The 'Clear' button clears the problem solving history. Once a rule becomes familiar to you, you can check off the rule in the 'Understood Rules' menu. The maplet will then apply that rule automatically whenever possible at any step of a problem.": # end helpStr ############################################################ ############################################################ partsStr := "parts - Integrate By Parts solve - Solve the Integral The parts rule implements integration by parts: Int(f(x)*g'(x),x) = f(x)*g(x) - Int(g(x)*f'(x),x). To apply the rule, you must specify the two functions f(x) and g(x): [parts, f(x), g(x)] That is, the first parameter (f(x)) is the term to be differentiated, and the second parameter (g(x)) is the integral of the term to be integrated when applying the rule. Often after multiple applications of integration by parts, the same integral appears more than once on both sides of the equation, then you can use 'solve' rule to solve the integral algebraically.": # end partsStr ############################################################ ############################################################ rewriteStr := "rewrite - Rewrite the form of expression The rewrite rule changes the form of the integrand when the integration variable is not changed. This rule has the general form: [rewrite, f1(x) = g1(x), f2(x) = g2(x), ...], where parameters of rewrite rule are input in the TextBox beside the rewrite rule button, separated by commas. The effect of applying the rewrite rule is to perform each substitution listed as a parameter to the rule, where occurrences of the left-hand side of each substitution are replaced by the corresponding right-hand side. ": # end rewriteStr ############################################################ ############################################################ changeStr := "change - Change Integral Variable revert - Revert Integral Variable The change rule changes the integration variable. It can take the following forms. [change, F(x,u) = G(x,u), u] [change, F(x,u) = G(x,u), u = H(x)] where parameters of rewrite rule are input in the TextBox beside the rewrite rule button, separated by commas. The first parameter (F(x,u) = G(x,u)) defines the relationship between the old variable (x) and the new variable (u). This most commonly takes the form x = G(u) or u = F(x), but can be much more general, provided it can be solved for x. Note: The name of the new variable (u in the preceding paragraph) must be previously unused in the problem to which you are applying this change of variables rule. If you use a name which has already appeared, the system just makes up a new name for you. Once the integration has been completed, you can use the revert rule to transform back to the original variable, if necessary.": # end revertStr ############################################################ # pre: iniEqn :: algebraic expression # post: returns the Presentation MathML of iniEqn iniMathML := proc(iniEqn) MathML:-ExportPresentation(iniEqn); end proc: ############################################################ ########################################################### # pre: mathMLStr :: string, in form of Presentation MathML # addEqn :: algebraic expression # post: addEqn appends to the next line of mathMLStr, # returns the updated mathMLStr addMathML := proc(mathMLStr, addEqn) local tree, cmc, child, children, nl, eqnSign; use XMLTools in tree := FromString(mathMLStr); cmc := ContentModelCount(tree); child := FromString(MathML:-ExportPresentation(addEqn)); children := ContentModel(child); nl := FromString(" "); eqnSign := Element("mo","="); tree := AddChild(tree,nl,cmc); tree := AddChild(tree,eqnSign,cmc+1); for child in children do cmc := ContentModelCount(tree); tree := AddChild(tree,child,cmc); end do: tree := MakeElement("mrow", [], ContentModel(tree) ): tree := Element("math", tree): ToString(tree): end use: end proc: ############################################################ ############################################################ # pre: mathMLStr :: string, in form of Presentation MathML # addEqn :: algebraic expression # post: addEqn appends to the next line of mathMLStr, # returns the updated mathMLStr addMathML2 := proc(mathMLStr, addEqn, rule) local tree, cmc, child, children, ruleName, nl, eqnSign; use XMLTools in tree := FromString(mathMLStr); cmc := ContentModelCount(tree); child := FromString(MathML:-ExportPresentation(addEqn)); children := ContentModel(child); nl := FromString(" "); eqnSign := Element("mo","="); ruleName := Element("mtext",convert(rule,string)); tree := AddChild(tree,nl,cmc); tree := AddChild(tree,eqnSign,cmc+1); for child in children do cmc := ContentModelCount(tree); tree := AddChild(tree,child,cmc); end do: cmc := ContentModelCount(tree); tree := AddChild(tree,ruleName,cmc); tree := MakeElement("mrow", [], ContentModel(tree) ): tree := Element("math", tree): ToString(tree): end use: end proc: ############################################################ ############################################################ # pre: mathMLStr :: string, in form of Presentation MathML # addEqn :: algebraic expression # post: addEqn appends to the next line of mathMLStr, # returns the updated mathMLStr addMathML3 := proc(mathMLStr, addEqn, rule) local tree, cmc, child, children, ruleName, nl, eqnSign; use XMLTools in tree := FromString(mathMLStr); cmc := ContentModelCount(tree); child := FromString(MathML:-ExportPresentation(addEqn)); children := ContentModel(child); nl := FromString(" "); eqnSign := Element("mo","="); ruleName := Element("mtext",convert(rule,string)); tree := AddChild(tree,nl,cmc); tree := AddChild(tree,ruleName,cmc+1); tree := AddChild(tree,eqnSign,cmc+2); for child in children do cmc := ContentModelCount(tree); tree := AddChild(tree,child,cmc); end do: tree := MakeElement("mrow", [], ContentModel(tree) ): tree := Element("math", tree): ToString(tree): end use: end proc: ############################################################ ############################################################ # pre: null # post: initializes the Integration problem solving process # if input is correct, integration equation is added to steps # understood rule(s) apply if capable # MathML Viewer updates too # else error message shows startRule := proc(p_fun, p_var, p_lower, p_upper) local funStr, varStr, lowerStr, upperStr, intStr, infoStr, mlStr, intExpr, intEqn, hints, i, uRules, uAppliedRules, rulesStr: use Student:-Calculus1 in clearSteps(): funStr := StringTools:-Trim(p_fun): varStr := StringTools:-Trim(p_var): lowerStr := StringTools:-Trim(p_lower): upperStr := StringTools:-Trim(p_upper): if lowerStr<>"" and upperStr<>"" then intStr := cat("Int(", funStr, ", ", varStr, "=", lowerStr, "..", upperStr, ")"): else intStr := cat("Int(", funStr, ", ", varStr, ")"): end if: intExpr := parse(intStr): hints := [Hint(intExpr)][1]: mlStr := iniMathML(GetProblem(`internal`)): iniMlStr := mlStr: infoStr:="initializing ...": save_settingsTB:=infoStr: if nops(hints)>0 then uRules := rhs(Understand(Int)): uAppliedRules := []: if nops(uRules) > 0 then for i from 1 to nops(hints) do if member(hints[i],uRules) = true then uAppliedRules := [op(uAppliedRules),hints[i]]: end if: end do: intEqn := Rule[](GetProblem(`internal`)): steps := [op(steps),intEqn]: if nops(uAppliedRules) > 0 then if nops(uRules) = 1 then rulesStr := convert(uRules,string): infoStr := cat("understood rule ", rulesStr, " is automatically applied."): else rulesStr := convert(uRules,string): infoStr := cat("understood rules ", rulesStr, " are automatically applied."): end if: # end if nops(uRules)=>1 save_settingsTB:=infoStr: mlStr := addMathML(mlStr,rhs(intEqn)): end if: # end if nops(uAppliedRules)>0 else intEqn := Rule[](GetProblem(`internal`)): steps := [op(steps),intEqn]: end if: # end if nops(uRules) > 0 save_settingsML:=mlStr: mlSteps := [op(mlSteps), mlStr]: infoStr := "please apply any rule below": save_settingsTB:=infoStr: else intEqn := Rule[](GetProblem(`internal`)): steps := [op(steps),intEqn]: save_settingsML:=mlStr: mlSteps := [op(mlSteps), mlStr]: infoStr := "no hint is given": save_settingsTB:=infoStr: end if : # end if nops(hints)>0 end use: end proc: ############################################################ ############################################################ # pre: null # post: if aRule is a valid integration rule and applicable # new step is stored in steps, updates MathMLViewer # else message shows the rule isn't applied applyRule := proc(aRule) local mlStr, infoStr, intEqn, oldEqn: use Student:-Calculus1, Maplets:-Tools in if nops(steps)=0 then startRule(): end if: mlStr:=save_settingsML: oldEqn := steps[nops(steps)]: if type(aRule,list)=true then intEqn := Rule[op(aRule)](steps[nops(steps)]): else intEqn := Rule[aRule](steps[nops(steps)]): end if: if (GetMessage()=NULL) or (not evalb(intEqn=oldEqn)) then steps := [op(steps),intEqn]: if type(aRule,list)=true then if save_RMISingle2=true then mlStr := addMathML2(mlStr,rhs(intEqn),aRule): elif save_RMISingle3=true then mlStr := addMathML3(mlStr,rhs(intEqn),aRule): else mlStr := addMathML(mlStr,rhs(intEqn)): end if: else if save_RMISingle2=true then mlStr := addMathML2(mlStr,rhs(intEqn),[aRule]): elif save_RMISingle2=true then mlStr := addMathML3(mlStr,rhs(intEqn),[aRule]): else mlStr := addMathML(mlStr,rhs(intEqn)): end if: end if: save_settingsML:=mlStr: mlSteps := [op(mlSteps), mlStr]: infoStr := convert(aRule,string): infoStr := cat(infoStr, " rule has been applied"): save_settingsTB:=infoStr: else infoStr := convert(aRule,string): infoStr := cat(infoStr, " rule is not applicable"): save_settingsTB:=infoStr: end if: # end if GetMessage()=NULL end use: end proc: # end applyRule() ############################################################ ############################################################ # pre: null # post: apply the integrating by parts # Int(f(x)*Diff(g(x),x),x) = f(x)*g(x) - Int(g(x)*Diff(f(x),x),x) # argument f(x) is entered in TF_parts_fx, and arguments g(x) is # entered in TF_parts_gx applyRuleParts := proc(p_parts_f, p_parts_g) local fx, gx: use Student:-Calculus1, Maplets:-Elements in fx := p_parts_f: gx := p_parts_g: if fx = "" or gx="" then Maplets:-Display(Maplet( MessageDialog("You must specify f(x) and g(x)."))): else applyRule([parts, parse(fx), parse(gx)]): end if: end use: end proc: # end applyRuleParts ############################################################ ############################################################ # pre: null # post: apply the rewrite rule # rewrite equations are listed in TB_args seperated # by commas, the left hand side of earch substitution # is replaced by the corresponding right hand side applyRuleRewrite := proc(p_args) local str: use Student:-Calculus1, Maplets:-Elements in str := p_args: if str = "" then Maplets:-Display(Maplet( MessageDialog("You must specify a rewrite-equation."))): else str := cat("rewrite, ", str): applyRule([parse(str)]): end if: end use: end proc: # end applyRuleWithArgs ############################################################ ############################################################ # pre: null # post: apply the change rule, which changes the integration # variable, arguments are listed in TB_args applyRuleChange := proc(p_args) local str: use Student:-Calculus1, Maplets:-Elements in str := p_args: if str = "" then Maplets:-Display(Maplet( MessageDialog("You must specify a change-of-variables equation"))): else str := cat("change, ", str): applyRule([parse(str)]): end if: end use: end proc: # end applyRuleWithArgs ############################################################ ############################################################ # pre: null # post: apply the definite integration rule split # require argument from TF_c applyRuleSplit := proc(p_c) local param: use Student:-Calculus1, Maplets:-Elements in param := StringTools:-Trim(p_c): if ruleArgs = "" then error cat("no split parameter in 'TF_c'"): end if: applyRule([split, parse(param)]): end use: end proc: # end applyRuleSplit ############################################################ ############################################################ # pre: null # post: read the integration rule from TF_other, and apply it # if TF_other is empty, error message shows applyOtherRule := proc(p_other) local aRule: use Maplets:-Tools, Maplets:-Elements in aRule := StringTools:-Trim(p_other): if aRule = "" then Maplets:-Display(Maplet( MessageDialog("No rule has been entered."))): else applyRule(aRule): end if: end use: end proc: # end applyOtherRule ############################################################ ############################################################ # pre: null # post: read the integration rule from TF_mathfunc, and apply it # if TF_mathfunc is empty, error message shows applyMathFuncRule := proc(p_mathfunc) local aRule: aRule := StringTools:-Trim(p_mathfunc): if aRule = "" then Maplets:-Display(Maplet( MessageDialog("No rule has been entered."))): else applyRule(parse(aRule)): end if: end proc: # end applyMathFuncRule ############################################################ ############################################################ # pre: null # post: hint for the current integration problem is shown # in the message TextField, info getHint := proc() local intEqn, hint, hints, infoStr, i: use Student:-Calculus1 in if nops(steps)=0 then startRule(): end if: intEqn := steps[nops(steps)]: hints := [Hint(intEqn)]: hint := hints[1]: if nops(hint)=0 then infoStr:="no hint can be given, or the problem is done.": save_settingsTB:=infoStr: else infoStr:=convert(hint,string); if nops(hints)>1 then for i in hints[2..-1] do infoStr := cat(infoStr, ", ", convert(i,string)); end do; end if: infoStr:=cat(infoStr, " could be applied."): save_settingsTB:=infoStr: end if: hint: # return value used in applyHint end use: end proc: # end getHint() ############################################################ ############################################################ # pre: null # post: hint for the current integration problem is applied applyHint := proc() local mlStr, infoStr, oriEqn, intEqn, hint: use Student:-Calculus1, Maplets:-Tools in hint := getHint(): if nops(hint)>0 then applyRule(hint): end if: end use: end proc: # end applyHint ############################################################ ############################################################ # pre: null # post: final answer for the current problem is shown getFinalAnswer := proc() local intEqn, hint, mlStr, infoStr: use Student:-Calculus1, Maplets:-Tools in if nops(steps)=0 then startRule(): end if: intEqn := steps[nops(steps)]: hint := [Hint(intEqn)][1]: if nops(hint)=0 then infoStr := "No rule could be applied, or the question is done.": save_settingsTB:=infoStr: else mlStr := save_settingsML: while nops(hint)>0 do infoStr := cat(convert(hint,string)," is being applied."): save_settingsTB:=infoStr: intEqn := Rule[hint](intEqn): hint := [Hint(intEqn)][1]: end do: steps := [op(steps),intEqn]: infoStr := "exporting final answer ...": mlStr := addMathML(mlStr,rhs(intEqn)): save_settingsML:=mlStr: mlSteps := [op(mlSteps), mlStr]: infoStr := "the final answer is shown": save_settingsTB:=infoStr: end if: # end if nops(hint)=0 end use: end proc: # end getFinalAnswer ############################################################ ################################################## # pre: null # post: a complete solution for the current problem is shown showAllSteps := proc(boo1, boo2) local intEqn, hint, mlStr, infoStr: use Student:-Calculus1 in if nops(steps)=0 then startRule(): end if: intEqn := steps[nops(steps)]: hint := [Hint(intEqn)][1]: if nops(hint)=0 then infoStr := "no rule could be applied, or the question is done.": save_settingsTB:=infoStr: else mlStr := save_settingsML: while nops(hint)>0 do infoStr := cat(convert(hint,string)," is being applied."): save_settingsTB:=infoStr: intEqn := Rule[hint](intEqn): if boo1 then mlStr := addMathML2(mlStr,rhs(intEqn),hint): elif boo2 then mlStr := addMathML3(mlStr,rhs(intEqn),hint): else mlStr := addMathML(mlStr,rhs(intEqn)): end if: steps := [op(steps),intEqn]: mlSteps := [op(mlSteps),mlStr]: hint := [Hint(intEqn)][1]: end do: infoStr := "exporting the full solution ...": save_settingsTB:=infoStr: save_settingsML:=mlStr: infoStr := "a complete solution is shown": save_settingsTB:=infoStr: end if: # end if nops(hint)=0 end use: end proc: # showAllSteps ############################################################ ############################################################ # pre: name is a valid integration rule # fun is in a valid algebraic expression or function # post: pop up a Window with the description of the rule 'name' aboutRule := proc(name,fun) local eqn, intEqn, understoodRules: use Student:-Calculus1, Maplets:-Tools in understoodRules := rhs(Understand(Int)): Understand(Int,'none'): intEqn := Int(fun,x): eqn := intEqn=rhs(Rule[name](intEqn)): save_settingsTB:=cat("Definition of the ", convert(name, string), " rule"): if fun <> x^n then save_settingsML:=MathML:-ExportPresentation(eqn): else save_settingsML:= " ∫ x n ⁢ ⅆ x = x n + 1 n + 1 if n -1 ": end if; Understand(Int, op(understoodRules)): end use: end proc: # end aboutRule ############################################################ ############################################################ # pre: name is a valid definite integration rule # post: pop up a Window with the description of the rule 'name' aboutDefRule := proc(name) local eqn, intEqn, understoodRules: use Student:-Calculus1, Maplets:-Tools in understoodRules := rhs(Understand(Int)): Understand(Int,'none'): if name=flip then intEqn := Int(f(x),x=a..b): eqn := intEqn=rhs(Rule[flip](intEqn)): elif name=join then intEqn := Int(f(x),x=a..c)+Int(f(x),x=c..b): eqn := intEqn=rhs(Rule[join](intEqn)): else intEqn := Int(f(x),x=a..b): eqn := intEqn=rhs(Rule[split,c](intEqn)): end if: Understand(Int, op(understoodRules)): return MathML:-ExportPresentation(eqn): end use: end proc: # end aboutDefRule ############################################################ ############################################################ # pre: aRule is a valid integration rule # post: if ruleState=true, aRule is understood # else, aRule is removed from understo0d integration rules changeUnderstoodRules := proc(aRule, ruleState) use Student:-Calculus1 in if ruleState=true then Understand(Int,aRule): else forgetUnderstoodRule(aRule): end if: end use: end proc: # end changeUnderstoodRules ############################################################ ############################################################ # pre: aRule is a valid integration rule # post: aRule is removed from understood integration rules forgetUnderstoodRule := proc(aRule) local rules: use Student:-Calculus1 in rules := rhs(Understand(Int)): rules := subs(aRule=NULL,rules): Understand(Int,'none'): if nops(rules)>0 then Understand(Int,op(rules)); end if: end use: end proc: ############################################################ ############################################################ # pre: null # post: clears the historic record of all steps clearSteps := proc() use Student:-Calculus1, Maplets:-Tools in save_settingsML:="": save_settingsTB:="": Clear(all): steps:=[]: mlSteps:=[]: end use: end proc: # end clearSteps() ############################################################ ############################################################ # pre: Maple 8 or higher is installed # post: run Step-by-Step Integration Solver runIntMaplet := proc() local maplet, bc, dc, lc: bc := 'background'="#DDFFFF": dc := 'background'="#CCFFFF": lc := 'background'="#EEFFFF": use Maplets, Maplets:-Elements, Student:-Calculus1 in maplet := Maplet( 'onstartup'=RunWindow('intWin'), ############################################################ Font['F1']("Default", 'bold'='true', 'size'=14), Font['F2']("Default", 'italic'='true', 'size'=12), ############################################################ Window['intWin']( 'menubar'='intMB', 'resizable'='false', 'title'="Calculus 1 - Step-by-Step Integration Solver", BoxColumn(bc, BoxRow('border'='true','inset'=0,'spacing'=0, 'caption'="Enter a function", bc, Label('caption'="Function ", 'font'='F1',bc), TextField['TF_fun']('value'=3*sin(x), 'width'=22, lc), Label('caption'=" Variable ", 'font'='F1',bc), TextField['TF_var']("x",4,lc), Label('caption'=" from ", 'font'='F1', bc), TextField['TF_lower']('value'=" ", 'width'=5, lc), Label('caption'=" to ", 'font'='F1',bc), TextField['TF_upper']('value'=" ", 'width'=5, lc) ), # end BoxRow BoxRow('inset'=0,'spacing'=0, bc, BoxColumn('border'='true', 'inset'=0, 'spacing'=0, 'caption'="Problem status", bc, BoxRow(MathMLViewer['ML']('height'=470, 'width'=400, lc), bc), BoxRow('halign'='right', bc, Button("Start", 'onclick'='A_start', lc), Button("Final Ans", 'onclick'='A_getFinalAnswer', lc), Button("All Steps", 'onclick'='A_showAllSteps', 'tooltip'="show a complete solution", lc), Button("Clear", 'onclick'='A_clear', 'tooltip'="clear output and problem history", lc), Button("Close", Shutdown(), 'tooltip'="close", lc) ) # end BoxRow ), # end BoxColumn BoxColumn('inset'=0, 'inset'=0, 'spacing'=0, bc, BoxRow('border'='true', 'caption'="Message", 'inset'=0, 'spacing'=0, bc, BoxCell( TextBox['info']('editable'='false', 'value'="", lc, 'tooltip'="message", 'height'=4, 'width'=24 ) # end TextBox ) # end BoxCell ), # end BoxRow BoxRow('border'='true', 'caption'="Hints", 'inset'=0, 'spacing'=10, bc, BoxCell(Button['B_getHint']("Obtain a Hint", 'onclick'='A_getHint', lc)), BoxCell(Button['B_applyHint']("Apply the Hint", 'onclick'='A_applyHint', lc)) ), # end BoxRow BoxColumn('border'='true', 'inset'=0, 'spacing'=0, 'caption'="Integration Rules", bc, BoxRow('halign'='left', 'inset'=0, 'spacing'=3, bc, BoxCell('halign'='left', Button['B_constant'](" Constant ", lc, 'onclick'='A_constant', 'tooltip'="Int(c, x)= c*x or Int(c, x=a..b) = c*b - c*a") ), # BoxCell BoxCell('halign'='left', Button['B_constantmultiple'](" Constant Multiple", lc, 'onclick'='A_constantmultiple', 'tooltip'="Int(c*f(x)) = c*Int(f(x))") ) # BoxCell ), # BoxRow BoxRow('halign'='left', 'inset'=0, 'spacing'=1, bc, BoxCell('halign'='left', Button['B_identity']("Identity", lc, 'onclick'='A_identity', 'tooltip'="Int(x,x) = x^2/2") ), # BoxCell BoxCell('halign'='left', Button['B_sum']("Sum", lc, 'onclick'='A_sum', 'tooltip'="apply sum rule: Int(f(x)+g(x)) = Int(f(x)) + Int(g(x))") ), # BoxCell BoxCell('halign'='left', Button['B_difference']("Difference", lc, 'onclick'='A_difference', 'tooltip'="Int(f(x)-g(x)) = Int(f(x)) - Int(g(x))") ) # BoxCell ), # BoxRow BoxRow('halign'='left', 'inset'=0, 'spacing'=5, bc, BoxCell('halign'='left', Button['B_power']("Power ", lc, 'onclick'='A_power', 'tooltip'="Int(x^n, x) = x^(n+1)/(n+1)") ), # BoxCell BoxCell('halign'='left', Button['B_revert'](" Revert ", lc, 'onclick'='A_revert', 'tooltip'="reverts a change of variables substitution") ), # BoxCell BoxCell('halign'='left', Button['B_solve'](" Solve ", lc, 'onclick'='A_solve', 'tooltip'="algebraically solve for the integral appeared more than once") ) # end BoxCell ) # end BoxRow ), # end Column BoxColumn('border'='true', 'inset'=0, 'spacing'=0, 'caption'="Integration Rules with Arguments", bc, BoxRow('inset'=0, 'spacing'=0, bc, Button['B_parts']("Int By Parts", lc, 'onclick'='A_applyRuleParts', 'tooltip'="Integrate By Parts: Int(f(x)*Diff(g(x),x),x) = f(x)*g(x) - Int(g(x)*Diff(f(x),x),x)" ), Label(" f(x)=", dc), TextField['TF_parts_f']('width'=3, lc), Label(" g(x)=", dc), TextField['TF_parts_g']('width'=3, lc) ), # end BoxRow BoxRow('inset'=0, 'spacing'=0, bc, BoxColumn('halign'='left', 'inset'=0, 'spacing'=0, bc, Button['B_rewrite']("rewrite ", lc, 'onclick'='A_applyRuleRewrite', 'tooltip'="change the form of the expression"), Button['B_change']("change", lc, 'onclick'='A_applyRuleChange', 'tooltip'="change the variable of the integration") ), # BoxColumn TextBox['TB_args']( 'value'="", lc, 'tooltip'="Arguments of the Rules", 'height'=2, 'width'=22 ) # end TextBox ) # end BoxRow ), # end BoxColumn BoxColumn('border'='true', 'inset'=0, 'spacing'=0, 'caption'="Function Rules", bc, BoxRow('halign'='left', 'inset'=0, 'spacing'=0, bc, Label('caption'="Enter a Function: ", bc), TextField['TF_mathfunc']('width'=6, lc) ), # end BoxRow BoxRow('halign'='left', 'inset'=0, 'spacing'=5, bc, Button['B_applyMathFunc']("Apply", lc, 'onclick'='A_applyMathFunc'), Button['B_selectMathfunc']("Select a Function", 'onclick'=RunWindow('mathfuncWin'), lc) ) # end BoxRow ), # end BoxColumn BoxRow('border'='true', 'inset'=0, 'spacing'=3, 'caption'="Definite Integral Rules", bc, Button("flip", lc, 'onclick'='A_flip', 'tooltip'="Int(f(x),x=a..b) = -Int(f(x),x=b..a)" ), Button("join", lc, 'onclick'='A_join', 'tooltip'="Int(f(x),x=a..c) + Int(f(x),x=c..b) = Int(f(x),x=a..b)" ), Button("split", lc, 'onclick'='A_applyRuleSplit', 'tooltip'="Int(f(x),x=a..b) = Int(f(x),x=a..c) + Int(f(x),x=c..b)" ), Label(" at ", dc), TextField['TF_c']('width'=2, lc) ) # end BoxRow ) # end BoxColumn ) # end BoxRow ) # end BoxColumn ), # end Window ############################################################ Window['mathfuncWin']('resizable'='false', 'title'="Select a Mathematical Function", 'defaultbutton'='B_close2', BoxColumn(bc, BoxRow('border'='true', 'inset'=1, 'spacing'=5, bc, 'caption'="Exponential and Logarithmic Functions", Button['B_exp']("Natural Exponential", lc, 'onclick'=Action( SetOption('TF_mathfunc'="exp"), CloseWindow('mathfuncWin')) ), # end Button exp Button['B_ln']("Natural Logarithmic", lc, 'onclick'=Action( SetOption('TF_mathfunc'="ln"), CloseWindow('mathfuncWin')) ) # end Button ln ), # end BoxRow GridLayout('border'='true', 'inset'=1, bc, 'caption'="Trigonometric, Hyperbolic Functions and their Inverses", GridRow( GridCell(Button['B_sin'](" sin ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="sin"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_cos'](" cos ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="cos"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_tan'](" tan ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="tan"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_cot'](" cot ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="cot"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_sec'](" sec ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="sec"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_csc'](" csc ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="csc"), CloseWindow('mathfuncWin') ) )) # end Button/GridCell ), # end GridRow GridRow( GridCell(Button['B_arcsin'](" arcsin ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="arcsin"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_arccos'](" arccos ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="arccos"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_arctan'](" arctan ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="arctan"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_arccot'](" arccot ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="arccot"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_arcsec'](" arcsec ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="arcsec"), CloseWindow('mathfuncWin') ) )), # end Button/GridCell GridCell(Button['B_arccsc'](" arccsc ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="arccsc"), CloseWindow('mathfuncWin')) )) # end Button/GridCell ), # end GridRow GridRow( GridCell(Button['B_sinh'](" sinh ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="sinh"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_cosh'](" cosh ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="cosh"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_tanh'](" tanh ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="tanh"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_coth'](" coth ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="coth"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_sech'](" sech ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="sech"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_csch'](" csch ", lc, 'onclick'=Action( SetOption('TF_mathfunc'="csch"), CloseWindow('mathfuncWin')) )) # end Button/GridCell ), # end GridRow GridRow( GridCell(Button['B_arcsinh']("arcsinh", lc, 'onclick'=Action( SetOption('TF_mathfunc'="arcsinh"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_arccosh']("arccosh", lc, 'onclick'=Action( SetOption('TF_mathfunc'="arccosh"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_arctanh']("arctanh", lc, 'onclick'=Action( SetOption('TF_mathfunc'="arctanh"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_arccoth']("arccoth", lc, 'onclick'=Action( SetOption('TF_mathfunc'="arccoth"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_arcsech']("arcsech", lc, 'onclick'=Action( SetOption('TF_mathfunc'="arcsech"), CloseWindow('mathfuncWin')) )), # end Button/GridCell GridCell(Button['B_arccsch']("arccsch", lc, 'onclick'=Action( SetOption('TF_mathfunc'="arccsch"), CloseWindow('mathfuncWin')) )) # end Button/GridCell ) # end GridRow ), # end GridLayout BoxRow('border'='true', 'inset'=1, 'spacing'=5, bc, 'caption'="Other Maple Mathematical Functions", Label('caption'="Enter a Maple Mathematical Function: ", bc), TextField['TF_other'](15, lc), Button['B_other']("Apply",'onclick'='A_other', lc) ), # end BoxRow BoxRow( Button['B_close2']("Close",CloseWindow('mathfuncWin'), lc), bc ) ) # end BoxColumn ), # end Window ############################################################ Window['argRuleWin']('defaultbutton'='closeArgRuleWin', 'title'="About the Rules with Arguments", 'resizable'='false', BoxColumn('inset'=6, 'spacing'=6, bc, BoxCell( TextBox['TB_argRule']('height'=15, 'width'=40, lc, 'editable'='false', 'font'='F2', 'value'="Click the Button below to see the description..." ) # end TextBox ), # end BoxCell BoxRow('inset'=0, 'spacing'=12, bc, Button("parts and solve", lc, 'onclick'=SetOption('TB_argRule'=partsStr)), Button("rewrite", lc, 'onclick'=SetOption('TB_argRule'=rewriteStr)), Button("change and revert", lc, 'onclick'=SetOption('TB_argRule'=changeStr)), Button['closeArgRuleWin']("Close", CloseWindow('argRuleWin'), lc) ) # end BoxRow ) # end BoxColumn ), # end Window ############################################################ Window['ruleWin']( 'title'="Integration Rule", 'resizable'='false', BoxColumn('inset'=0, 'spacing'=5, 'inset'=10, bc, BoxRow('inset'=0, 'spacing'=0, bc, TextBox[LABEL]('width'=25, lc)), BoxRow('inset'=0, 'spacing'=0, bc, MathMLViewer['ML_rule']('width'=380, 'height'=80, lc) ), # end BoxRow BoxRow('inset'=0, 'spacing'=0, bc, Button("Close", 'onclick'=A_ruleWin, lc) ) # end BoxRow ) # end BoxColumn ), # end ruleWin ############################################################ Window['helpWin']( 'resizable'='false', 'title'="About Step-by-Step Integration Problem Solver Maplet", BoxColumn('border'='true', 'inset'=0, 'spacing'=8, bc, BoxCell( TextBox('height'=24, 'width'=40, lc, 'editable'='false', 'font'='F1', 'foreground'="#333399", 'value'=helpStr ) # end TextBox ), # end BoxCell BoxRow('inset'=0, 'spacing'=0, bc, Button("Close", lc, CloseWindow('helpWin')) ) # end BoxRow ) # end BoxColumn ), # end helpWin ############################################################ MenuBar['intMB']( Menu("File", MenuItem("Start to Solve", 'onclick'='A_start'), MenuItem("Final Answer", 'onclick'='A_getFinalAnswer'), MenuItem("Show All Steps", 'onclick'='A_showAllSteps'), MenuSeparator(), MenuItem("Obtain a Hint", 'onclick'='A_getHint'), MenuItem("Apply the Hint", 'onclick'=Evaluate('function'='applyHint()')), MenuSeparator(), MenuItem("Clear", 'onclick'=Evaluate('function'='clearSteps()')), MenuSeparator(), MenuItem("Close", Shutdown()) ), # end Menu/File Menu("About the Rule", MenuItem("Constant Rule", 'onclick'='A_i_constant'), MenuItem("Constant Multiple", 'onclick'='A_i_constantmultiple'), MenuSeparator(), MenuItem("Sum Rule", 'onclick'='A_i_sum'), MenuItem("Difference Rule", 'onclick'='A_i_difference'), MenuSeparator(), MenuItem("Identity Rule", 'onclick'='A_i_identity'), MenuItem("Power Rule", 'onclick'='A_i_power'), MenuSeparator(), MenuItem("Flip Rule", 'onclick'='A_i_flip'), MenuItem("Join Rule", 'onclick'='A_i_join'), MenuItem("Split Rule", 'onclick'='A_i_split'), MenuSeparator(), MenuItem("Integrate by Parts", 'onclick'='A_i_parts'), MenuItem("Solve Integral", 'onclick'='A_i_parts'), MenuSeparator(), MenuItem("Rewrite Expression", 'onclick'='A_i_rewrite'), MenuSeparator(), MenuItem("Change (Int Variable)", 'onclick'='A_i_change'), MenuItem("Revert (Int Variable)", 'onclick'='A_i_change'), MenuSeparator(), MenuItem("Natural Exponential", 'onclick'='A_i_exp'), MenuItem("Natural Logorithm",'onclick'='A_i_ln'), MenuSeparator(), Menu("Trigonometric Functions", MenuItem("sin",'onclick'='A_i_sin'), MenuItem("cos",'onclick'='A_i_cos'), MenuItem("tan",'onclick'='A_i_tan'), MenuItem("cot",'onclick'='A_i_cot'), MenuItem("sec",'onclick'='A_i_sec'), MenuItem("csc",'onclick'='A_i_csc') ), # end Menu/Trig Menu("Inverse Trigonometric Functions", MenuItem("arcsin",'onclick'='A_i_arcsin'), MenuItem("arccos",'onclick'='A_i_arccos'), MenuItem("arctan",'onclick'='A_i_arctan'), MenuItem("arccot",'onclick'='A_i_arccot'), MenuItem("arcsec",'onclick'='A_i_arcsec'), MenuItem("arccsc",'onclick'='A_i_arccsc') ), # end Menu/Inverse Trig Menu("Hyperbolic Functions", MenuItem("sinh",'onclick'='A_i_sinh'), MenuItem("cosh",'onclick'='A_i_cosh'), MenuItem("tanh",'onclick'='A_i_tanh'), MenuItem("coth",'onclick'='A_i_coth'), MenuItem("sech",'onclick'='A_i_sech'), MenuItem("csch",'onclick'='A_i_csch') ), # end Menu/Hyperbolic Menu("Inverse Hyperbolic Functions", MenuItem("arcsinh",'onclick'='A_i_arcsinh'), MenuItem("arccosh",'onclick'='A_i_arccosh'), MenuItem("arctanh",'onclick'='A_i_arctanh'), MenuItem("arccoth",'onclick'='A_i_arccoth'), MenuItem("arcsech",'onclick'='A_i_arcsech'), MenuItem("arccsch",'onclick'='A_i_arccsch') ) # end Menu/Inverse hyperbolic ), # end Menu/About the Rule Menu("Apply the Rule", MenuItem("Constant Rule", 'onclick'='A_constant'), MenuItem("Constant Multiple", 'onclick'='A_constantmultiple'), MenuSeparator(), MenuItem("Sum Rule", 'onclick'='A_sum'), MenuItem("Difference Rule", 'onclick'='A_difference'), MenuSeparator(), MenuItem("Power Rule", 'onclick'='A_power'), MenuItem("Identity Rule", 'onclick'='A_identity'), MenuSeparator(), MenuItem("Solve", 'onclick'='A_solve'), MenuItem("Revert", 'onclick'='A_revert'), MenuSeparator(), MenuItem("Natural Exponential", 'onclick'='A_exp'), MenuItem("Natural Logorithm", 'onclick'='A_ln'), MenuSeparator(), Menu("Trigonometric Functions", MenuItem("sin", 'onclick'='A_sin'), MenuItem("cos", 'onclick'='A_cos'), MenuItem("tan", 'onclick'='A_tan'), MenuItem("cot", 'onclick'='A_cot'), MenuItem("sec", 'onclick'='A_sec'), MenuItem("csc", 'onclick'='A_csc') ), # end Menu/Trig Menu("Inverse Trigonometric Functions", MenuItem("arcsin", 'onclick'='A_arcsin'), MenuItem("arccos", 'onclick'='A_arccos'), MenuItem("arctan", 'onclick'='A_arctan'), MenuItem("arccot", 'onclick'='A_arccot'), MenuItem("arcsec", 'onclick'='A_arcsec'), MenuItem("arccsc", 'onclick'='A_arccsc') ), # end Menu/Inverse Trig Menu("Hyperbolic Functions", MenuItem("sinh", 'onclick'='A_sinh'), MenuItem("cosh", 'onclick'='A_cosh'), MenuItem("tanh", 'onclick'='A_tanh'), MenuItem("coth", 'onclick'='A_coth'), MenuItem("sech", 'onclick'='A_sech'), MenuItem("csch", 'onclick'='A_csch') ), # end Menu/Hyperbolic Menu("Inverse Hyperbolic Functions", MenuItem("arcsinh", 'onclick'='A_arcsinh'), MenuItem("arccosh", 'onclick'='A_arccosh'), MenuItem("arctanh", 'onclick'='A_arctanh'), MenuItem("arccoth", 'onclick'='A_arccoth'), MenuItem("arcsech", 'onclick'='A_arcsech'), MenuItem("arccsch", 'onclick'='A_arccsch') ) # end Menu/Inverse hyperbolic ), # end Menu/Apply Rules Menu("Understood Rules", CheckBoxMenuItem['CMI_constant']("Constant Rule", 'onclick'=Evaluate('function'='changeUnderstoodRules(constant,CMI_constant)') ), CheckBoxMenuItem['CMI_constantmultiple']("Constant Multiple", 'onclick'=Evaluate('function'= 'changeUnderstoodRules(constantmultiple,CMI_constantmultiple)') ), MenuSeparator(), CheckBoxMenuItem['CMI_sum']("Sum Rule", 'onclick'=Evaluate('function'='changeUnderstoodRules(sum,CMI_sum)') ), CheckBoxMenuItem['CMI_difference']("Difference Rule", 'onclick'=Evaluate('function'='changeUnderstoodRules(difference,CMI_sum)') ), MenuSeparator(), CheckBoxMenuItem['CMI_identity']("Identity Rule", 'onclick'=Evaluate('function'='changeUnderstoodRules(identity,CMI_identity)') ), CheckBoxMenuItem['CMI_power']("Power Rule", 'onclick'=Evaluate('function'='changeUnderstoodRules(power,CMI_power)') ), MenuSeparator(), CheckBoxMenuItem['CMI_solve']("Solve Rule", 'onclick'=Evaluate('function'='changeUnderstoodRules(solve,CMI_solve)') ), CheckBoxMenuItem['CMI_revert']("Revert Rule", 'onclick'=Evaluate('function'='changeUnderstoodRules(revert,CMI_revert)') ), MenuSeparator(), CheckBoxMenuItem['CMI_exp']("Natural Exponential", 'onclick'=Evaluate('function'='changeUnderstoodRules(exp,CMI_exp)') ), CheckBoxMenuItem['CMI_ln']("Natural Logorithm", 'onclick'=Evaluate('function'='changeUnderstoodRules(ln,CMI_ln)') ), MenuSeparator(), Menu("Trigonometric Functions", CheckBoxMenuItem['CMI_sin']("sin", 'onclick'=Evaluate('function'='changeUnderstoodRules(sin,CMI_sin)') ), CheckBoxMenuItem['CMI_cos']("cos", 'onclick'=Evaluate('function'='changeUnderstoodRules(cos,CMI_cos)')), CheckBoxMenuItem['CMI_tan']("tan", 'onclick'=Evaluate('function'='changeUnderstoodRules(tan,CMI_tan)') ), CheckBoxMenuItem['CMI_cot']("cot", 'onclick'=Evaluate('function'='changeUnderstoodRules(cot,CMI_cot)') ), CheckBoxMenuItem['CMI_sec']("sec", 'onclick'=Evaluate('function'='changeUnderstoodRules(sec,CMI_sec)') ), CheckBoxMenuItem['CMI_csc']("csc", 'onclick'=Evaluate('function'='changeUnderstoodRules(csc,CMI_csc)') ) ), # end Menu/Trig Menu("Inverse Trigonometric Functions", CheckBoxMenuItem['CMI_arcsin']("arcsin", 'onclick'=Evaluate('function'='changeUnderstoodRules(arcsin,CMI_arcsin)') ), CheckBoxMenuItem['CMI_arccos']("arccos", 'onclick'=Evaluate('function'='changeUnderstoodRules(arccos,CMI_arccos)') ), CheckBoxMenuItem['CMI_arctan']("arctan", 'onclick'=Evaluate('function'='changeUnderstoodRules(arctan,CMI_arctan)') ), CheckBoxMenuItem['CMI_arccot']("arccot", 'onclick'=Evaluate('function'='changeUnderstoodRules(arccot,CMI_arccot)') ), CheckBoxMenuItem['CMI_arcsec']("arcsec", 'onclick'=Evaluate('function'='changeUnderstoodRules(arcsec,CMI_arcsec)') ), CheckBoxMenuItem['CMI_arccsc']("arccsc", 'onclick'=Evaluate('function'='changeUnderstoodRules(arccsc,CMI_arccsc)') ) ), # end Menu/Inverse Trig Menu("Hyperbolic Functions", CheckBoxMenuItem['CMI_sinh']("sinh", 'onclick'=Evaluate('function'='changeUnderstoodRules(sinh,CMI_sinh)') ), CheckBoxMenuItem['CMI_cosh']("cosh", 'onclick'=Evaluate('function'='changeUnderstoodRules(cosh,CMI_cosh)') ), CheckBoxMenuItem['CMI_tanh']("tanh", 'onclick'=Evaluate('function'='changeUnderstoodRules(tanh,CMI_tanh)') ), CheckBoxMenuItem['CMI_coth']("coth", 'onclick'=Evaluate('function'='changeUnderstoodRules(coth,CMI_coth)') ), CheckBoxMenuItem['CMI_sech']("sech", 'onclick'=Evaluate('function'='changeUnderstoodRules(sech,CMI_sech)') ), CheckBoxMenuItem['CMI_csch']("csch", 'onclick'=Evaluate('function'='changeUnderstoodRules(csch,CMI_csch)') ) ), # end Menu/Hyperbolic Menu("Inverse Hyperbolic Functions", CheckBoxMenuItem['CMI_arcsinh']("arcsinh", 'onclick'=Evaluate('function'='changeUnderstoodRules(arcsinh,CMI_arcsinh)') ), CheckBoxMenuItem['CMI_arccosh']("arccosh", 'onclick'=Evaluate('function'='changeUnderstoodRules(arccosh,CMI_arccosh)') ), CheckBoxMenuItem['CMI_arctanh']("arctanh", 'onclick'=Evaluate('function'='changeUnderstoodRules(arctanh,CMI_arctanh)') ), CheckBoxMenuItem['CMI_arccoth']("arccoth", 'onclick'=Evaluate('function'='changeUnderstoodRules(arccoth,CMI_arccoth)') ), CheckBoxMenuItem['CMI_arcsech']("arcsech", 'onclick'=Evaluate('function'='changeUnderstoodRules(arccoth,CMI_arccoth)') ), CheckBoxMenuItem['CMI_arccsch']("arccsch", 'onclick'=Evaluate('function'='changeUnderstoodRules(arccoth,CMI_arccoth)') ) ) # end Menu/Inverse hyperbolic ), # end Menu/Understood Rules Menu("Help", RadioButtonMenuItem['RMI_all1']('value'=false, 'group'='RMI_all', "Hide the Rule in 'All Steps'" ), RadioButtonMenuItem['RMI_all2']('value'=true, 'group'='RMI_all', "Show the Rule on the Right in 'All Steps'" ), RadioButtonMenuItem['RMI_all3']('value'=false, 'group'='RMI_all', "Show the Rule on the Left in 'All Steps'" ), MenuSeparator(), RadioButtonMenuItem['RMI_single1']('value'=false, 'group'='RMI_single', "Hide the Rule in a single step" ), RadioButtonMenuItem['RMI_single2']('value'=true, 'group'='RMI_single', "Show the Rule on the Right in a single step" ), RadioButtonMenuItem['RMI_single3']('value'=false, 'group'='RMI_single', "Show the Rule on the Left in a single step" ), MenuSeparator(), MenuItem("About this maplet", 'onclick'=RunWindow('helpWin')) ) # end Menu/Help ), # end MenuBar ############################################################ ButtonGroup['RMI_all'](), ButtonGroup['RMI_single'](), ############################################################ Action['A_start'](Evaluate('function'='startRule', 'waitforresult'='false', Argument('TF_fun', quotedtext='true'), Argument('TF_var', quotedtext='true'), Argument('TF_lower', quotedtext='true'), Argument('TF_upper', quotedtext='true')), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false')), Action['A_getHint'](Evaluate('function'='getHint()'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false')), Action['A_applyHint'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyHint()'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false')), Action['A_applyMathFunc'](Evaluate('function'='applyMathFuncRule', Argument('TF_mathfunc', quotedtext='true')), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false')), Action['A_applyRuleParts'](Evaluate('function'='applyRuleParts', 'waitforresult'='false', Argument('TF_parts_f', quotedtext='true'), Argument('TF_parts_g', quotedtext='true')), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false')), Action['A_applyRuleRewrite'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRuleRewrite', Argument('TB_args', quotedtext='true')), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false')), Action['A_applyRuleChange'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRuleChange', Argument('TB_args', quotedtext='true')), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false')), Action['A_applyRuleSplit'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRuleSplit', Argument('TF_c', quotedtext='true')), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false')), Action['A_other']( SetOption('target'='TF_mathfunc',Argument('TF_other')), CloseWindow('mathfuncWin'), Evaluate('function'='applyOtherRule', Argument('TF_other', quotedtext='true')) ), # end A_other Action['A_getFinalAnswer'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='getFinalAnswer()'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false')), Action['A_ruleWin']( SetOption('ML_rule'=""), CloseWindow('ruleWin') ), # end A_ruleWin Action['A_showAllSteps'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='showAllSteps(RMI_all2, RMI_all3)'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false') ), # end A_showAllSteps Action['A_clear'](Evaluate('function'='clearSteps()'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false') ), # end A_clear ############################################################ Action['A_constant'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(constant)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_constant Action['A_constantmultiple'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(constantmultiple)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_constantmultiple Action['A_sum'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(sum)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_sum Action['A_difference'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(difference)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_difference Action['A_identity'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(identity)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_identity Action['A_power'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(power)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_power Action['A_solve'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(solve)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_product Action['A_revert'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(revert)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_quotient Action['A_flip'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(flip)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_chain Action['A_join'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(join)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_chain Action['A_exp'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(exp)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_exp Action['A_ln'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(ln)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_ln Action['A_sin'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(sin)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_sin Action['A_cos'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(cos)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_cos Action['A_tan'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(tan)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_tan Action['A_cot'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(cot)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_cot Action['A_sec'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(sec)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_sec Action['A_csc'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(csc)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_csc Action['A_arcsin'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(arcsin)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_arcsin Action['A_arccos'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(arccos)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_cos Action['A_arctan'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(arctan)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_arctan Action['A_arccot'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(arccot)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_arccot Action['A_arcsec'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(arcsec)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_arcsec Action['A_arccsc'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(arccsc)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_arccsc Action['A_sinh'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(sinh)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_sinh Action['A_cosh'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(cosh)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_cosh Action['A_tanh'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(tanh)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_tanh Action['A_coth'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(coth)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_coth Action['A_sech'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(sech)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_sech Action['A_csch'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(csch)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_csch Action['A_arcsinh'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(arcsinh)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_arcsinh Action['A_arccosh'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(arccosh)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_cosh Action['A_arctanh'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(arctanh)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_arctanh Action['A_arccoth'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(arccoth)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_arccoth Action['A_arcsech'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(arcsech)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_arcsech Action['A_arccsch'](Evaluate('function'='getRMISingle2', Argument('RMI_single2')), Evaluate('function'='getRMISingle3', Argument('RMI_single3')), Evaluate('function'='applyRule(arccsch)', 'waitforresult'='false'), Evaluate('target'='ML', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='info', 'function'='getLastString', 'waitforresult'='false') ), # end A_arccsch ############################################################ Action['A_i_constant']( Evaluate('function'='aboutRule(constant, c)'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_constant Action['A_i_constantmultiple']( Evaluate('function'='aboutRule(constantmultiple, c*f(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_constantmultiple Action['A_i_sum']( Evaluate('function'='aboutRule(sum,f(x)+g(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_sum Action['A_i_difference']( Evaluate('function'='aboutRule(difference,f(x)-g(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_difference Action['A_i_identity']( Evaluate('function'='aboutRule(identity,x)'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_identity Action['A_i_power']( Evaluate('function'='aboutRule(power,x^n)'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_power Action['A_i_flip']( Evaluate('ML_rule'='aboutDefRule(flip)'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_flip Action['A_i_join']( Evaluate('ML_rule'='aboutDefRule(join)'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_join Action['A_i_split']( Evaluate('ML_rule'='aboutDefRule(split)'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_split Action['A_i_parts']( SetOption('TB_argRule'=partsStr), RunWindow('argRuleWin') ), # end A_i_parts Action['A_i_rewrite']( SetOption('TB_argRule'=rewriteStr), RunWindow('argRuleWin') ), # end A_i_parts Action['A_i_change']( SetOption('TB_argRule'=changeStr), RunWindow('argRuleWin') ), # end A_i_parts Action['A_i_exp']( Evaluate('function'='aboutRule(exp,exp(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_exp Action['A_i_ln']( Evaluate('function'='aboutRule(ln,ln(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_ln Action['A_i_sin']( Evaluate('function'='aboutRule(sin,sin(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_sin Action['A_i_cos']( Evaluate('function'='aboutRule(cos,cos(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_cos Action['A_i_tan']( Evaluate('function'='aboutRule(tan,tan(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_tan Action['A_i_cot']( Evaluate('function'='aboutRule(cot,cot(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_cot Action['A_i_sec']( Evaluate('function'='aboutRule(sec,sec(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_sec Action['A_i_csc']( Evaluate('function'='aboutRule(csc,csc(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_csc Action['A_i_arcsin']( Evaluate('function'='aboutRule(arcsin,arcsin(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_arcsin Action['A_i_arccos']( Evaluate('function'='aboutRule(arccos,arccos(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_cos Action['A_i_arctan']( Evaluate('function'='aboutRule(arctan,arctan(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_arctan Action['A_i_arccot']( Evaluate('function'='aboutRule(arccot,arccot(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_arccot Action['A_i_arcsec']( Evaluate('function'='aboutRule(arcsec,arcsec(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_arcsec Action['A_i_arccsc']( Evaluate('function'='aboutRule(arccsc,arccsc(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_arccsc Action['A_i_sinh']( Evaluate('function'='aboutRule(sinh,sinh(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_sinh Action['A_i_cosh']( Evaluate('function'='aboutRule(cosh,cosh(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_cosh Action['A_i_tanh']( Evaluate('function'='aboutRule(tanh,tanh(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_tanh Action['A_i_coth']( Evaluate('function'='aboutRule(coth,coth(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_coth Action['A_i_sech']( Evaluate('function'='aboutRule(sech,sech(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_sech Action['A_i_csch']( Evaluate('function'='aboutRule(csch,csch(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_csch Action['A_i_arcsinh']( Evaluate('function'='aboutRule(arcsinh,arcsinh(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_arcsinh Action['A_i_arccosh']( Evaluate('function'='aboutRule(arccosh,arccosh(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_cosh Action['A_i_arctanh']( Evaluate('function'='aboutRule(arctanh,arctanh(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_arctanh Action['A_i_arccoth']( Evaluate('function'='aboutRule(arccoth,arccoth(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_arccoth Action['A_i_arcsech']( Evaluate('function'='aboutRule(arcsech,arcsech(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_arcsech Action['A_i_arccsch']( Evaluate('function'='aboutRule(arccsch,arccsch(x))'), Evaluate('target'='ML_rule', 'function'='getLastMath', 'waitforresult'='false'), Evaluate('target'='LABEL', 'function'='getLastString', 'waitforresult'='false'), RunWindow('ruleWin') ), # end A_i_arccsch ############################################################ Action['A']() ): # end maplet ############################################################ Understand(Int,none) : Maplets[Display](maplet) : end use: # end use end proc: # end runIntMaplet ############################################################ end module: # end IntMaplet() IntMaplet:-runIntMaplet();