\documentclass{article} \usepackage{axiom} \begin{document} \title{\$SPAD/src/algebra fortcat.spad} \author{Mike Dewar} \maketitle \begin{abstract} \end{abstract} \eject \tableofcontents \eject \section{category FORTFN FortranFunctionCategory} <>= )abbrev category FORTFN FortranFunctionCategory ++ Author: Mike Dewar ++ Date Created: 13 January 1994 ++ Date Last Updated: 18 March 1994 ++ Related Constructors: FortranProgramCategory. ++ Description: ++ \axiomType{FortranFunctionCategory} is the category of arguments to ++ NAG Library routines which return (sets of) function values. FortranFunctionCategory():Category == FortranProgramCategory with coerce : List FortranCode -> $ ++ coerce(e) takes an object from \spadtype{List FortranCode} and ++ uses it as the body of an ASP. coerce : FortranCode -> $ ++ coerce(e) takes an object from \spadtype{FortranCode} and ++ uses it as the body of an ASP. coerce : Record(localSymbols:SymbolTable,code:List(FortranCode)) -> $ ++ coerce(e) takes the component of \spad{e} from ++ \spadtype{List FortranCode} and uses it as the body of the ASP, ++ making the declarations in the \spadtype{SymbolTable} component. retract : Expression Float -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Expression Float -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retract : Expression Integer -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Expression Integer -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retract : Polynomial Float -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Polynomial Float -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retract : Polynomial Integer -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Polynomial Integer -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retract : Fraction Polynomial Float -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Fraction Polynomial Float -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retract : Fraction Polynomial Integer -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Fraction Polynomial Integer -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. -- NB: These ASPs also have a coerce from an appropriate instantiation -- of FortranExpression. @ \section{category FMC FortranMatrixCategory} <>= )abbrev category FMC FortranMatrixCategory ++ Author: Mike Dewar ++ Date Created: 21 March 1994 ++ Date Last Updated: ++ Related Constructors: FortranProgramCategory. ++ Description: ++ \axiomType{FortranMatrixCategory} provides support for ++ producing Functions and Subroutines when the input to these ++ is an AXIOM object of type \axiomType{Matrix} or in domains ++ involving \axiomType{FortranCode}. FortranMatrixCategory():Category == FortranProgramCategory with coerce : Matrix MachineFloat -> $ ++ coerce(v) produces an ASP which returns the value of \spad{v}. coerce : List FortranCode -> $ ++ coerce(e) takes an object from \spadtype{List FortranCode} and ++ uses it as the body of an ASP. coerce : FortranCode -> $ ++ coerce(e) takes an object from \spadtype{FortranCode} and ++ uses it as the body of an ASP. coerce : Record(localSymbols:SymbolTable,code:List(FortranCode)) -> $ ++ coerce(e) takes the component of \spad{e} from ++ \spadtype{List FortranCode} and uses it as the body of the ASP, ++ making the declarations in the \spadtype{SymbolTable} component. @ \section{category FORTCAT FortranProgramCategory} <>= )abbrev category FORTCAT FortranProgramCategory ++ Author: Mike Dewar ++ Date Created: November 1992 ++ Date Last Updated: ++ Basic Operations: ++ Related Constructors: FortranType, FortranCode, Switch ++ Also See: ++ AMS Classifications: ++ Keywords: ++ References: ++ Description: ++ \axiomType{FortranProgramCategory} provides various models of ++ FORTRAN subprograms. These can be transformed into actual FORTRAN ++ code. FortranProgramCategory():Category == Join(Type,CoercibleTo OutputForm) with outputAsFortran : $ -> Void ++ \axiom{outputAsFortran(u)} translates \axiom{u} into a legal FORTRAN ++ subprogram. @ \section{category FVC FortranVectorCategory} <>= )abbrev category FVC FortranVectorCategory ++ Author: Mike Dewar ++ Date Created: October 1993 ++ Date Last Updated: 18 March 1994 ++ Related Constructors: FortranProgramCategory. ++ Description: ++ \axiomType{FortranVectorCategory} provides support for ++ producing Functions and Subroutines when the input to these ++ is an AXIOM object of type \axiomType{Vector} or in domains ++ involving \axiomType{FortranCode}. FortranVectorCategory():Category == FortranProgramCategory with coerce : Vector MachineFloat -> $ ++ coerce(v) produces an ASP which returns the value of \spad{v}. coerce : List FortranCode -> $ ++ coerce(e) takes an object from \spadtype{List FortranCode} and ++ uses it as the body of an ASP. coerce : FortranCode -> $ ++ coerce(e) takes an object from \spadtype{FortranCode} and ++ uses it as the body of an ASP. coerce : Record(localSymbols:SymbolTable,code:List(FortranCode)) -> $ ++ coerce(e) takes the component of \spad{e} from ++ \spadtype{List FortranCode} and uses it as the body of the ASP, ++ making the declarations in the \spadtype{SymbolTable} component. @ \section{category FMTC FortranMachineTypeCategory} <>= )abbrev category FMTC FortranMachineTypeCategory ++ Author: Mike Dewar ++ Date Created: December 1993 ++ Date Last Updated: ++ Basic Operations: ++ Related Domains: ++ Also See: FortranExpression, MachineInteger, MachineFloat, MachineComplex ++ AMS Classifications: ++ Keywords: ++ Examples: ++ References: ++ Description: A category of domains which model machine arithmetic ++ used by machines in the AXIOM-NAG link. FortranMachineTypeCategory():Category == Join(IntegralDomain,OrderedSet, RetractableTo(Integer) ) @ \section{category FMFUN FortranMatrixFunctionCategory} <>= )abbrev category FMFUN FortranMatrixFunctionCategory ++ Author: Mike Dewar ++ Date Created: March 18 1994 ++ Date Last Updated: ++ Related Constructors: FortranProgramCategory. ++ Description: ++ \axiomType{FortranMatrixFunctionCategory} provides support for ++ producing Functions and Subroutines representing matrices of ++ expressions. FortranMatrixFunctionCategory():Category == FortranProgramCategory with coerce : List FortranCode -> $ ++ coerce(e) takes an object from \spadtype{List FortranCode} and ++ uses it as the body of an ASP. coerce : FortranCode -> $ ++ coerce(e) takes an object from \spadtype{FortranCode} and ++ uses it as the body of an ASP. coerce : Record(localSymbols:SymbolTable,code:List(FortranCode)) -> $ ++ coerce(e) takes the component of \spad{e} from ++ \spadtype{List FortranCode} and uses it as the body of the ASP, ++ making the declarations in the \spadtype{SymbolTable} component. retract : Matrix Expression Float -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Matrix Expression Float -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retract : Matrix Expression Integer -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Matrix Expression Integer -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retract : Matrix Polynomial Float -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Matrix Polynomial Float -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retract : Matrix Polynomial Integer -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Matrix Polynomial Integer -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retract : Matrix Fraction Polynomial Float -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Matrix Fraction Polynomial Float -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retract : Matrix Fraction Polynomial Integer -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Matrix Fraction Polynomial Integer -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. -- NB: These ASPs also have a coerce from an appropriate instantiation -- of Matrix FortranExpression. @ \section{category FVFUN FortranVectorFunctionCategory} <>= )abbrev category FVFUN FortranVectorFunctionCategory ++ Author: Mike Dewar ++ Date Created: 11 March 1994 ++ Date Last Updated: 18 March 1994 ++ Related Constructors: FortranProgramCategory. ++ Description: ++ \axiomType{FortranVectorFunctionCategory} is the catagory of arguments ++ to NAG Library routines which return the values of vectors of functions. FortranVectorFunctionCategory():Category == FortranProgramCategory with coerce : List FortranCode -> $ ++ coerce(e) takes an object from \spadtype{List FortranCode} and ++ uses it as the body of an ASP. coerce : FortranCode -> $ ++ coerce(e) takes an object from \spadtype{FortranCode} and ++ uses it as the body of an ASP. coerce : Record(localSymbols:SymbolTable,code:List(FortranCode)) -> $ ++ coerce(e) takes the component of \spad{e} from ++ \spadtype{List FortranCode} and uses it as the body of the ASP, ++ making the declarations in the \spadtype{SymbolTable} component. retract : Vector Expression Float -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Vector Expression Float -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retract : Vector Expression Integer -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Vector Expression Integer -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retract : Vector Polynomial Float -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Vector Polynomial Float -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retract : Vector Polynomial Integer -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Vector Polynomial Integer -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retract : Vector Fraction Polynomial Float -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Vector Fraction Polynomial Float -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retract : Vector Fraction Polynomial Integer -> $ ++ retract(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. retractIfCan : Vector Fraction Polynomial Integer -> Union($,"failed") ++ retractIfCan(e) tries to convert \spad{e} into an ASP, checking that ++ legal Fortran-77 is produced. -- NB: These ASPs also have a coerce from an appropriate instantiation -- of Vector FortranExpression. @ \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}