\documentclass{article}
\usepackage{axiom}
\begin{document}
\title{\$SPAD/src/algebra f02.spad}
\author{Godfrey Nolan, Mike Dewar}
\maketitle
\begin{abstract}
\end{abstract}
\eject
\tableofcontents
\eject
\section{package NAGF02 NagEigenPackage}
<<package NAGF02 NagEigenPackage>>=
)abbrev package NAGF02 NagEigenPackage
++ Author: Godfrey Nolan and Mike Dewar
++ Date Created: Jan 1994
++ Date Last Updated: Thu May 12 17:45:20 1994
++Description:
++This package uses the NAG Library to compute
++\begin{items}
++\item eigenvalues and eigenvectors of a matrix
++\item eigenvalues and eigenvectors of generalized matrix
++eigenvalue problems
++\item singular values and singular vectors of a matrix.
++\end{items}
++See \downlink{Manual Page}{manpageXXf02}. 

NagEigenPackage(): Exports == Implementation where
  S ==> Symbol
  FOP ==> FortranOutputStackPackage

  Exports ==> with
    f02aaf : (Integer,Integer,Matrix DoubleFloat,Integer) -> Result 
     ++ f02aaf(ia,n,a,ifail)
     ++ calculates all the eigenvalue.
     ++ See \downlink{Manual Page}{manpageXXf02aaf}.
    f02abf : (Matrix DoubleFloat,Integer,Integer,Integer,_
	Integer) -> Result 
     ++ f02abf(a,ia,n,iv,ifail)
     ++ calculates all the eigenvalues of a real 
     ++ symmetric matrix.
     ++ See \downlink{Manual Page}{manpageXXf02abf}.
    f02adf : (Integer,Integer,Integer,Matrix DoubleFloat,_
	Matrix DoubleFloat,Integer) -> Result 
     ++ f02adf(ia,ib,n,a,b,ifail)
     ++ calculates all the eigenvalues of  Ax=(lambda)Bx,  where A
     ++ is a real symmetric matrix and B is a real symmetric positive-
     ++ definite matrix.
     ++ See \downlink{Manual Page}{manpageXXf02adf}.
    f02aef : (Integer,Integer,Integer,Integer,_
	Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result 
     ++ f02aef(ia,ib,n,iv,a,b,ifail)
     ++ calculates all the eigenvalues of  
     ++ Ax=(lambda)Bx,  where A is a real symmetric matrix and B is a 
     ++ real symmetric positive-definite matrix.
     ++ See \downlink{Manual Page}{manpageXXf02aef}.
    f02aff : (Integer,Integer,Matrix DoubleFloat,Integer) -> Result 
     ++ f02aff(ia,n,a,ifail)
     ++ calculates all the eigenvalues of a real unsymmetric 
     ++ matrix.
     ++ See \downlink{Manual Page}{manpageXXf02aff}.
    f02agf : (Integer,Integer,Integer,Integer,_
	Matrix DoubleFloat,Integer) -> Result 
     ++ f02agf(ia,n,ivr,ivi,a,ifail)
     ++ calculates all the eigenvalues of a real 
     ++ unsymmetric matrix.
     ++ See \downlink{Manual Page}{manpageXXf02agf}.
    f02ajf : (Integer,Integer,Integer,Matrix DoubleFloat,_
	Matrix DoubleFloat,Integer) -> Result 
     ++ f02ajf(iar,iai,n,ar,ai,ifail)
     ++ calculates all the eigenvalue.
     ++ See \downlink{Manual Page}{manpageXXf02ajf}.
    f02akf : (Integer,Integer,Integer,Integer,_
	Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result 
     ++ f02akf(iar,iai,n,ivr,ivi,ar,ai,ifail)
     ++ calculates all the eigenvalues of a 
     ++ complex matrix.
     ++ See \downlink{Manual Page}{manpageXXf02akf}.
    f02awf : (Integer,Integer,Integer,Matrix DoubleFloat,_
	Matrix DoubleFloat,Integer) -> Result 
     ++ f02awf(iar,iai,n,ar,ai,ifail)
     ++ calculates all the eigenvalues of a complex Hermitian 
     ++ matrix.
     ++ See \downlink{Manual Page}{manpageXXf02awf}.
    f02axf : (Matrix DoubleFloat,Integer,Matrix DoubleFloat,Integer,_
	Integer,Integer,Integer,Integer) -> Result 
     ++ f02axf(ar,iar,ai,iai,n,ivr,ivi,ifail)
     ++ calculates all the eigenvalues of a 
     ++ complex Hermitian matrix.
     ++ See \downlink{Manual Page}{manpageXXf02axf}.
    f02bbf : (Integer,Integer,DoubleFloat,DoubleFloat,_
	Integer,Integer,Matrix DoubleFloat,Integer) -> Result 
     ++ f02bbf(ia,n,alb,ub,m,iv,a,ifail)
     ++ calculates selected eigenvalues of a real
     ++ symmetric matrix by reduction to tridiagonal form, bisection and 
     ++ inverse iteration, where the selected eigenvalues lie within a 
     ++ given interval.
     ++ See \downlink{Manual Page}{manpageXXf02bbf}.
    f02bjf : (Integer,Integer,Integer,DoubleFloat,_
	Boolean,Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result 
     ++ f02bjf(n,ia,ib,eps1,matv,iv,a,b,ifail)
     ++ calculates all the eigenvalues and, if required, all the 
     ++ eigenvectors of the generalized eigenproblem  Ax=(lambda)Bx   
     ++ where A and B are real, square matrices, using the QZ algorithm.
     ++ See \downlink{Manual Page}{manpageXXf02bjf}.
    f02fjf : (Integer,Integer,DoubleFloat,Integer,_
	Integer,Integer,Integer,Integer,Integer,Integer,Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp27(DOT)),Union(fn:FileName,fp:Asp28(IMAGE))) -> Result 
     ++ f02fjf(n,k,tol,novecs,nrx,lwork,lrwork,liwork,m,noits,x,ifail,dot,image)
     ++ finds eigenvalues of a real sparse symmetric 
     ++ or generalized symmetric eigenvalue problem.
     ++ See \downlink{Manual Page}{manpageXXf02fjf}.
    f02fjf : (Integer,Integer,DoubleFloat,Integer,_
	Integer,Integer,Integer,Integer,Integer,Integer,Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp27(DOT)),Union(fn:FileName,fp:Asp28(IMAGE)),FileName) -> Result 
     ++ f02fjf(n,k,tol,novecs,nrx,lwork,lrwork,liwork,m,noits,x,ifail,dot,image,monit)
     ++ finds eigenvalues of a real sparse symmetric 
     ++ or generalized symmetric eigenvalue problem.
     ++ See \downlink{Manual Page}{manpageXXf02fjf}.
    f02wef : (Integer,Integer,Integer,Integer,_
	Integer,Boolean,Integer,Boolean,Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result 
     ++ f02wef(m,n,lda,ncolb,ldb,wantq,ldq,wantp,ldpt,a,b,ifail)
     ++ returns all, or part, of the singular value decomposition 
     ++ of a general real matrix.
     ++ See \downlink{Manual Page}{manpageXXf02wef}.
    f02xef : (Integer,Integer,Integer,Integer,_
	Integer,Boolean,Integer,Boolean,Integer,Matrix Complex DoubleFloat,Matrix Complex DoubleFloat,Integer) -> Result 
     ++ f02xef(m,n,lda,ncolb,ldb,wantq,ldq,wantp,ldph,a,b,ifail)
     ++ returns all, or part, of the singular value decomposition 
     ++ of a general complex matrix.
     ++ See \downlink{Manual Page}{manpageXXf02xef}.
  Implementation ==> add

    import Lisp
    import DoubleFloat
    import Any
    import Record
    import Integer
    import Matrix DoubleFloat
    import Boolean
    import NAGLinkSupportPackage
    import FortranPackage
    import AnyFunctions1(Integer)
    import AnyFunctions1(Boolean)
    import AnyFunctions1(Matrix DoubleFloat)
    import AnyFunctions1(Matrix Complex DoubleFloat)
    import AnyFunctions1(DoubleFloat)


    f02aaf(iaArg:Integer,nArg:Integer,aArg:Matrix DoubleFloat,_
	ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"f02aaf",_
	["ia"::S,"n"::S,"ifail"::S,"r"::S,"a"::S,"e"::S]$Lisp,_
	["r"::S,"e"::S]$Lisp,_
	[["double"::S,["r"::S,"n"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp_
	,["e"::S,"n"::S]$Lisp]$Lisp_
	,["integer"::S,"ia"::S,"n"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["r"::S,"a"::S,"ifail"::S]$Lisp,_
	[([iaArg::Any,nArg::Any,ifailArg::Any,aArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    f02abf(aArg:Matrix DoubleFloat,iaArg:Integer,nArg:Integer,_
	ivArg:Integer,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"f02abf",_
	["ia"::S,"n"::S,"iv"::S,"ifail"::S,"a"::S,"r"::S,"v"::S,"e"::S]$Lisp,_
	["r"::S,"v"::S,"e"::S]$Lisp,_
	[["double"::S,["a"::S,"ia"::S,"n"::S]$Lisp_
	,["r"::S,"n"::S]$Lisp,["v"::S,"iv"::S,"n"::S]$Lisp,["e"::S,"n"::S]$Lisp]$Lisp_
	,["integer"::S,"ia"::S,"n"::S,"iv"::S,"ifail"::S_
	]$Lisp_
	]$Lisp,_
	["r"::S,"v"::S,"ifail"::S]$Lisp,_
	[([iaArg::Any,nArg::Any,ivArg::Any,ifailArg::Any,aArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    f02adf(iaArg:Integer,ibArg:Integer,nArg:Integer,_
	aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"f02adf",_
	["ia"::S,"ib"::S,"n"::S,"ifail"::S,"r"::S,"a"::S,"b"::S,"de"::S]$Lisp,_
	["r"::S,"de"::S]$Lisp,_
	[["double"::S,["r"::S,"n"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp_
	,["b"::S,"ib"::S,"n"::S]$Lisp,["de"::S,"n"::S]$Lisp]$Lisp_
	,["integer"::S,"ia"::S,"ib"::S,"n"::S,"ifail"::S_
	]$Lisp_
	]$Lisp,_
	["r"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_
	[([iaArg::Any,ibArg::Any,nArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    f02aef(iaArg:Integer,ibArg:Integer,nArg:Integer,_
	ivArg:Integer,aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,_
	ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"f02aef",_
	["ia"::S,"ib"::S,"n"::S,"iv"::S,"ifail"::S_
	,"r"::S,"v"::S,"a"::S,"b"::S,"dl"::S_
	,"e"::S]$Lisp,_
	["r"::S,"v"::S,"dl"::S,"e"::S]$Lisp,_
	[["double"::S,["r"::S,"n"::S]$Lisp,["v"::S,"iv"::S,"n"::S]$Lisp_
	,["a"::S,"ia"::S,"n"::S]$Lisp,["b"::S,"ib"::S,"n"::S]$Lisp,["dl"::S,"n"::S]$Lisp,["e"::S,"n"::S]$Lisp_
	]$Lisp_
	,["integer"::S,"ia"::S,"ib"::S,"n"::S,"iv"::S_
	,"ifail"::S]$Lisp_
	]$Lisp,_
	["r"::S,"v"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_
	[([iaArg::Any,ibArg::Any,nArg::Any,ivArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    f02aff(iaArg:Integer,nArg:Integer,aArg:Matrix DoubleFloat,_
	ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"f02aff",_
	["ia"::S,"n"::S,"ifail"::S,"rr"::S,"ri"::S,"intger"::S,"a"::S]$Lisp,_
	["rr"::S,"ri"::S,"intger"::S]$Lisp,_
	[["double"::S,["rr"::S,"n"::S]$Lisp,["ri"::S,"n"::S]$Lisp_
	,["a"::S,"ia"::S,"n"::S]$Lisp]$Lisp_
	,["integer"::S,"ia"::S,"n"::S,["intger"::S,"n"::S]$Lisp_
	,"ifail"::S]$Lisp_
	]$Lisp,_
	["rr"::S,"ri"::S,"intger"::S,"a"::S,"ifail"::S]$Lisp,_
	[([iaArg::Any,nArg::Any,ifailArg::Any,aArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    f02agf(iaArg:Integer,nArg:Integer,ivrArg:Integer,_
	iviArg:Integer,aArg:Matrix DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"f02agf",_
	["ia"::S,"n"::S,"ivr"::S,"ivi"::S,"ifail"::S_
	,"rr"::S,"ri"::S,"vr"::S,"vi"::S,"intger"::S_
	,"a"::S]$Lisp,_
	["rr"::S,"ri"::S,"vr"::S,"vi"::S,"intger"::S]$Lisp,_
	[["double"::S,["rr"::S,"n"::S]$Lisp,["ri"::S,"n"::S]$Lisp_
	,["vr"::S,"ivr"::S,"n"::S]$Lisp,["vi"::S,"ivi"::S,"n"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp]$Lisp_
	,["integer"::S,"ia"::S,"n"::S,"ivr"::S,"ivi"::S_
	,["intger"::S,"n"::S]$Lisp,"ifail"::S]$Lisp_
	]$Lisp,_
	["rr"::S,"ri"::S,"vr"::S,"vi"::S,"intger"::S,"a"::S,"ifail"::S]$Lisp,_
	[([iaArg::Any,nArg::Any,ivrArg::Any,iviArg::Any,ifailArg::Any,aArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    f02ajf(iarArg:Integer,iaiArg:Integer,nArg:Integer,_
	arArg:Matrix DoubleFloat,aiArg:Matrix DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"f02ajf",_
	["iar"::S,"iai"::S,"n"::S,"ifail"::S,"rr"::S,"ri"::S,"ar"::S,"ai"::S,"intger"::S_
	]$Lisp,_
	["rr"::S,"ri"::S,"intger"::S]$Lisp,_
	[["double"::S,["rr"::S,"n"::S]$Lisp,["ri"::S,"n"::S]$Lisp_
	,["ar"::S,"iar"::S,"n"::S]$Lisp,["ai"::S,"iai"::S,"n"::S]$Lisp]$Lisp_
	,["integer"::S,"iar"::S,"iai"::S,"n"::S,"ifail"::S_
	,["intger"::S,"n"::S]$Lisp]$Lisp_
	]$Lisp,_
	["rr"::S,"ri"::S,"ar"::S,"ai"::S,"ifail"::S]$Lisp,_
	[([iarArg::Any,iaiArg::Any,nArg::Any,ifailArg::Any,arArg::Any,aiArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    f02akf(iarArg:Integer,iaiArg:Integer,nArg:Integer,_
	ivrArg:Integer,iviArg:Integer,arArg:Matrix DoubleFloat,_
	aiArg:Matrix DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"f02akf",_
	["iar"::S,"iai"::S,"n"::S,"ivr"::S,"ivi"::S_
	,"ifail"::S,"rr"::S,"ri"::S,"vr"::S,"vi"::S,"ar"::S_
	,"ai"::S,"intger"::S]$Lisp,_
	["rr"::S,"ri"::S,"vr"::S,"vi"::S,"intger"::S]$Lisp,_
	[["double"::S,["rr"::S,"n"::S]$Lisp,["ri"::S,"n"::S]$Lisp_
	,["vr"::S,"ivr"::S,"n"::S]$Lisp,["vi"::S,"ivi"::S,"n"::S]$Lisp,["ar"::S,"iar"::S,"n"::S]$Lisp,["ai"::S,"iai"::S,"n"::S]$Lisp_
	]$Lisp_
	,["integer"::S,"iar"::S,"iai"::S,"n"::S,"ivr"::S_
	,"ivi"::S,"ifail"::S,["intger"::S,"n"::S]$Lisp]$Lisp_
	]$Lisp,_
	["rr"::S,"ri"::S,"vr"::S,"vi"::S,"ar"::S,"ai"::S,"ifail"::S]$Lisp,_
	[([iarArg::Any,iaiArg::Any,nArg::Any,ivrArg::Any,iviArg::Any,ifailArg::Any,arArg::Any,aiArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    f02awf(iarArg:Integer,iaiArg:Integer,nArg:Integer,_
	arArg:Matrix DoubleFloat,aiArg:Matrix DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"f02awf",_
	["iar"::S,"iai"::S,"n"::S,"ifail"::S,"r"::S,"ar"::S,"ai"::S,"wk1"::S,"wk2"::S_
	,"wk3"::S]$Lisp,_
	["r"::S,"wk1"::S,"wk2"::S,"wk3"::S]$Lisp,_
	[["double"::S,["r"::S,"n"::S]$Lisp,["ar"::S,"iar"::S,"n"::S]$Lisp_
	,["ai"::S,"iai"::S,"n"::S]$Lisp,["wk1"::S,"n"::S]$Lisp,["wk2"::S,"n"::S]$Lisp,["wk3"::S,"n"::S]$Lisp_
	]$Lisp_
	,["integer"::S,"iar"::S,"iai"::S,"n"::S,"ifail"::S_
	]$Lisp_
	]$Lisp,_
	["r"::S,"ar"::S,"ai"::S,"ifail"::S]$Lisp,_
	[([iarArg::Any,iaiArg::Any,nArg::Any,ifailArg::Any,arArg::Any,aiArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    f02axf(arArg:Matrix DoubleFloat,iarArg:Integer,aiArg:Matrix DoubleFloat,_
	iaiArg:Integer,nArg:Integer,ivrArg:Integer,_
	iviArg:Integer,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"f02axf",_
	["iar"::S,"iai"::S,"n"::S,"ivr"::S,"ivi"::S_
	,"ifail"::S,"ar"::S,"ai"::S,"r"::S,"vr"::S,"vi"::S_
	,"wk1"::S,"wk2"::S,"wk3"::S]$Lisp,_
	["r"::S,"vr"::S,"vi"::S,"wk1"::S,"wk2"::S,"wk3"::S]$Lisp,_
	[["double"::S,["ar"::S,"iar"::S,"n"::S]$Lisp_
	,["ai"::S,"iai"::S,"n"::S]$Lisp,["r"::S,"n"::S]$Lisp,["vr"::S,"ivr"::S,"n"::S]$Lisp,["vi"::S,"ivi"::S,"n"::S]$Lisp,["wk1"::S,"n"::S]$Lisp_
	,["wk2"::S,"n"::S]$Lisp,["wk3"::S,"n"::S]$Lisp]$Lisp_
	,["integer"::S,"iar"::S,"iai"::S,"n"::S,"ivr"::S_
	,"ivi"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["r"::S,"vr"::S,"vi"::S,"ifail"::S]$Lisp,_
	[([iarArg::Any,iaiArg::Any,nArg::Any,ivrArg::Any,iviArg::Any,ifailArg::Any,arArg::Any,aiArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    f02bbf(iaArg:Integer,nArg:Integer,albArg:DoubleFloat,_
	ubArg:DoubleFloat,mArg:Integer,ivArg:Integer,_
	aArg:Matrix DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"f02bbf",_
	["ia"::S,"n"::S,"alb"::S,"ub"::S,"m"::S_
	,"iv"::S,"mm"::S,"ifail"::S,"r"::S,"v"::S,"icount"::S,"a"::S,"d"::S_
	,"e"::S,"e2"::S,"x"::S,"g"::S,"c"::S_
	]$Lisp,_
	["mm"::S,"r"::S,"v"::S,"icount"::S,"d"::S,"e"::S,"e2"::S,"x"::S,"g"::S,"c"::S]$Lisp,_
	[["double"::S,"alb"::S,"ub"::S,["r"::S,"m"::S]$Lisp_
	,["v"::S,"iv"::S,"m"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp,["d"::S,"n"::S]$Lisp,["e"::S,"n"::S]$Lisp,["e2"::S,"n"::S]$Lisp_
	,["x"::S,"n"::S,7$Lisp]$Lisp,["g"::S,"n"::S]$Lisp]$Lisp_
	,["integer"::S,"ia"::S,"n"::S,"m"::S,"iv"::S_
	,"mm"::S,["icount"::S,"m"::S]$Lisp,"ifail"::S]$Lisp_
	,["logical"::S,["c"::S,"n"::S]$Lisp]$Lisp_
	]$Lisp,_
	["mm"::S,"r"::S,"v"::S,"icount"::S,"a"::S,"ifail"::S]$Lisp,_
	[([iaArg::Any,nArg::Any,albArg::Any,ubArg::Any,mArg::Any,ivArg::Any,ifailArg::Any,aArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    f02bjf(nArg:Integer,iaArg:Integer,ibArg:Integer,_
	eps1Arg:DoubleFloat,matvArg:Boolean,ivArg:Integer,_
	aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"f02bjf",_
	["n"::S,"ia"::S,"ib"::S,"eps1"::S,"matv"::S_
	,"iv"::S,"ifail"::S,"alfr"::S,"alfi"::S,"beta"::S,"v"::S,"iter"::S_
	,"a"::S,"b"::S]$Lisp,_
	["alfr"::S,"alfi"::S,"beta"::S,"v"::S,"iter"::S]$Lisp,_
	[["double"::S,"eps1"::S,["alfr"::S,"n"::S]$Lisp_
	,["alfi"::S,"n"::S]$Lisp,["beta"::S,"n"::S]$Lisp,["v"::S,"iv"::S,"n"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp,["b"::S,"ib"::S,"n"::S]$Lisp_
	]$Lisp_
	,["integer"::S,"n"::S,"ia"::S,"ib"::S,"iv"::S_
	,["iter"::S,"n"::S]$Lisp,"ifail"::S]$Lisp_
	,["logical"::S,"matv"::S]$Lisp_
	]$Lisp,_
	["alfr"::S,"alfi"::S,"beta"::S,"v"::S,"iter"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_
	[([nArg::Any,iaArg::Any,ibArg::Any,eps1Arg::Any,matvArg::Any,ivArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    f02fjf(nArg:Integer,kArg:Integer,tolArg:DoubleFloat,_
	novecsArg:Integer,nrxArg:Integer,lworkArg:Integer,_
	lrworkArg:Integer,liworkArg:Integer,mArg:Integer,_
	noitsArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer,_
	dotArg:Union(fn:FileName,fp:Asp27(DOT)),imageArg:Union(fn:FileName,fp:Asp28(IMAGE))): Result == 
	pushFortranOutputStack(dotFilename := aspFilename "dot")$FOP
	if dotArg case fn
		  then outputAsFortran(dotArg.fn)
		  else outputAsFortran(dotArg.fp)
	popFortranOutputStack()$FOP
	pushFortranOutputStack(imageFilename := aspFilename "image")$FOP
	if imageArg case fn
		  then outputAsFortran(imageArg.fn)
		  else outputAsFortran(imageArg.fp)
	popFortranOutputStack()$FOP
	pushFortranOutputStack(monitFilename := aspFilename "monit")$FOP
	outputAsFortran()$Asp29(MONIT)
	popFortranOutputStack()$FOP
	[(invokeNagman([dotFilename,imageFilename,monitFilename]$Lisp,_
	"f02fjf",_
	["n"::S,"k"::S,"tol"::S,"novecs"::S,"nrx"::S_
	,"lwork"::S,"lrwork"::S,"liwork"::S,"m"::S,"noits"::S_
	,"ifail"::S,"dot"::S,"image"::S,"monit"::S,"d"::S,"x"::S,"work"::S,"rwork"::S,"iwork"::S_
	]$Lisp,_
	["d"::S,"work"::S,"rwork"::S,"iwork"::S,"dot"::S,"image"::S,"monit"::S]$Lisp,_
	[["double"::S,"tol"::S,["d"::S,"k"::S]$Lisp_
	,["x"::S,"nrx"::S,"k"::S]$Lisp,["work"::S,"lwork"::S]$Lisp,["rwork"::S,"lrwork"::S]$Lisp,"dot"::S,"image"::S,"monit"::S_
	]$Lisp_
	,["integer"::S,"n"::S,"k"::S,"novecs"::S,"nrx"::S_
	,"lwork"::S,"lrwork"::S,"liwork"::S,"m"::S,"noits"::S,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp]$Lisp_
	]$Lisp,_
	["d"::S,"m"::S,"noits"::S,"x"::S,"ifail"::S]$Lisp,_
	[([nArg::Any,kArg::Any,tolArg::Any,novecsArg::Any,nrxArg::Any,lworkArg::Any,lrworkArg::Any,liworkArg::Any,mArg::Any,noitsArg::Any,ifailArg::Any,xArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    f02fjf(nArg:Integer,kArg:Integer,tolArg:DoubleFloat,_
	novecsArg:Integer,nrxArg:Integer,lworkArg:Integer,_
	lrworkArg:Integer,liworkArg:Integer,mArg:Integer,_
	noitsArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer,_
	dotArg:Union(fn:FileName,fp:Asp27(DOT)),imageArg:Union(fn:FileName,fp:Asp28(IMAGE)),monitArg:FileName): Result == 
	pushFortranOutputStack(dotFilename := aspFilename "dot")$FOP
	if dotArg case fn
		  then outputAsFortran(dotArg.fn)
		  else outputAsFortran(dotArg.fp)
	popFortranOutputStack()$FOP
	pushFortranOutputStack(imageFilename := aspFilename "image")$FOP
	if imageArg case fn
		  then outputAsFortran(imageArg.fn)
		  else outputAsFortran(imageArg.fp)
	popFortranOutputStack()$FOP
	pushFortranOutputStack(monitFilename := aspFilename "monit")$FOP
	outputAsFortran(monitArg)
	[(invokeNagman([dotFilename,imageFilename,monitFilename]$Lisp,_
	"f02fjf",_
	["n"::S,"k"::S,"tol"::S,"novecs"::S,"nrx"::S_
	,"lwork"::S,"lrwork"::S,"liwork"::S,"m"::S,"noits"::S_
	,"ifail"::S,"dot"::S,"image"::S,"monit"::S,"d"::S,"x"::S,"work"::S,"rwork"::S,"iwork"::S_
	]$Lisp,_
	["d"::S,"work"::S,"rwork"::S,"iwork"::S,"dot"::S,"image"::S,"monit"::S]$Lisp,_
	[["double"::S,"tol"::S,["d"::S,"k"::S]$Lisp_
	,["x"::S,"nrx"::S,"k"::S]$Lisp,["work"::S,"lwork"::S]$Lisp,["rwork"::S,"lrwork"::S]$Lisp,"dot"::S,"image"::S,"monit"::S_
	]$Lisp_
	,["integer"::S,"n"::S,"k"::S,"novecs"::S,"nrx"::S_
	,"lwork"::S,"lrwork"::S,"liwork"::S,"m"::S,"noits"::S,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp]$Lisp_
	]$Lisp,_
	["d"::S,"m"::S,"noits"::S,"x"::S,"ifail"::S]$Lisp,_
	[([nArg::Any,kArg::Any,tolArg::Any,novecsArg::Any,nrxArg::Any,lworkArg::Any,lrworkArg::Any,liworkArg::Any,mArg::Any,noitsArg::Any,ifailArg::Any,xArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    f02wef(mArg:Integer,nArg:Integer,ldaArg:Integer,_
	ncolbArg:Integer,ldbArg:Integer,wantqArg:Boolean,_
	ldqArg:Integer,wantpArg:Boolean,ldptArg:Integer,_
	aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,ifailArg:Integer): Result == 
        workLength : Integer :=
          mArg >= nArg =>
            wantqArg and wantpArg =>
              max(max(nArg**2 + 5*(nArg - 1),nArg + ncolbArg),4)
            wantqArg =>
              max(max(nArg**2 + 4*(nArg - 1),nArg + ncolbArg),4)
            wantpArg =>
              zero? ncolbArg => max(3*(nArg - 1),2)
              max(5*(nArg - 1),2)
            zero? ncolbArg => max(2*(nArg - 1),2)
            max(3*(nArg - 1),2)
          wantqArg and wantpArg =>
            max(mArg**2 + 5*(mArg - 1),2)
          wantqArg =>
            max(3*(mArg - 1),1)
          wantpArg =>
            zero? ncolbArg => max(mArg**2+3*(mArg - 1),2)
            max(mArg**2+5*(mArg - 1),2)
          zero? ncolbArg => max(2*(mArg - 1),1)
          max(3*(mArg - 1),1)

	[(invokeNagman(NIL$Lisp,_
	"f02wef",_
	["m"::S,"n"::S,"lda"::S,"ncolb"::S,"ldb"::S_
	,"wantq"::S,"ldq"::S,"wantp"::S,"ldpt"::S,"ifail"::S_
	,"q"::S,"sv"::S,"pt"::S,"work"::S,"a"::S_
	,"b"::S]$Lisp,_
	["q"::S,"sv"::S,"pt"::S,"work"::S]$Lisp,_
	[["double"::S,["q"::S,"ldq"::S,"m"::S]$Lisp_
	,["sv"::S,"m"::S]$Lisp,["pt"::S,"ldpt"::S,"n"::S]$Lisp,["work"::S,workLength]$Lisp,["a"::S,"lda"::S,"n"::S]$Lisp,["b"::S,"ldb"::S,"ncolb"::S]$Lisp_
	]$Lisp_
	,["integer"::S,"m"::S,"n"::S,"lda"::S,"ncolb"::S_
	,"ldb"::S,"ldq"::S,"ldpt"::S,"ifail"::S]$Lisp_
	,["logical"::S,"wantq"::S,"wantp"::S]$Lisp_
	]$Lisp,_
	["q"::S,"sv"::S,"pt"::S,"work"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_
	[([mArg::Any,nArg::Any,ldaArg::Any,ncolbArg::Any,ldbArg::Any,wantqArg::Any,ldqArg::Any,wantpArg::Any,ldptArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    f02xef(mArg:Integer,nArg:Integer,ldaArg:Integer,_
	ncolbArg:Integer,ldbArg:Integer,wantqArg:Boolean,_
	ldqArg:Integer,wantpArg:Boolean,ldphArg:Integer,_
	aArg:Matrix Complex DoubleFloat,bArg:Matrix Complex DoubleFloat,ifailArg:Integer): Result == 
        -- This segment added by hand, to deal with an assumed size array GDN
        tem : Integer := (min(mArg,nArg)-1)
	rLen : Integer := 
          zero? ncolbArg and not wantqArg and not wantpArg => 2*tem
          zero? ncolbArg and wantpArg and not wantqArg => 3*tem
          not wantpArg =>
            ncolbArg >0 or wantqArg => 3*tem
          5*tem
	cLen : Integer :=
          mArg >= nArg =>
            wantqArg and wantpArg => 2*(nArg + max(nArg**2,ncolbArg))
            wantqArg and not wantpArg => 2*(nArg + max(nArg**2+nArg,ncolbArg))
            2*(nArg + max(nArg,ncolbArg))
          wantpArg => 2*(mArg**2 + mArg)
          2*mArg          
	svLength : Integer :=
          min(mArg,nArg)
	[(invokeNagman(NIL$Lisp,_
	"f02xef",_
	["m"::S,"n"::S,"lda"::S,"ncolb"::S,"ldb"::S_
	,"wantq"::S,"ldq"::S,"wantp"::S,"ldph"::S,"ifail"::S_
	,"q"::S,"sv"::S,"ph"::S,"rwork"::S,"a"::S_
	,"b"::S,"cwork"::S]$Lisp,_
	["q"::S,"sv"::S,"ph"::S,"rwork"::S,"cwork"::S]$Lisp,_
	[["double"::S,["sv"::S,svLength]$Lisp,["rwork"::S,rLen]$Lisp_
	]$Lisp_
	,["integer"::S,"m"::S,"n"::S,"lda"::S,"ncolb"::S_
	,"ldb"::S,"ldq"::S,"ldph"::S,"ifail"::S]$Lisp_
	,["logical"::S,"wantq"::S,"wantp"::S]$Lisp_
	,["double complex"::S,["q"::S,"ldq"::S,"m"::S]$Lisp,["ph"::S,"ldph"::S,"n"::S]$Lisp,["a"::S,"lda"::S,"n"::S]$Lisp,["b"::S,"ldb"::S,"ncolb"::S]$Lisp,["cwork"::S,cLen]$Lisp]$Lisp_
	]$Lisp,_
	["q"::S,"sv"::S,"ph"::S,"rwork"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_
	[([mArg::Any,nArg::Any,ldaArg::Any,ncolbArg::Any,ldbArg::Any,wantqArg::Any,ldqArg::Any,wantpArg::Any,ldphArg::Any,ifailArg::Any,aArg::Any,bArg::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 NAGF02 NagEigenPackage>>
@
\eject
\begin{thebibliography}{99}
\bibitem{1} nothing
\end{thebibliography}
\end{document}