# Calculus Exploration 2: Limit Rules
# 
# The following is the Maple code for the Limit Rules Maplet, which should be used to both explore the limit rules and obtain step-by-step solutions to problems using the limit rules. You can either execute the code below or run the corresponding Maplet from the webpage.
# 
# Limit Rules Maplet Code
# Click in red area and press [Enter].
# Step-by-Step Limit Problem Solver Maplet
# Copyright 2002 Waterloo Maple
# 
# This maplet guides the user through a limit problem. The user can apply limit rules one at a time to a function f and see the resulting expression. The Messages box displays status information.
# 
# The user enters a function with its independent variable, x, and the limit point, a, that x approaches. The user can apply limit rules, for example, the sum rule or any specified mathematical function, such as the sine rule. The user can also apply l'Hopital's rule, a rewrite rule, or a change of variable rule by specifying additional arguments. When the user applies a rule, the Problem Status box displays the result.
# 
# For any rule, the user can display a definition.
# 
# 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 is 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:
LimMaplet := module()

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

export iniMathML, addMathML, runLimMaplet, 
       startRule, applyRule, applyOtherRule,
       applyMathFuncRule, getHint, applyHint, 
       getFinalAnswer, showAllSteps, clearSteps,
       applyRuleWithArgs, changeUnderstoodRules, forgetUnderstoodRule,
       aboutRule, helpStr:
local steps, lhopitalStr, changeStr, rewriteStr:
steps := []:

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

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

lhopitalStr := 
"If f(x)/g(x) is an indeterminate form at x = a, then L(f(x)/g(x)) = L(f'(x)/g'(x)) (if the latter limit exists).

To use l'Hopital's rule, you must enter the numerator for the application of the rule in the 'Rules with Arguments' text box.":

rewriteStr := 
"The rewrite rule changes the form of the expression in the limit without changing the limit variable.

To use the rewrite rule, you must enter one or more substitution equations in the 'Rules with Arguments' text box. The maplet performs each substitution listed. Occurrences of the left-hand side of each substitution are replaced by the corresponding right-hand side.":
 
changeStr := 
"The change rule changes the variable with respect to which the limit is computed.

To use the change rule, you must enter an equation describing the change of variables, F(x,u) = G(x,u), in the 'Rules with Arguments' text box.":

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

############################################################
helpStr := 
"This maplet guides you through a limit problem. You can apply limit rules one at a time to a function f and see the resulting expression. The 'Messages' box displays status information.

Enter a function with its independent variable, x, and the limit point, a, that x approaches. Click the 'Start' button. This clears the problem history and starts a new one.  

To apply limit rules click the corresponding buttons or select rules from the 'Apply the Rule' menu. Rules include the sum rule and any specified mathematical functions, such as the sine rule. To apply math functions enter a valid math function command and then click the 'Apply' button, or click the 'Select a Function' button and then click or enter a math function in the pop-up window and then click the 'Apply' button. To apply l'Hopital's rule, a 'rewrite' rule, or a 'change' rule, you must specify additional arguments. Enter the arguments in the text box above the buttons (separated by commas if there is more than one). For more information on rules that use additional arguments, select 'Using Rules with Arguments' from the 'File' menu.

When you apply a rule, the 'Problem Status' box displays the result.

To view the definition of a rule, select the rule from the 'Rule Definition' menu.   

At any time, you can request a hint for the next step. To request a hint, click the 'Obtain a Hint' button or select 'Obtain a Hint' from the 'File' menu. To apply a 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 the rule when possible.

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

To clear the problem history, click the 'Clear' button or select 'Clear' from the 'File' menu.": # end helpStr

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

############################################################
# pre: iniEqn :: algebraic expression
# post: returns the Presentation MathML of iniEqn

iniMathML := proc(iniEqn)
  MathML:-ExportPresentation(iniEqn);
end proc: # end iniMathML

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

############################################################
# 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("<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: # end addMathML

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

############################################################
# pre: null 
# post: initializes the Limit problem solving process
#       if input is correct, limit equation is added to steps
#       understood rules apply if capable
#       MathML Viewer updates too
#       else error message shows

startRule := proc()
  local funStr, varStr, ptStr, dirStr, limStr, 
        infoStr, mlStr, limExpr, limEqn, hints, 
        i, uRules, uAppliedRules, rulesStr:
  use Student:-Calculus1, Maplets:-Tools in
    
    clearSteps():
    funStr := Get('TF_fun'):
    if funStr = "" then 
      infoStr := "Enter a valid expression":
      Set('info'=infoStr):
      error "No expression entered in 'Function' text field":
    end if: 

    varStr := Get('TF_var'):
    if varStr = "" then 
      infoStr := "Enter the limit variable":
      Set('info'=infoStr):
      error "No limit variable entered in 'Variable' text field":
    end if: 

    ptStr := Get('CB'):
    if ptStr = "" then 
      infoStr := "Enter the limit point":
      Set('info'=infoStr):
      error "No limit point in 'at' combination box":
    end if: 

    dirStr := Get('DDB'):
    if dirStr <> "" then 
      dirStr := cat(", ",dirStr):
    end if: 

    limStr := cat("Limit(", funStr, ", " ,varStr, "=", ptStr, dirStr, ")"):
    limExpr := parse(limStr):
    hints := Hint(limExpr):
    mlStr := iniMathML(GetProblem()):
    infoStr := "Initializing":
    Set('info'=infoStr):
    
    if nops(hints)>0 then
      uRules := rhs(Understand(Limit)):
      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:

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

        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
          Set('info'=infoStr):
          mlStr := addMathML(mlStr,rhs(limEqn)):
        end if: # end if nops(uAppliedRules)>0
      
      else 
        limEqn := Rule[](GetProblem()):
        steps := [op(steps),limEqn]:  
  
      end if: # end if nops(uRules) > 0
      
      Set('ML'=mlStr):
      infoStr := "Apply any rule below":
      Set('info'=infoStr):
 
    else 
      infoStr := "No limit rules could be applied":
      Set('info'=infoStr):  

    end if : # end if nops(hints)>0
  end use:
end proc:

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

############################################################
# pre: null 
# post: if aRule is a valid limit 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, limEqn, oldEqn:
  use Student:-Calculus1, Maplets:-Tools in
    
    if nops(steps)=0 then
      startRule():
    end if:

    mlStr := Get('ML'):
    oldEqn := steps[nops(steps)]:
    limEqn := Rule[aRule](steps[nops(steps)]):

    if GetMessage()=NULL or (not evalb(limEqn=oldEqn)) then
      infoStr := convert(aRule,string): 
      infoStr := cat(infoStr, " rule is being applied"):
      Set('info'=infoStr):

      steps := [op(steps),limEqn]:
      mlStr := addMathML(mlStr,rhs(limEqn)):
      Set('ML'=mlStr):

      infoStr := convert(aRule,string): 
      infoStr := cat(infoStr, " rule has been applied"):
      Set('info'=infoStr):
    else
      infoStr := convert(aRule,string): 
      infoStr := cat(infoStr, " rule is not applicable"):
      Set('info'=infoStr):
    end if: # end if GetMessage()=NULL

  end use:
end proc: # end applyRule()

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

############################################################
# pre: null
# post: apply the limit rule with arguments
#       if arguments missing, error message shows

applyRuleWithArgs := proc(aRule)
  local ruleArgs, ruleStr:
  use Student:-Calculus1, Maplets:-Tools, Maplets:-Elements in
    
    ruleStr := convert(aRule,string):

    ruleArgs := Get('TB_args'):
    if ruleArgs = "" then
      Maplets:-Display(Maplet(
         MessageDialog("You must enter arguments to use this rule"))):  
    
    else
      ruleStr := cat(ruleStr,", ",ruleArgs):
      applyRule([parse(ruleStr)]):
    end if:

  end use:
end proc: # end applyRuleWithArgs

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

############################################################
# pre: null 
# post: read the limit rule from TF_other, and apply it
#       if TF_other is empty, error message shows

applyOtherRule := proc()
  local aRule:
  use Maplets:-Tools in
    aRule := Get('TF_other'):
    if aRule = "" then
      error "No rule entered in 'Other Maple Mathematical Functions' text field":
    else 
      applyRule(parse(aRule)):
    end if:
  end use:
end proc: # end applyOtherRule

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

############################################################
# pre: null 
# post: read the limit rule from TF_mathfunc, and apply it
#       if TF_mathfunc is empty, error message shows

applyMathFuncRule := proc()
  local aRule:
  use Maplets:-Tools in
    aRule := Get('TF_mathfunc'):
    if aRule = "" then
      error "No rule has been entered in 'Function Rules' text field":
    else 
      applyRule(parse(aRule)):
    end if:
  end use:
end proc: # end applyOtherRule

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

############################################################
# pre: null
# post: hint for the current limit problem is shown 
#       in the message TextField, info

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

    if nops(steps)=0 then
      startRule():
    end if:
    
    limEqn := steps[nops(steps)]:
    hint := Hint(limEqn):
    
    if nops(hint)=0 then
      infoStr:="No rule could be applied, or the problem is done":
      Set('info'=infoStr):
    else
      infoStr:=cat(convert(hint,string), " could be applied"):
      Set('info'=infoStr):
    end if:

    hint: # return value used in applyHint

  end use:
end proc: # end getHint()

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

############################################################
# pre: null
# post: hint for the current limit problem is applied 

applyHint := proc()
  local hint:

  hint := getHint():  

  if nops(hint)>0 then
    applyRule(hint):
  end if:

end proc: # end applyRule

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

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

getFinalAnswer := proc()
  local limEqn, hint, mlStr, infoStr:
  use Student:-Calculus1, Maplets:-Tools in

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

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

    if nops(hint)=0 then
      infoStr := "No rule could be applied, or the question is done":
      Set('info'=infoStr):
   
    else 
      mlStr := Get('ML'):  
      while nops(hint)>0 do
        infoStr := cat(convert(hint,string)," is being applied"):
        Set('info'=infoStr):
        limEqn := Rule[hint](limEqn):
        hint := Hint(limEqn): 
      end do:
      steps := [op(steps),limEqn]:
      infoStr := "Exporting final answer":
      mlStr := addMathML(mlStr,rhs(limEqn)):
      Set('ML'=mlStr):
      infoStr := "The final answer is displayed":
      Set('info'=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()
  local limEqn, hint, mlStr, infoStr:
  use Student:-Calculus1, Maplets:-Tools in

    if nops(steps)=0 then
      startRule():
    end if:
    
    limEqn := steps[nops(steps)]:
    hint := Hint(limEqn):

    if nops(hint)=0 then
      infoStr := "No rule could be applied, or the question is done":
      Set('info'=infoStr):
   
    else 
      mlStr := Get('ML'):

      while nops(hint)>0 do
        infoStr := cat(convert(hint,string)," is being applied"):
        Set('info'=infoStr):
        limEqn := Rule[hint](limEqn):
        mlStr := addMathML(mlStr,rhs(limEqn)):
        hint := Hint(limEqn): 
      end do:

      steps := [op(steps),limEqn]:

      infoStr := "Exporting the complete solution":
      Set('info'=infoStr):
      Set('ML'=mlStr):
      infoStr := "A complete solution is displayed":
      Set('info'=infoStr):  

    end if: # end if nops(hint)=0
     
     
  end use:
end proc: # showAllSteps

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

############################################################
# pre: name is a valid limit 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, limEqn, understoodRules:
  
 use Student:-Calculus1, Maplets:-Tools in

    understoodRules := rhs(Understand(Limit)):
    Understand(Limit,'none'):

    limEqn := Limit(fun,x='a'): 
    eqn := limEqn=rhs(Rule[name](limEqn)):  
  
    Set('ruleWin(title)'=cat(convert(name,string)," rule")):
    Set('ML_rule'=MathML:-ExportPresentation(eqn)):

    Understand(Limit, op(understoodRules)):  
   
  end use: 
end proc: # end aboutRule

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

############################################################
# pre: aRule is a valid limit rule
# post: if ruleState=true, aRule is understood
#       else, aRule is removed from understo0d limit rules

changeUnderstoodRules := proc(aRule, ruleState)
  use Student:-Calculus1 in
    if ruleState=true then 
      Understand(Limit,aRule):
    else
      forgetUnderstoodRule(aRule):
    end if:
  end use: 
end proc: # end changeUnderstoodRules

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

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

forgetUnderstoodRule := proc(aRule)
  local rules:
  use Student:-Calculus1 in
    rules := rhs(Understand(Limit)):
    rules := subs(aRule=NULL,rules):
    Understand(Limit,'none'):
    if nops(rules)>0 then
      Understand(Limit,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
    Set('ML'=""): Set('info'=""): Set('TB_args'=""): 
    Clear(all): steps:=[]:
  end use:
end proc: # end clearSteps()

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

############################################################
# pre: Maple 8 or higher is installed
# post: run Step-by-Step Limit Solver

runLimMaplet := 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('limWin'),

  Font['F1']("Default", 'bold'='true', 'size'=14),

############################################################
  
  Window['limWin']( 'menubar'='limMB',
    'resizable'='false', 
    'title'="Limit Rules:  Step-by-Step Problem Solver",
    BoxColumn(bc, 

      BoxRow('border'='true','inset'=0,'spacing'=0, 
        'caption'="Enter a function", bc, 
        Label('caption'="Function  ",  bc, 'font'=F1),
        TextField['TF_fun']('value'=x*cos(x)+3*x^2,'width'=20, 'onchange'='A', lc),
        Label('caption'="  Variable  ", bc, 'font'=F1), 
        TextField['TF_var'](" x", 'width'=2,'onchange'='A', lc),
        Label('caption'="  at  ", bc, 'font'=F1),
        ComboBox[CB]('value'=" Pi",'onchange'='A',  
                     ["0","infinity","-infinity"], lc),
        Label('caption'="  Direction  ", bc, 'font'=F1),
        DropDownBox[DDB]('value'="",'onchange'='A',
                         ["","left","right"], lc)  
      ), # end BoxRow

      BoxRow('inset'=0,'spacing'=0, bc, 
        BoxColumn('border'='true', 'inset'=0, 'spacing'=0, 
          'caption'="Problem Status", bc, 
          BoxRow(MathMLViewer['ML']('height'=470, 'width'=400, lc), bc),
          BoxRow('halign'='right', bc,
            Button("Start", 
              'onclick'=Evaluate('function'='startRule()'),
              'tooltip'="Initialize limit problem", lc),
            Button("Final Ans", 
              'onclick'=Evaluate('function'='getFinalAnswer()'),
              'tooltip'="Display the final answer", lc), 
            Button("All Steps", 
              'onclick'=Evaluate('function'='showAllSteps()'),
              'tooltip'="Display the complete solution", lc),
            Button("Clear", 
              'onclick'=Evaluate('function'='clearSteps()'),
              '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'="Messages",  
                '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'=Evaluate('function'='getHint()'), 
                   'tooltip'="Receive a hint", lc)),
            BoxCell(Button['B_applyHint']("Apply the Hint", 
                   'onclick'=Evaluate('function'='applyHint()'), 
                   'tooltip'="Apply the hint", lc))
          ), # end BoxRow

          BoxColumn('border'='true', 'inset'=0, 'spacing'=0,
                     'caption'="Limit Rules", bc, 
            BoxRow('halign'='left', 'inset'=0, 'spacing'=4, bc,
              BoxCell('halign'='left',
                Button['B_constant'](" Constant ", lc,  
                  Evaluate('function'='applyRule(constant)'), 
                  'tooltip'="Apply constant rule: L(c)=c")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_constantmultiple'](" Constant Multiple ", lc,  
                  Evaluate('function'='applyRule(constantmultiple)'), 
                  'tooltip'="Apply constant multiple rule: L(c*f(x)) = c*L(f(x))")
              ) # BoxCell
            ), # BoxRow

            BoxRow('halign'='left', 'inset'=0, 'spacing'=2, bc, 
              BoxCell('halign'='left',
                Button['B_identity']("Identity", lc,  
                  Evaluate('function'='applyRule(identity)'), 
                  'tooltip'="Apply identity rule:L(x) = a")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_sum']("Sum", lc, 
                  Evaluate('function'='applyRule(sum)'), 
                  'tooltip'="Apply sum rule: L(f(x)+g(x)) = L(f(x)) + L(g(x))")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_difference']("Difference", lc, 
                  Evaluate('function'='applyRule(difference)'), 
                  'tooltip'="Apply difference rule: L(f(x)-g(x)) = L(f(x)) - L(g(x))")
              ) # BoxCell
            ), # BoxRow

            BoxRow('halign'='left', 'inset'=0, 'spacing'=1, bc,
              BoxCell('halign'='left',
                Button['B_product']("Product", lc, 
                  Evaluate('function'='applyRule(product)'), 
                  'tooltip'="Apply product rule: L(f(x)*g(x)) = L(f(x)) * L(g(x))")
              ), # BoxCell
              BoxCell('halign'='left', 
                Button['B_quotient']("Quotient", lc, 
                  Evaluate('function'='applyRule(quotient)'), 
                  'tooltip'="Apply quotient rule: L(f(x)/g(x)) = L(f(x)) / L(g(x))")
              ), # end BoxCell
              BoxCell('halign'='left',
                Button['B_power']("Power", lc, 
                  Evaluate('function'='applyRule(power)'), 
                  'tooltip'="Apply power rule: L(f(x)^g(x)) = L(f(x)) ^ L(g(x))")
              ) # BoxCell
            ) # 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'=7, lc)
             ), # end BoxRow
             BoxRow('halign'='left', 'inset'=0, 'spacing'=5, bc, 
               Button['B_applyMathFunc']("Apply",
                 'onclick'='A_mathfunc', lc,
                 'tooltip'="Apply the math function"),
               Button['B_selectMathfunc']("Select a Function", 
                'onclick'=RunWindow('mathfuncWin'), lc, 
                'tooltip'="Select a math function" )
             ) # end BoxRow
          ), # end BoxColumn

          BoxColumn('border'='true', 'inset'=0, 'spacing'=0,
                     'caption'="Rules with Arguments", bc, 
            BoxCell(
              TextBox['TB_args'](
                'value'="", lc,
                'tooltip'="Arguments for the rule",  
                'height'=2, 'width'=16 
              ) # end TextBox
            ), # end BoxCell

            BoxRow('halign'='left', 'inset'=0, 'spacing'=0, bc, 
              BoxCell('halign'='left',
                Button['B_lhopital']("L'Hopital's", lc, 
                  'onclick'=Evaluate('function'='applyRuleWithArgs(lhopital)'), 
                  'tooltip'="Apply l'Hopital's rule: Enter the numerator")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_rewrite'](" Rewrite", lc, 
                  'onclick'=Evaluate('function'='applyRuleWithArgs(rewrite)'), 
                  'tooltip'="Change the form of the limit expression: Enter the substitution equations")
              ), # BoxCell
              BoxCell('halign'='left',
                Button['B_change'](" Change ", lc, 
                  'onclick'=Evaluate('function'='applyRuleWithArgs(change)'), 
                  'tooltip'="Change the variable of the limit: Enter the relationship equation between the current and new variables")
              ) # BoxCell
            ) # BoxRow

          ) # end BoxColumn        

        ) # end BoxColumn 
      ) # end BoxRow

    ) # end BoxColumn
  ), # end Window

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

  Window['mathfuncWin']('resizable'='false',
    'title'="Select a Mathematical Function",
    'defaultbutton'='B_close2',
    BoxColumn(bc, 

      BoxRow('border'='true', 'inset'=1, 'spacing'=5, bc, 
        'caption'="Exponential and Logarithmic Functions", 
        Button['B_exp']("Natural Exponential", lc,
          'onclick'=Action(
             SetOption('TF_mathfunc'="exp"),
             CloseWindow('mathfuncWin'), 
             Evaluate('function'='applyRule(exp)')) 
        ), # end Button exp
        Button['B_ln']("Natural Logarithm", lc,
          'onclick'=Action(
             SetOption('TF_mathfunc'="ln"),
             CloseWindow('mathfuncWin'), 
             Evaluate('function'='applyRule(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'=Action(
               SetOption('TF_mathfunc'="sin"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(sin)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_cos']("   cos    ", lc,
            'onclick'=Action(
              SetOption('TF_mathfunc'="cos"),
              CloseWindow('mathfuncWin'), 
              Evaluate('function'='applyRule(cos)')) 
          )), # end Button/GridCell
          GridCell(Button['B_tan']("   tan    ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="tan"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(tan)') )  
          )), # end Button/GridCell
          GridCell(Button['B_cot']("   cot    ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="cot"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(cot)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_sec']("   sec    ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="sec"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(sec)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_csc']("   csc    ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="csc"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(csc)') ) 
          )) # end Button/GridCell
        ), # end GridRow
     
        GridRow(
          GridCell(Button['B_arcsin'](" arcsin ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="arcsin"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(arcsin)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_arccos'](" arccos ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="arccos"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(arccos)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_arctan'](" arctan ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="arctan"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(arctan)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_arccot'](" arccot ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="arccot"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(arccot)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_arcsec'](" arcsec ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="arcsec"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(arcsec)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_arccsc'](" arccsc ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="arccsc"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(arccsc)') ) 
          )) # end Button/GridCell
        ), # end GridRow
   
        GridRow(
          GridCell(Button['B_sinh']("  sinh   ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="sinh"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(sinh)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_cosh']("  cosh   ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="cosh"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(cosh)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_tanh']("  tanh   ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="tanh"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(tanh)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_coth']("  coth   ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="coth"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(coth)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_sech']("  sech   ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="sech"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(sech)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_csch']("  csch   ", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="csch"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(csch)') ) 
          )) # end Button/GridCell
        ), # end GridRow

        GridRow(
          GridCell(Button['B_arcsinh']("arcsinh", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="arcsinh"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(arcsinh)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_arccosh']("arccosh", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="arccosh"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(arccosh)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_arctanh']("arctanh", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="arctanh"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(arctanh)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_arccoth']("arccoth", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="arccoth"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(arccoth)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_arcsech']("arcsech", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="arcsech"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(arcsech)') ) 
          )), # end Button/GridCell
          GridCell(Button['B_arccsch']("arccsch", lc,
            'onclick'=Action(
               SetOption('TF_mathfunc'="arccsch"),
               CloseWindow('mathfuncWin'), 
               Evaluate('function'='applyRule(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),
        Button['B_other']("Apply",'onclick'='A_other', lc)
      ), # end BoxRow

      BoxRow( Button['B_close2']("Close",CloseWindow('mathfuncWin'), lc), bc )

    ) # end BoxColumn
  ), # end Window
 
############################################################

  Window['cmdWin']('defaultbutton'='closeCmdWin',
    'title'="Descriptions of l'Hopital's, Rewrite, and Change Rules",
    'resizable'='false',
    BoxColumn('inset'=0, 'spacing'=0, bc, 
      BoxColumn('inset'=0, 'spacing'=3, bc, 
        BoxCell(
          TextBox['TB_cmd']('height'=12, 'width'=40, lc,  
            'editable'='false', 
            'value'="Click the button below to see the corresponding description."
          ) # end TextBox
        ) # end BoxCell
      ), # end BoxColumn 
      BoxRow('inset'=10, 'spacing'=0, bc,
         Button['closeCmdWin']("Close", CloseWindow('cmdWin'), lc) 
      ) # end BoxRow
    ) # end BoxColumn 
  ), # end Window

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

  Window['ruleWin'](
    'title'="Limit Rule", 'resizable'='false',
    BoxColumn('inset'=0, 'spacing'=10, bc,  
      BoxRow('inset'=0, 'spacing'=0, bc, 
         MathMLViewer['ML_rule']('width'=375, lc) 
      ), # end BoxRow
      BoxRow('inset'=0, 'spacing'=0, bc, 
        Button("Close",CloseWindow('ruleWin'), lc)
      ) # end BoxRow
    ) # end BoxColumn
  ), # end ruleWin

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

  Window['helpWin']( 'resizable'='false',
    'title'="Using the Step-by-Step Limit 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['limMB'](

    Menu("File",
      MenuItem("Start to Solve", 
        'onclick'=Evaluate('function'='startRule()')),
      MenuItem("Final Answer", 
        'onclick'=Evaluate('function'='getFinalAnswer()')),
      MenuItem("Show All Steps", 
        'onclick'=Evaluate('function'='showAllSteps()')),
      MenuSeparator(),
      MenuItem("Obtain a Hint", 
        'onclick'=Evaluate('function'='getHint()')),
      MenuItem("Apply the Hint", 
        'onclick'=Evaluate('function'='applyHint()')),
      MenuSeparator(),
      MenuItem("Clear", 
        'onclick'=Evaluate('function'='clearSteps()')),
      MenuSeparator(),
      MenuItem("Close", Shutdown())
    ), # end Menu/File
   
    Menu("Rule Definition",
      MenuItem("Constant Rule", 'onclick'='A_i_constant'),
      MenuItem("Constant Multiple Rule", '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'),
      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(),
      Menu("Rules with Arguments", 
        MenuItem("L'Hopital's",
          'onclick'='A_i_lhopitals'),   
        MenuItem("Rewrite",
          'onclick'='A_i_rewrite'),
        MenuItem("Change",
          'onclick'='A_i_change')
       ) # end Menu/Rules with Arguments

    ), # end Menu/Rule Definition
 



   Menu("Apply the Rule",
      MenuItem("Constant Rule", 
        'onclick'=Evaluate('function'='applyRule(constant)')),
      MenuItem("Constant Multiple Rule", 
        'onclick'=Evaluate('function'='applyRule(constantmultiple)')),
      MenuSeparator(),
      MenuItem("Identity Rule", 
        'onclick'=Evaluate('function'='applyRule(identity)')),
      MenuItem("Power Rule", 
        'onclick'=Evaluate('function'='applyRule(power)')),
      MenuSeparator(),
      MenuItem("Sum Rule", 
        'onclick'=Evaluate('function'='applyRule(sum)')),
      MenuItem("Difference Rule", 
        'onclick'=Evaluate('function'='applyRule(difference)')),
      MenuSeparator(),
      MenuItem("Product Rule", 
        'onclick'=Evaluate('function'='applyRule(product)')),
      MenuItem("Quotient Rule", 
        'onclick'=Evaluate('function'='applyRule(quotient)')),
      MenuSeparator(),
      MenuItem("Natural Exponential",
        'onclick'=Evaluate('function'='applyRule(exp)')),
      MenuItem("Natural Logorithm", 
        'onclick'=Evaluate('function'='applyRule(ln)')),
      MenuSeparator(),
      Menu("Trigonometric Functions",
        MenuItem("sin",
          'onclick'=Evaluate('function'='applyRule(sin)')),
        MenuItem("cos",
          'onclick'=Evaluate('function'='applyRule(cos)')),
        MenuItem("tan",
          'onclick'=Evaluate('function'='applyRule(tan)')),
        MenuItem("cot",
          'onclick'=Evaluate('function'='applyRule(cot)')),
        MenuItem("sec",
          'onclick'=Evaluate('function'='applyRule(sec)')),
        MenuItem("csc",
          'onclick'=Evaluate('function'='applyRule(csc)'))
      ), # end Menu/Trig
      Menu("Inverse Trigonometric Functions",
        MenuItem("arcsin",
          'onclick'=Evaluate('function'='applyRule(arcsin)')),
        MenuItem("arccos",
          'onclick'=Evaluate('function'='applyRule(arccos)')),
        MenuItem("arctan",
          'onclick'=Evaluate('function'='applyRule(arctan)')),
        MenuItem("arccot",
          'onclick'=Evaluate('function'='applyRule(arccot)')),
        MenuItem("arcsec",
          'onclick'=Evaluate('function'='applyRule(arcsec)')),
        MenuItem("arccsc",
          'onclick'=Evaluate('function'='applyRule(arccsc)'))
      ), # end Menu/Inverse Trig
      Menu("Hyperbolic Functions",
        MenuItem("sinh",
          'onclick'=Evaluate('function'='applyRule(sinh)')),
        MenuItem("cosh",
          'onclick'=Evaluate('function'='applyRule(cosh)')),
        MenuItem("tanh",
          'onclick'=Evaluate('function'='applyRule(tanh)')),
        MenuItem("coth",
          'onclick'=Evaluate('function'='applyRule(coth)')),
        MenuItem("sech",
          'onclick'=Evaluate('function'='applyRule(sech)')),
        MenuItem("csch",
          'onclick'=Evaluate('function'='applyRule(csch)'))
      ), # end Menu/Hyperbolic 
      Menu("Inverse Hyperbolic Functions",
        MenuItem("arcsinh",
          'onclick'=Evaluate('function'='applyRule(arcsinh)')),
        MenuItem("arccosh",
          'onclick'=Evaluate('function'='applyRule(arccosh)')),
        MenuItem("arctanh",
          'onclick'=Evaluate('function'='applyRule(arctanh)')),
        MenuItem("arccoth",
          'onclick'=Evaluate('function'='applyRule(arccoth)')),
        MenuItem("arcsech",
          'onclick'=Evaluate('function'='applyRule(arcsech)')),
        MenuItem("arccsch",
          'onclick'=Evaluate('function'='applyRule(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 Rule",
        'onclick'=Evaluate('function'=         
        'changeUnderstoodRules(constantmultiple,CMI_constantmultiple)') ),
      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_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_product']("Product Rule", 
        'onclick'=Evaluate('function'='changeUnderstoodRules(product,CMI_product)') ),
      CheckBoxMenuItem['CMI_quotient']("Quotient Rule", 
        'onclick'=Evaluate('function'='changeUnderstoodRules(quotient,CMI_quotient)') ),
      MenuSeparator(),

      CheckBoxMenuItem['CMI_exp']("Natural Exponential",  
        'onclick'=Evaluate('function'='changeUnderstoodRules(exp,CMI_exp)') ),
      CheckBoxMenuItem['CMI_ln']("Natural Logarithm", 
        '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",
      MenuItem("Using this Maplet", 'onclick'=RunWindow('helpWin'))
    ) # end Menu/Help

  ), # end MenuBar

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

  Action['A_other'](
    SetOption('target'='TF_mathfunc',Argument('TF_other')),
    CloseWindow('mathfuncWin'), 
    Evaluate('function'='applyOtherRule()')  
  ), # end A_other

  Action['A_mathfunc'](
    Evaluate('function'='applyMathFuncRule()')  
  ), # end A_mathfunc

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

  Action['A_i_constant'](
    Evaluate('function'='aboutRule(constant, c)'),
    RunWindow('ruleWin')
  ), # end A_i_constant
 
  Action['A_i_constantmultiple'](
    Evaluate('function'='aboutRule(constantmultiple, c*f(x))'),
    RunWindow('ruleWin')
  ), # end A_i_constantmultiple
  
  Action['A_i_sum'](
    Evaluate('function'='aboutRule(sum,f(x)+g(x))'),
    RunWindow('ruleWin')  
  ), # end A_i_sum

  Action['A_i_difference'](
    Evaluate('function'='aboutRule(difference,f(x)-g(x))'),
    RunWindow('ruleWin')  
  ), # end A_i_difference
  
  Action['A_i_identity'](
    Evaluate('function'='aboutRule(identity,x)'),
    RunWindow('ruleWin')
  ), # end A_i_identity
  
  Action['A_i_power'](
    Evaluate('function'='aboutRule(power,x^n)'),
    RunWindow('ruleWin')
  ), # end A_i_power

  Action['A_i_product'](
    Evaluate('function'='aboutRule(product,f(x)*g(x))'),
    RunWindow('ruleWin')
  ), # end A_i_product

  Action['A_i_quotient'](
    Evaluate('function'='aboutRule(quotient,f(x)/g(x))'),
    RunWindow('ruleWin')
  ), # end A_i_quotient

  Action['A_i_exp'](
    Evaluate('function'='aboutRule(exp,exp(x))'),
    RunWindow('ruleWin')
  ), # end A_i_exp

  Action['A_i_ln'](
    Evaluate('function'='aboutRule(ln,ln(x))'),
    RunWindow('ruleWin')
  ), # end A_i_ln

  Action['A_i_sin'](
    Evaluate('function'='aboutRule(sin,sin(x))'),
    RunWindow('ruleWin')
  ), # end A_i_sin

  Action['A_i_cos'](
    Evaluate('function'='aboutRule(cos,cos(x))'),
    RunWindow('ruleWin')
  ), # end A_cos

  Action['A_i_tan'](
    Evaluate('function'='aboutRule(tan,tan(x))'),
    RunWindow('ruleWin')
  ), # end A_i_tan

  Action['A_i_cot'](
    Evaluate('function'='aboutRule(cot,cot(x))'),
    RunWindow('ruleWin')
  ), # end A_i_cot

  Action['A_i_sec'](
    Evaluate('function'='aboutRule(sec,sec(x))'),
    RunWindow('ruleWin')
  ), # end A_i_sec

  Action['A_i_csc'](
    Evaluate('function'='aboutRule(csc,csc(x))'),
    RunWindow('ruleWin')
  ), # end A_i_csc

  Action['A_i_arcsin'](
    Evaluate('function'='aboutRule(arcsin,arcsin(x))'),
    RunWindow('ruleWin')
  ), # end A_i_arcsin

  Action['A_i_arccos'](
    Evaluate('function'='aboutRule(arccos,arccos(x))'),
    RunWindow('ruleWin')
  ), # end A_i_cos

  Action['A_i_arctan'](
    Evaluate('function'='aboutRule(arctan,arctan(x))'),
    RunWindow('ruleWin')
  ), # end A_i_arctan

  Action['A_i_arccot'](
    Evaluate('function'='aboutRule(arccot,arccot(x))'),
    RunWindow('ruleWin')
  ), # end A_i_arccot

  Action['A_i_arcsec'](
    Evaluate('function'='aboutRule(arcsec,arcsec(x))'),
    RunWindow('ruleWin')
  ), # end A_i_arcsec

  Action['A_i_arccsc'](
    Evaluate('function'='aboutRule(arccsc,arccsc(x))'),
    RunWindow('ruleWin')
  ), # end A_i_arccsc

  Action['A_i_sinh'](
    Evaluate('function'='aboutRule(sinh,sinh(x))'),
    RunWindow('ruleWin')
  ), # end A_i_sinh

  Action['A_i_cosh'](
    Evaluate('function'='aboutRule(cosh,cosh(x))'),
    RunWindow('ruleWin')
  ), # end A_i_cosh

  Action['A_i_tanh'](
    Evaluate('function'='aboutRule(tanh,tanh(x))'),
    RunWindow('ruleWin')
  ), # end A_i_tanh

  Action['A_i_coth'](
    Evaluate('function'='aboutRule(coth,coth(x))'),
    RunWindow('ruleWin')
  ), # end A_i_coth

  Action['A_i_sech'](
    Evaluate('function'='aboutRule(sech,sech(x))'),
    RunWindow('ruleWin')
  ), # end A_i_sech

  Action['A_i_csch'](
    Evaluate('function'='aboutRule(csch,csch(x))'),
    RunWindow('ruleWin')
  ), # end A_i_csch

  Action['A_i_arcsinh'](
    Evaluate('function'='aboutRule(arcsinh,arcsinh(x))'),
    RunWindow('ruleWin')
  ), # end A_i_arcsinh

  Action['A_i_arccosh'](
    Evaluate('function'='aboutRule(arccosh,arccosh(x))'),
    RunWindow('ruleWin')
  ), # end A_i_cosh

  Action['A_i_arctanh'](
    Evaluate('function'='aboutRule(arctanh,arctanh(x))'),
    RunWindow('ruleWin')
  ), # end A_i_arctanh

  Action['A_i_arccoth'](
    Evaluate('function'='aboutRule(arccoth,arccoth(x))'),
    RunWindow('ruleWin')
  ), # end A_i_arccoth

  Action['A_i_arcsech'](
    Evaluate('function'='aboutRule(arcsech,arcsech(x))'),
    RunWindow('ruleWin')
  ), # end A_i_arcsech

  Action['A_i_arccsch'](
    Evaluate('function'='aboutRule(arccsch,arccsch(x))'),
    RunWindow('ruleWin')
  ), # end A_i_arccsch

  Action[A_i_lhopitals](
    RunWindow(cmdWin),
    SetOption('cmdWin(title)'="L'Hopital's rule"),
    SetOption('TB_cmd'=lhopitalStr)
   ), # end A_i_lhopitals

  Action[A_i_rewrite](
    RunWindow(cmdWin),
    SetOption('cmdWin(title)'="Rewrite rule"),
    SetOption('TB_cmd'=rewriteStr)
   ), # end A_i_rewrite

  Action[A_i_change](
    RunWindow(cmdWin),
    SetOption('cmdWin(title)'="Change rule"),
    SetOption('TB_cmd'=changeStr)
   ), # end A_i_change

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

  Action['A']()

):  # end maplet

Understand(Limit,none) :
Maplets[Display](maplet) :

end use: # end use
end proc: # end runLimMaplet

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

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

end module: # end LimMaplet()
LimMaplet:-runLimMaplet();

#