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

\documentclass{article}
\usepackage{open-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}