# Step-by-Step Integration Problem Solver Maplet
# Copyright 2002 Waterloo Maple Inc.
#
# This maplet guides the user through an integration problem. The user can apply integration rules one at a time to a function f and view the resulting expression. The Messages box displays the status information.
#
# The user enters a function with its independent variable. Various integration rules can be applied.
#
# At any time, the user can request a hint for the next step, and then apply the hint.
# The user can also specify that a set of rules are understood, in which case those rules are automatically applied when possible.
#
# At any time, the user can display all solution steps in the solution or display the final answer.
#
# To run this maplet, click the Execute (!!!) button in the context bar.
#
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:
local steps, mlSteps, iniMlStr, getMathStr, getSavedStr,mathStr,savedStr, G_fun, G_var, G_, G_lower, G_upper, getInitParam,getRMIString2, getRMIString3, isRMISingle2, isRMISingle3, getMRuleStr, mRuleStr:
steps:=[]: mlSteps:=[]:
iniMlStr := "":
############################################################
############################################################
savedStr:="":
mathStr:="":
helpStr :=
"This maplet guides you through an integration problem. You can apply integration rules one at a time to a function f and view the resulting expression. The 'Messages' box displays the status information.
Enter a function with its independent variable. Click the 'Start' button. This clears the problem history and starts a new one.
To apply integration rules, click the corresponding buttons or select rules from the 'Apply the Rule' menu.
When you apply a rule, the display of the problem is updated with the result of the applied rule.
If you understand a rule, you can select the rule from the 'Understood Rules' menu. The maplet then applies that rule when possible.
To show all steps in the solution, click the 'All Steps' button.
To request a hint, click the 'Obtain a Hint' button or select 'Receive a Hint' from the 'File' menu. To apply the hint, click the 'Apply the Hint' button or select 'Apply the Hint' from the 'File' menu.
To clear the problem history, click the 'Clear' button.
To display the final answer, click the 'Final Ans' button or select 'Get the Final Answer' from the 'File' menu.": # 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. You can use the '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 text box 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 text box 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 creates a new name.
Once the integration has been completed, you can use the revert rule to revert 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:
############################################################
getInitParam:= proc(P_fun, P_var, P_upper, P_lower)
G_fun:=P_fun:
G_var:=P_var:
G_upper:=P_upper:
G_lower:=P_lower:
end proc:
getMathStr:= proc()
mathStr;
end proc:
getMRuleStr:= proc()
mRuleStr;
end proc:
getSavedStr:=proc()
savedStr;
end proc:
getRMIString2:=proc(value)
isRMISingle2:=value:
end proc:
getRMIString3:=proc(value)
isRMISingle3:=value:
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()
local funStr, varStr, lowerStr, upperStr, intStr,
infoStr, mlStr, intExpr, intEqn, hints,
i, uRules, uAppliedRules, rulesStr:
use Student:-Calculus1, Maplets:-Tools , StringTools in
clearSteps():
funStr := Trim(G_fun):
if funStr = "" then
infoStr := "Enter a valid integration expression":
savedStr:=infoStr:
error "No integration expression in TextField TF_fun":
end if:
varStr := Trim(G_var):
if varStr = "" then
infoStr := "Enter the variable expression":
savedStr:=infoStr:
error "No integration var in TextField TF_var":
end if:
lowerStr := Trim(G_lower):
upperStr := Trim(G_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 ...":
savedStr:=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
savedStr:=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
mathStr:=mlStr:
mlSteps := [op(mlSteps), mlStr]:
infoStr := "Apply any rule below":
savedStr:= infoStr:
else
intEqn := Rule[](GetProblem(`internal`)):
steps := [op(steps),intEqn]:
mathStr:=mlStr:
mlSteps := [op(mlSteps), mlStr]:
infoStr := "no hint is given":
savedStr:= 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 is not applied
applyRule := proc(aRule)
local mlStr, infoStr, intEqn, oldEqn:
use Student:-Calculus1, Maplets:-Tools in
if nops(steps)=0 then
startRule():
end if:
mlStr:=mathStr:
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
infoStr := convert(aRule,string):
infoStr := cat(infoStr, " rule is being applied"):
savedStr:=infoStr:
steps := [op(steps),intEqn]:
if type(aRule,list)=true then
if isRMISingle2 = true then
mlStr := addMathML2(mlStr,rhs(intEqn),aRule):
elif isRMISingle3=true then
mlStr := addMathML3(mlStr,rhs(intEqn),aRule):
else
mlStr := addMathML(mlStr,rhs(intEqn)):
end if:
else
if isRMISingle2=true then
mlStr := addMathML2(mlStr,rhs(intEqn),[aRule]):
elif isRMISingle3=true then
mlStr := addMathML3(mlStr,rhs(intEqn),[aRule]):
else
mlStr := addMathML(mlStr,rhs(intEqn)):
end if:
end if:
mathStr:=mlStr:
mlSteps := [op(mlSteps), mlStr]:
infoStr := convert(aRule,string):
infoStr := cat(infoStr, " rule has been applied"):
savedStr:=infoStr:
else
infoStr := convert(aRule,string):
infoStr := cat(infoStr, " rule is not applicable"):
savedStr:=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_f, P_g)
local fx, gx:
use Student:-Calculus1, Maplets:-Tools, Maplets:-Elements, StringTools in
fx:=Trim(P_f):
gx:=Trim(P_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 each substitution
# is replaced by the corresponding right-hand side
applyRuleRewrite := proc(P_args)
local str:
use Student:-Calculus1, Maplets:-Tools, Maplets:-Elements,StringTools in
str := Trim(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:-Tools, Maplets:-Elements, StringTools in
str := Trim(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:-Tools, Maplets:-Elements, StringTools in
param := 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, StringTools in
aRule := Trim(P_other):
if aRule = "" then
Maplets:-Display(Maplet(
MessageDialog("No rule has been entered"))):
else
applyRule(parse(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:
use Maplets:-Tools,StringTools in
aRule := Trim(P_mathFunc):
if aRule = "" then
Maplets:-Display(Maplet(
MessageDialog("No rule has been entered"))):
else
applyRule(parse(aRule)):
end if:
end use:
end proc: # end applyOtherRule
############################################################
############################################################
# 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, Maplets:-Tools 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":
savedStr:=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."):
savedStr:=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":
savedStr:=infoStr:
else
mlStr:=mathStr:
while nops(hint)>0 do
infoStr := cat(convert(hint,string)," is being applied."):
savedStr:=infoStr:
intEqn := Rule[hint](intEqn):
hint := [Hint(intEqn)][1]:
end do:
steps := [op(steps),intEqn]:
infoStr := "Exporting final answer ...":
mlStr := addMathML(mlStr,rhs(intEqn)):
mathStr:=mlStr:
mlSteps := [op(mlSteps), mlStr]:
infoStr := "The final answer is displayed":
savedStr:=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, 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":
savedStr:=infoStr:
else
mlStr:=mathStr:
while nops(hint)>0 do
infoStr := cat(convert(hint,string)," is being applied."):
savedStr:=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 ...":
savedStr:=infoStr:
mathStr:=mlStr:
infoStr := "A complete solution is displayed":
savedStr:=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)):
if fun <> x^n then
mRuleStr:=MathML:-ExportPresentation(eqn):
else
mRuleStr:=
"":
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:
mRuleStr:= MathML:-ExportPresentation(eqn):
Understand(Int, op(understoodRules)):
end use:
end proc: # end aboutRule
############################################################
############################################################
# 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
mathStr:="":
savedStr:="":
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']('width'=5, lc, value=" "),
Label('caption'=" to ", 'font'='F1',bc),
TextField['TF_upper']('width'=5, lc, value=" ")
), # 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',
'tooltip'="Initialize to find a integration", lc),
Button("Final Ans",
'onclick'='A_getFinalAnswer',
'tooltip'="Get the final answer", 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'="Messages",
'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',
'tooltip'="Receive a Hint", lc)),
BoxCell(Button['B_applyHint']("Apply the Hint",
'onclick'='A_applyHint',
'tooltip'="Apply the Hint", 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'="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, value=" "),
Label(" g(x)=", dc),
TextField['TF_parts_g']('width'=3, lc, value=" ")
), # 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, value=" ")
), # 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, value=" ")
) # 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'='A_exp'), # end Button exp
Button['B_ln']("Natural Logarithmic", lc,
'onclick'='A_ln') # 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'='A_sin'
)), # end Button/GridCell
GridCell(Button['B_cos'](" cos ", lc,
'onclick'='A_cos'
)), # end Button/GridCell
GridCell(Button['B_tan'](" tan ", lc,
'onclick'='A_tan'
)), # end Button/GridCell
GridCell(Button['B_cot'](" cot ", lc,
'onclick'='A_cot'
)), # end Button/GridCell
GridCell(Button['B_sec'](" sec ", lc,
'onclick'='A_sec'
)), # end Button/GridCell
GridCell(Button['B_csc'](" csc ", lc,
'onclick'='A_csc'
)) # end Button/GridCell
), # end GridRow
GridRow(
GridCell(Button['B_arcsin'](" arcsin ", lc,
'onclick'='A_arcsin'
)), # end Button/GridCell
GridCell(Button['B_arccos'](" arccos ", lc,
'onclick'='A_arccos'
)), # end Button/GridCell
GridCell(Button['B_arctan'](" arctan ", lc,
'onclick'='A_arccot'
)), # end Button/GridCell
GridCell(Button['B_arccot'](" arccot ", lc,
'onclick'='A_arccot'
)), # end Button/GridCell
GridCell(Button['B_arcsec'](" arcsec ", lc,
'onclick'='A_arcsec'
)), # end Button/GridCell
GridCell(Button['B_arccsc'](" arccsc ", lc,
'onclick'='A_arccsc'
)) # end Button/GridCell
), # end GridRow
GridRow(
GridCell(Button['B_sinh'](" sinh ", lc,
'onclick'='A_sinh'
)), # end Button/GridCell
GridCell(Button['B_cosh'](" cosh ", lc,
'onclick'='A_cosh'
)), # end Button/GridCell
GridCell(Button['B_tanh'](" tanh ", lc,
'onclick'='A_tanh'
)), # end Button/GridCell
GridCell(Button['B_coth'](" coth ", lc,
'onclick'='A_coth'
)), # end Button/GridCell
GridCell(Button['B_sech'](" sech ", lc,
'onclick'='A_sech'
)), # end Button/GridCell
GridCell(Button['B_csch'](" csch ", lc,
'onclick'='A_csch'
)) # end Button/GridCell
), # end GridRow
GridRow(
GridCell(Button['B_arcsinh']("arcsinh", lc,
'onclick'='A_arcsinh'
)), # end Button/GridCell
GridCell(Button['B_arccosh']("arccosh", lc,
'onclick'='A_arccosh'
)), # end Button/GridCell
GridCell(Button['B_arctanh']("arctanh", lc,
'onclick'='A_arctanh'
)), # end Button/GridCell
GridCell(Button['B_arccoth']("arccoth", lc,
'onclick'='A_arccoth'
)), # end Button/GridCell
GridCell(Button['B_arcsech']("arcsech", lc,
'onclick'='A_arcsech'
)), # end Button/GridCell
GridCell(Button['B_arccsch']("arccsch", lc,
'onclick'='A_arccsch'
)) # 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, value=" "),
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'="Using 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,
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'="Using the 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'='A_applyHint'),
MenuSeparator(),
MenuItem("Clear",
'onclick'='A_clear'),
MenuSeparator(),
MenuItem("Close", Shutdown())
), # end Menu/File
Menu("Rule Definition",
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'=Evaluate('function'='applyRule(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("Using this Maplet", 'onclick'=RunWindow('helpWin'))
) # end Menu/Help
), # end MenuBar
############################################################
ButtonGroup['RMI_all'](), ButtonGroup['RMI_single'](),
############################################################
Action['A_other'](
SetOption('target'='TF_mathfunc',Argument('TF_other')),
CloseWindow('mathfuncWin'),
Evaluate
( 'waitforresult'='false','function'='applyOtherRule',
Argument('TF_other', quotedtext='true')
),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
), # end A_other
Action['A_ruleWin'](
SetOption('ML_rule'=""),
CloseWindow('ruleWin')
), # end A_ruleWin
############################################################
Action[A_join]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(join)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_flip]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(flip)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_applyRuleParts]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate
( 'waitforresult'='false', 'function'='applyRuleParts',
Argument(TF_parts_f, quotedtext='true'),
Argument(TF_parts_g, quotedtext='true')
),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_applyRuleSplit]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate
( 'waitforresult'='false', 'function'='applyRuleSplit',
Argument(TF_c, quotedtext='true')
),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_applyRuleReWrite]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate
( 'waitforresult'='false', 'function'='applyRuleReWrite',
Argument(TB_args, quotedtext='true')
),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_applyRuleChange]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate
( 'waitforresult'='false', 'function'='applyRuleChange',
Argument(TB_args, quotedtext='true')
),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_constant]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(constant)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_constantmultiple]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(constantmultiple)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_sum]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(sum)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_difference]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(difference)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_power]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(power)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_identity]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(identity)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_solve]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(solve)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_revert]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(revert)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_exp]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="exp"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(exp)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_ln]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="ln"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(ln)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_sin]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="sin"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(sin)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_cos]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="cos"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(cos)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_tan]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="tan"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(tan)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_cot]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="cot"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(cot)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_sec]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="sec"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(sec)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_csc]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="csc"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(csc)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_arcsin]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="arcsin"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(arcsin)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_arccos]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="arccos"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(arccos)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_arctan]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="arctan"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(arctan)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_arccot]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="arccot"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(arccot)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_arcsec]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="arcsec"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(arcsec)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_arccsc]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="arccsc"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(arccsc)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_sinh]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="sinh"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(sinh)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_cosh]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="cosh"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(cosh)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_tanh]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="tanh"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(tanh)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_coth]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="coth"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(coth)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_sech]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="sech"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(sech)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_csch]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="csch"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(csch)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_arcsinh]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="arcsinh"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(arcsinh)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_arccosh]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="arccosh"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(arccosh)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_arctanh]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="arctanh"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(arctanh)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_arccoth]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="arccoth"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(arccoth)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_arcsech]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="arcsech"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(arcsech)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action[A_arccsch]
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
SetOption('TF_mathfunc'="arccsch"),
CloseWindow('mathfuncWin'),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyRule(arccsch)'),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
Action['A_applyMathFunc']
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate('waitforresult'='false','function'='applyMathFuncRule',
Argument('TF_mathfunc', quotedtext='true')
),
Evaluate('waitforresult'='false','function'='getMathStr', 'target'='ML'),
Evaluate('waitforresult'='false','function'='getSavedStr', 'target'='info')
),
############################################################
Action['A_i_constant']
( Evaluate
( 'function'='aboutRule(constant, c)'
),
SetOption('ruleWin'('title') = 'constant'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_constant
Action['A_i_constantmultiple'](
Evaluate('function'='aboutRule(constantmultiple, c*f(x))'),
SetOption('ruleWin'('title') = 'constantmultiple'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_constantmultiple
Action['A_i_sum'](
Evaluate('function'='aboutRule(sum,f(x)+g(x))'),
SetOption('ruleWin'('title') = 'sum'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_sum
Action['A_i_difference'](
Evaluate('function'='aboutRule(difference,f(x)-g(x))'),
SetOption('ruleWin'('title') = 'difference'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_difference
Action['A_i_identity'](
Evaluate('function'='aboutRule(identity,x)'),
SetOption('ruleWin'('title') = 'identity'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_identity
Action['A_i_power'](
Evaluate('function'='aboutRule(power,x^n)'),
SetOption('ruleWin'('title') = 'power'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_power
Action['A_i_flip'](
Evaluate('function'='aboutDefRule(flip)'),
SetOption('ruleWin'('title') = 'flip'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_flip
Action['A_i_join'](
Evaluate('function'='aboutDefRule(join)'),
SetOption('ruleWin'('title') = 'join'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_join
Action['A_i_split'](
Evaluate('function'='aboutDefRule(split)'),
SetOption('ruleWin'('title') = 'split'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_split
Action['A_i_parts'](
SetOption('TB_argRule'=partsStr),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('argRuleWin')
), # end A_i_parts
Action['A_i_rewrite'](
SetOption('TB_argRule'=rewriteStr),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
), 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))'),
SetOption('ruleWin'('title') = 'exp'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_exp
Action['A_i_ln'](
Evaluate('function'='aboutRule(ln,ln(x))'),
SetOption('ruleWin'('title') = 'ln'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_ln
Action['A_i_sin'](
Evaluate('function'='aboutRule(sin,sin(x))'),
SetOption('ruleWin'('title') = 'sin'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_sin
Action['A_i_cos'](
Evaluate('function'='aboutRule(cos,cos(x))'),
SetOption('ruleWin'('title') = 'cos'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_cos
Action['A_i_tan'](
Evaluate('function'='aboutRule(tan,tan(x))'),
SetOption('ruleWin'('title') = 'tan'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_tan
Action['A_i_cot'](
Evaluate('function'='aboutRule(cot,cot(x))'),
SetOption('ruleWin'('title') = 'cot'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_cot
Action['A_i_sec'](
Evaluate('function'='aboutRule(sec,sec(x))'),
SetOption('ruleWin'('title') = 'sec'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_sec
Action['A_i_csc'](
Evaluate('function'='aboutRule(csc,csc(x))'),
SetOption('ruleWin'('title') = 'csc'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_csc
Action['A_i_arcsin'](
Evaluate('function'='aboutRule(arcsin,arcsin(x))'),
SetOption('ruleWin'('title') = 'arcsin'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_arcsin
Action['A_i_arccos'](
Evaluate('function'='aboutRule(arccos,arccos(x))'),
SetOption('ruleWin'('title') = 'arccos'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_cos
Action['A_i_arctan'](
Evaluate('function'='aboutRule(arctan,arctan(x))'),
SetOption('ruleWin'('title') = 'arctan'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_arctan
Action['A_i_arccot'](
Evaluate('function'='aboutRule(arccot,arccot(x))'),
SetOption('ruleWin'('title') = 'arccot'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_arccot
Action['A_i_arcsec'](
Evaluate('function'='aboutRule(arcsec,arcsec(x))'),
SetOption('ruleWin'('title') = 'arcsec'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_arcsec
Action['A_i_arccsc'](
Evaluate('function'='aboutRule(arccsc,arccsc(x))'),
SetOption('ruleWin'('title') = 'arccsc'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_arccsc
Action['A_i_sinh'](
Evaluate('function'='aboutRule(sinh,sinh(x))'),
SetOption('ruleWin'('title') = 'sinh'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_sinh
Action['A_i_cosh'](
Evaluate('function'='aboutRule(cosh,cosh(x))'),
SetOption('ruleWin'('title') = 'cosh'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_cosh
Action['A_i_tanh'](
Evaluate('function'='aboutRule(tanh,tanh(x))'),
SetOption('ruleWin'('title') = 'tanh'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_tanh
Action['A_i_coth'](
Evaluate('function'='aboutRule(coth,coth(x))'),
SetOption('ruleWin'('title') = 'coth'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_coth
Action['A_i_sech'](
Evaluate('function'='aboutRule(sech,sech(x))'),
SetOption('ruleWin'('title') = 'sech'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_sech
Action['A_i_csch'](
Evaluate('function'='aboutRule(csch,csch(x))'),
SetOption('ruleWin'('title') = 'csch'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_csch
Action['A_i_arcsinh'](
Evaluate('function'='aboutRule(arcsinh,arcsinh(x))'),
SetOption('ruleWin'('title') = 'arcsinh'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_arcsinh
Action['A_i_arccosh'](
Evaluate('function'='aboutRule(arccosh,arccosh(x))'),
SetOption('ruleWin'('title') = 'arccosh'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_cosh
Action['A_i_arctanh'](
Evaluate('function'='aboutRule(arctanh,arctanh(x))'),
SetOption('ruleWin'('title') = 'arctanh'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_arctanh
Action['A_i_arccoth'](
Evaluate('function'='aboutRule(arccoth,arccoth(x))'),
SetOption('ruleWin'('title') = 'arccoth'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_arccoth
Action['A_i_arcsech'](
Evaluate('function'='aboutRule(arcsech,arcsech(x))'),
SetOption('ruleWin'('title') = 'arcsech'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_arcsech
Action['A_i_arccsch'](
Evaluate('function'='aboutRule(arccsch,arccsch(x))'),
SetOption('ruleWin'('title') = 'arccsch'),
Evaluate
( 'function'='getMRuleStr', 'target'='ML_rule', 'waitforresult'='false'
),
RunWindow('ruleWin')
), # end A_i_arccsch
############################################################
Action['A'](),
Action['A_start']
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate
( 'waitforresult'='false','function'='startRule'
),
Evaluate
('waitforresult'='false','function'='getSavedStr', 'target'='info'
),
Evaluate
('waitforresult'='false','function'='getMathStr', 'target'='ML'
)
),
Action['A_getFinalAnswer']
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate
( 'waitforresult'='false','function'='getFinalAnswer'
),
Evaluate
('waitforresult'='false','function'='getSavedStr', 'target'='info'
),
Evaluate
('waitforresult'='false','function'='getMathStr', 'target'='ML'
)
),
Action['A_showAllSteps']
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate
( 'waitforresult'='false','function'='showAllSteps',
Argument('RMI_all2'),
Argument('RMI_all3')
),
Evaluate
('waitforresult'='false','function'='getSavedStr', 'target'='info'
),
Evaluate
('waitforresult'='false','function'='getMathStr', 'target'='ML'
)
),
Action['A_getHint']
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate
( 'waitforresult'='false', 'function'='getHint'
),
Evaluate
( 'waitforresult'='false','function'='getSavedStr', 'target'='info'
),
Evaluate
( 'waitforresult'='false','function'='getMathStr', 'target'='ML'
)
),
Action['A_applyHint']
( Evaluate
( 'waitforresult'='false', 'function'='getInitParam',
Argument('TF_fun',quotedtext='true'),
Argument('TF_var',quotedtext='true'),
Argument('TF_upper',quotedtext='true'),
Argument('TF_lower',quotedtext='true')
),
Evaluate('function'='getRMIString2', Argument('RMI_single2')),
Evaluate('function'='getRMIString3', Argument('RMI_single3')),
Evaluate
( 'waitforresult'='false', 'function'='applyHint'
),
Evaluate
( 'waitforresult'='false','function'='getSavedStr', 'target'='info'
),
Evaluate
( 'waitforresult'='false','function'='getMathStr', 'target'='ML'
)
),
Action['A_clear']
( Evaluate
( 'waitforresult'='false','function'='clearSteps'
),
Evaluate
('waitforresult'='false','function'='getSavedStr', 'target'='info'
),
Evaluate
('waitforresult'='false','function'='getMathStr', 'target'='ML'
)
)
): # end maplet
############################################################
Understand(Int,none) :
Maplets[Display](maplet) :
end use: # end use
end proc: # end runIntMaplet
############################################################
end module: # end IntMaplet()
IntMaplet:-runIntMaplet();