Initial population.

1 files changed, 648 insertions, 0 deletions

diff --git a/src/algebra/routines.spad.pamphlet b/src/algebra/routines.spad.pamphlet
new file mode 100644
index 00000000..c491b23d
--- /dev/null
+++ b/src/algebra/routines.spad.pamphlet
@@ -0,0 +1,648 @@
+\documentclass{article}
+\usepackage{axiom}
+\begin{document}
+\title{\$SPAD/src/algebra routines.spad}
+\author{Brian Dupee}
+\maketitle
+\begin{abstract}
+\end{abstract}
+\eject
+\tableofcontents
+\eject
+\section{domain ROUTINE RoutinesTable}
+<<domain ROUTINE RoutinesTable>>=
+)abbrev domain ROUTINE RoutinesTable
+++ Author: Brian Dupee
+++ Date Created: August 1994
+++ Date Last Updated: December 1997
+++ Basic Operations: routines, getMeasure
+++ Related Constructors: TableAggregate(Symbol,Any)
+++ Description:
+++ \axiomType{RoutinesTable} implements a database and associated tuning
+++ mechanisms for a set of known NAG routines
+RoutinesTable(): E == I where
+  F	==> Float
+  ST	==> String
+  LST	==> List String
+  Rec	==> Record(key:Symbol,entry:Any)
+  RList	==> List(Record(key:Symbol,entry:Any))
+  IFL	==> List(Record(ifail:Integer,instruction:ST))
+  Entry	==> Record(chapter:ST, type:ST, domainName: ST, 
+                     defaultMin:F, measure:F, failList:IFL, explList:LST)
+
+  E ==> TableAggregate(Symbol,Any) with
+
+    concat:(%,%) -> %
+      ++ concat(x,y) merges two tables x and y
+    routines:() -> %
+      ++ routines() initialises a database of known NAG routines
+    selectIntegrationRoutines:% -> % 
+      ++ selectIntegrationRoutines(R) chooses only those routines from 
+      ++ the database which are for integration
+    selectOptimizationRoutines:% -> % 
+      ++ selectOptimizationRoutines(R) chooses only those routines from 
+      ++ the database which are for integration
+    selectPDERoutines:% -> % 
+      ++ selectPDERoutines(R) chooses only those routines from the 
+      ++ database which are for the solution of PDE's
+    selectODEIVPRoutines:% -> % 
+      ++ selectODEIVPRoutines(R) chooses only those routines from the 
+      ++ database which are for the solution of ODE's
+    selectFiniteRoutines:% -> % 
+      ++ selectFiniteRoutines(R) chooses only those routines from the 
+      ++ database which are designed for use with finite expressions
+    selectSumOfSquaresRoutines:% -> % 
+      ++ selectSumOfSquaresRoutines(R) chooses only those routines from the 
+      ++ database which are designed for use with sums of squares
+    selectNonFiniteRoutines:% -> % 
+      ++ selectNonFiniteRoutines(R) chooses only those routines from the 
+      ++ database which are designed for use with non-finite expressions.
+    selectMultiDimensionalRoutines:% -> %
+      ++ selectMultiDimensionalRoutines(R) chooses only those routines from 
+      ++ the database which are designed for use with multi-dimensional
+      ++ expressions
+    changeThreshhold:(%,Symbol,F) -> %
+      ++ changeThreshhold(R,s,newValue) changes the value below which, 
+      ++ given a NAG routine generating a higher measure, the routines will 
+      ++ make no attempt to generate a measure.
+    changeMeasure:(%,Symbol,F) -> %
+      ++ changeMeasure(R,s,newValue) changes the maximum value for a 
+      ++ measure of the given NAG routine.
+    getMeasure:(%,Symbol) -> F
+      ++ getMeasure(R,s) gets the current value of the maximum measure for 
+      ++ the given NAG routine.
+    getExplanations:(%,ST) -> LST
+      ++ getExplanations(R,s) gets the explanations of the output parameters for 
+      ++ the given NAG routine.
+    deleteRoutine!:(%,Symbol) -> %
+      ++ deleteRoutine!(R,s) destructively deletes the given routine from 
+      ++ the current database of NAG routines
+    showTheRoutinesTable:() -> %
+      ++ showTheRoutinesTable() returns the current table of NAG routines.
+    recoverAfterFail:(%,ST,Integer) ->  Union(ST,"failed")
+      ++ recoverAfterFail(routs,routineName,ifailValue) acts on the 
+      ++ instructions given by the ifail list
+    finiteAggregate
+
+  I ==> Result add
+
+    Rep := Result
+    import Rep
+
+    theRoutinesTable:% := routines()
+
+    showTheRoutinesTable():% == theRoutinesTable
+
+    integrationRoutine?(r:Record(key:Symbol,entry:Any)):Boolean ==
+      (a := retractIfCan(r.entry)$AnyFunctions1(Entry)) case Entry =>
+        elt(a,chapter) = "Integration"
+      false
+
+    selectIntegrationRoutines(R:%):% == select(integrationRoutine?,R)
+     
+    optimizationRoutine?(r:Record(key:Symbol,entry:Any)):Boolean ==
+      (a := retractIfCan(r.entry)$AnyFunctions1(Entry)) case Entry =>
+        elt(a,chapter) = "Optimization"
+      false
+
+    selectOptimizationRoutines(R:%):% == select(optimizationRoutine?,R)
+     
+    PDERoutine?(r:Record(key:Symbol,entry:Any)):Boolean ==
+      (a := retractIfCan(r.entry)$AnyFunctions1(Entry)) case Entry =>
+        elt(a,chapter) = "PDE"
+      false
+
+    selectPDERoutines(R:%):% == select(PDERoutine?,R)
+     
+    ODERoutine?(r:Record(key:Symbol,entry:Any)):Boolean ==
+      (a := retractIfCan(r.entry)$AnyFunctions1(Entry)) case Entry =>
+        elt(a,chapter) = "ODE"
+      false
+
+    selectODEIVPRoutines(R:%):% == select(ODERoutine?,R)
+     
+    sumOfSquaresRoutine?(r:Record(key:Symbol,entry:Any)):Boolean ==
+      (a := retractIfCan(r.entry)$AnyFunctions1(Entry)) case Entry =>
+        elt(a,type) = "SS"
+      false
+
+    selectSumOfSquaresRoutines(R:%):% == select(sumOfSquaresRoutine?,R)
+
+    finiteRoutine?(r:Record(key:Symbol,entry:Any)):Boolean ==
+      (a := retractIfCan(r.entry)$AnyFunctions1(Entry)) case Entry =>
+        elt(a,type) = "One-dimensional finite"
+      false
+
+    selectFiniteRoutines(R:%):% == select(finiteRoutine?,R)
+
+    infiniteRoutine?(r:Record(key:Symbol,entry:Any)):Boolean ==
+      (a := retractIfCan(r.entry)$AnyFunctions1(Entry)) case Entry =>
+        elt(a,type) = "One-dimensional infinite"
+      false
+
+    semiInfiniteRoutine?(r:Record(key:Symbol,entry:Any)):Boolean ==
+      (a := retractIfCan(r.entry)$AnyFunctions1(Entry)) case Entry =>
+        elt(a,type) = "One-dimensional semi-infinite"
+      false
+
+    nonFiniteRoutine?(r:Record(key:Symbol,entry:Any)):Boolean ==
+      (semiInfiniteRoutine?(r) or infiniteRoutine?(r))
+
+    selectNonFiniteRoutines(R:%):% == select(nonFiniteRoutine?,R)
+
+    multiDimensionalRoutine?(r:Record(key:Symbol,entry:Any)):Boolean ==
+      (a := retractIfCan(r.entry)$AnyFunctions1(Entry)) case Entry =>
+        elt(a,type) = "Multi-dimensional"
+      false
+
+    selectMultiDimensionalRoutines(R:%):% == select(multiDimensionalRoutine?,R)
+
+    concat(a:%,b:%):% ==
+      membersOfa := (members(a)@List(Record(key:Symbol,entry:Any)))
+      membersOfb := (members(b)@List(Record(key:Symbol,entry:Any)))
+      allMembers:=
+        concat(membersOfa,membersOfb)$List(Record(key:Symbol,entry:Any))
+      construct(allMembers)
+
+    changeThreshhold(R:%,s:Symbol,newValue:F):% ==
+      (a := search(s,R)) case Any =>
+        e := retract(a)$AnyFunctions1(Entry)
+        e.defaultMin := newValue
+        a := coerce(e)$AnyFunctions1(Entry)
+        insert!([s,a],R)
+      error("changeThreshhold","Cannot find routine of that name")$ErrorFunctions
+      
+    changeMeasure(R:%,s:Symbol,newValue:F):% ==
+      (a := search(s,R)) case Any =>
+        e := retract(a)$AnyFunctions1(Entry)
+        e.measure := newValue
+        a := coerce(e)$AnyFunctions1(Entry)
+        insert!([s,a],R)
+      error("changeMeasure","Cannot find routine of that name")$ErrorFunctions
+      
+    getMeasure(R:%,s:Symbol):F ==
+      (a := search(s,R)) case Any =>
+        e := retract(a)$AnyFunctions1(Entry)
+        e.measure
+      error("getMeasure","Cannot find routine of that name")$ErrorFunctions
+
+    deleteRoutine!(R:%,s:Symbol):% ==
+      (a := search(s,R)) case Any =>
+        e:Record(key:Symbol,entry:Any) := [s,a]
+        remove!(e,R)
+      error("deleteRoutine!","Cannot find routine of that name")$ErrorFunctions
+
+    routines():% ==
+      f := "One-dimensional finite"
+      s := "One-dimensional semi-infinite"
+      i := "One-dimensional infinite"
+      m := "Multi-dimensional"
+      int := "Integration"
+      ode := "ODE"
+      pde := "PDE"
+      opt := "Optimization"
+      d01ajfExplList:LST := ["result:  Calculated value of the integral",
+                                 "iw:  iw(1) contains the actual number of sub-intervals used, the rest is workspace",
+                                  "w:  contains the end-points of the sub-intervals used along with the integral contributions and error estimates over the sub-intervals",
+                                   "abserr:  the estimate of the absolute error of the result",
+                                    "ifail:  the error warning parameter",
+                                     "method:  details of the method used and measures of all methods",
+                                      "attributes:  a list of the attributes pertaining to the integrand which had some bearing on the choice of method"]
+      d01asfExplList:LST := ["result:  Calculated value of the integral",
+                                 "iw:  iw(1) contains the actual number of sub-intervals used, the rest is workspace",
+                                  "lst:  contains the actual number of sub-intervals used",
+                                   "erlst:  contains the error estimates over the sub-intervals",
+                                    "rslst:  contains the integral contributions of the sub-intervals",
+                                     "ierlst:  contains the error flags corresponding to the values in rslst",
+                                      "abserr:  the estimate of the absolute error of the result",
+                                       "ifail:  the error warning parameter",
+                                        "method:  details of the method used and measures of all methods",
+                                         "attributes:  a list of the attributes pertaining to the integrand which had some bearing on the choice of method"]
+      d01fcfExplList:LST := ["result:  Calculated value of the integral",
+                                 "acc:  the estimate of the relative error of the result",
+                                  "minpts:  the number of integrand evaluations",
+                                   "ifail:  the error warning parameter",
+                                    "method:  details of the method used and measures of all methods",
+                                     "attributes:  a list of the attributes pertaining to the integrand which had some bearing on the choice of method"]
+      d01transExplList:LST := ["result:  Calculated value of the integral",
+                                   "abserr:  the estimate of the absolute error of the result",
+                                    "method:  details of the method and transformation used and measures of all methods",
+                                     "d01***AnnaTypeAnswer:  the individual results from the routines",
+                                      "attributes:  a list of the attributes pertaining to the integrand which had some bearing on the choice of method"]
+      d02bhfExplList:LST := ["x:  the value of x at the end of the calculation",
+                                  "y:  the computed values of Y\[1\]..Y\[n\] at x",
+                                   "tol:   the (possible) estimate of the error; this is not guarunteed",
+                                    "ifail:  the error warning parameter",
+                                     "method:  details of the method used and measures of all methods",
+                                      "intensityFunctions:  a list of the attributes and values pertaining to the ODE which had some bearing on the choice of method"]
+      d02bbfExplList:LST := concat(["result:  the computed values of the solution at the required points"],d02bhfExplList)$LST
+      d03eefExplList:LST := ["See the NAG On-line Documentation for D03EEF/D03EDF",
+                                  "u:  the computed solution u[i][j] is returned in u(i+(j-1)*ngx),for i = 1,2,..ngx; j = 1,2,..ngy"]
+      e04fdfExplList:LST := ["x:  the position of the minimum",
+                                  "objf:  the value of the objective function at x",
+                                   "ifail:  the error warning parameter",
+                                    "method:  details of the method used and measures of all methods",
+                                      "attributes:  a list of the attributes pertaining to the function or functions which had some bearing on the choice of method"]
+      e04dgfExplList:LST := concat(e04fdfExplList,
+                                        ["objgrd:  the values of the derivatives at x",
+                                          "iter:  the number of iterations performed"])$LST
+      e04jafExplList:LST := concat(e04fdfExplList,
+                                        ["bu:  the values of the upper bounds used",
+                                          "bl:  the values of the lower bounds used"])$LST
+      e04ucfExplList:LST := concat(e04dgfExplList,
+                                        ["istate:  the status of every constraint at x",
+                                          "clamda:  the QP multipliers for the last QP sub-problem",
+                                           "For other output parameters see the NAG On-line Documentation for E04UCF"])$LST
+      e04mbfExplList:LST := concat(e04fdfExplList,
+                                        ["istate:  the status of every constraint at x",
+                                          "clamda:  the Lagrange multipliers for each constraint"])$LST
+      d01ajfIfail:IFL := [[1,"incrFunEvals"], [2,"delete"], [3,"delete"], [4,"delete"],  
+                          [5,"delete"], [6,"delete"]]
+      d01akfIfail:IFL := [[1,"incrFunEvals"], [2,"delete"], [3,"delete"], [4,"delete"]]
+      d01alfIfail:IFL := [[1,"incrFunEvals"], [2,"delete"], [3,"delete"], [4,"delete"], 
+                          [5,"delete"], [6,"delete"], [7,"delete"]]
+      d01amfIfail:IFL := [[1,"incrFunEvals"], [2,"delete"], [3,"delete"], [4,"delete"], 
+                          [5,"delete"], [6,"delete"]]
+      d01anfIfail:IFL := [[1,"incrFunEvals"], [2,"delete"], [3,"delete"], [4,"delete"], 
+                          [5,"delete"], [6,"delete"], [7,"delete"]]
+      d01apfIfail:IFL :=
+        [[1,"incrFunEvals"], [2,"delete"], [3,"delete"], [4,"delete"], [5,"delete"]]
+      d01aqfIfail:IFL :=
+        [[1,"incrFunEvals"], [2,"delete"], [3,"delete"], [4,"delete"], [5,"delete"]]
+      d01asfIfail:IFL := [[1,"incrFunEvals"], [2,"delete"], [3,"delete"], [4,"delete"], 
+            [5,"delete"], [6,"delete"], [7,"delete"], [8,"delete"], [9,"delete"]]
+      d01fcfIfail:IFL := [[1,"delete"], [2,"incrFunEvals"], [3,"delete"]]
+      d01gbfIfail:IFL := [[1,"delete"], [2,"incrFunEvals"]]
+      d02bbfIfail:IFL := 
+        [[1,"delete"], [2,"decrease tolerance"], [3,"increase tolerance"],
+         [4,"delete"], [5,"delete"], [6,"delete"], [7,"delete"]]
+      d02bhfIfail:IFL := 
+        [[1,"delete"], [2,"decrease tolerance"], [3,"increase tolerance"],
+         [4,"no action"], [5,"delete"], [6,"delete"], [7,"delete"]]
+      d02cjfIfail:IFL := 
+        [[1,"delete"], [2,"decrease tolerance"], [3,"increase tolerance"],
+         [4,"delete"], [5,"delete"], [6,"no action"], [7,"delete"]]
+      d02ejfIfail:IFL := 
+        [[1,"delete"], [2,"decrease tolerance"], [3,"increase tolerance"],
+         [4,"delete"], [5,"delete"], [6,"no action"], [7,"delete"], [8,"delete"],
+          [9,"delete"]]
+      e04dgfIfail:IFL := [[3,"delete"], [4,"no action"], [6,"delete"], 
+                          [7,"delete"], [8,"delete"], [9,"delete"]]
+      e04fdfIfail:IFL := 
+        [[1,"delete"], [2,"delete"], [3,"delete"], [4,"delete"], 
+          [5,"no action"], [6,"no action"], [7,"delete"], [8,"delete"]]
+      e04gcfIfail:IFL := [[1,"delete"], [2,"delete"], [3,"delete"], [4,"delete"], 
+        [5,"no action"], [6,"no action"], [7,"delete"], [8,"delete"], [9,"delete"]]
+      e04jafIfail:IFL := [[1,"delete"], [2,"delete"], [3,"delete"], [4,"delete"], 
+        [5,"no action"], [6,"no action"], [7,"delete"], [8,"delete"], [9,"delete"]]
+      e04mbfIfail:IFL := 
+        [[1,"delete"], [2,"delete"], [3,"delete"], [4,"delete"], [5,"delete"]]
+      e04nafIfail:IFL := 
+        [[1,"delete"], [2,"delete"], [3,"delete"], [4,"delete"], [5,"delete"],
+          [6,"delete"], [7,"delete"], [8,"delete"], [9,"delete"]]
+      e04ucfIfail:IFL := [[1,"delete"], [2,"delete"], [3,"delete"], [4,"delete"], 
+        [5,"delete"], [6,"delete"], [7,"delete"], [8,"delete"], [9,"delete"]]
+      d01ajfEntry:Entry := [int, f, "d01ajfAnnaType",0.4,0.4,d01ajfIfail,d01ajfExplList]
+      d01akfEntry:Entry := [int, f, "d01akfAnnaType",0.6,1.0,d01akfIfail,d01ajfExplList]
+      d01alfEntry:Entry := [int, f, "d01alfAnnaType",0.6,0.6,d01alfIfail,d01ajfExplList]
+      d01amfEntry:Entry := [int, i, "d01amfAnnaType",0.5,0.5,d01amfIfail,d01ajfExplList]
+      d01anfEntry:Entry := [int, f, "d01anfAnnaType",0.6,0.9,d01anfIfail,d01ajfExplList]
+      d01apfEntry:Entry := [int, f, "d01apfAnnaType",0.7,0.7,d01apfIfail,d01ajfExplList]
+      d01aqfEntry:Entry := [int, f, "d01aqfAnnaType",0.6,0.7,d01aqfIfail,d01ajfExplList]
+      d01asfEntry:Entry := [int, s, "d01asfAnnaType",0.6,0.9,d01asfIfail,d01asfExplList]
+      d01transEntry:Entry:=[int, i, "d01TransformFunctionType",0.6,0.9,[],d01transExplList]
+      d01gbfEntry:Entry := [int, m, "d01gbfAnnaType",0.6,0.6,d01gbfIfail,d01fcfExplList]
+      d01fcfEntry:Entry := [int, m, "d01fcfAnnaType",0.5,0.5,d01fcfIfail,d01fcfExplList]
+      d02bbfEntry:Entry := [ode, "IVP", "d02bbfAnnaType",0.7,0.5,d02bbfIfail,d02bbfExplList]
+      d02bhfEntry:Entry := [ode, "IVP", "d02bhfAnnaType",0.7,0.49,d02bhfIfail,d02bhfExplList]
+      d02cjfEntry:Entry := [ode, "IVP", "d02cjfAnnaType",0.7,0.5,d02cjfIfail,d02bbfExplList]
+      d02ejfEntry:Entry := [ode, "IVP", "d02ejfAnnaType",0.7,0.5,d02ejfIfail,d02bbfExplList]
+      d03eefEntry:Entry := [pde, "2", "d03eefAnnaType",0.6,0.5,[],d03eefExplList]
+      --d03fafEntry:Entry := [pde, "3", "d03fafAnnaType",0.6,0.5,[],[]]
+      e04dgfEntry:Entry := [opt, "CGA", "e04dgfAnnaType",0.4,0.4,e04dgfIfail,e04dgfExplList]
+      e04fdfEntry:Entry := [opt, "SS", "e04fdfAnnaType",0.7,0.7,e04fdfIfail,e04fdfExplList]
+      e04gcfEntry:Entry := [opt, "SS", "e04gcfAnnaType",0.8,0.8,e04gcfIfail,e04fdfExplList]
+      e04jafEntry:Entry := [opt, "QNA", "e04jafAnnaType",0.5,0.5,e04jafIfail,e04jafExplList]
+      e04mbfEntry:Entry := [opt, "LP", "e04mbfAnnaType",0.7,0.7,e04mbfIfail,e04mbfExplList]
+      e04nafEntry:Entry := [opt, "QP", "e04nafAnnaType",0.7,0.7,e04nafIfail,e04mbfExplList]
+      e04ucfEntry:Entry := [opt, "SQP", "e04ucfAnnaType",0.6,0.6,e04ucfIfail,e04ucfExplList]
+      rl:RList :=
+        [["d01apf" :: Symbol, coerce(d01apfEntry)$AnyFunctions1(Entry)],_
+         ["d01aqf" :: Symbol, coerce(d01aqfEntry)$AnyFunctions1(Entry)],_
+         ["d01alf" :: Symbol, coerce(d01alfEntry)$AnyFunctions1(Entry)],_
+         ["d01anf" :: Symbol, coerce(d01anfEntry)$AnyFunctions1(Entry)],_
+         ["d01akf" :: Symbol, coerce(d01akfEntry)$AnyFunctions1(Entry)],_
+         ["d01ajf" :: Symbol, coerce(d01ajfEntry)$AnyFunctions1(Entry)],_
+         ["d01asf" :: Symbol, coerce(d01asfEntry)$AnyFunctions1(Entry)],_
+         ["d01amf" :: Symbol, coerce(d01amfEntry)$AnyFunctions1(Entry)],_
+         ["d01transform" :: Symbol, coerce(d01transEntry)$AnyFunctions1(Entry)],_
+         ["d01gbf" :: Symbol, coerce(d01gbfEntry)$AnyFunctions1(Entry)],_
+         ["d01fcf" :: Symbol, coerce(d01fcfEntry)$AnyFunctions1(Entry)],_
+         ["d02bbf" :: Symbol, coerce(d02bbfEntry)$AnyFunctions1(Entry)],_
+         ["d02bhf" :: Symbol, coerce(d02bhfEntry)$AnyFunctions1(Entry)],_
+         ["d02cjf" :: Symbol, coerce(d02cjfEntry)$AnyFunctions1(Entry)],_
+         ["d02ejf" :: Symbol, coerce(d02ejfEntry)$AnyFunctions1(Entry)],_
+         ["d03eef" :: Symbol, coerce(d03eefEntry)$AnyFunctions1(Entry)],_
+         --["d03faf" :: Symbol, coerce(d03fafEntry)$AnyFunctions1(Entry)],
+         ["e04dgf" :: Symbol, coerce(e04dgfEntry)$AnyFunctions1(Entry)],_
+         ["e04fdf" :: Symbol, coerce(e04fdfEntry)$AnyFunctions1(Entry)],_
+         ["e04gcf" :: Symbol, coerce(e04gcfEntry)$AnyFunctions1(Entry)],_
+         ["e04jaf" :: Symbol, coerce(e04jafEntry)$AnyFunctions1(Entry)],_
+         ["e04mbf" :: Symbol, coerce(e04mbfEntry)$AnyFunctions1(Entry)],_
+         ["e04naf" :: Symbol, coerce(e04nafEntry)$AnyFunctions1(Entry)],_
+         ["e04ucf" :: Symbol, coerce(e04ucfEntry)$AnyFunctions1(Entry)]]
+      construct(rl)
+
+    getIFL(s:Symbol,l:%):Union(IFL,"failed") ==
+      o := search(s,l)$%
+      o case "failed" => "failed"
+      e := retractIfCan(o)$AnyFunctions1(Entry)
+      e case "failed" => "failed"
+      e.failList
+
+    getInstruction(l:IFL,ifailValue:Integer):Union(ST,"failed") ==
+      output := empty()$ST
+      for i in 1..#l repeat
+        if ((l.i).ifail=ifailValue)@Boolean then 
+          output := (l.i).instruction
+      empty?(output)$ST => "failed"
+      output
+
+    recoverAfterFail(routs:%,routineName:ST,
+                      ifailValue:Integer):Union(ST,"failed") ==
+      name := routineName :: Symbol
+      failedList := getIFL(name,routs)
+      failedList case "failed" => "failed"
+      empty? failedList => "failed"
+      instr := getInstruction(failedList,ifailValue)
+      instr case "failed" => concat(routineName," failed")$ST
+      (instr = "delete")@Boolean => 
+        deleteRoutine!(routs,name)
+        concat(routineName," failed - trying alternatives")$ST
+      instr
+
+    getExplanations(R:%,routineName:ST):LST ==
+      name := routineName :: Symbol
+      (a := search(name,R)) case Any => 
+        e := retract(a)$AnyFunctions1(Entry)
+        e.explList
+      empty()$LST
+
+@
+\section{domain ATTRBUT AttributeButtons}
+<<domain ATTRBUT AttributeButtons>>=
+)abbrev domain ATTRBUT AttributeButtons
+++ Author: Brian Dupee
+++ Date Created: April 1996
+++ Date Last Updated: December 1997
+++ Basic Operations: increase, decrease, getButtonValue, setButtonValue
+++ Related Constructors: Table(String,Float)
+++ Description:
+++ \axiomType{AttributeButtons} implements a database and associated
+++ adjustment mechanisms for a set of attributes.
+++
+++ For ODEs these attributes are "stiffness", "stability" (i.e. how much
+++ affect the cosine or sine component of the solution has on the stability of
+++ the result), "accuracy" and "expense" (i.e. how expensive is the evaluation
+++ of the ODE).  All these have bearing on the cost of calculating the 
+++ solution given that reducing the step-length to achieve greater accuracy 
+++ requires considerable number of evaluations and calculations.
+++
+++ The effect of each of these attributes can be altered by increasing or
+++ decreasing the button value.
+++
+++ For Integration there is a button for increasing and decreasing the preset
+++ number of function evaluations for each method.  This is automatically used
+++ by ANNA when a method fails due to insufficient workspace or where the
+++ limit of function evaluations has been reached before the required
+++ accuracy is achieved. 
+++ 
+AttributeButtons(): E == I where
+  F	==> Float
+  ST	==> String
+  LST	==> List String
+  Rec	==> Record(key:Symbol,entry:Any)
+  RList	==> List(Record(key:Symbol,entry:Any))
+  IFL	==> List(Record(ifail:Integer,instruction:ST))
+  Entry	==> Record(chapter:ST, type:ST, domainName: ST, 
+                     defaultMin:F, measure:F, failList:IFL, explList:LST)
+
+
+  E ==> SetCategory with
+
+    increase:(ST,ST) -> F
+      ++ \axiom{increase(routineName,attributeName)} increases the value
+      ++ for the effect of the attribute \axiom{attributeName} with routine 
+      ++ \axiom{routineName}.
+      ++
+      ++ \axiom{attributeName} should be one of the values
+      ++ "stiffness", "stability", "accuracy", "expense" or
+      ++ "functionEvaluations".
+    increase:(ST) -> F
+      ++ \axiom{increase(attributeName)} increases the value for the
+      ++ effect of the attribute \axiom{attributeName} with all routines.
+      ++
+      ++ \axiom{attributeName} should be one of the values
+      ++ "stiffness", "stability", "accuracy", "expense" or
+      ++ "functionEvaluations".
+    decrease:(ST,ST) -> F
+      ++ \axiom{decrease(routineName,attributeName)} decreases the value
+      ++ for the effect of the attribute \axiom{attributeName} with routine
+      ++ \axiom{routineName}.
+      ++
+      ++ \axiom{attributeName} should be one of the values
+      ++ "stiffness", "stability", "accuracy", "expense" or
+      ++ "functionEvaluations".
+    decrease:(ST) -> F
+      ++ \axiom{decrease(attributeName)} decreases the value for the
+      ++ effect of the attribute \axiom{attributeName} with all routines.
+      ++
+      ++ \axiom{attributeName} should be one of the values
+      ++ "stiffness", "stability", "accuracy", "expense" or
+      ++ "functionEvaluations".
+    getButtonValue:(ST,ST) -> F
+      ++ \axiom{getButtonValue(routineName,attributeName)} returns the 
+      ++ current value for the effect of the attribute \axiom{attributeName}  
+      ++ with routine \axiom{routineName}.
+      ++
+      ++ \axiom{attributeName} should be one of the values
+      ++ "stiffness", "stability", "accuracy", "expense" or
+      ++ "functionEvaluations".
+    resetAttributeButtons:() -> Void 
+      ++ \axiom{resetAttributeButtons()} resets the Attribute buttons to a 
+      ++ neutral level.
+    setAttributeButtonStep:(F) -> F
+      ++ \axiom{setAttributeButtonStep(n)} sets the value of the steps for 
+      ++ increasing and decreasing the button values. \axiom{n} must be 
+      ++ greater than 0 and less than 1.  The preset value is 0.5.
+    setButtonValue:(ST,F) -> F
+      ++ \axiom{setButtonValue(attributeName,n)} sets the
+      ++ value of all buttons of attribute \spad{attributeName}
+      ++ to \spad{n}. \spad{n} must be in the range [0..1].
+      ++
+      ++ \axiom{attributeName} should be one of the values
+      ++ "stiffness", "stability", "accuracy", "expense" or
+      ++ "functionEvaluations".
+    setButtonValue:(ST,ST,F) -> F
+      ++ \axiom{setButtonValue(attributeName,routineName,n)} sets the
+      ++ value of the button of attribute \spad{attributeName} to routine
+      ++ \spad{routineName} to \spad{n}. \spad{n} must be in the range [0..1].
+      ++
+      ++ \axiom{attributeName} should be one of the values
+      ++ "stiffness", "stability", "accuracy", "expense" or
+      ++ "functionEvaluations".
+    finiteAggregate
+
+  I ==> add
+
+    Rep := StringTable(F)
+    import Rep
+
+    buttons:() -> $
+
+    buttons():$ == 
+      eList := empty()$List(Record(key:ST,entry:F))
+      l1:List String := ["stability","stiffness","accuracy","expense"]
+      l2:List String := ["functionEvaluations"]
+      ro1 := selectODEIVPRoutines(r := routines()$RoutinesTable)$RoutinesTable
+      ro2 := selectIntegrationRoutines(r)$RoutinesTable
+      k1:List String := [string(i)$Symbol for i in keys(ro1)$RoutinesTable]
+      k2:List String := [string(i)$Symbol for i in keys(ro2)$RoutinesTable]
+      for i in k1 repeat
+        for j in l1 repeat
+          e:Record(key:ST,entry:F) := [i j,0.5]
+          eList := cons(e,eList)$List(Record(key:ST,entry:F))
+      for i in k2 repeat
+        for j in l2 repeat
+          e:Record(key:ST,entry:F) := [i j,0.5]
+          eList := cons(e,eList)$List(Record(key:ST,entry:F))
+      construct(eList)$Rep
+
+    attributeButtons:$ := buttons()
+
+    attributeStep:F := 0.5
+
+    setAttributeButtonStep(n:F):F ==
+      positive?(n)$F and (n<1$F) => attributeStep:F := n
+      error("setAttributeButtonStep","New value must be in (0..1)")$ErrorFunctions
+
+    resetAttributeButtons():Void ==
+      attributeButtons := buttons()
+      void()$Void
+
+    setButtonValue(routineName:ST,attributeName:ST,n:F):F ==
+      f := search(routineName attributeName,attributeButtons)$Rep
+      f case Float => 
+        n>=0$F and n<=1$F => 
+          setelt(attributeButtons,routineName attributeName,n)$Rep
+        error("setAttributeButtonStep","New value must be in [0..1]")$ErrorFunctions
+      error("setButtonValue","attribute name " attributeName 
+             " not found for routine " routineName)$ErrorFunctions
+
+    setButtonValue(attributeName:ST,n:F):F ==
+      ro1 := selectODEIVPRoutines(r := routines()$RoutinesTable)$RoutinesTable
+      ro2 := selectIntegrationRoutines(r)$RoutinesTable
+      l1:List String := ["stability","stiffness","accuracy","expense"]
+      l2:List String := ["functionEvaluations"]
+      if attributeName="functionEvaluations" then
+        for i in keys(ro2)$RoutinesTable repeat
+          setButtonValue(string(i)$Symbol,attributeName,n)
+      else
+        for i in keys(ro1)$RoutinesTable repeat
+          setButtonValue(string(i)$Symbol,attributeName,n)
+      n
+
+    increase(routineName:ST,attributeName:ST):F ==
+      f := search(routineName attributeName,attributeButtons)$Rep
+      f case Float => 
+        newValue:F := (1$F-attributeStep)*f+attributeStep
+        setButtonValue(routineName,attributeName,newValue)
+      error("increase","attribute name " attributeName 
+             " not found for routine " routineName)$ErrorFunctions
+
+    increase(attributeName:ST):F ==
+      ro1 := selectODEIVPRoutines(r := routines()$RoutinesTable)$RoutinesTable
+      ro2 := selectIntegrationRoutines(r)$RoutinesTable
+      l1:List String := ["stability","stiffness","accuracy","expense"]
+      l2:List String := ["functionEvaluations"]
+      if attributeName="functionEvaluations" then
+        for i in keys(ro2)$RoutinesTable repeat
+          increase(string(i)$Symbol,attributeName)
+      else
+        for i in keys(ro1)$RoutinesTable repeat
+          increase(string(i)$Symbol,attributeName)
+      getButtonValue(string(i)$Symbol,attributeName)
+
+    decrease(routineName:ST,attributeName:ST):F ==
+      f := search(routineName attributeName,attributeButtons)$Rep
+      f case Float => 
+        newValue:F := (1$F-attributeStep)*f
+        setButtonValue(routineName,attributeName,newValue)
+      error("increase","attribute name " attributeName 
+             " not found for routine " routineName)$ErrorFunctions
+
+    decrease(attributeName:ST):F ==
+      ro1 := selectODEIVPRoutines(r := routines()$RoutinesTable)$RoutinesTable
+      ro2 := selectIntegrationRoutines(r)$RoutinesTable
+      l1:List String := ["stability","stiffness","accuracy","expense"]
+      l2:List String := ["functionEvaluations"]
+      if attributeName="functionEvaluations" then
+        for i in keys(ro2)$RoutinesTable repeat
+          decrease(string(i)$Symbol,attributeName)
+      else
+        for i in keys(ro1)$RoutinesTable repeat
+          decrease(string(i)$Symbol,attributeName)
+      getButtonValue(string(i)$Symbol,attributeName)
+
+
+    getButtonValue(routineName:ST,attributeName:ST):F == 
+      f := search(routineName attributeName,attributeButtons)$Rep
+      f case Float => f
+      error("getButtonValue","attribute name " attributeName 
+              " not found for routine " routineName)$ErrorFunctions
+
+@
+\section{License}
+<<license>>=
+--Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd.
+--All rights reserved.
+--
+--Redistribution and use in source and binary forms, with or without
+--modification, are permitted provided that the following conditions are
+--met:
+--
+--    - Redistributions of source code must retain the above copyright
+--      notice, this list of conditions and the following disclaimer.
+--
+--    - Redistributions in binary form must reproduce the above copyright
+--      notice, this list of conditions and the following disclaimer in
+--      the documentation and/or other materials provided with the
+--      distribution.
+--
+--    - Neither the name of The Numerical ALgorithms Group Ltd. nor the
+--      names of its contributors may be used to endorse or promote products
+--      derived from this software without specific prior written permission.
+--
+--THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+--IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+--TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+--PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+--OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+--EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+--PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+--PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+--LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+--NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+--SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+@
+<<*>>=
+<<license>>
+
+<<domain ROUTINE RoutinesTable>>
+<<domain ATTRBUT AttributeButtons>>
+@
+\eject
+\begin{thebibliography}{99}
+\bibitem{1} nothing
+\end{thebibliography}
+\end{document}