{VERSION 6 0 "IBM INTEL NT" "6.0" } {USTYLETAB {CSTYLE "Maple Input" -1 0 "Courier" 0 1 255 0 0 1 0 1 0 0 1 0 0 0 0 1 }{CSTYLE "" -1 256 "" 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 } {CSTYLE "" -1 257 "" 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 }{CSTYLE "" -1 258 "" 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 }{CSTYLE "" -1 259 "" 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 }{CSTYLE "" -1 260 "" 1 18 0 0 0 0 0 1 0 0 0 0 0 0 0 0 }{CSTYLE "" -1 261 "" 1 18 0 0 0 0 0 0 0 0 0 0 0 0 0 0 } {PSTYLE "Normal" -1 0 1 {CSTYLE "" -1 -1 "Times" 1 12 0 0 0 1 2 2 2 2 2 2 1 1 1 1 }1 1 0 0 0 0 1 0 1 0 2 2 0 1 }{PSTYLE "Heading 1" -1 3 1 {CSTYLE "" -1 -1 "Times" 1 18 0 0 0 1 2 1 2 2 2 2 1 1 1 1 }1 1 0 0 8 4 1 0 1 0 2 2 0 1 }{PSTYLE "Normal" -1 256 1 {CSTYLE "" -1 -1 "Times" 1 12 0 0 0 1 2 2 2 2 2 2 1 1 1 1 }3 1 0 0 0 0 1 0 1 0 2 2 0 1 }} {SECT 0 {PARA 256 "" 0 "" {TEXT 260 57 "Calculus Exploration 8: Indef inite & Definite Integrals " }}{PARA 0 "" 0 "" {TEXT -1 0 "" }}{PARA 0 "" 0 "" {TEXT 261 296 "The following is the Maple code for the Indef inite & Definite Integrals Maplet, which should be used to both explor e antiderivative techniques, and obtain step-by-step solutions to defi nite integral problems. You can either execute the code below or run t he corresponding Maplet from the webpage." }}{PARA 0 "" 0 "" {TEXT -1 0 "" }}{SECT 1 {PARA 3 "" 0 "" {TEXT -1 31 "Indefinite & Definite Inte grals" }}{EXCHG {PARA 0 "" 0 "" {TEXT -1 125 "This maplet guides the u ser through an integration problem. The user can apply integration rul es one at a time to a function " }{TEXT 257 1 "f" }{TEXT -1 40 " and v iew the resulting expression. The " }{TEXT 258 8 "Messages" }{TEXT -1 37 " box displays the status information." }}{PARA 0 "" 0 "" {TEXT -1 0 "" }}{PARA 0 "" 0 "" {TEXT -1 100 "The user enters a function with i ts independent variable. Various integration rules can be applied.\n" }}{PARA 0 "" 0 "" {TEXT -1 86 "At any time, the user can request a hin t for the next step, and then apply the hint. " }}{PARA 0 "" 0 "" {TEXT -1 128 "The user can also specify that a set of rules are unders tood, in which case those rules are automatically applied when possibl e." }}{PARA 0 "" 0 "" {TEXT -1 0 "" }{TEXT 256 0 "" }}{PARA 0 "" 0 "" {TEXT -1 99 "At any time, the user can display all solution steps in t he solution or display the final answer. " }}{PARA 0 "" 0 "" {TEXT 259 36 "Click in red area and press [Enter]." }{TEXT -1 0 "" }}{PARA 0 "> " 0 "" {MPLTEXT 1 0 63218 "restart:\nIntMaplet := module()\n\n### #########################################################\n\n######### ###################################################\n\nexport iniMathM L, addMathML, addMathML2, addMathML3,\n runIntMaplet, \n s tartRule, applyRule, applyOtherRule,\n applyMathFuncRule, getHin t, applyHint, \n getFinalAnswer, showAllSteps, clearSteps,\n \+ applyRuleParts, applyRuleSplit,\n applyRuleRewrite, applyRule Change,\n changeUnderstoodRules, forgetUnderstoodRule,\n a boutRule, aboutDefRule, undoLastStep, \n helpStr, partsStr, rewr iteStr, changeStr:\nlocal steps, mlSteps, iniMlStr:\nsteps:=[]: mlStep s:=[]:\niniMlStr := \"\":\n\n######################################### ###################\n\n############################################### #############\n\nhelpStr := \n\"This maplet guides you through an inte gration problem. You can apply integration rules one at a time to a fu nction f and view the resulting expression. The 'Messages' box display s the status information.\n\nEnter a function with its independent var iable. Click the 'Start' button. This clears the problem history and s tarts a new one.\n\nTo apply integration rules, click the correspondin g buttons or select rules from the 'Apply the Rule' menu.\nWhen you ap ply a rule, the display of the problem is updated with the result of t he applied rule.\nIf you understand a rule, you can select the rule fr om the 'Understood Rules' menu. The maplet then applies that rule when possible.\n\nTo show all steps in the solution, click the 'All Steps' button. \n\nTo request a hint, click the 'Obtain a Hint' button or se lect 'Receive a Hint' from the 'File' menu. To apply the hint, click t he 'Apply the Hint' button or select 'Apply the Hint' from the 'File' \+ menu.\n\nTo clear the problem history, click the 'Clear' button.\n\nTo display the final answer, click the 'Final Ans' button or select 'Get the Final Answer' from the 'File' menu.\": # end helpStr\n\n\n####### #####################################################\n\n############# ###############################################\n\npartsStr := \n\"par ts - Integrate By Parts \nsolve - Solve the Integral \n\nThe parts rul e implements integration by parts: \nInt(f(x)*g'(x),x) = f(x)*g(x) - I nt(g(x)*f'(x),x). \n\nTo apply the rule, you must specify the two func tions f(x) and g(x): \n [parts, f(x), g(x)]\n\nThat is, the first par ameter (f(x)) is the term to be differentiated, and the second paramet er (g(x)) is the integral of the term to be integrated when applying t he rule. \n\nOften after multiple applications of integration by parts , the same integral appears more than once on both sides of the equati on. You can use the 'solve' rule to solve the integral algebraically. \": # end partsStr\n\n################################################ ############\n\n###################################################### ######\n\nrewriteStr := \n\"rewrite - Rewrite the form of expression\n \n\nThe rewrite rule changes the form of the integrand when the integr ation variable is not changed. \n\nThis rule has the general form: [re write, f1(x) = g1(x), f2(x) = g2(x), ...],\n\nwhere parameters of rewr ite rule are input in the text box beside the rewrite rule button, sep arated by commas.\n\nThe effect of applying the rewrite rule is to per form each substitution listed as a parameter to the rule, where occurr ences of the left-hand side of each substitution are replaced by the c orresponding right-hand side. \": # end rewriteStr\n\n################ ############################################\n\n###################### ######################################\n\nchangeStr := \n\"change - Ch ange Integral Variable\nrevert - Revert Integral Variable\n\nThe chang e rule changes the integration variable. \n\nIt can take the following forms. \n [change, F(x,u) = G(x,u), u]\n [change, F(x,u) = G(x, u), u = H(x)]\n\nwhere parameters of rewrite rule are input in the tex t box beside the rewrite rule button, separated by commas.\n\nThe firs t 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 f orm x = G(u) or u = F(x), but can be much more general, provided it ca n be solved for x. \n\nNote: The name of the new variable (u in the p receding paragraph) must be previously unused in the problem to which \+ you are applying this change of variables rule.\nIf you use a name whi ch has already appeared, the system creates a new name.\nOnce the inte gration has been completed, you can use the revert rule to revert to t he original variable, if necessary.\": # end revertStr\n\n############ ################################################\n\n################## ##########################################\n# pre: iniEqn :: algebraic expression\n# post: returns the Presentation MathML of iniEqn\n\niniM athML := proc(iniEqn)\n MathML:-ExportPresentation(iniEqn);\nend proc :\n\n############################################################\n\n# ###########################################################\n# pre: ma thMLStr :: string, in form of Presentation MathML\n# addEqn :: al gebraic expression\n# post: addEqn appends to the next line of mathMLS tr,\n# returns the updated mathMLStr \n\naddMathML := proc(math MLStr, addEqn)\n local tree, cmc, child, children, nl, eqnSign;\n us e XMLTools in\n tree := FromString(mathMLStr);\n cmc := ContentM odelCount(tree);\n child := FromString(MathML:-ExportPresentation(a ddEqn));\n children := ContentModel(child);\n nl := FromString( \" \");\n eqnSign := Element(\"mo\",\"=\"); \n tree := AddChild(tree,nl,cmc);\n tree := AddChild(tree,eqnSig n,cmc+1);\n for child in children do \n cmc := ContentModelCou nt(tree);\n tree := AddChild(tree,child,cmc);\n end do:\n t ree := MakeElement(\"mrow\", [], ContentModel(tree) ):\n tree := El ement(\"math\", tree):\n ToString(tree):\n end use:\nend proc:\n\n ############################################################\n\n###### ######################################################\n# pre: mathMLS tr :: string, in form of Presentation MathML\n# addEqn :: algebra ic expression\n# post: addEqn appends to the next line of mathMLStr,\n # returns the updated mathMLStr \n\naddMathML2 := proc(mathMLSt r, addEqn, rule)\n local tree, cmc, child, children, ruleName, nl, eq nSign;\n use XMLTools in\n tree := FromString(mathMLStr);\n cmc := ContentModelCount(tree);\n child := FromString(MathML:-ExportPr esentation(addEqn));\n children := ContentModel(child);\n nl := \+ FromString(\" \");\n eqnSign := Element(\"mo \",\"=\");\n ruleName := Element(\"mtext\",convert(rule,string));\n tree := AddChild(tree,nl,cmc);\n tree := AddChild(tree,eqnSign, cmc+1);\n for child in children do \n cmc := ContentModelCount (tree);\n tree := AddChild(tree,child,cmc);\n end do:\n cmc := ContentModelCount(tree);\n tree := AddChild(tree,ruleName,cmc); \n tree := MakeElement(\"mrow\", [], ContentModel(tree) ):\n tre e := Element(\"math\", tree):\n ToString(tree):\n end use:\nend pr oc:\n\n############################################################\n \n############################################################\n# pre: mathMLStr :: string, in form of Presentation MathML\n# addEqn :: algebraic expression\n# post: addEqn appends to the next line of math MLStr,\n# returns the updated mathMLStr \n\naddMathML3 := proc( mathMLStr, addEqn, rule)\n local tree, cmc, child, children, ruleName , nl, eqnSign;\n use XMLTools in\n tree := FromString(mathMLStr); \n cmc := ContentModelCount(tree);\n child := FromString(MathML: -ExportPresentation(addEqn));\n children := ContentModel(child);\n \+ nl := FromString(\" \");\n eqnSign := Ele ment(\"mo\",\"=\");\n ruleName := Element(\"mtext\",convert(rule,st ring));\n tree := AddChild(tree,nl,cmc);\n tree := AddChild(tree ,ruleName,cmc+1);\n tree := AddChild(tree,eqnSign,cmc+2);\n for \+ child in children do \n cmc := ContentModelCount(tree);\n tr ee := AddChild(tree,child,cmc);\n end do:\n tree := MakeElement( \"mrow\", [], ContentModel(tree) ):\n tree := Element(\"math\", tre e):\n ToString(tree):\n end use:\nend proc:\n\n################### #########################################\n\n######################### ###################################\n# pre: null \n# post: initializes the Integration problem solving process\n# if input is correct, integration equation is added to steps\n# understood rule(s) ap ply if capable\n# MathML Viewer updates too\n# else error \+ message shows\n\nstartRule := proc()\n local funStr, varStr, lowerStr , upperStr, intStr, \n infoStr, mlStr, intExpr, intEqn, hints, \+ \n i, uRules, uAppliedRules, rulesStr:\n use Student:-Calculus 1, Maplets:-Tools in\n \n clearSteps():\n funStr := Get('TF_f un'):\n if funStr = \"\" then \n infoStr := \"Enter a valid in tegration expression\":\n Set('info'=infoStr):\n error \"No \+ integration expression in TextField TF_fun\":\n end if: \n\n var Str := Get('TF_var'):\n if varStr = \"\" then \n infoStr := \" Enter the variable expression\":\n Set('info'=infoStr):\n er ror \"No integration var in TextField TF_var\":\n end if: \n\n l owerStr := Get('TF_lower'):\n upperStr := Get('TF_upper'):\n\n i f lowerStr<>\"\" and upperStr<>\"\" then \n intStr := cat(\"Int( \", funStr, \", \", varStr, \"=\", lowerStr, \"..\", upperStr, \")\"): \n else \n intStr := cat(\"Int(\", funStr, \", \", varStr, \") \"):\n end if: \n\n intExpr := parse(intStr):\n hints := [Hin t(intExpr)][1]:\n\n mlStr := iniMathML(GetProblem(`internal`)):\n \+ iniMlStr := mlStr:\n infoStr := \"Initializing ...\":\n Set('i nfo'=infoStr):\n \n if nops(hints)>0 then\n uRules := rhs(U nderstand(Int)):\n uAppliedRules := []:\n\n if nops(uRules) \+ > 0 then\n for i from 1 to nops(hints) do \n if member (hints[i],uRules) = true then\n uAppliedRules := [op(uAppli edRules),hints[i]]:\n end if:\n end do:\n\n int Eqn := Rule[](GetProblem(`internal`)): \n steps := [op(steps),i ntEqn]:\n\n if nops(uAppliedRules) > 0 then\n if nops( uRules) = 1 then \n rulesStr := convert(uRules,string):\n \+ infoStr := cat(\"understood rule \", rulesStr,\n \+ \" is automatically applied.\"):\n else \n \+ rulesStr := convert(uRules,string):\n infoStr := c at(\"understood rules \", rulesStr, \n \" ar e automatically applied.\"):\n end if: # end if nops(uRules)= >1\n Set('info'=infoStr):\n mlStr := addMathML(mlStr ,rhs(intEqn)):\n end if: # end if nops(uAppliedRules)>0\n \+ \n else \n intEqn := Rule[](GetProblem(`internal`)):\n \+ steps := [op(steps),intEqn]: \n \n end if: # end if nops(uR ules) > 0\n \n Set('ML'=mlStr):\n mlSteps := [op(mlStep s), mlStr]:\n infoStr := \"Apply any rule below\":\n Set('in fo'=infoStr):\n \n else \n intEqn := Rule[](GetProblem(`intern al`)): \n steps := [op(steps),intEqn]:\n Set('ML'=mlStr):\n \+ mlSteps := [op(mlSteps), mlStr]:\n infoStr := \"no hint is g iven\":\n Set('info'=infoStr):\n end if : # end if nops(hints) >0\n end use:\nend proc:\n\n######################################### ###################\n\n############################################### #############\n# pre: null \n# post: if aRule is a valid integration r ule and applicable\n# new step is stored in steps, updates MathM LViewer \n# else message shows the rule is not applied\n\napplyR ule := proc(aRule)\n local mlStr, infoStr, intEqn, oldEqn:\n use Stu dent:-Calculus1, Maplets:-Tools in\n \n if nops(steps)=0 then\n \+ startRule():\n end if:\n\n mlStr := Get('ML'):\n oldEqn \+ := steps[nops(steps)]:\n if type(aRule,list)=true then\n intEq n := Rule[op(aRule)](steps[nops(steps)]):\n else \n intEqn := \+ Rule[aRule](steps[nops(steps)]):\n end if: \n\n if (GetMessage() =NULL) or (not evalb(intEqn=oldEqn)) then\n infoStr := convert(aR ule,string):\n infoStr := cat(infoStr, \" rule is being applied\" ):\n Set('info'=infoStr):\n\n steps := [op(steps),intEqn]:\n if nops(steps)=2 then Set(undomenu(enabled)=true) end if:\n\n \+ if type(aRule,list)=true then \n if Get('RMI_single2')=true \+ then\n mlStr := addMathML2(mlStr,rhs(intEqn),aRule):\n \+ elif Get('RMI_single3')=true then\n mlStr := addMathML3(mlSt r,rhs(intEqn),aRule):\n else\n mlStr := addMathML(mlSt r,rhs(intEqn)):\n end if:\n else\n if Get('RMI_sing le2')=true then\n mlStr := addMathML2(mlStr,rhs(intEqn),[aRul e]):\n elif Get('RMI_single3')=true then\n mlStr := ad dMathML3(mlStr,rhs(intEqn),[aRule]):\n else\n mlStr := addMathML(mlStr,rhs(intEqn)):\n end if:\n end if:\n\n \+ Set('ML'=mlStr):\n mlSteps := [op(mlSteps), mlStr]:\n\n in foStr := convert(aRule,string): \n infoStr := cat(infoStr, \" rul e has been applied\"):\n Set('info'=infoStr):\n else\n in foStr := convert(aRule,string):\n infoStr := cat(infoStr, \" rule is not applicable\"):\n Set('info'=infoStr):\n end if: # end \+ if GetMessage()=NULL\n\n end use:\nend proc: # end applyRule()\n\n### #########################################################\n\n######### ###################################################\n# pre: null\n# po st: apply the integrating by parts\n# Int(f(x)*Diff(g(x),x),x) = f(x)*g(x) - Int(g(x)*Diff(f(x),x),x)\n# argument f(x) is entere d in TF_parts_fx, and arguments g(x) is \n# entered in TF_parts_ gx\n\napplyRuleParts := proc()\n local fx, gx:\n use Student:-Calcul us1, Maplets:-Tools, Maplets:-Elements in\n \n fx := Get('TF_pa rts_f'):\n gx := Get('TF_parts_g'):\n\n if fx = \"\" or gx=\"\" then \n Maplets:-Display(Maplet(\n MessageDialog(\"You m ust specify f(x) and g(x).\"))): \n else\n applyRule([parts, \+ parse(fx), parse(gx)]):\n\n end if:\n\n end use:\nend proc: # end \+ applyRuleParts\n\n#################################################### ########\n\n########################################################## ##\n# pre: null\n# post: apply the rewrite rule\n# rewrite equat ions are listed in TB_args seperated\n# by commas, the left-hand side of each substitution\n# is replaced by the corresponding r ight-hand side\n\napplyRuleRewrite := proc()\n local str:\n use Stud ent:-Calculus1, Maplets:-Tools, Maplets:-Elements in\n \n str := Get('TB_args'):\n if str = \"\" then \n Maplets:-Display(Mapl et(\n MessageDialog(\"You must specify a rewrite equation\"))) : \n \n else\n str := cat(\"rewrite, \", str):\n appl yRule([parse(str)]):\n end if:\n\n end use:\nend proc: # end apply RuleWithArgs\n\n###################################################### ######\n\n############################################################ \n# pre: null\n# post: apply the change rule, which changes the integr ation \n# variable, arguments are listed in TB_args\n\napplyRule Change := proc()\n local str:\n use Student:-Calculus1, Maplets:-Too ls, Maplets:-Elements in\n \n str := Get('TB_args'):\n if str = \"\" then \n Maplets:-Display(Maplet(\n MessageDialog( \"You must specify a change-of-variables equation\"))): \n else\n \+ str := cat(\"change, \", str):\n applyRule([parse(str)]):\n \+ end if:\n\n end use:\nend proc: # end applyRuleWithArgs\n\n####### #####################################################\n\n############# ###############################################\n# pre: null\n# post: \+ apply the definite integration rule split\n# require argument fr om TF_c\n\napplyRuleSplit := proc()\n local param:\n use Student:-Ca lculus1, Maplets:-Tools, Maplets:-Elements in\n \n param := Get( 'TF_c'):\n if ruleArgs = \"\" then \n error cat(\"no split par ameter in 'TF_c'\"): \n end if:\n applyRule([split, parse(param) ]):\n\n end use:\nend proc: # end applyRuleSplit\n################### #########################################\n\n######################### ###################################\n# pre: null \n# post: read the in tegration rule from TF_other, and apply it\n# if TF_other is emp ty, error message shows\n\napplyOtherRule := proc()\n local aRule:\n \+ use Maplets:-Tools, Maplets:-Elements in\n aRule := Get('TF_other' ):\n if aRule = \"\" then\n Maplets:-Display(Maplet(\n \+ MessageDialog(\"No rule has been entered\"))): \n else \n ap plyRule(parse(aRule)):\n end if:\n end use:\nend proc: # end apply OtherRule\n\n######################################################### ###\n\n############################################################\n# pre: null \n# post: read the integration rule from TF_mathfunc, and a pply it\n# if TF_mathfunc is empty, error message shows\n\napply MathFuncRule := proc()\n local aRule:\n use Maplets:-Tools in\n a Rule := Get('TF_mathfunc'):\n if aRule = \"\" then\n Maplets:- Display(Maplet(\n MessageDialog(\"No rule has been entered\")) ): \n else \n applyRule(parse(aRule)):\n end if:\n end us e:\nend proc: # end applyOtherRule\n\n################################ ############################\n\n###################################### ######################\n# pre: null\n# post: hint for the current inte gration problem is shown \n# in the message TextField, info\n\ng etHint := proc()\n local intEqn, hint, hints, infoStr, i:\n use Stud ent:-Calculus1, Maplets:-Tools in\n\n if nops(steps)=0 then\n \+ startRule():\n end if:\n \n intEqn := steps[nops(steps)]:\n \+ hints := [Hint(intEqn)]:\n hint := hints[1]:\n \n if nops(h int)=0 then\n infoStr:=\"No hint can be given, or the problem is \+ done\":\n Set('info'=infoStr):\n else\n infoStr:=convert( hint,string);\n if nops(hints)>1 then \n for i in hints[2. .-1] do\n infoStr := cat(infoStr, \", \", convert(i,string)); \n end do;\n end if:\n infoStr:=cat(infoStr, \" could be applied.\"):\n Set('info'=infoStr):\n end if:\n\n hint: # return value used in applyHint\n\n end use:\nend proc: # end getHi nt()\n\n############################################################\n \n############################################################\n# pre: null\n# post: hint for the current integration problem is applied \n \napplyHint := proc()\n local mlStr, infoStr, oriEqn, intEqn, hint:\n use Student:-Calculus1, Maplets:-Tools in\n\n hint := getHint(): \n if nops(hint)>0 then \n applyRule(hint):\n end if: \n\n \+ end use:\nend proc: # end applyHint\n################################ ############################\n\n###################################### ######################\n# pre: null \n# post: final answer for the cu rrent problem is shown\n\ngetFinalAnswer := proc()\n local intEqn, hi nt, mlStr, infoStr:\n use Student:-Calculus1, Maplets:-Tools in\n\n \+ if nops(steps)=0 then\n startRule():\n end if:\n\n intEqn := steps[nops(steps)]:\n hint := [Hint(intEqn)][1]: \n\n if nop s(hint)=0 then\n infoStr := \"No rule could be applied, or the qu estion is done\":\n Set('info'=infoStr):\n \n else \n m lStr := Get('ML'): \n while nops(hint)>0 do\n infoStr := \+ cat(convert(hint,string),\" is being applied.\"):\n Set('info'= infoStr):\n intEqn := Rule[hint](intEqn):\n hint := [Hin t(intEqn)][1]: \n end do:\n steps := [op(steps),intEqn]:\n \+ if nops(steps)=2 then Set(undomenu(enabled)=true) end if:\n i nfoStr := \"Exporting final answer ...\":\n mlStr := addMathML(ml Str,rhs(intEqn)):\n Set('ML'=mlStr):\n mlSteps := [op(mlStep s), mlStr]:\n infoStr := \"The final answer is displayed\":\n \+ Set('info'=infoStr):\n\n end if: # end if nops(hint)=0\n\n end u se:\nend proc: # end getFinalAnswer\n\n############################### #############################\n\n##################################### #######################\n# pre: null\n# post: a complete solution for \+ the current problem is shown\n\nundoLastStep := proc()\n local i, inf oStr, mlStr:\n use Student:-Calculus1, Maplets:-Tools in\n\n if (n ops(steps) > 1) and (not evalb(iniMlStr=\"\")) then\n steps:=[seq (steps[i], i=1..nops(steps)-1)]:\n mlSteps:=[seq(mlSteps[i], i=1. .nops(mlSteps)-1)]:\n\n Set('ML'=mlSteps[nops(mlSteps)]):\n \+ infoStr := \"Undo last step\":\n Set('info'=infoStr):\n if n ops(steps)=1 then Set(undomenu(enabled)=false) end if:\n else \n \+ infoStr := \"Undo is not available\":\n Set('info'=infoStr):\n end if : # end if nops(steps)\n\n end use:\nend proc: # end undoL astStep\n\n########################################################### #\n\n##################################################\n# pre: null\n # post: a complete solution for the current problem is shown\n\nshowAl lSteps := proc(boo1, boo2)\n local intEqn, hint, mlStr, infoStr:\n u se Student:-Calculus1, Maplets:-Tools in\n\n if nops(steps)=0 then \n startRule():\n end if:\n \n intEqn := steps[nops(step s)]:\n hint := [Hint(intEqn)][1]:\n\n if nops(hint)=0 then\n \+ infoStr := \"No rule could be applied, or the question is done\":\n \+ Set('info'=infoStr):\n \n else \n mlStr := Get('ML'):\n \n while nops(hint)>0 do\n infoStr := cat(convert(hint,str ing),\" is being applied.\"):\n Set('info'=infoStr):\n i ntEqn := Rule[hint](intEqn):\n if boo1 then\n mlStr := addMathML2(mlStr,rhs(intEqn),hint):\n elif boo2 then\n \+ mlStr := addMathML3(mlStr,rhs(intEqn),hint):\n else\n \+ mlStr := addMathML(mlStr,rhs(intEqn)):\n end if:\n ste ps := [op(steps),intEqn]:\n if nops(steps)=2 then Set(undomenu( enabled)=true) end if:\n mlSteps := [op(mlSteps),mlStr]:\n \+ hint := [Hint(intEqn)][1]: \n end do:\n \n infoStr := \+ \"Exporting the full solution ...\":\n Set('info'=infoStr):\n \+ Set('ML'=mlStr):\n infoStr := \"A complete solution is displaye d\":\n Set('info'=infoStr): \n\n end if: # end if nops(hint)= 0\n \n \n end use:\nend proc: # showAllSteps\n\n############# ###############################################\n\n################### #########################################\n# pre: name is a valid inte gration rule \n# fun is in a valid algebraic expression or functi on \n# post: pop up a Window with the description of the rule 'name'\n \naboutRule := proc(name,fun)\n local eqn, intEqn, understoodRules:\n use Student:-Calculus1, Maplets:-Tools in\n\n understoodRules := \+ rhs(Understand(Int)):\n Understand(Int,'none'):\n \n intEqn : = Int(fun,x): \n eqn := intEqn=rhs(Rule[name](intEqn)): \n\nif f un <> x^n then\n Set('ruleWin(title)'=cat(convert(name,string),\" r ule\")):\n Set('ML_rule'=MathML:-ExportPresentation(eqn)):\n\nelse \n Set('ruleWin(title)'=cat(convert(name,string),\" rule\")):\n \+ Set('ML_rule'=\n\"\n \n ∫\n \+ \n \n x\n n\n \+ \n \n ⁢\n\n \n ⅆ\n x\n \n\n \+ = \n \n\n \n x\n \n \n n\n +\n \+ 1\n \n \n\n \n\n \n n\n +\n 1\n \n\n\nif n \n \n< mtext fontsize=16 fontweight=bold> -1\n\n \"): \n\nend if;\n\n Understand(Int, op(understoodRules)): \n \n end use: \nend proc: # end aboutRule\n################################### #########################\n\n######################################### ###################\n# pre: name is a valid definite integration rule \+ \n# post: pop up a Window with the description of the rule 'name'\n\na boutDefRule := proc(name)\n local eqn, intEqn, understoodRules:\n us e Student:-Calculus1, Maplets:-Tools in\n\n understoodRules := rhs( Understand(Int)):\n Understand(Int,'none'):\n \n if name=flip t hen\n intEqn := Int(f(x),x=a..b): \n eqn := intEqn=rhs(Rule[ flip](intEqn)): \n elif name=join then\n intEqn := Int(f(x),x =a..c)+Int(f(x),x=c..b):\n eqn := intEqn=rhs(Rule[join](intEqn)): \n else\n intEqn := Int(f(x),x=a..b): \n eqn := intEqn= rhs(Rule[split,c](intEqn)): \n end if:\n\n Set('ruleWin(title)' =cat(convert(name,string),\" rule\")):\n # Set('ML_rule'=MathML:-Ex portPresentation(eqn)):\n\n Understand(Int, op(understoodRules)): \+ \n \n return MathML:-ExportPresentation(eqn):\n end use: \nend p roc: # end aboutRule\n\n############################################## ##############\n\n#################################################### ########\n# pre: aRule is a valid integration rule\n# post: if ruleSta te=true, aRule is understood\n# else, aRule is removed from unde rsto0d integration rules\n\nchangeUnderstoodRules := proc(aRule, ruleS tate)\n use Student:-Calculus1 in\n if ruleState=true then \n \+ Understand(Int,aRule):\n else\n forgetUnderstoodRule(aRule): \n end if:\n end use: \nend proc: # end changeUnderstoodRules\n\n# ###########################################################\n\n####### #####################################################\n# pre: aRule is a valid integration rule \n# post: aRule is removed from understood i ntegration rules\n\nforgetUnderstoodRule := proc(aRule)\n local rules :\n use Student:-Calculus1 in\n rules := rhs(Understand(Int)):\n \+ rules := subs(aRule=NULL,rules):\n Understand(Int,'none'):\n i f nops(rules)>0 then\n Understand(Int,op(rules));\n end if:\n \+ end use:\nend proc:\n################################################ ############\n\n###################################################### ######\n# pre: null\n# post: clears the historic record of all steps\n \nclearSteps := proc()\n use Student:-Calculus1, Maplets:-Tools in\n \+ Set('ML'=\"\"): Set('info'=\"\"): \n Clear(all): steps:=[]: mlSt eps:=[]:\n Set(undomenu(enabled)=false) \n end use:\nend proc: # e nd clearSteps()\n\n################################################### #########\n\n######################################################### ###\n# pre: Maple 8 or higher is installed\n# post: run Step-by-Step I ntegration Solver\n\nrunIntMaplet := proc()\n\nlocal maplet, bc, dc, l c:\nbc := 'background'=\"#DDFFFF\":\ndc := 'background'=\"#CCFFFF\":\n lc := 'background'=\"#EEFFFF\":\n\nuse Maplets, Maplets:-Elements, Stu dent:-Calculus1 in\n\nmaplet := Maplet( \n 'onstartup'=RunWindow('int Win'),\n\n############################################################ \n\n Font['F1'](\"Default\", 'bold'='true', 'size'=14),\n Font['F2'] (\"Default\", 'italic'='true', 'size'=12), \n\n####################### #####################################\n \n Window['intWin']( 'menuba r'='intMB',\n 'resizable'='false', \n 'title'=\"Calculus 1 - Ste p-by-Step Indefinite & Definite Integrals Solver\",\n BoxColumn(bc, \n\n BoxRow('border'='true','inset'=0,'spacing'=0, \n 'ca ption'=\"Enter a function\", bc, \n Label('caption'=\"Function \+ \", 'font'='F1',bc),\n TextField['TF_fun']('value'=3*sin(x), ' width'=22, lc),\n Label('caption'=\" Variable \", 'font'='F1', bc), \n TextField['TF_var'](\"x\",4,lc),\n Label('captio n'=\" from \", 'font'='F1', bc),\n TextField['TF_lower']('width '=5, lc),\n Label('caption'=\" to \", 'font'='F1',bc), \n \+ TextField['TF_upper']('width'=5, lc) \n ), # end BoxRow\n\n \+ BoxRow('inset'=0,'spacing'=0, bc, \n BoxColumn('border'='tr ue', 'inset'=0, 'spacing'=0, \n 'caption'=\"Note: To find ant iderivatives (indefinite integrals) omit limits of integration above. \", bc, \n BoxRow(MathMLViewer['ML']('height'=470, 'width'=40 0, lc), bc),\n BoxRow('halign'='right', bc,\n Butt on(\"Start\", \n 'onclick'=Evaluate('function'='startRule ()'),\n 'tooltip'=\"Initialize to find a integration\", l c),\n Button(\"Final Ans\", \n 'onclick'=Evalu ate('function'='getFinalAnswer()'),\n 'tooltip'=\"Get the final answer\", lc), \n Button(\"All Steps\", \n \+ 'onclick'=Evaluate('function'='showAllSteps(RMI_all2, RMI_all3)'), \n 'tooltip'=\"Show a complete solution\", lc),\n \+ Button(\"Clear\", \n 'onclick'=Evaluate('function'='c learSteps()'),\n 'tooltip'=\"Clear output and problem his tory\", lc),\n Button(\"Close\", Shutdown(), 'tooltip'=\"cl ose\", lc) \n ) # end BoxRow\n ), # end BoxColumn\n\n \+ BoxColumn('inset'=0, 'inset'=0, 'spacing'=0, bc, \n\n \+ BoxRow('border'='true', 'caption'=\"Messages\", \n 'in set'=0, 'spacing'=0, bc, \n BoxCell(\n TextBo x['info']('editable'='false',\n 'value'=\"\", lc, \n \+ 'tooltip'=\"Message\", \n 'height'=4, 'wi dth'=24 \n ) # end TextBox\n ) # end BoxCell\n ), # end BoxRow \n\n BoxRow('border'='true ', 'caption'=\"Hints\", \n 'inset'=0, 'spacing'=10, bc , \n BoxCell(Button['B_getHint'](\"Obtain a Hint\", \n \+ 'onclick'=Evaluate('function'='getHint()'), \n \+ 'tooltip'=\"Receive a Hint\", lc)),\n BoxCell(But ton['B_applyHint'](\"Apply the Hint\", \n 'onclick'= Evaluate('function'='applyHint()'), \n 'tooltip'=\"A pply the Hint\", lc))\n ), # end BoxRow\n\n BoxColum n('border'='true', 'inset'=0, 'spacing'=0,\n 'capt ion'=\"Integration Rules\", bc, \n BoxRow('halign'='left', \+ 'inset'=0, 'spacing'=3, bc,\n BoxCell('halign'='left',\n \+ Button['B_constant'](\" Constant \", lc, \n \+ Evaluate('function'='applyRule(constant)'), \n \+ 'tooltip'=\"Int(c, x)= c*x or Int(c, x=a..b) = c*b - c*a\")\n \+ ), # BoxCell\n BoxCell('halign'='left',\n \+ Button['B_constantmultiple'](\" Constant Multiple\", lc, \n \+ Evaluate('function'='applyRule(constantmultiple)'), \n \+ 'tooltip'=\"Int(c*f(x)) = c*Int(f(x))\")\n \+ ) # BoxCell\n ), # BoxRow\n\n BoxRow('halign'= 'left', 'inset'=0, 'spacing'=1, bc, \n BoxCell('halign'=' left',\n Button['B_identity'](\"Identity\", lc, \n \+ Evaluate('function'='applyRule(identity)'), \n \+ 'tooltip'=\"Int(x,x) = x^2/2\")\n ), # BoxCell\n \+ BoxCell('halign'='left',\n Button['B_sum']( \"Sum\", lc, \n Evaluate('function'='applyRule(sum)') , \n 'tooltip'=\"Apply sum rule: Int(f(x)+g(x)) = Int (f(x)) + Int(g(x))\")\n ), # BoxCell\n BoxCe ll('halign'='left',\n Button['B_difference'](\"Differen ce\", lc, \n Evaluate('function'='applyRule(differenc e)'), \n 'tooltip'=\"Int(f(x)-g(x)) = Int(f(x)) - Int (g(x))\")\n ) # BoxCell\n ), # BoxRow\n\n \+ BoxRow('halign'='left', 'inset'=0, 'spacing'=5, bc,\n \+ BoxCell('halign'='left',\n Button['B_power'](\"Powe r \", lc, \n Evaluate('function'='applyRule(power)'), \n 'tooltip'=\"Int(x^n, x) = x^(n+1)/(n+1)\")\n \+ ), # BoxCell\n BoxCell('halign'='left',\n \+ Button['B_revert'](\" Revert \", lc, \n Eval uate('function'='applyRule(revert)'),\n 'tooltip'=\"R everts a change of variables substitution\")\n ), # BoxCe ll\n BoxCell('halign'='left', \n Button['B _solve'](\" Solve \", lc, \n Evaluate('function'='app lyRule(solve)'), \n 'tooltip'=\"Algebraically solve f or the integral appeared more than once\")\n ) # end BoxC ell\n ) # end BoxRow\n ), # end Column\n\n \+ BoxColumn('border'='true', 'inset'=0, 'spacing'=0,\n \+ 'caption'=\"Integration Rules with Arguments\", bc,\n \+ BoxRow('inset'=0, 'spacing'=0, bc,\n Button['B_parts'](\" Int By Parts\", lc, \n 'onclick'=Evaluate('function'='a pplyRuleParts()'), \n 'tooltip'=\"Int(f(x)*Diff(g(x),x) ,x) = f(x)*g(x)-Int(g(x)*Diff(f(x),x),x)\" ),\n Label(\" f( x)=\", dc), \n TextField['TF_parts_f']('width'=3, lc), \n \+ Label(\" g(x)=\", dc), \n TextField['TF_parts_g'] ('width'=3, lc) \n ), # end BoxRow\n \n Bo xRow('inset'=0, 'spacing'=0, bc,\n BoxColumn('halign'='le ft', 'inset'=0, 'spacing'=0, bc, \n Button['B_rewrite'] (\"Rewrite \", lc, \n 'onclick'=Evaluate('function'=' applyRuleRewrite()'), \n 'tooltip'=\"Change the form \+ of the expression\"),\n Button['B_change'](\"Change\", \+ lc, \n 'onclick'=Evaluate('function'='applyRuleChange ()'), \n 'tooltip'=\"Change the variable of the integ ration\")\n ), # BoxColumn\n TextBox['TB_arg s'](\n 'value'=\"\", lc,\n 'tooltip'=\"A rguments of the Rules\", \n 'height'=2, 'width'=22 \n \+ ) # end TextBox\n ) # end BoxRow\n ), # end BoxColumn \n\n BoxColumn('border'='true', 'inset'=0, ' spacing'=0,\n 'caption'=\"Function Rules\", bc, \n BoxRow('halign'='left', 'inset'=0, 'spacing'=0, bc, \n \+ Label('caption'=\"Enter a Function: \", bc),\n \+ TextField['TF_mathfunc']('width'=6, lc)\n ), # end BoxR ow\n BoxRow('halign'='left', 'inset'=0, 'spacing'=5, bc, \+ \n Button['B_applyMathFunc'](\"Apply\", lc,\n \+ Evaluate('function'='applyMathFuncRule()')),\n But ton['B_selectMathfunc'](\"Select a Function\", \n 'oncl ick'=RunWindow('mathfuncWin'), lc)\n ) # end BoxRow\n \+ ), # end BoxColumn \n\n BoxRow('border'='true', 'inset '=0, 'spacing'=3,\n 'caption'=\"Definite Integral Rule s\", bc, \n Button(\"Flip\", lc, \n Evaluate( 'function'='applyRule(flip)'), \n 'tooltip'=\"Int(f(x),x= a..b) = -Int(f(x),x=b..a)\" ),\n Button(\"Join\", lc, \n \+ Evaluate('function'='applyRule(join)'), \n 't ooltip'=\"Int(f(x),x=a..c) + Int(f(x),x=c..b) = Int(f(x),x=a..b)\" ), \n Button(\"Split\", lc, \n 'onclick'=Evaluat e('function'='applyRuleSplit()'), \n 'tooltip'=\"Int(f(x) ,x=a..b) = Int(f(x),x=a..c) + Int(f(x),x=c..b)\" ), \n Labe l(\" at \", dc), \n TextField['TF_c']('width'=2, lc)\n \+ ) # end BoxRow\n \n ) # end BoxColumn \n ) # end BoxR ow\n\n ) # end BoxColumn\n ), # end Window\n\n#################### ########################################\n\n Window['mathfuncWin']('r esizable'='false',\n 'title'=\"Select a Mathematical Function\",\n \+ 'defaultbutton'='B_close2',\n BoxColumn(bc, \n\n BoxRow('bo rder'='true', 'inset'=1, 'spacing'=5, bc, \n 'caption'=\"Expone ntial and Logarithmic Functions\", \n Button['B_exp'](\"Natural Exponential\", lc,\n 'onclick'=Action(\n SetOpti on('TF_mathfunc'=\"exp\"),\n CloseWindow('mathfuncWin'), \+ \n Evaluate('function'='applyRule(exp)')) \n ), # e nd Button exp\n Button['B_ln'](\"Natural Logarithmic\", lc,\n \+ 'onclick'=Action(\n SetOption('TF_mathfunc'=\"ln\" ),\n CloseWindow('mathfuncWin'), \n Evaluate(' function'='applyRule(ln)')) \n ) # end Button ln\n ), # en d BoxRow\n\n GridLayout('border'='true', 'inset'=1, bc, \n \+ 'caption'=\"Trigonometric, Hyperbolic Functions and their Inverses\", \n\n GridRow(\n GridCell(Button['B_sin'](\" sin \+ \", lc,\n 'onclick'=Action(\n SetOption('TF_m athfunc'=\"sin\"),\n CloseWindow('mathfuncWin'), \n \+ Evaluate('function'='applyRule(sin)') ) \n )), # en d Button/GridCell\n GridCell(Button['B_cos'](\" cos \", \+ lc,\n 'onclick'=Action(\n SetOption('TF_mathfu nc'=\"cos\"),\n CloseWindow('mathfuncWin'), \n \+ Evaluate('function'='applyRule(cos)')) \n )), # end Button /GridCell\n GridCell(Button['B_tan'](\" tan \", lc,\n \+ 'onclick'=Action(\n SetOption('TF_mathfunc'=\"t an\"),\n CloseWindow('mathfuncWin'), \n Ev aluate('function'='applyRule(tan)') ) \n )), # end Button/Gr idCell\n GridCell(Button['B_cot'](\" cot \", lc,\n \+ 'onclick'=Action(\n SetOption('TF_mathfunc'=\"cot \"),\n CloseWindow('mathfuncWin'), \n Eval uate('function'='applyRule(cot)') ) \n )), # end Button/GridC ell\n GridCell(Button['B_sec'](\" sec \", lc,\n \+ 'onclick'=Action(\n SetOption('TF_mathfunc'=\"sec\"), \n CloseWindow('mathfuncWin'), \n Evaluate ('function'='applyRule(sec)') ) \n )), # end Button/GridCell \n GridCell(Button['B_csc'](\" csc \", lc,\n \+ 'onclick'=Action(\n SetOption('TF_mathfunc'=\"csc\"),\n \+ CloseWindow('mathfuncWin'), \n Evaluate('f unction'='applyRule(csc)') ) \n )) # end Button/GridCell\n \+ ), # end GridRow\n \n GridRow(\n GridCell(But ton['B_arcsin'](\" arcsin \", lc,\n 'onclick'=Action(\n \+ SetOption('TF_mathfunc'=\"arcsin\"),\n CloseW indow('mathfuncWin'), \n Evaluate('function'='applyRule( arcsin)') ) \n )), # end Button/GridCell\n GridCell( Button['B_arccos'](\" arccos \", lc,\n 'onclick'=Action(\n \+ SetOption('TF_mathfunc'=\"arccos\"),\n Clo seWindow('mathfuncWin'), \n Evaluate('function'='applyRu le(arccos)') ) \n )), # end Button/GridCell\n GridCe ll(Button['B_arctan'](\" arctan \", lc,\n 'onclick'=Action( \n SetOption('TF_mathfunc'=\"arctan\"),\n \+ CloseWindow('mathfuncWin'), \n Evaluate('function'='appl yRule(arctan)') ) \n )), # end Button/GridCell\n Gri dCell(Button['B_arccot'](\" arccot \", lc,\n 'onclick'=Acti on(\n SetOption('TF_mathfunc'=\"arccot\"),\n \+ CloseWindow('mathfuncWin'), \n Evaluate('function'='a pplyRule(arccot)') ) \n )), # end Button/GridCell\n \+ GridCell(Button['B_arcsec'](\" arcsec \", lc,\n 'onclick'=A ction(\n SetOption('TF_mathfunc'=\"arcsec\"),\n \+ CloseWindow('mathfuncWin'), \n Evaluate('function' ='applyRule(arcsec)') ) \n )), # end Button/GridCell\n \+ GridCell(Button['B_arccsc'](\" arccsc \", lc,\n 'onclick '=Action(\n SetOption('TF_mathfunc'=\"arccsc\"),\n \+ CloseWindow('mathfuncWin'), \n Evaluate('functi on'='applyRule(arccsc)') ) \n )) # end Button/GridCell\n \+ ), # end GridRow\n \n GridRow(\n GridCell(Button[ 'B_sinh'](\" sinh \", lc,\n 'onclick'=Action(\n \+ SetOption('TF_mathfunc'=\"sinh\"),\n CloseWindow(' mathfuncWin'), \n Evaluate('function'='applyRule(sinh)') ) \n )), # end Button/GridCell\n GridCell(Button['B _cosh'](\" cosh \", lc,\n 'onclick'=Action(\n \+ SetOption('TF_mathfunc'=\"cosh\"),\n CloseWindow('ma thfuncWin'), \n Evaluate('function'='applyRule(cosh)') ) \n )), # end Button/GridCell\n GridCell(Button['B_t anh'](\" tanh \", lc,\n 'onclick'=Action(\n \+ SetOption('TF_mathfunc'=\"tanh\"),\n CloseWindow('math funcWin'), \n Evaluate('function'='applyRule(tanh)') ) \+ \n )), # end Button/GridCell\n GridCell(Button['B_co th'](\" coth \", lc,\n 'onclick'=Action(\n \+ SetOption('TF_mathfunc'=\"coth\"),\n CloseWindow('mathf uncWin'), \n Evaluate('function'='applyRule(coth)') ) \n )), # end Button/GridCell\n GridCell(Button['B_sech '](\" sech \", lc,\n 'onclick'=Action(\n S etOption('TF_mathfunc'=\"sech\"),\n CloseWindow('mathfun cWin'), \n Evaluate('function'='applyRule(sech)') ) \n \+ )), # end Button/GridCell\n GridCell(Button['B_csch'] (\" csch \", lc,\n 'onclick'=Action(\n Set Option('TF_mathfunc'=\"csch\"),\n CloseWindow('mathfuncW in'), \n Evaluate('function'='applyRule(csch)') ) \n \+ )) # end Button/GridCell\n ), # end GridRow\n\n Gr idRow(\n GridCell(Button['B_arcsinh'](\"arcsinh\", lc,\n \+ 'onclick'=Action(\n SetOption('TF_mathfunc'=\"arc sinh\"),\n CloseWindow('mathfuncWin'), \n \+ Evaluate('function'='applyRule(arcsinh)') ) \n )), # end Butt on/GridCell\n GridCell(Button['B_arccosh'](\"arccosh\", lc,\n 'onclick'=Action(\n SetOption('TF_mathfunc'= \"arccosh\"),\n CloseWindow('mathfuncWin'), \n \+ Evaluate('function'='applyRule(arccosh)') ) \n )), # end Button/GridCell\n GridCell(Button['B_arctanh'](\"arctanh\", \+ lc,\n 'onclick'=Action(\n SetOption('TF_mathf unc'=\"arctanh\"),\n CloseWindow('mathfuncWin'), \n \+ Evaluate('function'='applyRule(arctanh)') ) \n )), \+ # end Button/GridCell\n GridCell(Button['B_arccoth'](\"arccot h\", lc,\n 'onclick'=Action(\n SetOption('TF_ mathfunc'=\"arccoth\"),\n CloseWindow('mathfuncWin'), \n Evaluate('function'='applyRule(arccoth)') ) \n \+ )), # end Button/GridCell\n GridCell(Button['B_arcsech'](\"a rcsech\", lc,\n 'onclick'=Action(\n SetOption ('TF_mathfunc'=\"arcsech\"),\n CloseWindow('mathfuncWin' ), \n Evaluate('function'='applyRule(arcsech)') ) \n \+ )), # end Button/GridCell\n GridCell(Button['B_arccsch' ](\"arccsch\", lc,\n 'onclick'=Action(\n SetO ption('TF_mathfunc'=\"arccsch\"),\n CloseWindow('mathfun cWin'), \n Evaluate('function'='applyRule(arccsch)') ) \+ \n )) # end Button/GridCell\n ) # end GridRow\n\n \+ ), # end GridLayout\n\n BoxRow('border'='true', 'inset'=1, 'spac ing'=5, bc, \n 'caption'=\"Other Maple Mathematical Functions\" , \n Label('caption'=\"Enter a Maple Mathematical Function: \", bc),\n TextField['TF_other'](15, lc),\n Button['B_other '](\"Apply\",'onclick'='A_other', lc)\n ), # end BoxRow\n\n \+ BoxRow( Button['B_close2'](\"Close\",CloseWindow('mathfuncWin'), lc), \+ bc )\n\n ) # end BoxColumn\n ), # end Window\n \n################# ###########################################\n\n Window['argRuleWin']( 'defaultbutton'='closeArgRuleWin',\n 'title'=\"Using Rules with Arg uments\",\n 'resizable'='false',\n BoxColumn('inset'=6, 'spacing '=6, bc, \n BoxCell(\n TextBox['TB_argRule']('height'= 15, 'width'=40, lc, \n 'editable'='false', 'font'='F2', \n 'value'=\"Click the button below to see the description\" \n ) # end TextBox\n ), # end BoxCell\n BoxRow('ins et'=0, 'spacing'=12, bc, \n Button(\"Parts and Solve\", lc, \+ \n 'onclick'=SetOption('TB_argRule'=partsStr)),\n Bu tton(\"Rewrite\", lc, \n 'onclick'=SetOption('TB_argRule'= rewriteStr)),\n Button(\"Change and Revert\", lc, \n \+ 'onclick'=SetOption('TB_argRule'=changeStr)),\n Button['closeA rgRuleWin'](\"Close\", CloseWindow('argRuleWin'), lc)\n ) # end B oxRow\n ) # end BoxColumn \n ), # end Window\n\n################## ##########################################\n\n Window['ruleWin'](\n \+ 'title'=\"Integration Rule\", 'resizable'='false',\n BoxColumn('i nset'=0, 'spacing'=5, 'inset'=10, bc, \n BoxRow('inset'=0, 'spac ing'=0, bc, \n MathMLViewer['ML_rule']('width'=380, 'height'=8 0, lc) \n ), # end BoxRow\n BoxRow('inset'=0, 'spacing'=0, b c, \n Button(\"Close\", 'onclick'=A_ruleWin, lc)\n ) # end BoxRow\n ) # end BoxColumn\n ), # end ruleWin\n\n################ ############################################\n\n Window['helpWin']( ' resizable'='false',\n 'title'=\"Using the Step-by-Step Integration \+ Problem Solver Maplet\",\n BoxColumn('border'='true', 'inset'=0, 's pacing'=8, bc,\n BoxCell(\n TextBox('height'=24, 'width'=4 0, lc,\n 'editable'='false', 'font'='F1', 'foreground'=\"#333 399\",\n 'value'=helpStr\n ) # end TextBox\n ), # end BoxCell\n BoxRow('inset'=0, 'spacing'=0, bc,\n Button (\"Close\", lc, \n CloseWindow('helpWin'))\n ) # end Bo xRow\n ) # end BoxColumn\n ), # end helpWin\n\n################### #########################################\n\n MenuBar['intMB'](\n\n \+ Menu(\"File\",\n MenuItem(\"Start to Solve\", \n 'onclic k'=Evaluate('function'='startRule()')),\n MenuItem(\"Final Answer \", \n 'onclick'=Evaluate('function'='getFinalAnswer()')),\n \+ MenuItem(\"Show All Steps\", \n 'onclick'=Evaluate('function '='showAllSteps(RMI_all2, RMI_all3)')),\n MenuSeparator(),\n \+ MenuItem(\"Obtain a Hint\", \n 'onclick'=Evaluate('function'=' getHint()')),\n MenuItem(\"Apply the Hint\", \n 'onclick'= Evaluate('function'='applyHint()')),\n MenuSeparator(),\n Me nuItem['undomenu'](\"Undo\", 'enabled'=false, \n 'onclick'=Eval uate('function'='undoLastStep()')), \n MenuSeparator(),\n Me nuItem(\"Clear\", \n 'onclick'=Evaluate('function'='clearSteps( )')),\n MenuSeparator(),\n MenuItem(\"Close\", Shutdown())\n ), # end Menu/File\n \n Menu(\"Rule Definition\",\n Menu Item(\"Constant Rule\", 'onclick'='A_i_constant'),\n MenuItem(\"C onstant Multiple\", 'onclick'='A_i_constantmultiple'),\n MenuSepa rator(),\n MenuItem(\"Sum Rule\", 'onclick'='A_i_sum'),\n Me nuItem(\"Difference Rule\", 'onclick'='A_i_difference'),\n MenuSe parator(),\n MenuItem(\"Identity Rule\", 'onclick'='A_i_identity' ),\n MenuItem(\"Power Rule\", 'onclick'='A_i_power'),\n Menu Separator(),\n MenuItem(\"Flip Rule\", 'onclick'='A_i_flip'),\n \+ MenuItem(\"Join Rule\", 'onclick'='A_i_join'),\n MenuItem(\"S plit Rule\", 'onclick'='A_i_split'),\n MenuSeparator(),\n Me nuItem(\"Integrate by Parts\", 'onclick'='A_i_parts'),\n MenuItem (\"Solve Integral\", 'onclick'='A_i_parts'),\n MenuSeparator(),\n MenuItem(\"Rewrite Expression\", 'onclick'='A_i_rewrite'),\n \+ MenuSeparator(),\n MenuItem(\"Change (Int Variable)\", 'onclick '='A_i_change'),\n MenuItem(\"Revert (Int Variable)\", 'onclick'= 'A_i_change'),\n MenuSeparator(),\n MenuItem(\"Natural Expon ential\", 'onclick'='A_i_exp'),\n MenuItem(\"Natural Logorithm\", 'onclick'='A_i_ln'),\n MenuSeparator(),\n Menu(\"Trigonometr ic Functions\",\n MenuItem(\"sin\",'onclick'='A_i_sin'),\n \+ MenuItem(\"cos\",'onclick'='A_i_cos'),\n MenuItem(\"tan\",'o nclick'='A_i_tan'),\n MenuItem(\"cot\",'onclick'='A_i_cot'),\n \+ MenuItem(\"sec\",'onclick'='A_i_sec'),\n MenuItem(\"csc \",'onclick'='A_i_csc')\n ), # end Menu/Trig\n Menu(\"Invers e Trigonometric Functions\",\n MenuItem(\"arcsin\",'onclick'='A _i_arcsin'),\n MenuItem(\"arccos\",'onclick'='A_i_arccos'),\n \+ MenuItem(\"arctan\",'onclick'='A_i_arctan'),\n MenuItem( \"arccot\",'onclick'='A_i_arccot'),\n MenuItem(\"arcsec\",'oncl ick'='A_i_arcsec'),\n MenuItem(\"arccsc\",'onclick'='A_i_arccsc ')\n ), # end Menu/Inverse Trig\n Menu(\"Hyperbolic Function s\",\n MenuItem(\"sinh\",'onclick'='A_i_sinh'),\n MenuIt em(\"cosh\",'onclick'='A_i_cosh'),\n MenuItem(\"tanh\",'onclick '='A_i_tanh'),\n MenuItem(\"coth\",'onclick'='A_i_coth'),\n \+ MenuItem(\"sech\",'onclick'='A_i_sech'),\n MenuItem(\"csch \",'onclick'='A_i_csch')\n ), # end Menu/Hyperbolic \n Menu( \"Inverse Hyperbolic Functions\",\n MenuItem(\"arcsinh\",'oncli ck'='A_i_arcsinh'),\n MenuItem(\"arccosh\",'onclick'='A_i_arcco sh'),\n MenuItem(\"arctanh\",'onclick'='A_i_arctanh'),\n \+ MenuItem(\"arccoth\",'onclick'='A_i_arccoth'),\n MenuItem(\"ar csech\",'onclick'='A_i_arcsech'),\n MenuItem(\"arccsch\",'oncli ck'='A_i_arccsch')\n ) # end Menu/Inverse hyperbolic\n ), # en d Menu/About the Rule\n \n Menu(\"Apply the Rule\",\n MenuItem (\"Constant Rule\", \n 'onclick'=Evaluate('function'='applyRule (constant)')),\n MenuItem(\"Constant Multiple\", \n 'oncli ck'=Evaluate('function'='applyRule(constantmultiple)')),\n MenuSe parator(),\n MenuItem(\"Sum Rule\", \n 'onclick'=Evaluate( 'function'='applyRule(sum)')),\n MenuItem(\"Difference Rule\", \n 'onclick'=Evaluate('function'='applyRule(difference)')),\n \+ MenuSeparator(),\n MenuItem(\"Power Rule\", \n 'onclick' =Evaluate('function'='applyRule(power)')),\n MenuItem(\"Identity \+ Rule\", \n 'onclick'=Evaluate('function'='applyRule(identity)') ),\n MenuSeparator(),\n MenuItem(\"Solve\", \n 'oncli ck'=Evaluate('function'='applyRule(solve)')),\n MenuItem(\"Revert \", \n 'onclick'=Evaluate('function'='applyRule(revert)')),\n \+ MenuSeparator(),\n MenuItem(\"Natural Exponential\",\n \+ 'onclick'=Evaluate('function'='applyRule(exp)')),\n MenuItem(\"N atural Logorithm\", \n 'onclick'=Evaluate('function'='applyRule (ln)')),\n MenuSeparator(),\n Menu(\"Trigonometric Functions \",\n MenuItem(\"sin\",\n 'onclick'=Evaluate('function '='applyRule(sin)')),\n MenuItem(\"cos\",\n 'onclick'= Evaluate('function'='applyRule(cos)')),\n MenuItem(\"tan\",\n \+ 'onclick'=Evaluate('function'='applyRule(tan)')),\n Men uItem(\"cot\",\n 'onclick'=Evaluate('function'='applyRule(cot )')),\n MenuItem(\"sec\",\n 'onclick'=Evaluate('functi on'='applyRule(sec)')),\n MenuItem(\"csc\",\n 'onclick '=Evaluate('function'='applyRule(csc)'))\n ), # end Menu/Trig\n \+ Menu(\"Inverse Trigonometric Functions\",\n MenuItem(\"arcs in\",\n 'onclick'=Evaluate('function'='applyRule(arcsin)')), \n MenuItem(\"arccos\",\n 'onclick'=Evaluate('function '='applyRule(arccos)')),\n MenuItem(\"arctan\",\n 'onc lick'=Evaluate('function'='applyRule(arctan)')),\n MenuItem(\"a rccot\",\n 'onclick'=Evaluate('function'='applyRule(arccot)') ),\n MenuItem(\"arcsec\",\n 'onclick'=Evaluate('functi on'='applyRule(arcsec)')),\n MenuItem(\"arccsc\",\n 'o nclick'=Evaluate('function'='applyRule(arccsc)'))\n ), # end Menu /Inverse Trig\n Menu(\"Hyperbolic Functions\",\n MenuItem( \"sinh\",\n 'onclick'=Evaluate('function'='applyRule(sinh)')) ,\n MenuItem(\"cosh\",\n 'onclick'=Evaluate('function' ='applyRule(cosh)')),\n MenuItem(\"tanh\",\n 'onclick' =Evaluate('function'='applyRule(tanh)')),\n MenuItem(\"coth\", \n 'onclick'=Evaluate('function'='applyRule(coth)')),\n \+ MenuItem(\"sech\",\n 'onclick'=Evaluate('function'='applyRu le(sech)')),\n MenuItem(\"csch\",\n 'onclick'=Evaluate ('function'='applyRule(csch)'))\n ), # end Menu/Hyperbolic \n \+ Menu(\"Inverse Hyperbolic Functions\",\n MenuItem(\"arcsinh\" ,\n 'onclick'=Evaluate('function'='applyRule(arcsinh)')),\n \+ MenuItem(\"arccosh\",\n 'onclick'=Evaluate('function'=' applyRule(arccosh)')),\n MenuItem(\"arctanh\",\n 'oncl ick'=Evaluate('function'='applyRule(arctanh)')),\n MenuItem(\"a rccoth\",\n 'onclick'=Evaluate('function'='applyRule(arccoth) ')),\n MenuItem(\"arcsech\",\n 'onclick'=Evaluate('fun ction'='applyRule(arcsech)')),\n MenuItem(\"arccsch\",\n \+ 'onclick'=Evaluate('function'='applyRule(arccsch)'))\n ) # end Menu/Inverse hyperbolic\n ), # end Menu/Apply Rules\n\n Menu(\" Understood Rules\",\n CheckBoxMenuItem['CMI_constant'](\"Constant Rule\", \n 'onclick'=Evaluate('function'='changeUnderstoodRule s(constant,CMI_constant)') ),\n CheckBoxMenuItem['CMI_constantmul tiple'](\"Constant Multiple\",\n 'onclick'=Evaluate('function'= \n 'changeUnderstoodRules(constantmultiple,CMI_constan tmultiple)') ),\n MenuSeparator(),\n CheckBoxMenuItem['CMI_s um'](\"Sum Rule\", \n 'onclick'=Evaluate('function'='changeUnde rstoodRules(sum,CMI_sum)') ),\n CheckBoxMenuItem['CMI_difference' ](\"Difference Rule\", \n 'onclick'=Evaluate('function'='change UnderstoodRules(difference,CMI_sum)') ),\n MenuSeparator(), \n \+ CheckBoxMenuItem['CMI_identity'](\"Identity Rule\", \n 'onc lick'=Evaluate('function'='changeUnderstoodRules(identity,CMI_identity )') ),\n CheckBoxMenuItem['CMI_power'](\"Power Rule\", \n \+ 'onclick'=Evaluate('function'='changeUnderstoodRules(power,CMI_power) ') ),\n MenuSeparator(),\n CheckBoxMenuItem['CMI_solve'](\"S olve Rule\", \n 'onclick'=Evaluate('function'='changeUnderstood Rules(solve,CMI_solve)') ),\n CheckBoxMenuItem['CMI_revert'](\"Re vert Rule\", \n 'onclick'=Evaluate('function'='changeUnderstood Rules(revert,CMI_revert)') ),\n MenuSeparator(), \n CheckBox MenuItem['CMI_exp'](\"Natural Exponential\", \n 'onclick'=Eval uate('function'='changeUnderstoodRules(exp,CMI_exp)') ),\n CheckB oxMenuItem['CMI_ln'](\"Natural Logorithm\", \n 'onclick'=Evalua te('function'='changeUnderstoodRules(ln,CMI_ln)') ),\n MenuSepara tor(),\n Menu(\"Trigonometric Functions\",\n CheckBoxMenuI tem['CMI_sin'](\"sin\", \n 'onclick'=Evaluate('function'='cha ngeUnderstoodRules(sin,CMI_sin)') ),\n CheckBoxMenuItem['CMI_co s'](\"cos\", \n 'onclick'=Evaluate('function'='changeUndersto odRules(cos,CMI_cos)')),\n CheckBoxMenuItem['CMI_tan'](\"tan\", \n 'onclick'=Evaluate('function'='changeUnderstoodRules(tan, CMI_tan)') ),\n CheckBoxMenuItem['CMI_cot'](\"cot\", \n \+ 'onclick'=Evaluate('function'='changeUnderstoodRules(cot,CMI_cot)') \+ ),\n CheckBoxMenuItem['CMI_sec'](\"sec\", \n 'onclick' =Evaluate('function'='changeUnderstoodRules(sec,CMI_sec)') ),\n \+ CheckBoxMenuItem['CMI_csc'](\"csc\", \n 'onclick'=Evaluate(' function'='changeUnderstoodRules(csc,CMI_csc)') )\n ), # end Menu /Trig\n Menu(\"Inverse Trigonometric Functions\",\n CheckB oxMenuItem['CMI_arcsin'](\"arcsin\", \n 'onclick'=Evaluate('f unction'='changeUnderstoodRules(arcsin,CMI_arcsin)') ),\n Check BoxMenuItem['CMI_arccos'](\"arccos\", \n 'onclick'=Evaluate(' function'='changeUnderstoodRules(arccos,CMI_arccos)') ),\n Chec kBoxMenuItem['CMI_arctan'](\"arctan\", \n 'onclick'=Evaluate( 'function'='changeUnderstoodRules(arctan,CMI_arctan)') ),\n Che ckBoxMenuItem['CMI_arccot'](\"arccot\", \n 'onclick'=Evaluate ('function'='changeUnderstoodRules(arccot,CMI_arccot)') ),\n Ch eckBoxMenuItem['CMI_arcsec'](\"arcsec\", \n 'onclick'=Evaluat e('function'='changeUnderstoodRules(arcsec,CMI_arcsec)') ),\n C heckBoxMenuItem['CMI_arccsc'](\"arccsc\", \n 'onclick'=Evalua te('function'='changeUnderstoodRules(arccsc,CMI_arccsc)') )\n ), \+ # end Menu/Inverse Trig\n Menu(\"Hyperbolic Functions\",\n \+ CheckBoxMenuItem['CMI_sinh'](\"sinh\", \n 'onclick'=Evaluate ('function'='changeUnderstoodRules(sinh,CMI_sinh)') ),\n CheckB oxMenuItem['CMI_cosh'](\"cosh\", \n 'onclick'=Evaluate('funct ion'='changeUnderstoodRules(cosh,CMI_cosh)') ),\n CheckBoxMenuI tem['CMI_tanh'](\"tanh\", \n 'onclick'=Evaluate('function'='c hangeUnderstoodRules(tanh,CMI_tanh)') ),\n CheckBoxMenuItem['CM I_coth'](\"coth\", \n 'onclick'=Evaluate('function'='changeUn derstoodRules(coth,CMI_coth)') ),\n CheckBoxMenuItem['CMI_sech' ](\"sech\", \n 'onclick'=Evaluate('function'='changeUnderstoo dRules(sech,CMI_sech)') ),\n CheckBoxMenuItem['CMI_csch'](\"csc h\", \n 'onclick'=Evaluate('function'='changeUnderstoodRules( csch,CMI_csch)') )\n ), # end Menu/Hyperbolic \n Menu(\"Inv erse Hyperbolic Functions\",\n CheckBoxMenuItem['CMI_arcsinh']( \"arcsinh\", \n 'onclick'=Evaluate('function'='changeUndersto odRules(arcsinh,CMI_arcsinh)') ),\n CheckBoxMenuItem['CMI_arcco sh'](\"arccosh\", \n 'onclick'=Evaluate('function'='changeUnd erstoodRules(arccosh,CMI_arccosh)') ),\n CheckBoxMenuItem['CMI_ arctanh'](\"arctanh\", \n 'onclick'=Evaluate('function'='chan geUnderstoodRules(arctanh,CMI_arctanh)') ),\n CheckBoxMenuItem[ 'CMI_arccoth'](\"arccoth\", \n 'onclick'=Evaluate('function'= 'changeUnderstoodRules(arccoth,CMI_arccoth)') ),\n CheckBoxMenu Item['CMI_arcsech'](\"arcsech\", \n 'onclick'=Evaluate('funct ion'='changeUnderstoodRules(arccoth,CMI_arccoth)') ),\n CheckBo xMenuItem['CMI_arccsch'](\"arccsch\", \n 'onclick'=Evaluate(' function'='changeUnderstoodRules(arccoth,CMI_arccoth)') )\n ) # e nd Menu/Inverse hyperbolic\n ), # end Menu/Understood Rules\n \n \+ Menu(\"Help\", \n RadioButtonMenuItem['RMI_all1']('value'=false , 'group'='RMI_all',\n \"Hide the Rule in 'All Steps'\" ),\n \+ RadioButtonMenuItem['RMI_all2']('value'=true, 'group'='RMI_all', \n \"Show the Rule on the Right in 'All Steps'\" ), \n Radio ButtonMenuItem['RMI_all3']('value'=false, 'group'='RMI_all',\n \+ \"Show the Rule on the Left in 'All Steps'\" ),\n MenuSeparator() ,\n RadioButtonMenuItem['RMI_single1']('value'=false, 'group'='RM I_single',\n \"Hide the Rule in a single step\" ),\n Radio ButtonMenuItem['RMI_single2']('value'=true, 'group'='RMI_single', \n \+ \"Show the Rule on the Right in a single step\" ), \n Radio ButtonMenuItem['RMI_single3']('value'=false, 'group'='RMI_single',\n \+ \"Show the Rule on the Left in a single step\" ),\n MenuSep arator(),\n MenuItem(\"Using this Maplet\", 'onclick'=RunWindow(' helpWin'))\n ) # end Menu/Help\n\n ), # end MenuBar\n\n\n######### ###################################################\n\n ButtonGroup[' RMI_all'](), ButtonGroup['RMI_single'](), \n\n######################## ####################################\n\n Action['A_other'](\n SetO ption('target'='TF_mathfunc',Argument('TF_other')),\n CloseWindow(' mathfuncWin'), \n Evaluate('function'='applyOtherRule()') \n ), # end A_other\n\n Action['A_ruleWin'](\n SetOption('ML_rule'=\"\"), \n CloseWindow('ruleWin')\n ), # end A_ruleWin\n \n############ ################################################\n\n Action['A_i_cons tant'](\n Evaluate('function'='aboutRule(constant, c)'),\n RunWi ndow('ruleWin')\n ), # end A_i_constant\n \n Action['A_i_constantmul tiple'](\n Evaluate('function'='aboutRule(constantmultiple, c*f(x)) '),\n RunWindow('ruleWin')\n ), # end A_i_constantmultiple\n \n \+ Action['A_i_sum'](\n Evaluate('function'='aboutRule(sum,f(x)+g(x))' ),\n RunWindow('ruleWin') \n ), # end A_i_sum\n\n Action['A_i_di fference'](\n Evaluate('function'='aboutRule(difference,f(x)-g(x))' ),\n RunWindow('ruleWin') \n ), # end A_i_difference\n \n Actio n['A_i_identity'](\n Evaluate('function'='aboutRule(identity,x)'), \n RunWindow('ruleWin')\n ), # end A_i_identity\n \n Action['A_i _power'](\n Evaluate('function'='aboutRule(power,x^n)'),\n RunWi ndow('ruleWin')\n ), # end A_i_power\n\n Action['A_i_flip'](\n Ev aluate('ML_rule'='aboutDefRule(flip)'),\n RunWindow('ruleWin')\n ) , # end A_i_flip\n\n Action['A_i_join'](\n Evaluate('ML_rule'='abo utDefRule(join)'),\n RunWindow('ruleWin')\n ), # end A_i_join\n\n \+ Action['A_i_split'](\n Evaluate('ML_rule'='aboutDefRule(split)'), \n RunWindow('ruleWin')\n ), # end A_i_split\n\n Action['A_i_part s'](\n SetOption('TB_argRule'=partsStr),\n RunWindow('argRuleWin ')\n ), # end A_i_parts\n\n Action['A_i_rewrite'](\n SetOption('T B_argRule'=rewriteStr),\n RunWindow('argRuleWin')\n ), # end A_i_p arts\n\n Action['A_i_change'](\n SetOption('TB_argRule'=changeStr) ,\n RunWindow('argRuleWin')\n ), # end A_i_parts\n\n Action['A_i_ exp'](\n Evaluate('function'='aboutRule(exp,exp(x))'),\n RunWind ow('ruleWin')\n ), # end A_i_exp\n\n Action['A_i_ln'](\n Evaluate ('function'='aboutRule(ln,ln(x))'),\n RunWindow('ruleWin')\n ), # \+ end A_i_ln\n\n Action['A_i_sin'](\n Evaluate('function'='aboutRule (sin,sin(x))'),\n RunWindow('ruleWin')\n ), # end A_i_sin\n\n Act ion['A_i_cos'](\n Evaluate('function'='aboutRule(cos,cos(x))'),\n \+ RunWindow('ruleWin')\n ), # end A_cos\n\n Action['A_i_tan'](\n \+ Evaluate('function'='aboutRule(tan,tan(x))'),\n RunWindow('ruleWin' )\n ), # end A_i_tan\n\n Action['A_i_cot'](\n Evaluate('function' ='aboutRule(cot,cot(x))'),\n RunWindow('ruleWin')\n ), # end A_i_c ot\n\n Action['A_i_sec'](\n Evaluate('function'='aboutRule(sec,sec (x))'),\n RunWindow('ruleWin')\n ), # end A_i_sec\n\n Action['A_i _csc'](\n Evaluate('function'='aboutRule(csc,csc(x))'),\n RunWin dow('ruleWin')\n ), # end A_i_csc\n\n Action['A_i_arcsin'](\n Eva luate('function'='aboutRule(arcsin,arcsin(x))'),\n RunWindow('ruleW in')\n ), # end A_i_arcsin\n\n Action['A_i_arccos'](\n Evaluate(' function'='aboutRule(arccos,arccos(x))'),\n RunWindow('ruleWin')\n \+ ), # end A_i_cos\n\n Action['A_i_arctan'](\n Evaluate('function'= 'aboutRule(arctan,arctan(x))'),\n RunWindow('ruleWin')\n ), # end \+ A_i_arctan\n\n Action['A_i_arccot'](\n Evaluate('function'='aboutR ule(arccot,arccot(x))'),\n RunWindow('ruleWin')\n ), # end A_i_arc cot\n\n Action['A_i_arcsec'](\n Evaluate('function'='aboutRule(arc sec,arcsec(x))'),\n RunWindow('ruleWin')\n ), # end A_i_arcsec\n\n Action['A_i_arccsc'](\n Evaluate('function'='aboutRule(arccsc,arc csc(x))'),\n RunWindow('ruleWin')\n ), # end A_i_arccsc\n\n Actio n['A_i_sinh'](\n Evaluate('function'='aboutRule(sinh,sinh(x))'),\n \+ RunWindow('ruleWin')\n ), # end A_i_sinh\n\n Action['A_i_cosh']( \n Evaluate('function'='aboutRule(cosh,cosh(x))'),\n RunWindow(' ruleWin')\n ), # end A_i_cosh\n\n Action['A_i_tanh'](\n Evaluate( 'function'='aboutRule(tanh,tanh(x))'),\n RunWindow('ruleWin')\n ), # end A_i_tanh\n\n Action['A_i_coth'](\n Evaluate('function'='abo utRule(coth,coth(x))'),\n RunWindow('ruleWin')\n ), # end A_i_coth \n\n Action['A_i_sech'](\n Evaluate('function'='aboutRule(sech,sec h(x))'),\n RunWindow('ruleWin')\n ), # end A_i_sech\n\n Action['A _i_csch'](\n Evaluate('function'='aboutRule(csch,csch(x))'),\n R unWindow('ruleWin')\n ), # end A_i_csch\n\n Action['A_i_arcsinh'](\n Evaluate('function'='aboutRule(arcsinh,arcsinh(x))'),\n RunWind ow('ruleWin')\n ), # end A_i_arcsinh\n\n Action['A_i_arccosh'](\n \+ Evaluate('function'='aboutRule(arccosh,arccosh(x))'),\n RunWindow( 'ruleWin')\n ), # end A_i_cosh\n\n Action['A_i_arctanh'](\n Evalu ate('function'='aboutRule(arctanh,arctanh(x))'),\n RunWindow('ruleW in')\n ), # end A_i_arctanh\n\n Action['A_i_arccoth'](\n Evaluate ('function'='aboutRule(arccoth,arccoth(x))'),\n RunWindow('ruleWin' )\n ), # end A_i_arccoth\n\n Action['A_i_arcsech'](\n Evaluate('f unction'='aboutRule(arcsech,arcsech(x))'),\n RunWindow('ruleWin')\n ), # end A_i_arcsech\n\n Action['A_i_arccsch'](\n Evaluate('func tion'='aboutRule(arccsch,arccsch(x))'),\n RunWindow('ruleWin')\n ) , # end A_i_arccsch\n\n############################################### #############\n\n Action['A']()\n\n): # end maplet\n\n############## ##############################################\n\nUnderstand(Int,none) :\nMaplets[Display](maplet) :\n\nend use: # end use\nend proc: # end \+ runIntMaplet\n\n###################################################### ######\n\nend module: # end IntMaplet()\nIntMaplet:-runIntMaplet();" } }}{EXCHG {PARA 0 "> " 0 "" {MPLTEXT 1 0 0 "" }}}}{EXCHG }}{MARK "3 0" 0 }{VIEWOPTS 1 1 0 1 1 1803 1 1 1 1 }{PAGENUMBERS 0 1 2 33 1 1 }