diff options
Diffstat (limited to 'src/algebra/f01.spad.pamphlet')
| -rw-r--r-- | src/algebra/f01.spad.pamphlet | 343 |
1 files changed, 343 insertions, 0 deletions
diff --git a/src/algebra/f01.spad.pamphlet b/src/algebra/f01.spad.pamphlet new file mode 100644 index 00000000..edbbc356 --- /dev/null +++ b/src/algebra/f01.spad.pamphlet @@ -0,0 +1,343 @@ +\documentclass{article} +\usepackage{axiom} +\begin{document} +\title{\$SPAD/src/algebra f01.spad} +\author{Godfrey Nolan, Mike Dewar} +\maketitle +\begin{abstract} +\end{abstract} +\eject +\tableofcontents +\eject +\section{package NAGF01 NagMatrixOperationsPackage} +<<package NAGF01 NagMatrixOperationsPackage>>= +)abbrev package NAGF01 NagMatrixOperationsPackage +++ Author: Godfrey Nolan and Mike Dewar +++ Date Created: Jan 1994 +++ Date Last Updated: Thu May 12 17:45:15 1994 +++Description: +++This package uses the NAG Library to provide facilities for matrix factorizations and +++associated transformations. +++See \downlink{Manual Page}{manpageXXf01}. +NagMatrixOperationsPackage(): Exports == Implementation where + S ==> Symbol + FOP ==> FortranOutputStackPackage + + Exports ==> with + f01brf : (Integer,Integer,Integer,Integer,_ + DoubleFloat,Boolean,Boolean,List Boolean,Matrix DoubleFloat,Matrix Integer,Matrix Integer,Integer) -> Result + ++ f01brf(n,nz,licn,lirn,pivot,lblock,grow,abort,a,irn,icn,ifail) + ++ factorizes a real sparse matrix. The routine either forms + ++ the LU factorization of a permutation of the entire matrix, or, + ++ optionally, first permutes the matrix to block lower triangular + ++ form and then only factorizes the diagonal blocks. + ++ See \downlink{Manual Page}{manpageXXf01brf}. + f01bsf : (Integer,Integer,Integer,Matrix Integer,_ + Matrix Integer,Matrix Integer,Matrix Integer,Boolean,DoubleFloat,Boolean,Matrix Integer,Matrix DoubleFloat,Integer) -> Result + ++ f01bsf(n,nz,licn,ivect,jvect,icn,ikeep,grow,eta,abort,idisp,avals,ifail) + ++ factorizes a real sparse matrix using the pivotal sequence + ++ previously obtained by F01BRF when a matrix of the same sparsity + ++ pattern was factorized. + ++ See \downlink{Manual Page}{manpageXXf01bsf}. + f01maf : (Integer,Integer,Integer,Integer,_ + List Boolean,Matrix DoubleFloat,Matrix Integer,Matrix Integer,DoubleFloat,DoubleFloat,Integer) -> Result + ++ f01maf(n,nz,licn,lirn,abort,avals,irn,icn,droptl,densw,ifail) + ++ computes an incomplete Cholesky factorization of a real + ++ sparse symmetric positive-definite matrix A. + ++ See \downlink{Manual Page}{manpageXXf01maf}. + f01mcf : (Integer,Matrix DoubleFloat,Integer,Matrix Integer,_ + Integer) -> Result + ++ f01mcf(n,avals,lal,nrow,ifail) + ++ computes the Cholesky factorization of a real symmetric + ++ positive-definite variable-bandwidth matrix. + ++ See \downlink{Manual Page}{manpageXXf01mcf}. + f01qcf : (Integer,Integer,Integer,Matrix DoubleFloat,_ + Integer) -> Result + ++ f01qcf(m,n,lda,a,ifail) + ++ finds the QR factorization of the real m by n matrix A, + ++ where m>=n. + ++ See \downlink{Manual Page}{manpageXXf01qcf}. + f01qdf : (String,String,Integer,Integer,_ + Matrix DoubleFloat,Integer,Matrix DoubleFloat,Integer,Integer,Matrix DoubleFloat,Integer) -> Result + ++ f01qdf(trans,wheret,m,n,a,lda,zeta,ncolb,ldb,b,ifail) + ++ performs one of the transformations + ++ See \downlink{Manual Page}{manpageXXf01qdf}. + f01qef : (String,Integer,Integer,Integer,_ + Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result + ++ f01qef(wheret,m,n,ncolq,lda,zeta,a,ifail) + ++ returns the first ncolq columns of the real m by m + ++ orthogonal matrix Q, where Q is given as the product of + ++ Householder transformation matrices. + ++ See \downlink{Manual Page}{manpageXXf01qef}. + f01rcf : (Integer,Integer,Integer,Matrix Complex DoubleFloat,_ + Integer) -> Result + ++ f01rcf(m,n,lda,a,ifail) + ++ finds the QR factorization of the complex m by n matrix A, + ++ where m>=n. + ++ See \downlink{Manual Page}{manpageXXf01rcf}. + f01rdf : (String,String,Integer,Integer,_ + Matrix Complex DoubleFloat,Integer,Matrix Complex DoubleFloat,Integer,Integer,Matrix Complex DoubleFloat,Integer) -> Result + ++ f01rdf(trans,wheret,m,n,a,lda,theta,ncolb,ldb,b,ifail) + ++ performs one of the transformations + ++ See \downlink{Manual Page}{manpageXXf01rdf}. + f01ref : (String,Integer,Integer,Integer,_ + Integer,Matrix Complex DoubleFloat,Matrix Complex DoubleFloat,Integer) -> Result + ++ f01ref(wheret,m,n,ncolq,lda,theta,a,ifail) + ++ returns the first ncolq columns of the complex m by m + ++ unitary matrix Q, where Q is given as the product of Householder + ++ transformation matrices. + ++ See \downlink{Manual Page}{manpageXXf01ref}. + Implementation ==> add + + import Lisp + import DoubleFloat + import Any + import Record + import Integer + import Matrix DoubleFloat + import Boolean + import NAGLinkSupportPackage + import AnyFunctions1(Integer) + import AnyFunctions1(DoubleFloat) + import AnyFunctions1(Boolean) + import AnyFunctions1(String) + import AnyFunctions1(List Boolean) + import AnyFunctions1(Matrix DoubleFloat) + import AnyFunctions1(Matrix Complex DoubleFloat) + import AnyFunctions1(Matrix Integer) + + + f01brf(nArg:Integer,nzArg:Integer,licnArg:Integer,_ + lirnArg:Integer,pivotArg:DoubleFloat,lblockArg:Boolean,_ + growArg:Boolean,abortArg:List Boolean,aArg:Matrix DoubleFloat,_ + irnArg:Matrix Integer,icnArg:Matrix Integer,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01brf",_ + ["n"::S,"nz"::S,"licn"::S,"lirn"::S,"pivot"::S_ + ,"lblock"::S,"grow"::S,"ifail"::S,"abort"::S,"ikeep"::S,"w"::S,"idisp"::S,"a"::S_ + ,"irn"::S,"icn"::S,"iw"::S]$Lisp,_ + ["ikeep"::S,"w"::S,"idisp"::S,"iw"::S]$Lisp,_ + [["double"::S,"pivot"::S,["w"::S,"n"::S]$Lisp_ + ,["a"::S,"licn"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"nz"::S,"licn"::S,"lirn"::S_ + ,["ikeep"::S,["*"::S,5$Lisp,"n"::S]$Lisp]$Lisp,["idisp"::S,10$Lisp]$Lisp,["irn"::S,"lirn"::S]$Lisp,["icn"::S,"licn"::S]$Lisp_ + ,"ifail"::S,["iw"::S,["*"::S,8$Lisp,"n"::S]$Lisp]$Lisp]$Lisp_ + ,["logical"::S,"lblock"::S,"grow"::S,["abort"::S,4$Lisp]$Lisp]$Lisp_ + ]$Lisp,_ + ["ikeep"::S,"w"::S,"idisp"::S,"a"::S,"irn"::S,"icn"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,nzArg::Any,licnArg::Any,lirnArg::Any,pivotArg::Any,lblockArg::Any,growArg::Any,ifailArg::Any,abortArg::Any,aArg::Any,irnArg::Any,icnArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result + + f01bsf(nArg:Integer,nzArg:Integer,licnArg:Integer,_ + ivectArg:Matrix Integer,jvectArg:Matrix Integer,icnArg:Matrix Integer,_ + ikeepArg:Matrix Integer,growArg:Boolean,etaArg:DoubleFloat,_ + abortArg:Boolean,idispArg:Matrix Integer,avalsArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01bsf",_ + ["n"::S,"nz"::S,"licn"::S,"grow"::S,"eta"::S_ + ,"abort"::S,"rpmin"::S,"ifail"::S,"ivect"::S,"jvect"::S,"icn"::S,"ikeep"::S,"idisp"::S_ + ,"w"::S,"avals"::S,"iw"::S]$Lisp,_ + ["w"::S,"rpmin"::S,"iw"::S]$Lisp,_ + [["double"::S,"eta"::S,["w"::S,"n"::S]$Lisp_ + ,"rpmin"::S,["avals"::S,"licn"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"nz"::S,"licn"::S,["ivect"::S,"nz"::S]$Lisp_ + ,["jvect"::S,"nz"::S]$Lisp,["icn"::S,"licn"::S]$Lisp,["ikeep"::S,["*"::S,5$Lisp,"n"::S]$Lisp]$Lisp_ + ,["idisp"::S,2$Lisp]$Lisp,"ifail"::S,["iw"::S,["*"::S,8$Lisp,"n"::S]$Lisp]$Lisp]$Lisp_ + ,["logical"::S,"grow"::S,"abort"::S]$Lisp_ + ]$Lisp,_ + ["w"::S,"rpmin"::S,"avals"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,nzArg::Any,licnArg::Any,growArg::Any,etaArg::Any,abortArg::Any,ifailArg::Any,ivectArg::Any,jvectArg::Any,icnArg::Any,ikeepArg::Any,idispArg::Any,avalsArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result + + f01maf(nArg:Integer,nzArg:Integer,licnArg:Integer,_ + lirnArg:Integer,abortArg:List Boolean,avalsArg:Matrix DoubleFloat,_ + irnArg:Matrix Integer,icnArg:Matrix Integer,droptlArg:DoubleFloat,_ + denswArg:DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01maf",_ + ["n"::S,"nz"::S,"licn"::S,"lirn"::S,"droptl"::S_ + ,"densw"::S,"ifail"::S,"abort"::S,"wkeep"::S,"ikeep"::S,"inform"::S,"avals"::S_ + ,"irn"::S,"icn"::S,"iwork"::S]$Lisp,_ + ["wkeep"::S,"ikeep"::S,"inform"::S,"iwork"::S]$Lisp,_ + [["double"::S,["wkeep"::S,["*"::S,3$Lisp,"n"::S]$Lisp]$Lisp_ + ,["avals"::S,"licn"::S]$Lisp,"droptl"::S,"densw"::S]$Lisp_ + ,["integer"::S,"n"::S,"nz"::S,"licn"::S,"lirn"::S_ + ,["ikeep"::S,["*"::S,2$Lisp,"n"::S]$Lisp]$Lisp,["inform"::S,4$Lisp]$Lisp,["irn"::S,"lirn"::S]$Lisp,["icn"::S,"licn"::S]$Lisp_ + ,"ifail"::S,["iwork"::S,["*"::S,6$Lisp,"n"::S]$Lisp]$Lisp]$Lisp_ + ,["logical"::S,["abort"::S,3$Lisp]$Lisp]$Lisp_ + ]$Lisp,_ + ["wkeep"::S,"ikeep"::S,"inform"::S,"avals"::S,"irn"::S,"icn"::S,"droptl"::S,"densw"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,nzArg::Any,licnArg::Any,lirnArg::Any,droptlArg::Any,denswArg::Any,ifailArg::Any,abortArg::Any,avalsArg::Any,irnArg::Any,icnArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result + + f01mcf(nArg:Integer,avalsArg:Matrix DoubleFloat,lalArg:Integer,_ + nrowArg:Matrix Integer,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01mcf",_ + ["n"::S,"lal"::S,"ifail"::S,"avals"::S,"nrow"::S,"al"::S,"d"::S]$Lisp,_ + ["al"::S,"d"::S]$Lisp,_ + [["double"::S,["avals"::S,"lal"::S]$Lisp,["al"::S,"lal"::S]$Lisp_ + ,["d"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"lal"::S,["nrow"::S,"n"::S]$Lisp_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["al"::S,"d"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,lalArg::Any,ifailArg::Any,avalsArg::Any,nrowArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result + + f01qcf(mArg:Integer,nArg:Integer,ldaArg:Integer,_ + aArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01qcf",_ + ["m"::S,"n"::S,"lda"::S,"ifail"::S,"zeta"::S,"a"::S]$Lisp,_ + ["zeta"::S]$Lisp,_ + [["double"::S,["zeta"::S,"n"::S]$Lisp,["a"::S,"lda"::S,"n"::S]$Lisp_ + ]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"lda"::S,"ifail"::S_ + ]$Lisp_ + ]$Lisp,_ + ["zeta"::S,"a"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,ldaArg::Any,ifailArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result + + f01qdf(transArg:String,wheretArg:String,mArg:Integer,_ + nArg:Integer,aArg:Matrix DoubleFloat,ldaArg:Integer,_ + zetaArg:Matrix DoubleFloat,ncolbArg:Integer,ldbArg:Integer,_ + bArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01qdf",_ + ["trans"::S,"wheret"::S,"m"::S,"n"::S,"lda"::S_ + ,"ncolb"::S,"ldb"::S,"ifail"::S,"a"::S,"zeta"::S,"b"::S,"work"::S]$Lisp,_ + ["work"::S]$Lisp,_ + [["double"::S,["a"::S,"lda"::S,"n"::S]$Lisp_ + ,["zeta"::S,"n"::S]$Lisp,["b"::S,"ldb"::S,"ncolb"::S]$Lisp,["work"::S,"ncolb"::S]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"lda"::S,"ncolb"::S_ + ,"ldb"::S,"ifail"::S]$Lisp_ + ,["character"::S,"trans"::S,"wheret"::S]$Lisp_ + ]$Lisp,_ + ["b"::S,"ifail"::S]$Lisp,_ + [([transArg::Any,wheretArg::Any,mArg::Any,nArg::Any,ldaArg::Any,ncolbArg::Any,ldbArg::Any,ifailArg::Any,aArg::Any,zetaArg::Any,bArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result + + f01qef(wheretArg:String,mArg:Integer,nArg:Integer,_ + ncolqArg:Integer,ldaArg:Integer,zetaArg:Matrix DoubleFloat,_ + aArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01qef",_ + ["wheret"::S,"m"::S,"n"::S,"ncolq"::S,"lda"::S_ + ,"ifail"::S,"zeta"::S,"a"::S,"work"::S]$Lisp,_ + ["work"::S]$Lisp,_ + [["double"::S,["zeta"::S,"n"::S]$Lisp,["a"::S,"lda"::S,"ncolq"::S]$Lisp_ + ,["work"::S,"ncolq"::S]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"ncolq"::S,"lda"::S_ + ,"ifail"::S]$Lisp_ + ,["character"::S,"wheret"::S]$Lisp_ + ]$Lisp,_ + ["a"::S,"ifail"::S]$Lisp,_ + [([wheretArg::Any,mArg::Any,nArg::Any,ncolqArg::Any,ldaArg::Any,ifailArg::Any,zetaArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result + + f01rcf(mArg:Integer,nArg:Integer,ldaArg:Integer,_ + aArg:Matrix Complex DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01rcf",_ + ["m"::S,"n"::S,"lda"::S,"ifail"::S,"theta"::S,"a"::S]$Lisp,_ + ["theta"::S]$Lisp,_ + [["integer"::S,"m"::S,"n"::S,"lda"::S,"ifail"::S_ + ]$Lisp_ + ,["double complex"::S,["theta"::S,"n"::S]$Lisp,["a"::S,"lda"::S,"n"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["theta"::S,"a"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,ldaArg::Any,ifailArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result + + f01rdf(transArg:String,wheretArg:String,mArg:Integer,_ + nArg:Integer,aArg:Matrix Complex DoubleFloat,ldaArg:Integer,_ + thetaArg:Matrix Complex DoubleFloat,ncolbArg:Integer,ldbArg:Integer,_ + bArg:Matrix Complex DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01rdf",_ + ["trans"::S,"wheret"::S,"m"::S,"n"::S,"lda"::S_ + ,"ncolb"::S,"ldb"::S,"ifail"::S,"a"::S,"theta"::S,"b"::S,"work"::S]$Lisp,_ + ["work"::S]$Lisp,_ + [["integer"::S,"m"::S,"n"::S,"lda"::S,"ncolb"::S_ + ,"ldb"::S,"ifail"::S]$Lisp_ + ,["character"::S,"trans"::S,"wheret"::S]$Lisp_ + ,["double complex"::S,["a"::S,"lda"::S,"n"::S]$Lisp,["theta"::S,"n"::S]$Lisp,["b"::S,"ldb"::S,"ncolb"::S]$Lisp,["work"::S,"ncolb"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["b"::S,"ifail"::S]$Lisp,_ + [([transArg::Any,wheretArg::Any,mArg::Any,nArg::Any,ldaArg::Any,ncolbArg::Any,ldbArg::Any,ifailArg::Any,aArg::Any,thetaArg::Any,bArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result + + f01ref(wheretArg:String,mArg:Integer,nArg:Integer,_ + ncolqArg:Integer,ldaArg:Integer,thetaArg:Matrix Complex DoubleFloat,_ + aArg:Matrix Complex DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01ref",_ + ["wheret"::S,"m"::S,"n"::S,"ncolq"::S,"lda"::S_ + ,"ifail"::S,"theta"::S,"a"::S,"work"::S]$Lisp,_ + ["work"::S]$Lisp,_ + [["integer"::S,"m"::S,"n"::S,"ncolq"::S,"lda"::S_ + ,"ifail"::S]$Lisp_ + ,["character"::S,"wheret"::S]$Lisp_ + ,["double complex"::S,["theta"::S,"n"::S]$Lisp,["a"::S,"lda"::S,"n"::S]$Lisp,["work"::S,"ncolq"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["a"::S,"ifail"::S]$Lisp,_ + [([wheretArg::Any,mArg::Any,nArg::Any,ncolqArg::Any,ldaArg::Any,ifailArg::Any,thetaArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result + +@ +\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>> + +<<package NAGF01 NagMatrixOperationsPackage>> +@ +\eject +\begin{thebibliography}{99} +\bibitem{1} nothing +\end{thebibliography} +\end{document} |