Initial population.

1 files changed, 345 insertions, 0 deletions

diff --git a/src/algebra/fortcat.spad.pamphlet b/src/algebra/fortcat.spad.pamphlet
new file mode 100644
index 00000000..16daa51d
--- /dev/null
+++ b/src/algebra/fortcat.spad.pamphlet
@@ -0,0 +1,345 @@
+\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}
+<<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}
+<<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}
+<<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}
+<<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}
+<<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}
+<<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}
+<<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}
+<<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>>
+
+<<category FORTFN FortranFunctionCategory>>
+<<category FMC FortranMatrixCategory>>
+<<category FORTCAT FortranProgramCategory>>
+<<category FVC FortranVectorCategory>>
+<<category FMTC FortranMachineTypeCategory>>
+<<category FMFUN FortranMatrixFunctionCategory>>
+<<category FVFUN FortranVectorFunctionCategory>>
+
+@
+\eject
+\begin{thebibliography}{99}
+\bibitem{1} nothing
+\end{thebibliography}
+\end{document}