path: root/src/algebra/annacat.spad.pamphlet

\documentclass{article}
\usepackage{axiom}
\begin{document}
\title{\$SPAD/src/algebra annacat.spad}
\author{Brian Dupee}
\maketitle
\begin{abstract}
\end{abstract}
\eject
\tableofcontents
\eject
\section{domain NIPROB NumericalIntegrationProblem}
<<domain NIPROB NumericalIntegrationProblem>>=
)abbrev domain NIPROB NumericalIntegrationProblem
++ Author: Brian Dupee
++ Date Created: December 1997
++ Date Last Updated: December 1997
++ Basic Operations: coerce, retract
++ Related Constructors: Union
++ Description:
++ \axiomType{NumericalIntegrationProblem} is a \axiom{domain}
++ for the representation of Numerical Integration problems for use
++ by ANNA. 
++
++ The representation is a Union of two record types - one for integration of
++ a function of one variable:
++
++ \axiomType{Record}(var:\axiomType{Symbol},
++ fn:\axiomType{Expression DoubleFloat},
++ range:\axiomType{Segment OrderedCompletion DoubleFloat},
++ abserr:\axiomType{DoubleFloat},
++ relerr:\axiomType{DoubleFloat},)
++
++ and one for multivariate integration:
++
++ \axiomType{Record}(fn:\axiomType{Expression DoubleFloat},
++ range:\axiomType{List Segment OrderedCompletion DoubleFloat},
++ abserr:\axiomType{DoubleFloat},
++ relerr:\axiomType{DoubleFloat},).
++

EDFA   ==> Expression DoubleFloat
SOCDFA ==> Segment OrderedCompletion DoubleFloat
DFA    ==> DoubleFloat
NIAA   ==> Record(var:Symbol,fn:EDFA,range:SOCDFA,abserr:DFA,relerr:DFA)
MDNIAA ==> Record(fn:EDFA,range:List SOCDFA,abserr:DFA,relerr:DFA)
 
NumericalIntegrationProblem():SetCategory with
    coerce: NIAA -> %
      ++ coerce(x) \undocumented{}
    coerce: MDNIAA -> %
      ++ coerce(x) \undocumented{}
    coerce: Union(nia:NIAA,mdnia:MDNIAA) -> %
      ++ coerce(x) \undocumented{}
    coerce: % -> OutputForm
      ++ coerce(x) \undocumented{}
    retract: % -> Union(nia:NIAA,mdnia:MDNIAA)
      ++ retract(x) \undocumented{}

  ==
 
    add
      Rep := Union(nia:NIAA,mdnia:MDNIAA)
 
      coerce(s:NIAA) == [s]
      coerce(s:MDNIAA) == [s]
      coerce(s:Union(nia:NIAA,mdnia:MDNIAA)) == s
      coerce(x:%):OutputForm ==
        (x) case nia => (x.nia)::OutputForm
        (x.mdnia)::OutputForm
      retract(x:%):Union(nia:NIAA,mdnia:MDNIAA) ==
        (x) case nia => [x.nia]
        [x.mdnia]

@
\section{domain ODEPROB NumericalODEProblem}
<<domain ODEPROB NumericalODEProblem>>=
)abbrev domain ODEPROB NumericalODEProblem
++ Author: Brian Dupee
++ Date Created: December 1997
++ Date Last Updated: December 1997
++ Basic Operations: coerce, retract
++ Related Constructors: Union
++ Description:
++ \axiomType{NumericalODEProblem} is a \axiom{domain}
++ for the representation of Numerical ODE problems for use
++ by ANNA. 
++
++ The representation is of type: 
++
++ \axiomType{Record}(xinit:\axiomType{DoubleFloat},
++ xend:\axiomType{DoubleFloat},
++ fn:\axiomType{Vector Expression DoubleFloat},
++ yinit:\axiomType{List DoubleFloat},intvals:\axiomType{List DoubleFloat},
++ g:\axiomType{Expression DoubleFloat},abserr:\axiomType{DoubleFloat},
++ relerr:\axiomType{DoubleFloat})
++

DFB   ==> DoubleFloat
VEDFB ==> Vector Expression DoubleFloat
LDFB  ==> List DoubleFloat
EDFB  ==> Expression DoubleFloat
ODEAB ==> Record(xinit:DFB,xend:DFB,fn:VEDFB,yinit:LDFB,intvals:LDFB,g:EDFB,abserr:DFB,relerr:DFB)
NumericalODEProblem():SetCategory with

    coerce: ODEAB -> %
      ++ coerce(x) \undocumented{}
    coerce: % -> OutputForm
      ++ coerce(x) \undocumented{}
    retract: % -> ODEAB
      ++ retract(x) \undocumented{}

  ==
 
    add
      Rep := ODEAB
 
      coerce(s:ODEAB) == s
      coerce(x:%):OutputForm ==
        (retract(x))::OutputForm
      retract(x:%):ODEAB == x :: Rep

@
\section{domain PDEPROB NumericalPDEProblem}
<<domain PDEPROB NumericalPDEProblem>>=
)abbrev domain PDEPROB NumericalPDEProblem
++ Author: Brian Dupee
++ Date Created: December 1997
++ Date Last Updated: December 1997
++ Basic Operations: coerce, retract
++ Related Constructors: Union
++ Description:
++ \axiomType{NumericalPDEProblem} is a \axiom{domain}
++ for the representation of Numerical PDE problems for use
++ by ANNA. 
++
++ The representation is of type: 
++
++ \axiomType{Record}(pde:\axiomType{List Expression DoubleFloat}, 
++ constraints:\axiomType{List PDEC}, 
++ f:\axiomType{List List Expression DoubleFloat},
++ st:\axiomType{String},
++ tol:\axiomType{DoubleFloat})
++
++ where \axiomType{PDEC} is of type:
++
++ \axiomType{Record}(start:\axiomType{DoubleFloat}, 
++ finish:\axiomType{DoubleFloat},
++ grid:\axiomType{NonNegativeInteger},
++ boundaryType:\axiomType{Integer},
++ dStart:\axiomType{Matrix DoubleFloat}, 
++ dFinish:\axiomType{Matrix DoubleFloat})
++

DFC   ==> DoubleFloat
NNIC  ==> NonNegativeInteger
INTC  ==> Integer
MDFC  ==> Matrix DoubleFloat
PDECC ==> Record(start:DFC, finish:DFC, grid:NNIC, boundaryType:INTC,
                dStart:MDFC, dFinish:MDFC)
LEDFC ==> List Expression DoubleFloat
PDEBC ==> Record(pde:LEDFC, constraints:List PDECC, f:List LEDFC, 
                    st:String, tol:DFC)
NumericalPDEProblem():SetCategory with

    coerce: PDEBC -> %
      ++ coerce(x) \undocumented{}
    coerce: % -> OutputForm
      ++ coerce(x) \undocumented{}
    retract: % -> PDEBC
      ++ retract(x) \undocumented{}

  ==
 
    add
      Rep := PDEBC
 
      coerce(s:PDEBC) == s
      coerce(x:%):OutputForm ==
        (retract(x))::OutputForm
      retract(x:%):PDEBC == x :: Rep

@
\section{domain OPTPROB NumericalOptimizationProblem}
<<domain OPTPROB NumericalOptimizationProblem>>=
)abbrev domain OPTPROB NumericalOptimizationProblem
++ Author: Brian Dupee
++ Date Created: December 1997
++ Date Last Updated: December 1997
++ Basic Operations: coerce, retract
++ Related Constructors: Union
++ Description:
++ \axiomType{NumericalOptimizationProblem} is a \axiom{domain}
++ for the representation of Numerical Optimization problems for use
++ by ANNA. 
++
++ The representation is a Union of two record types - one for otimization of
++ a single function of one or more variables:
++
++ \axiomType{Record}(
++ fn:\axiomType{Expression DoubleFloat},
++ init:\axiomType{List DoubleFloat},
++ lb:\axiomType{List OrderedCompletion DoubleFloat},
++ cf:\axiomType{List Expression DoubleFloat},
++ ub:\axiomType{List OrderedCompletion DoubleFloat})
++
++ and one for least-squares problems i.e. optimization of a set of
++ observations of a data set:
++
++ \axiomType{Record}(lfn:\axiomType{List Expression DoubleFloat},
++ init:\axiomType{List DoubleFloat}).
++

LDFD     ==> List DoubleFloat
LEDFD    ==> List Expression DoubleFloat
LSAD     ==> Record(lfn:LEDFD, init:LDFD)
UNOALSAD ==> Union(noa:NOAD,lsa:LSAD)
EDFD     ==> Expression DoubleFloat
LOCDFD   ==> List OrderedCompletion DoubleFloat
NOAD     ==> Record(fn:EDFD, init:LDFD, lb:LOCDFD, cf:LEDFD, ub:LOCDFD)
NumericalOptimizationProblem():SetCategory with

    coerce: NOAD -> %
      ++ coerce(x) \undocumented{}
    coerce: LSAD -> %
      ++ coerce(x) \undocumented{}
    coerce: UNOALSAD -> %
      ++ coerce(x) \undocumented{}
    coerce: % -> OutputForm
      ++ coerce(x) \undocumented{}
    retract: % -> UNOALSAD
      ++ retract(x) \undocumented{}

  ==
 
    add
      Rep := UNOALSAD
 
      coerce(s:NOAD) == [s]
      coerce(s:LSAD) == [s]
      coerce(x:UNOALSAD) == x
      coerce(x:%):OutputForm ==
        (x) case noa => (x.noa)::OutputForm
        (x.lsa)::OutputForm
      retract(x:%):UNOALSAD ==
        (x) case noa => [x.noa]
        [x.lsa]

@
\section{category NUMINT NumericalIntegrationCategory}
<<category NUMINT NumericalIntegrationCategory>>=
)abbrev category NUMINT NumericalIntegrationCategory
++ Author: Brian Dupee
++ Date Created: February 1994
++ Date Last Updated: March 1996
++ Description:
++ \axiomType{NumericalIntegrationCategory} is the \axiom{category} for 
++ describing the set of Numerical Integration \axiom{domains} with
++ \axiomFun{measure} and \axiomFun{numericalIntegration}.

EDFE   ==> Expression DoubleFloat
SOCDFE ==> Segment OrderedCompletion DoubleFloat
DFE    ==> DoubleFloat
NIAE   ==> Record(var:Symbol,fn:EDFE,range:SOCDFE,abserr:DFE,relerr:DFE)
MDNIAE ==> Record(fn:EDFE,range:List SOCDFE,abserr:DFE,relerr:DFE)
NumericalIntegrationCategory(): Category == SetCategory with

  measure:(RoutinesTable,NIAE)->Record(measure:Float,explanations:String,extra:Result)
    ++ measure(R,args) calculates an estimate of the ability of a particular
    ++ method to solve a problem.  
    ++
    ++ This method may be either a specific NAG routine or a strategy (such
    ++ as transforming the function from one which is difficult to one which
    ++ is easier to solve).
    ++
    ++ It will call whichever agents are needed to perform analysis on the
    ++ problem in order to calculate the measure. There is a parameter,
    ++ labelled \axiom{sofar}, which would contain the best compatibility
    ++ found so far.

  numericalIntegration: (NIAE, Result) -> Result
    ++ numericalIntegration(args,hints) performs the integration of the
    ++ function given the strategy or method returned by \axiomFun{measure}.

  measure:(RoutinesTable,MDNIAE)->Record(measure:Float,explanations:String,extra:Result)
    ++ measure(R,args) calculates an estimate of the ability of a particular
    ++ method to solve a problem.  
    ++
    ++ This method may be either a specific NAG routine or a strategy (such
    ++ as transforming the function from one which is difficult to one which
    ++ is easier to solve).
    ++
    ++ It will call whichever agents are needed to perform analysis on the
    ++ problem in order to calculate the measure. There is a parameter,
    ++ labelled \axiom{sofar}, which would contain the best compatibility
    ++ found so far.

  numericalIntegration: (MDNIAE, Result) -> Result
    ++ numericalIntegration(args,hints) performs the integration of the
    ++ function given the strategy or method returned by \axiomFun{measure}.

@
\section{category ODECAT OrdinaryDifferentialEquationsSolverCategory}
<<category ODECAT OrdinaryDifferentialEquationsSolverCategory>>=
)abbrev category ODECAT OrdinaryDifferentialEquationsSolverCategory
++ Author: Brian Dupee
++ Date Created: February 1995
++ Date Last Updated: June 1995
++ Basic Operations: 
++ Description:
++ \axiomType{OrdinaryDifferentialEquationsSolverCategory} is the 
++ \axiom{category} for describing the set of ODE solver \axiom{domains} 
++ with \axiomFun{measure} and \axiomFun{ODEsolve}.

DFF   ==> DoubleFloat
VEDFF ==> Vector Expression DoubleFloat
LDFF  ==> List DoubleFloat
EDFF  ==> Expression DoubleFloat
ODEAF ==> Record(xinit:DFF,xend:DFF,fn:VEDFF,yinit:LDFF,intvals:LDFF,g:EDFF,abserr:DFF,relerr:DFF)
OrdinaryDifferentialEquationsSolverCategory(): Category == SetCategory with

  measure:(RoutinesTable,ODEAF) -> Record(measure:Float,explanations:String)
    ++ measure(R,args) calculates an estimate of the ability of a particular
    ++ method to solve a problem.  
    ++
    ++ This method may be either a specific NAG routine or a strategy (such
    ++ as transforming the function from one which is difficult to one which
    ++ is easier to solve).
    ++
    ++ It will call whichever agents are needed to perform analysis on the
    ++ problem in order to calculate the measure. There is a parameter,
    ++ labelled \axiom{sofar}, which would contain the best compatibility
    ++ found so far.

  ODESolve: ODEAF -> Result
    ++ ODESolve(args) performs the integration of the
    ++ function given the strategy or method returned by \axiomFun{measure}.

@
\section{category PDECAT PartialDifferentialEquationsSolverCategory}
<<category PDECAT PartialDifferentialEquationsSolverCategory>>=
)abbrev category PDECAT PartialDifferentialEquationsSolverCategory
++ Author: Brian Dupee
++ Date Created: February 1995
++ Date Last Updated: June 1995
++ Basic Operations: 
++ Description:
++ \axiomType{PartialDifferentialEquationsSolverCategory} is the 
++ \axiom{category} for describing the set of PDE solver \axiom{domains} 
++ with \axiomFun{measure} and \axiomFun{PDEsolve}.

-- PDEA	==> Record(xmin:F,xmax:F,ymin:F,ymax:F,ngx:NNI,ngy:NNI,_
--             pde:List Expression Float, bounds:List List Expression Float,_
--             st:String, tol:DF)

--  measure:(RoutinesTable,PDEA) -> Record(measure:F,explanations:String)
--    ++ measure(R,args) calculates an estimate of the ability of a particular
--    ++ method to solve a problem.  
--    ++
--    ++ This method may be either a specific NAG routine or a strategy (such
--    ++ as transforming the function from one which is difficult to one which
--    ++ is easier to solve).
--    ++
--    ++ It will call whichever agents are needed to perform analysis on the
--    ++ problem in order to calculate the measure. There is a parameter,
--    ++ labelled \axiom{sofar}, which would contain the best compatibility
--    ++ found so far.

--  PDESolve: PDEA -> Result
--    ++ PDESolve(args) performs the integration of the
--    ++ function given the strategy or method returned by \axiomFun{measure}.

DFG   ==> DoubleFloat
NNIG  ==> NonNegativeInteger
INTG  ==> Integer
MDFG  ==> Matrix DoubleFloat
PDECG ==> Record(start:DFG, finish:DFG, grid:NNIG, boundaryType:INTG,
                  dStart:MDFG, dFinish:MDFG)
LEDFG ==> List Expression DoubleFloat
PDEBG ==> Record(pde:LEDFG, constraints:List PDECG, f:List LEDFG, 
                    st:String, tol:DFG)
PartialDifferentialEquationsSolverCategory(): Category == SetCategory with

  measure:(RoutinesTable,PDEBG) -> Record(measure:Float,explanations:String)
    ++ measure(R,args) calculates an estimate of the ability of a particular
    ++ method to solve a problem.  
    ++
    ++ This method may be either a specific NAG routine or a strategy (such
    ++ as transforming the function from one which is difficult to one which
    ++ is easier to solve).
    ++
    ++ It will call whichever agents are needed to perform analysis on the
    ++ problem in order to calculate the measure. There is a parameter,
    ++ labelled \axiom{sofar}, which would contain the best compatibility
    ++ found so far.

  PDESolve: PDEBG -> Result
    ++ PDESolve(args) performs the integration of the
    ++ function given the strategy or method returned by \axiomFun{measure}.

@
\section{category OPTCAT NumericalOptimizationCategory}
<<category OPTCAT NumericalOptimizationCategory>>=
)abbrev category OPTCAT NumericalOptimizationCategory
++ Author: Brian Dupee
++ Date Created: January 1996
++ Date Last Updated: March 1996
++ Description:
++ \axiomType{NumericalOptimizationCategory} is the \axiom{category} for 
++ describing the set of Numerical Optimization \axiom{domains} with
++ \axiomFun{measure} and \axiomFun{optimize}.

LDFH   ==> List DoubleFloat
LEDFH  ==> List Expression DoubleFloat
LSAH   ==> Record(lfn:LEDFH, init:LDFH)
EDFH   ==> Expression DoubleFloat
LOCDFH ==> List OrderedCompletion DoubleFloat
NOAH   ==> Record(fn:EDFH, init:LDFH, lb:LOCDFH, cf:LEDFH, ub:LOCDFH)
NumericalOptimizationCategory(): Category == SetCategory with
  measure:(RoutinesTable,NOAH)->Record(measure:Float,explanations:String)
    ++ measure(R,args) calculates an estimate of the ability of a particular
    ++ method to solve an optimization problem.  
    ++
    ++ This method may be either a specific NAG routine or a strategy (such
    ++ as transforming the function from one which is difficult to one which
    ++ is easier to solve).
    ++
    ++ It will call whichever agents are needed to perform analysis on the
    ++ problem in order to calculate the measure. There is a parameter,
    ++ labelled \axiom{sofar}, which would contain the best compatibility
    ++ found so far.

  measure:(RoutinesTable,LSAH)->Record(measure:Float,explanations:String)
    ++ measure(R,args) calculates an estimate of the ability of a particular
    ++ method to solve an optimization problem.  
    ++
    ++ This method may be either a specific NAG routine or a strategy (such
    ++ as transforming the function from one which is difficult to one which
    ++ is easier to solve).
    ++
    ++ It will call whichever agents are needed to perform analysis on the
    ++ problem in order to calculate the measure. There is a parameter,
    ++ labelled \axiom{sofar}, which would contain the best compatibility
    ++ found so far.

  numericalOptimization:LSAH -> Result
    ++ numericalOptimization(args) performs the optimization of the
    ++ function given the strategy or method returned by \axiomFun{measure}.

  numericalOptimization:NOAH -> Result
    ++ numericalOptimization(args) performs the optimization of the
    ++ function given the strategy or method returned by \axiomFun{measure}.

@
\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 NIPROB NumericalIntegrationProblem>>
<<domain ODEPROB NumericalODEProblem>>
<<domain PDEPROB NumericalPDEProblem>>
<<domain OPTPROB NumericalOptimizationProblem>>
<<category NUMINT NumericalIntegrationCategory>>
<<category ODECAT OrdinaryDifferentialEquationsSolverCategory>>
<<category PDECAT PartialDifferentialEquationsSolverCategory>>
<<category OPTCAT NumericalOptimizationCategory>>
@
\eject
\begin{thebibliography}{99}
\bibitem{1} nothing
\end{thebibliography}
\end{document}