\documentclass{article} \usepackage{open-axiom} \begin{document} \title{\$SPAD/src/algebra annacat.spad} \author{Brian Dupee} \maketitle \begin{abstract} \end{abstract} \eject \tableofcontents \eject \section{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{} 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} <>= )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{} 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} <>= )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{} 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} <>= )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{} 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} <>= )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} <>= )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} <>= )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} <>= )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} <>= --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. @ <<*>>= <> <> <> <> <> <> <> <> <> @ \eject \begin{thebibliography}{99} \bibitem{1} nothing \end{thebibliography} \end{document}