# Step-by-Step Differentiation Problem Solver Maplet
# Copyright 2002 Waterloo Maple Inc.
# This maplet guides the user through a differentiation problem. The user can apply differentiation rules one at a time to a function f and view the resulting expression. The Messages box displays status information.   
# 
# The user enters a function with its independent variable. The user can apply differentiation rules, for example, the sum rule (D(f+g) = D(f) + D(g)), the chain rule (D(f(g(x)) = D(f)(g(x))* D(g)(x)), and rules for special functions such as D(sin(x))=cos(x). When the user applies a rule, the Problem Status box is updated with the result of the applied rule.
# 
# At any time, the user can request a hint for the next rule to apply, and then apply the hint.  
# 
# The user can also specify that a set of rules is understood, in which case those rules are automatically applied (when possible).
# 
# The user can rewrite a problem in a more convenient form. The rewrite rule is useful for an expression like 
x^x;# , which can be rewritten as 
exp(x*ln(x));# .  
# 
# 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;
DiffMaplet := module() 

############################################################


############################################################

export iniMathML, addMathML, runDiffMaplet, 
       startRule, applyRule, diffAllSteps, 
       clearSteps, getHint, applyHint, aboutRule,
       changeUnderstoodRules, removeRule,
       getFinalResult, applyOtherRule, applyRewriteRule:
local rewriteStr, helpStr, steps,mathStr, savedStr, G_fun, G_var,getInitParam, getSavedStr, getMathStr, aboutRuleStr, getAboutRuleStr, mRuleStr, getMRuleStr:
steps := []:

############################################################

############################################################

rewriteStr :=
"This differentiation rule requires parameters. This rule is used to change the form of the expression being differentiated. It has the general form: 
 [rewrite, f1(x) = g1(x), f2(x) = g2(x), ...]
The effect of applying the rewrite rule is to perform each of the substitutions listed as the parameters to the rule, where occurrences of the left-hand side of each substitution are replaced by the corresponding right-hand side. 
The main application of this rule is to rewrite an expression of the form f(x)^g(x), where the exponent (at least) depends on the differentiation variable, as an exponential. The rule would thus be given as: 
 [rewrite, f(x)^g(x) = exp(g(x) * ln(f(x))) ]":

############################################################

############################################################

helpStr := 
"This maplet guides you through a differentiation problem.  You can apply differentiation rules one at a time to a function f and view the resulting expression.  At any step of the problem, you can request a hint for the next rule to apply.  You can also specify that you understand a set of rules, in which case those rules are automatically applied (when possible).

Enter a function with its independent variable. Click the 'Start' button. This clears the problem history and starts a new one.

To apply differentiation rules, click the corresponding buttons or select rules from the 'Apply the Rule' menu. Rules include the sum rule (D(f+g) = D(f) + D(g)), the chain rule (D(f(g(x))) = D(f)(g(x))* D(g)(x)), and rules for special functions like D(sin(x))=cos(x).
You can also rewrite a problem in a more convenient form. The rewrite rule is useful for an expression such as x^x, which can be rewritten as exp( x*ln(x) ).  

When you apply a rule, the 'Problem Status' box is updated with the result of the applied rule.

To request a hint, click the 'Obtain a Hint' button or select 'Obtain 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.

If you understand a rule, you can select the rule from the 'Understood Rules' menu. The maplet then applies that rule automatically when possible.

To clear the problem history, click the 'Clear' button.

To show all steps in the solution, click the 'All Steps' button. To display the final answer, click the 'Final Ans' button or select 'Final Answer' from the 'File' menu.
":

############################################################

############################################################
# 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 

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("<mtext>&NewLine;</mtext>");
    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:

############################################################

getSavedStr:=proc()
savedStr;
end proc:

getMathStr:=proc()
mathStr;
end proc:

getAboutRuleStr:=proc()
aboutRuleStr;
end proc:

getInitParam:=proc(P_fun, P_var)
  G_fun:= P_fun:
  G_var:= P_var: 
end proc:

getMRuleStr:=proc()
  mRuleStr;
end proc:
############################################################
# pre: null 
# post: initializes the differentiation
#       if input is correct, differentiation equation
#       is added to steps, understood rules applied
#       if applicapable, MathMLViewer updates as well
#       else error message shows 

startRule := proc()
  local diffFun, cal_eqn, mlStr, infoStr, uRulesStr, 
        uRules, uAppliedRules, i, hints,  
        diffVarStr, diffFunStr, diffEqnStr:

  use Student:-Calculus1, Maplets:-Tools, StringTools in
    clearSteps():

    diffFunStr := Trim(G_fun):
    if diffFunStr="" then 
      infoStr := "Enter a valid function":
      savedStr:=infoStr:
      error "No function has been entered": 
    end if:

    diffVarStr := Trim(G_var):
    if diffVarStr="" then 
      infoStr := "Enter a valid independent variable":
      savedStr:=infoStr:
      error "No independent variable has been entered": 
    end if:

    diffEqnStr := cat("Diff(",diffFunStr,",",diffVarStr,")"):
    diffFun := parse(diffEqnStr):
    hints := Hint(diffFun):
    mlStr := iniMathML(GetProblem()):
    infoStr := "Initializing":
    savedStr:=infoStr:

    if nops(hints)>0 then
      uRules := rhs(Understand(Diff)):
      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:

        cal_eqn := Rule[](GetProblem()):
        steps := [op(steps), cal_eqn]: 

        if nops(uAppliedRules) > 0 then
   
          if nops(uAppliedRules) = 1 then 
            uRulesStr := convert(uAppliedRules,string):
            infoStr := cat("Understood rule ", uRulesStr, " is "):
          else 
            uRulesStr := convert(uAppliedRules,string):
            infoStr := cat("Understood rules ", uRulesStr, " are "):
          end if :# end if nops(uAppliedRules)=1

          infoStr := cat(infoStr, "automatically applied"):
          savedStr:=infoStr:
          mlStr := addMathML(mlStr,rhs(cal_eqn)): 

        end if: # end if nops(uAppliedRules)>0

      else # nops(uRules)=0
        cal_eqn := Rule[](GetProblem()):
        steps := [op(steps), cal_eqn]: 

      end if : # end if nops(uRules)>0        

      mathStr:=mlStr:
      infoStr := "Apply a rule below":
      savedStr:=infoStr:        

    else
      infoStr := ("No differentiation rule could be applied"):
      
      savedStr:=infoStr:         

    end if: # nops(hints)
  end use:
end proc: # end startRule

############################################################

############################################################
# pre: null
# post: if aRule is a valid differentiation rule 
#       and applicable new step is stored in steps, 
#       updates MathMLViewer 
#       else message displays the rule is not applicable

applyRule := proc(aRule)
  local mlStr, infoStr, cal_eqn:
  use Student:-Calculus1, Maplets:-Tools in

    if nops(steps)=0 then
      startRule():
    end if:

    mlStr:=mathStr:
    cal_eqn := Rule[aRule](steps[nops(steps)]):

    if GetMessage()=NULL then
      infoStr := cat(convert(aRule,string),  
                     " rule is being applied"):
      savedStr:=infoStr:

      steps := [op(steps),cal_eqn]:
      mlStr := addMathML(mlStr,rhs(cal_eqn)):

      mathStr:=mlStr:
      infoStr := cat(convert(aRule,string), 
                     " rule has been applied"):
      savedStr:=infoStr:

    else
      infoStr := cat(convert(aRule,string), 
                     " rule is not applicable"):
      savedStr:=infoStr: 

    end if: 

  end use:
end proc: # end applyRule

############################################################

############################################################
# pre: null
# post: read the differentiation rule from 
#       in otherWin, and apply it
#       if TF_other is empty, error message displays

applyOtherRule := proc(G_other)
  local aRule:
  use Maplets:-Tools, Maplets:-Elements, StringTools in
    aRule := Trim(G_other):
    if aRule = "" then 
      Maplets:-Display(Maplet(
         MessageDialog("No rule has been entered"))):  
    else
      applyRule(parse(aRule)):
    end if:
  end use:
end proc:

############################################################

############################################################
# pre: null
# post: get argument from TF_args, and apply
#       the rewrite rule to the diff problem

applyRewriteRule := proc(G_args)
  local str:
  use Student:-Calculus1, Maplets:-Tools, Maplets:-Elements, StringTools in

  str := Trim(G_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:

############################################################

############################################################
# pre: null
# post: a complete solution for the current problem is displayed

diffAllSteps := proc() 
  local diffEqn, hint, mlStr, infoStr:
  use Student:-Calculus1, Maplets:-Tools in 
    
    if nops(steps)=0 then
      startRule():
    end if:

    diffEqn := steps[nops(steps)]:
    hint := Hint(diffEqn):

    if nops(hint)=0 then
      infoStr:="No rule could be applied, or the problem is done":
      
      savedStr:=infoStr:
   
    else
      mlStr:=mathStr:

      while nops(hint)>0 do
        infoStr := convert(hint,string):
        infoStr := cat(infoStr, " is being applied"):
        savedStr:=infoStr:
        diffEqn:=Rule[hint](diffEqn):
        mlStr := addMathML(mlStr,rhs(diffEqn)):
        hint := Hint(diffEqn):
      end do:
      
      steps := [op(steps),diffEqn]:

      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: # end diffAllSteps

############################################################

############################################################
# pre: null
# post: final answer for the current problem is displayed

getFinalResult := proc()
  local diffEqn, hint, mlStr, infoStr:
  use Student:-Calculus1, Maplets:-Tools in 
    
    if nops(steps)=0 then
      startRule():
    end if:

    diffEqn := steps[nops(steps)]:
    hint := Hint(diffEqn):

    if nops(hint)=0 then
      infoStr:="No rule could be applied, or the problem is done":

      savedStr:=infoStr:
   
    else
      mlStr:=mathStr:

      while nops(hint)>0 do
        infoStr := convert(hint,string):
        infoStr := cat(infoStr, " is being applied"):

        savedStr:=infoStr:
        diffEqn:=Rule[hint](diffEqn):
        hint := Hint(diffEqn):
      end do:
      
      steps := [op(steps),diffEqn]:

      infoStr := "Exporting final answer":
      savedStr:=infoStr: 
      mlStr := addMathML(mlStr,rhs(diffEqn)):
      mathStr:=mlStr:
      infoStr := "The final answer is displayed":
      savedStr:=infoStr:

    end if: # end if nops(hint)=0

  end use: 
end proc: # end getFinalResult

############################################################

############################################################
# pre: null
# post: clears the historic record of all steps

clearSteps := proc()
  use Student:-Calculus1, Maplets:-Tools in
    mathStr:="":
    savedStr:="":
    
    Clear(all): steps:=[]:
  end use:
end proc: # end clearStep:

############################################################

############################################################
# pre: null
# post: a hint to solve the question is displayed

getHint := proc()
  local cal_eqn, hint, infoStr: 
  use Student:-Calculus1, Maplets:-Tools in

    if nops(steps)=0 then
      startRule():
    end if:

    cal_eqn := steps[nops(steps)]:
    hint := Hint(cal_eqn):

    if nops(hint)=0 then
      infoStr:="No rule could be applied, or the problem is done":

      savedStr:=infoStr:
    else
      infoStr:=convert(hint,string):
      
      savedStr:=infoStr:
    end if:

    hint:

  end use
end proc: # end getHint

############################################################

############################################################
# pre: null
# post: a rule is applied if there is at least
#       one rule that works

applyHint := proc()
  local hint:

  hint := getHint():
  if nops(hint)>0 then 
    applyRule(hint):
  end if: 
end proc: # end applyHint

############################################################

############################################################
# pre: name is a valid differentiation rule
#      fun is in a valid algebraic expression or function
# post: Window ruleInfo pop ups with the
#       description of the differentiation rule 'name'

aboutRule := proc(name,fun)
  local eqn:
  use Maplets[Tools] in 
    aboutRuleStr:=cat(convert(name,string), " rule"):
    if name=power then 
      eqn := Diff(fun,x)=n*x^(n-1):
    elif name=quotient then
      eqn := Diff(fun,x)=normal(diff(fun,x),expanded):
    else 
      eqn := Diff(fun,x)=diff(fun,x):
    end if:
      mRuleStr:= MathML:-ExportPresentation(eqn)  
    end use: 
end proc: # end aboutRule

############################################################

############################################################
# pre: aRule is a differentiation rule, ruleState:boolean
# post: if ruleState=true, then aRule is understood
#       else aRule is removed from understood rules list
changeUnderstoodRules := proc(aRule, ruleState)
  use Student:-Calculus1 in
    if ruleState=true then
      Understand(Diff,aRule):
    else 
      removeRule(aRule):
    end if:
  end use:
end proc: # end changeUnderstoodRules

############################################################

############################################################
# pre: aRule is a valid differentiation rule
# post: aRule is removed from understood rules list

removeRule := proc(aRule)
  local rules;
  use Student:-Calculus1 in
    rules := rhs(Understand(Diff));
    rules := subs(aRule = NULL,rules);
    Understand(Diff,'none');
    if nops(rules) > 0 then
      Understand(Diff,op(rules));
    end if:
  end use:
end proc: # end removeRule

############################################################

############################################################
# pre: Maple 8 or a higher version is installed
# post: run Step-by-Step differentiator

runDiffMaplet := proc()

local maplet, color, lightcolor, darkcolor:
color := 'background'="#DDFFFF":
lightcolor := 'background'="#EEFFFF":
darkcolor := 'background'="#CCFFFF":

use Maplets, Maplets:-Elements, Student:-Calculus1 in

maplet := Maplet( 
  'onstartup'=RunWindow('diffWin'),
  Font['F1']('family'="Default",italic='true','size'=12),
  Font['F2']('family'="Default", 'bold'='true', 'size'=14), 
  
  Window['diffWin']('menubar'='diffMB', 'resizable'='false', 
    'title'="Calculus 1 - Step-by-Step Differentiation Problem Solver",
    BoxColumn(color, 'inset'=0, 'spacing'=0,  

      BoxRow(color, 'border'='true','inset'=0,'spacing'=3,   
        'caption'="Enter a function",
        Label('caption'="Function ",  'font'=F2,'background'="#DDFFFF"), 
        TextField['TF_fun']('value'=sin(x)*x, lightcolor, 'width'=36),
         Label('caption'="Variable ",  'font'=F2,'background'="#DDFFFF"), 
        TextField['TF_var'](lightcolor,"x",8)
      ), # end BoxRow

      BoxRow(color, 'inset'=0,'spacing'=0,  
        BoxColumn(color, 'border'='true', 'inset'=0, 'spacing'=0,   
          'caption'="Problem Status",
          BoxRow(color,    
            MathMLViewer['ML']('height'=470, 'width'=400, lightcolor)
          ), # end BoxRow
          BoxRow(color, 'halign'='right', color, 
            Button("Start", 'onclick'='A_Diff', lightcolor, 
              'tooltip'="Initialize differentiation"),
            Button("Final Ans", 'onclick'='A_diff', lightcolor,
              'tooltip'="Display final answer"), 
            Button("All Steps", 'onclick'='A_diffAll', lightcolor,
              'tooltip'="Display a complete solution"),
            Button("Clear", 'onclick'='A_clear', lightcolor,
              'tooltip'="Clear the problem history"),
            Button("Close", Shutdown(), 'tooltip'="Close the maplet", lightcolor) 
          ) # end BoxRow
        ), # end BoxColumn

        BoxColumn(color, 'inset'=0, 'inset'=0, 'spacing'=0, 

          BoxRow(color, 'border'='true', 'caption'="Messages", 
                 'inset'=0, 'spacing'=0,   
            BoxCell(
              TextBox['TB'](lightcolor, 'editable'='false',
                'value'="",
                'tooltip'="Messages", 'font'='F1', 'height'=3 
              ) # end TextBox
            ) # end BoxCell
          ), # end BoxRow          

          BoxRow(color, 'border'='true', 'caption'="Hints", 
                 'inset'=0, 'spacing'=12, 
            BoxCell(Button['B_getHint']("Obtain a Hint", lightcolor,  
                   'onclick'='A_getHint', 'tooltip'="Receive a hint")),
            BoxCell(Button['B_applyHint']("Apply the Hint", lightcolor, 
                    'onclick'='A_applyHint', 'tooltip'="Apply the hint displayed in the Messages box"))
          ), # end BoxRow

          BoxColumn(color, 'border'='true', 'inset'=0, 'spacing'=0,
                     'caption'="Differentiation Rules", 
            
            BoxRow(color, 'halign'='left', 'inset'=0, 'spacing'=0,
              BoxCell('halign'='left',
                Button['B_constant'](" Constant ", 
                  'onclick'='A_constant', lightcolor, 
                  'tooltip'="Apply constant rule: c' = 0")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_constantmultiple']("Constant Multiple", 
                  'onclick'='A_constantmultiple', lightcolor, 
                  'tooltip'="Apply constant multiple rule: (c*f)' = c*f'")
              ) # BoxCell
            ), # BoxRow

            BoxRow(color, 'halign'='left', 'inset'=0, 'spacing'=0,
              BoxCell('halign'='left',
                Button['B_identiy']("Identity", 
                  'onclick'='A_identity', lightcolor, 
                  'tooltip'="Apply identity rule: x' = 1")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_power']("Power", 
                  'onclick'='A_power', lightcolor, 
                  'tooltip'="Apply power rule: (x^n)' = n*x^(n-1)")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_int']("Integral ", 
                  'onclick'='A_int', lightcolor, 
                  'tooltip'="Apply integral rule: (Int(f(t),t=c..x))'=f(x)")
              ) # BoxCell
            ), # BoxRow

            BoxRow(color, 'halign'='left', 'inset'=0, 'spacing'=0,
              BoxCell('halign'='left',
                Button['B_sum']("Sum ", 
                  'onclick'='A_sum', lightcolor, 
                  'tooltip'="Apply sum rule: (f+g)' = f'+g'")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_product']("Product", 
                  'onclick'='A_product', lightcolor,
                  'tooltip'="Apply product rule: (f*g)' = f'*g + f*g'")
              ), # BoxCell
              BoxCell('halign'='left', 
                Button['B_quotient']("Quotient", 
                  'onclick'='A_quotient', lightcolor, 
                  'tooltip'="Apply quotient rule: (f/g)'= (g*f'-f'*g)/g^2")
              ) # BoxCell
            ), # BoxRow

            BoxRow(color, 'halign'='left', 'inset'=0, 'spacing'=0, 
              BoxCell('halign'='left',
                Button['B_chain']("Chain Rule", 
                  'onclick'='A_chain', lightcolor, 
                  'tooltip'="Apply chain rule: (f(g(x)))'=f'(g(x))*g'(x)")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_exp']("Exponential ", 
                  'onclick'='A_exp', lightcolor, 
                  'tooltip'="Differentiate natural exponential function")
              ) # BoxCell
            ), # BoxRow

            BoxRow(color, 'halign'='left', 'inset'=0, 'spacing'=0, 
              BoxCell('halign'='left',
                Button['B_ln']("Natural Logarithm", 
                  'onclick'='A_ln', lightcolor, 
                  'tooltip'="Differentiate natural logarithm function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_log10']("Log 10", 
                  'onclick'='A_log10', lightcolor, 
                  'tooltip'="Differentiate common logarithm function")
              ) # BoxCell
            ), # BoxRow

            BoxRow(color, 'halign'='left', 'inset'=0, 'spacing'=0, 
              BoxCell('halign'='left',
                Button['B_sin']("    sin   ", 
                  'onclick'='A_sin', lightcolor, 
                  'tooltip'="Differentiate sine function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_cos']("   cos   ", 
                  'onclick'='A_cos', lightcolor, 
                  'tooltip'="Differentiate cosine function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_tan']("   tan   ", 
                  'onclick'='A_tan', lightcolor, 
                  'tooltip'="Differentiate tangent function")
              ) # BoxCell
            ), # BoxRow

            BoxRow(color, 'halign'='left', 'inset'=0, 'spacing'=0, 
              BoxCell('halign'='left',
                Button['B_cot']("  cot     ", 
                  'onclick'='A_cot', lightcolor, 
                  'tooltip'="Differentiate cotangent function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_sec']("   sec   ", 
                  'onclick'='A_sec', lightcolor, 
                  'tooltip'="Differentiate secant function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_csc']("   csc   ", 
                  'onclick'='A_csc', lightcolor, 
                  'tooltip'="Differentiate cosecant function")
              ) # BoxCell
            ), # BoxRow

            BoxRow(color, 'halign'='left', 'inset'=0, 'spacing'=0, 
              BoxCell('halign'='left',
                Button['B_sinh']("  sinh  ", 
                  'onclick'='A_sinh', lightcolor, 
                  'tooltip'="Differentiate sinh function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_cosh']("  cosh  ", 
                  'onclick'='A_cosh', lightcolor, 
                  'tooltip'="Differentiate cosh function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_tanh']("  tanh  ", 
                  'onclick'='A_tanh', lightcolor, 
                  'tooltip'="Differentiate tanh function")
              ) # BoxCell
            ), # BoxRow

            BoxRow(color, 'halign'='left', 'inset'=0, 'spacing'=0, 
              BoxCell('halign'='left',
                Button['B_coth']("  coth  ", 
                  'onclick'='A_coth', lightcolor, 
                  'tooltip'="Differentiate coth function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_sech']("  sech  ", 
                  'onclick'='A_sech', lightcolor, 
                  'tooltip'="Differentiate sech function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_csch']("  csch  ", 
                  'onclick'='A_csch', lightcolor, 
                  'tooltip'="Differentiate csch function")
              ) # BoxCell
            ), # BoxRow

            BoxRow(color, 'halign'='left', 'inset'=0, 'spacing'=0, 
              BoxCell('halign'='left',
                Button['B_arcsin'](" arcsin ", 
                  'onclick'='A_arcsin', lightcolor, 
                  'tooltip'="Differentiate arcsin function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_arccos'](" arccos ", 
                  'onclick'='A_arccos', lightcolor, 
                  'tooltip'="Differentiate arccos function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_arctan'](" arctan ", 
                  'onclick'='A_arctan', lightcolor, 
                  'tooltip'="Differentiate arctan function")
              ) # BoxCell
            ), # BoxRow

            BoxRow(color, 'halign'='left', 'inset'=0, 'spacing'=0, 
              BoxCell('halign'='left',
                Button['B_arccot'](" arccot ", 
                  'onclick'='A_arccot', lightcolor, 
                  'tooltip'="Differentiate arccot function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_arcsec'](" arcsec ", 
                  'onclick'='A_arcsec', lightcolor, 
                  'tooltip'="Differentiate arcsec function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_arccsc'](" arccsc ", 
                  'onclick'='A_arccsc', lightcolor, 
                  'tooltip'="Differentiate arccsc function")
              ) # BoxCell
            ), # BoxRow

            BoxRow(color, 'halign'='left', 'inset'=0, 'spacing'=0, 
              BoxCell('halign'='left', 
                Button['B_arcsinh']("arcsinh", 
                  'onclick'='A_arcsinh', lightcolor, 
                  'tooltip'="Differentiate arcsinh function")
              ), # BoxCell
              BoxCell('halign'='left', 
                Button['B_arccosh']("arccosh", 
                  'onclick'='A_arccosh', lightcolor, 
                  'tooltip'="Differentiate arccosh function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_arctanh']("arctanh", 
                  'onclick'='A_arctanh', lightcolor, 
                  'tooltip'="Differentiate arctanh function")
              ) # BoxCell
            ), # BoxRow

            BoxRow(color, 'halign'='left', 'inset'=0, 'spacing'=0, 
              BoxCell('halign'='left',
                Button['B_arccoth']("arccoth", 
                  'onclick'='A_arccoth', lightcolor, 
                  'tooltip'="Differentiate arccoth function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_arcsech']("arcsech", 
                  'onclick'='A_arcsech', lightcolor, 
                  'tooltip'="Differentiate arcsech function")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_arccsch']("arccsch", 
                  'onclick'='A_arccsch', lightcolor, 
                  'tooltip'="Differentiate arccsch function")
              ) # BoxCell
            ) # BoxRow

          ) # end BoxLayout
        
        ) # end BoxColumn 
      ) # end BoxRow

    ) # end BoxColumn
  ), # end Window

############################################################

  MenuBar['diffMB'](
    Menu("File",
      MenuItem("Obtain a Hint", 'onclick'='A_getHint'),
      MenuItem("Apply the Hint", 'onclick'='A_applyHint'),
      MenuSeparator(),
      MenuItem("Start to Differentiate", 'onclick'='A_Diff'),
      MenuItem("Show All Steps", 'onclick'='A_diffAll'),
      MenuItem("Final Answer", 'onclick'='A_diff'),      
      MenuSeparator(),
      MenuItem("Clear", 'onclick'='A_clear'),
      MenuSeparator(),
      MenuItem("Close", Shutdown())
    ), # end Menu/File
 
    Menu("Rule Definition",
      MenuItem("Chain Rule", 'onclick'='A_i_chain'),
      MenuSeparator(),
      MenuItem("Constant Rule", 'onclick'='A_i_constant'),
      MenuItem("Constant Multiple", 'onclick'='A_i_constantmultiple'),
      MenuSeparator(),
      MenuItem("Identity Rule", 'onclick'='A_i_identity'),
      MenuItem("Power Rule", 'onclick'='A_i_power'),
      MenuSeparator(),
      MenuItem("Sum Rule", 'onclick'='A_i_sum'),
      MenuItem("Difference Rule", 'onclick'='A_i_difference'),
      MenuSeparator(),
      MenuItem("Product Rule", 'onclick'='A_i_product'),
      MenuItem("Quotient Rule", 'onclick'='A_i_quotient'),
      MenuSeparator(),
      MenuItem("Natural Exponential", 'onclick'='A_i_exp'),
      MenuItem("Natural Logarithm",'onclick'='A_i_ln'),
      MenuItem("Logarithm Base 10",'onclick'='A_i_log10'),
      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
      MenuSeparator(),
      MenuItem("Integral Rule", 'onclick'='A_i_int'),
      MenuItem("Rewrite Rule", 'onclick'=RunWindow('rewriteInfoWin'))
    ), # end Menu/Rule Definition

  Menu("Apply the Rule",
      MenuItem("Chain Rule", 'onclick'='A_chain'),
      MenuSeparator(),
      MenuItem("Constant Rule", 'onclick'='A_constant'),
      MenuItem("Constant Multiple", 'onclick'='A_constantmultiple'),
      MenuSeparator(),
      MenuItem("Identity Rule", 'onclick'='A_identity'),
      MenuItem("Power Rule", 'onclick'='A_power'),
      MenuSeparator(),
      MenuItem("Sum Rule", 'onclick'='A_sum'),
      MenuItem("Difference Rule", 'onclick'='A_difference'),
      MenuSeparator(),
      MenuItem("Product Rule", 'onclick'='A_product'),
      MenuItem("Quotient Rule", 'onclick'='A_quotient'),
      MenuSeparator(),
      MenuItem("Natural Exponential", 'onclick'='A_exp'),
      MenuItem("Natural Logarithm",'onclick'='A_ln'),
      MenuItem("Logarithm Base 10",'onclick'='A_log10'),
      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
      MenuSeparator(),
      MenuItem("Integral Rule", 'onclick'='A_int'),
      MenuItem("Rewrite Rule", 'onclick'=RunWindow('rewriteWin')),
      MenuSeparator(),
      MenuItem("Enter a Diff Rule", 'onclick'=RunWindow('otherWin'))
    ), # end Menu/Apply Rules
    
    Menu("Understood Rules",
      CheckBoxMenuItem['CMI_chain']("Chain Rule", 'onclick'='A_u_chain'),
      MenuSeparator(),   
      CheckBoxMenuItem['CMI_constant'](
           "Constant Rule", 'onclick'='A_u_constant'),
      CheckBoxMenuItem['CMI_constantmultiple'](
           "Constant Multiple", 'onclick'='A_u_constantmultiple'),
      MenuSeparator(),
      CheckBoxMenuItem['CMI_identity']("Identity Rule", 'onclick'='A_u_identity'),
      CheckBoxMenuItem['CMI_power']("Power Rule", 'onclick'='A_u_power'),
      MenuSeparator(),
      CheckBoxMenuItem['CMI_sum']("Sum Rule", 'onclick'='A_u_sum'),
      CheckBoxMenuItem['CMI_difference']("Difference Rule", 'onclick'='A_u_difference'),
      MenuSeparator(),
      CheckBoxMenuItem['CMI_product']("Product Rule", 'onclick'='A_u_product'),
      CheckBoxMenuItem['CMI_quotient']("Quotient Rule", 'onclick'='A_u_quotient'),
      MenuSeparator(),
      CheckBoxMenuItem['CMI_exp']("Natural Exponential", 'onclick'='A_u_exp'),
      CheckBoxMenuItem['CMI_ln']("Natural Logarithm",'onclick'='A_u_ln'),
      CheckBoxMenuItem['CMI_log10']("Logarithm Base 10",'onclick'='A_u_log10'),
      MenuSeparator(),
      Menu("Trigonometric Functions",
        CheckBoxMenuItem['CMI_sin']("sin",'onclick'='A_u_sin'),
        CheckBoxMenuItem['CMI_cos']("cos",'onclick'='A_u_cos'),
        CheckBoxMenuItem['CMI_tan']("tan",'onclick'='A_u_tan'),
        CheckBoxMenuItem['CMI_cot']("cot",'onclick'='A_u_cot'),
        CheckBoxMenuItem['CMI_sec']("sec",'onclick'='A_u_sec'),
        CheckBoxMenuItem['CMI_csc']("csc",'onclick'='A_u_csc')
      ), # end Menu/Trig
      Menu("Inverse Trigonometric Functions",
        CheckBoxMenuItem['CMI_arcsin']("arcsin",'onclick'='A_u_arcsin'),
        CheckBoxMenuItem['CMI_arccos']("arccos",'onclick'='A_u_arccos'),
        CheckBoxMenuItem['CMI_arctan']("arctan",'onclick'='A_u_arctan'),
        CheckBoxMenuItem['CMI_arccot']("arccot",'onclick'='A_u_arccot'),
        CheckBoxMenuItem['CMI_arcsec']("arcsec",'onclick'='A_u_arcsec'),
        CheckBoxMenuItem['CMI_arccsc']("arccsc",'onclick'='A_u_arccsc')
      ), # end Menu/Inverse Trig
      Menu("Hyperbolic Functions",
        CheckBoxMenuItem['CMI_sinh']("sinh",'onclick'='A_u_sinh'),
        CheckBoxMenuItem['CMI_cosh']("cosh",'onclick'='A_u_cosh'),
        CheckBoxMenuItem['CMI_tanh']("tanh",'onclick'='A_u_tanh'),
        CheckBoxMenuItem['CMI_coth']("coth",'onclick'='A_u_coth'),
        CheckBoxMenuItem['CMI_sech']("sech",'onclick'='A_u_sech'),
        CheckBoxMenuItem['CMI_csch']("csch",'onclick'='A_u_csch')
      ), # end Menu/Hyperbolic 
      Menu("Inverse Hyperbolic Functions",
        CheckBoxMenuItem['CMI_arcsinh']("arcsinh",'onclick'='A_u_arcsinh'),
        CheckBoxMenuItem['CMI_arccosh']("arccosh",'onclick'='A_u_arccosh'),
        CheckBoxMenuItem['CMI_arctanh']("arctanh",'onclick'='A_u_arctanh'),
        CheckBoxMenuItem['CMI_arccoth']("arccoth",'onclick'='A_u_arccoth'),
        CheckBoxMenuItem['CMI_arcsech']("arcsech",'onclick'='A_u_arcsech'),
        CheckBoxMenuItem['CMI_arccsch']("arccsch",'onclick'='A_u_arccsch')
      ), # end Menu/Inverse hyperbolic
      MenuSeparator(),
      CheckBoxMenuItem['CMI_int']("Integral Rule", 'onclick'='A_u_int')
    ), # end Menu/Understood Rules
 
    Menu("Help",
      MenuItem("Using this Maplet", 'onclick'=RunWindow('helpWin'))
    ) # end Menu/Help

  ), # end MenuBar

############################################################

  #Window[ruleWin]('resizable'='false',
  #  'title'="Differentiation Rule",
   # BoxColumn(color, 'inset'=0, 'spacing'=10, 
  #    'border'='true',  
  #    BoxRow(color, 'inset'=0, 'spacing'=0, 
  #       MathMLViewer['ML_rule']('width'=375, lightcolor) 
  #    ), # end BoxRow
  #    BoxRow(color, 'inset'=0, 'spacing'=0, 
  #      Button("Close", lightcolor, CloseWindow(ruleWin))
  #    ) # end BoxRow
  #  ) # end BoxColumn
  #), # end ruleInfo

 Window['ruleWin'](
    'title'="Differentiation Rule", 'resizable'='false',
    BoxColumn(color,'inset'=0, 'spacing'=10, 'border'='true',  
      BoxRow(color,'inset'=0, 'spacing'=0, 
         TextBox[LABEL]('width'=25, lightcolor)),
       BoxRow('inset'=0, 'spacing'=0, 
         MathMLViewer['ML_rule']('width'=375,lightcolor) 
      ), # end BoxRow
      BoxRow(color,'inset'=0, 'spacing'=0,  
        Button("Close", lightcolor, CloseWindow(ruleWin))
      ) # end BoxRow
    ) # end BoxColumn
  ), # end ruleWin


############################################################

  Window['otherWin']( 'resizable'='false',
    'title'="Enter Diff Rule", 
    BoxColumn(color, 'inset'=0, 'spacing'=5, 
      'border'='true',  
      BoxRow(color, 'inset'=0, 'spacing'=0,  
        TextField['TF_other']('width'=10, lightcolor, 'value'=" ")
      ), # end BoxRow
      BoxRow(color, 'inset'=0, 'spacing'=10, 
        Button("Apply",  
          'onclick'='A_other', darkcolor),
        Button("Close",  
          'onclick'=CloseWindow('otherWin'), darkcolor)
      ) # end BoxRow
    ) # end BoxColumn
  ), # end Window otherWin 

############################################################

  Window['rewriteWin']( 'resizable'='false', 
    'title'="Apply Rewrite Rule",
    BoxColumn(color, 'inset'=0, 'spacing'=5,  
      'border'='true',  
      BoxRow(color, 'inset'=0, 'spacing'=0,   
        Label("Enter the parameters (separated by commas): ") 
      ), # end BoxRow
      BoxRow(color, 'inset'=0, 'spacing'=0,  
        TextField['TF_args']('width'=18, lightcolor, 'value'=" ")
      ), # end BoxRow
      BoxRow(color, 'inset'=0, 'spacing'=8, 
        Button("Apply", darkcolor,  
          'onclick'='A_reWriteRule' ),
        Button("About", darkcolor,  
          'onclick'=RunWindow('rewriteInfoWin') ), 
        Button("Close", darkcolor,  
          'onclick'=CloseWindow('rewriteWin') )
      ) # end BoxRow
    ) # end BoxColumn    
  ), # end rewriteWin
  
############################################################

  Window['rewriteInfoWin']( 'resizable'='false',
    'title'="Using the Rewrite Rule", 
    BoxColumn(color, 'inset'=0, 'spacing'=5,  
      'border'='true',  
      BoxRow(color, 'inset'=0, 'spacing'=0, 
        TextBox['TB_rewrite']('value'=rewriteStr,  
          'editable'='false', 'visible'='true', lightcolor,  
          'height'=19, 'width'=50, 'tooltip'="Using the rewrite rule")  
      ),  # end BoxRow
      BoxRow(color, 'inset'=0, 'spacing'=20, 
        Button("Close", darkcolor, 'onclick'=CloseWindow('rewriteInfoWin'))
      ) # end BoxRow
    ) # end BoxColumn    
  ), # end rewriteWin

############################################################

  Window['helpWin']( 'resizable'='false',
    'title'="Using the Step-by-Step Differentiation Problem Solver Maplet",
    BoxColumn(color, 'border'='true', 'inset'=0, 'spacing'=8,
      BoxCell(
        TextBox('height'=24, 'width'=40,
          lightcolor, 'foreground'="#333399", 
          'editable'='false', 'font'='F2', 
          'value'=helpStr
        ) # end TextBox
      ), # end BoxCell
      BoxRow(color, 'inset'=0, 'spacing'=0, 
        Button("Close", lightcolor, 
          CloseWindow('helpWin'))
      ) # end BoxRow
    ) # end BoxColumn
  ), # end helpWin

############################################################

  Action['A_Diff']
  (
    Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate
    ( 'function'='startRule'
    ),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    ) 
  ), # end A_Diff
  
  Action['A_diffAll']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),

    Evaluate('function'='diffAllSteps()'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    ) 

  ), # end A_diffAll

  Action['A_diff']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='getFinalResult()'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    ) 

  ), # end A_diff  

  Action['A_clear'](
    Evaluate('function'='clearSteps()'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    ) 

  ), # end A_clear
  
  Action['A_getHint']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='getHint'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    ) 

  ), # end A_getHint

  Action['A_applyHint']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyHint'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    ) 

  ), # end A_applyHint

  Action['A_other']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate
    ( 'waitforresult'='false','function'='applyOtherRule',
      Argument('TF_other', quotedtext='true')
    ),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    ), 

    CloseWindow('otherWin'), 
    SetOption('TF_other'="")
  ), # end A_other

  Action['A_reWriteRule']
  ( Evaluate
    ( 'waitforresult'='false','function'='applyRewriteRule',
       Argument('TF_args',quotedtext='true')
    ),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    ) 

  ), # end A_reWriteRule

############################################################

  Action['A_i_constant'](
    Evaluate('function'='aboutRule(constant,c)'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    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))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    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))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    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))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')  
  ), # end A_i_difference
  
  Action['A_i_identity'](
    Evaluate('function'='aboutRule(identity,x)'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_identity
  
  Action['A_i_power'](
    Evaluate('function'='aboutRule(power,x^n)'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_power

  Action['A_i_product'](
    Evaluate('function'='aboutRule(product,f(x)*g(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_product

  Action['A_i_quotient'](
    Evaluate('function'='aboutRule(quotient,f(x)/g(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_sum

  Action['A_i_chain'](
    Evaluate('function'='aboutRule(chain,f(g(x)))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_chain

  Action['A_i_int'](
    Evaluate('function'='aboutRule(int,Int(f(t),t=c..x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_chain

  Action['A_i_exp'](
    Evaluate('function'='aboutRule(exp,exp(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_exp

  Action['A_i_log10'](
    Evaluate('function'='aboutRule(log10,log10(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_log10

  Action['A_i_ln'](
    Evaluate('function'='aboutRule(ln,ln(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_ln

  Action['A_i_sin'](
    Evaluate('function'='aboutRule(sin,sin(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_sin

  Action['A_i_cos'](
    Evaluate('function'='aboutRule(cos,cos(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_cos

  Action['A_i_tan'](
    Evaluate('function'='aboutRule(tan,tan(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_tan

  Action['A_i_cot'](
    Evaluate('function'='aboutRule(cot,cot(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_cot

  Action['A_i_sec'](
    Evaluate('function'='aboutRule(sec,sec(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_sec

  Action['A_i_csc'](
    Evaluate('function'='aboutRule(csc,csc(x))'), 
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_csc

  Action['A_i_arcsin'](
    Evaluate('function'='aboutRule(arcsin,arcsin(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_arcsin

  Action['A_i_arccos'](
    Evaluate('function'='aboutRule(arccos,arccos(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_cos

  Action['A_i_arctan'](
    Evaluate('function'='aboutRule(arctan,arctan(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_arctan

  Action['A_i_arccot'](
    Evaluate('function'='aboutRule(arccot,arccot(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_arccot

  Action['A_i_arcsec'](
    Evaluate('function'='aboutRule(arcsec,arcsec(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_arcsec

  Action['A_i_arccsc'](
    Evaluate('function'='aboutRule(arccsc,arccsc(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_arccsc

  Action['A_i_sinh'](
    Evaluate('function'='aboutRule(sinh,sinh(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_sinh

  Action['A_i_cosh'](
    Evaluate('function'='aboutRule(cosh,cosh(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_cosh

  Action['A_i_tanh'](
    Evaluate('function'='aboutRule(tanh,tanh(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_tanh

  Action['A_i_coth'](
    Evaluate('function'='aboutRule(coth,coth(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_coth

  Action['A_i_sech'](
    Evaluate('function'='aboutRule(sech,sech(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_sech

  Action['A_i_csch'](
    Evaluate('function'='aboutRule(csch,csch(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_csch

  Action['A_i_arcsinh'](
    Evaluate('function'='aboutRule(arcsinh,arcsinh(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_arcsinh

  Action['A_i_arccosh'](
    Evaluate('function'='aboutRule(arccosh,arccosh(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_cosh

  Action['A_i_arctanh'](
    Evaluate('function'='aboutRule(arctanh,arctanh(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_arctanh

  Action['A_i_arccoth'](
    Evaluate('function'='aboutRule(arccoth,arccoth(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_arccoth

  Action['A_i_arcsech'](
    Evaluate('function'='aboutRule(arcsech,arcsech(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_arcsech

  Action['A_i_arccsch'](
    Evaluate('function'='aboutRule(arccsch,arccsch(x))'),
    Evaluate('function'='getAboutRuleStr', 'target'='LABEL','waitforresult'='false'),
    Evaluate('function'='getMRuleStr', 'target'='ML_rule','waitforresult'='false'),
    RunWindow('ruleWin')
  ), # end A_i_arccsch

############################################################

  Action['A_constant']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),         
    Evaluate('function'='applyRule(constant)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   
), # end A_constant
  
  Action['A_constantmultiple']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(constantmultiple)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_constantmultiple
  
  Action['A_sum']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(sum)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_sum

  Action['A_difference']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(difference)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_difference
  
  Action['A_identity']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(identity)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_identity
  
  Action['A_power']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ), 
    Evaluate('function'='applyRule(power)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_power

  Action['A_product']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(product)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_product

  Action['A_quotient']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(quotient)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_quotient

  Action['A_chain']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(chain)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_chain

  Action['A_int']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(int)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_chain

  Action['A_exp']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(exp)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_exp

  Action['A_log10']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(log10)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_log10

  Action['A_ln']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(ln)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_ln

  Action['A_sin']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(sin)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_sin

  Action['A_cos']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(cos)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_cos

  Action['A_tan']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(tan)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_tan

  Action['A_cot']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(cot)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_cot

  Action['A_sec']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(sec)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_sec

  Action['A_csc']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(csc)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_csc

  Action['A_arcsin']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(arcsin)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_arcsin

  Action['A_arccos']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(arccos)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_cos

  Action['A_arctan']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(arctan)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_arctan

  Action['A_arccot']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(arccot)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_arccot

  Action['A_arcsec']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(arcsec)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_arcsec

  Action['A_arccsc']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(arccsc)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_arccsc

  Action['A_sinh']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(sinh)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_sinh

  Action['A_cosh']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(cosh)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_cosh

  Action['A_tanh']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(tanh)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_tanh

  Action['A_coth']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(coth)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_coth

  Action['A_sech']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(sech)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_sech

  Action['A_csch']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(csch)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_csch

  Action['A_arcsinh']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(arcsinh)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_arcsinh

  Action['A_arccosh']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(arccosh)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_cosh

  Action['A_arctanh']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(arctanh)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_arctanh

  Action['A_arccoth']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(arccoth)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_arccoth

  Action['A_arcsech']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(arcsech)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_arcsech

  Action['A_arccsch']
  ( Evaluate
    ( 'waitforresult'='false','function'='getInitParam',
      Argument('TF_fun',quotedtext='true'),
      Argument('TF_var',quotedtext='true')
    ),
    Evaluate('function'='applyRule(arccsch)'),
    Evaluate
    ( 'function'='getMathStr','target'='ML'
    ),
    Evaluate
    ( 'function'='getSavedStr','target'='TB'
    )   

  ), # end A_arccsch


############################################################

  Action['A_u_constant'](
    Evaluate('function'='changeUnderstoodRules(constant, CMI_constant)')
  ), # end A_u_constant
  
  Action['A_u_constantmultiple'](
    Evaluate('function'='changeUnderstoodRules(constantmultiple, CMI_constantmultiple)')
  ), # end A_u_constantmultiple
  
  Action['A_u_sum'](
    Evaluate('function'='changeUnderstoodRules(sum, CMI_sum)')
  ), # end A_u_sum

  Action['A_u_difference'](
    Evaluate('function'='changeUnderstoodRules(difference, CMI_difference)')
  ), # end A_u_difference
  
  Action['A_u_identity'](
    Evaluate('function'='changeUnderstoodRules(identity, CMI_identity)')
  ), # end A_u_identity
  
  Action['A_u_power'](
    Evaluate('function'='changeUnderstoodRules(power, CMI_power)')
  ), # end A_u_power

  Action['A_u_product'](
    Evaluate('function'='changeUnderstoodRules(product, CMI_product)')
  ), # end A_u_product

  Action['A_u_quotient'](
    Evaluate('function'='changeUnderstoodRules(quotient, CMI_quotient)')
  ), # end A_u_quotient

  Action['A_u_chain'](
    Evaluate('function'='changeUnderstoodRules(chain, CMI_chain)')
  ), # end A_u_chain

  Action['A_u_int'](
    Evaluate('function'='changeUnderstoodRules(int, CMI_int)')
  ), # end A_u_chain

  Action['A_u_exp'](
    Evaluate('function'='changeUnderstoodRules(exp, CMI_exp)')
  ), # end A_u_exp

  Action['A_u_log10'](
    Evaluate('function'='changeUnderstoodRules(log10, CMI_log10)')
  ), # end A_u_log10

  Action['A_u_ln'](
    Evaluate('function'='changeUnderstoodRules(ln, CMI_ln)')
  ), # end A_u_ln

  Action['A_u_sin'](
    Evaluate('function'='changeUnderstoodRules(sin, CMI_sin)')
  ), # end A_u_sin

  Action['A_u_cos'](
    Evaluate('function'='changeUnderstoodRules(cos, CMI_cos)')
  ), # end A_u_cos

  Action['A_u_tan'](
    Evaluate('function'='changeUnderstoodRules(tan, CMI_tan)')
  ), # end A_u_tan

  Action['A_u_cot'](
    Evaluate('function'='changeUnderstoodRules(cot, CMI_cot)')
  ), # end A_u_cot

  Action['A_u_sec'](
    Evaluate('function'='changeUnderstoodRules(sec, CMI_sec)')
  ), # end A_u_sec

  Action['A_u_csc'](
    Evaluate('function'='changeUnderstoodRules(csc, CMI_csc)')
  ), # end A_u_csc

  Action['A_u_arcsin'](
    Evaluate('function'='changeUnderstoodRules(arcsin, CMI_arcsin)')
  ), # end A_u_arcsin

  Action['A_u_arccos'](
    Evaluate('function'='changeUnderstoodRules(arccos, CMI_arccos)')
  ), # end A_u_cos

  Action['A_u_arctan'](
    Evaluate('function'='changeUnderstoodRules(arctan, CMI_arctan)')
  ), # end A_u_arctan

  Action['A_u_arccot'](
    Evaluate('function'='changeUnderstoodRules(arccot, CMI_arccot)')
  ), # end A_u_arccot

  Action['A_u_arcsec'](
    Evaluate('function'='changeUnderstoodRules(arcsec, CMI_arcsec)')
  ), # end A_u_arcsec

  Action['A_u_arccsc'](
    Evaluate('function'='changeUnderstoodRules(arccsc, CMI_arccsc)')
  ), # end A_u_arccsc

  Action['A_u_sinh'](
    Evaluate('function'='changeUnderstoodRules(sinh, CMI_sinh)')
  ), # end A_u_sinh

  Action['A_u_cosh'](
    Evaluate('function'='changeUnderstoodRules(cosh, CMI_cosh)')
  ), # end A_u_cosh

  Action['A_u_tanh'](
    Evaluate('function'='changeUnderstoodRules(tanh, CMI_tanh)')
  ), # end A_u_tanh

  Action['A_u_coth'](
    Evaluate('function'='changeUnderstoodRules(coth, CMI_coth)')
  ), # end A_u_coth

  Action['A_u_sech'](
    Evaluate('function'='changeUnderstoodRules(sech, CMI_sech)')
  ), # end A_u_sech

  Action['A_u_csch'](
    Evaluate('function'='changeUnderstoodRules(csch, CMI_csch)')
  ), # end A_u_csch

  Action['A_u_arcsinh'](
    Evaluate('function'='changeUnderstoodRules(arcsinh, CMI_arcsinh)')
  ), # end A_u_arcsinh

  Action['A_u_arccosh'](
    Evaluate('function'='changeUnderstoodRules(arccosh, CMI_arccosh)')
  ), # end A_u_cosh

  Action['A_u_arctanh'](
    Evaluate('function'='changeUnderstoodRules(arctanh, CMI_arctanh)')
  ), # end A_u_arctanh

  Action['A_u_arccoth'](
    Evaluate('function'='changeUnderstoodRules(arccoth, CMI_arccoth)')
  ), # end A_u_arccoth

  Action['A_u_arcsech'](
    Evaluate('function'='changeUnderstoodRules(arcsech, CMI_arcsech)')
  ), # end A_u_arcsech

  Action['A_u_arccsch'](
    Evaluate('function'='changeUnderstoodRules(arccsch, CMI_arccsch)')
  ), # end A_u_arccsch

  Action['A']()

) : # end maplet

Student:-Calculus1:-Understand(Diff,none):
Maplets[Display](maplet) :

end use: # end use
end proc: # end runDiffMaplet

###########################################################

###########################################################
end module: # end DiffMaplet()
DiffMaplet:-runDiffMaplet();