\documentclass{article} \usepackage{axiom} \begin{document} \title{\$SPAD/src/algebra d02.spad} \author{Godfrey Nolan, Mike Dewar} \maketitle \begin{abstract} \end{abstract} \eject \tableofcontents \eject \section{package NAGD02 NagOrdinaryDifferentialEquationsPackage} <>= )abbrev package NAGD02 NagOrdinaryDifferentialEquationsPackage ++ Author: Godfrey Nolan and Mike Dewar ++ Date Created: Jan 1994 ++ Date Last Updated: Mon Jun 20 17:56:33 1994 ++Description: ++This package uses the NAG Library to calculate the numerical solution of ordinary ++differential equations. There are two main types of problem, ++those in which all boundary conditions are specified at one point ++(initial-value problems), and those in which the boundary ++conditions are distributed between two or more points (boundary- ++value problems and eigenvalue problems). Routines are available ++for initial-value problems, two-point boundary-value problems and ++Sturm-Liouville eigenvalue problems. ++See \downlink{Manual Page}{manpageXXd02}. NagOrdinaryDifferentialEquationsPackage(): Exports == Implementation where S ==> Symbol FOP ==> FortranOutputStackPackage Exports ==> with d02bbf : (DoubleFloat,Integer,Integer,Integer,_ DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,Union(fn:FileName,fp:Asp7(FCN)),Union(fn:FileName,fp:Asp8(OUTPUT))) -> Result ++ d02bbf(xend,m,n,irelab,x,y,tol,ifail,fcn,output) ++ integrates a system of first-order ordinary differential ++ equations over an interval with suitable initial conditions, ++ using a Runge-Kutta-Merson method, and returns the solution at ++ points specified by the user. ++ See \downlink{Manual Page}{manpageXXd02bbf}. d02bhf : (DoubleFloat,Integer,Integer,DoubleFloat,_ DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,Union(fn:FileName,fp:Asp9(G)),Union(fn:FileName,fp:Asp7(FCN))) -> Result ++ d02bhf(xend,n,irelab,hmax,x,y,tol,ifail,g,fcn) ++ integrates a system of first-order ordinary differential ++ equations over an interval with suitable initial conditions, ++ using a Runge-Kutta-Merson method, until a user-specified ++ function of the solution is zero. ++ See \downlink{Manual Page}{manpageXXd02bhf}. d02cjf : (DoubleFloat,Integer,Integer,DoubleFloat,_ String,DoubleFloat,Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp9(G)),Union(fn:FileName,fp:Asp7(FCN)),Union(fn:FileName,fp:Asp8(OUTPUT))) -> Result ++ d02cjf(xend,m,n,tol,relabs,x,y,ifail,g,fcn,output) ++ integrates a system of first-order ordinary differential ++ equations over a range with suitable initial conditions, using a ++ variable-order, variable-step Adams method until a user-specified ++ function, if supplied, of the solution is zero, and returns the ++ solution at points specified by the user, if desired. ++ See \downlink{Manual Page}{manpageXXd02cjf}. d02ejf : (DoubleFloat,Integer,Integer,String,_ Integer,DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,Union(fn:FileName,fp:Asp9(G)),Union(fn:FileName,fp:Asp7(FCN)),Union(fn:FileName,fp:Asp31(PEDERV)),Union(fn:FileName,fp:Asp8(OUTPUT))) -> Result ++ d02ejf(xend,m,n,relabs,iw,x,y,tol,ifail,g,fcn,pederv,output) ++ integrates a stiff system of first-order ordinary ++ differential equations over an interval with suitable initial ++ conditions, using a variable-order, variable-step method ++ implementing the Backward Differentiation Formulae (BDF), until a ++ user-specified function, if supplied, of the solution is zero, ++ and returns the solution at points specified by the user, if ++ desired. ++ See \downlink{Manual Page}{manpageXXd02ejf}. d02gaf : (Matrix DoubleFloat,Matrix DoubleFloat,Integer,DoubleFloat,_ DoubleFloat,DoubleFloat,Integer,Integer,Integer,Matrix DoubleFloat,Integer,Integer,Union(fn:FileName,fp:Asp7(FCN))) -> Result ++ d02gaf(u,v,n,a,b,tol,mnp,lw,liw,x,np,ifail,fcn) ++ solves the two-point boundary-value problem with assigned ++ boundary values for a system of ordinary differential equations, ++ using a deferred correction technique and a Newton iteration. ++ See \downlink{Manual Page}{manpageXXd02gaf}. d02gbf : (DoubleFloat,DoubleFloat,Integer,DoubleFloat,_ Integer,Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Integer,Integer,Union(fn:FileName,fp:Asp77(FCNF)),Union(fn:FileName,fp:Asp78(FCNG))) -> Result ++ d02gbf(a,b,n,tol,mnp,lw,liw,c,d,gam,x,np,ifail,fcnf,fcng) ++ solves a general linear two-point boundary value problem ++ for a system of ordinary differential equations using a deferred ++ correction technique. ++ See \downlink{Manual Page}{manpageXXd02gbf}. d02kef : (Matrix DoubleFloat,Integer,Integer,DoubleFloat,_ Integer,Integer,DoubleFloat,DoubleFloat,Matrix DoubleFloat,Integer,Integer,Union(fn:FileName,fp:Asp10(COEFFN)),Union(fn:FileName,fp:Asp80(BDYVAL))) -> Result ++ d02kef(xpoint,m,k,tol,maxfun,match,elam,delam,hmax,maxit,ifail,coeffn,bdyval) ++ finds a specified eigenvalue of a regular singular second- ++ order Sturm-Liouville system on a finite or infinite range, using ++ a Pruefer transformation and a shooting method. It also reports ++ values of the eigenfunction and its derivatives. Provision is ++ made for discontinuities in the coefficient functions or their ++ derivatives. ++ See \downlink{Manual Page}{manpageXXd02kef}. ++ ASP domains Asp12 and Asp33 are used to supply default ++ subroutines for the MONIT and REPORT arguments via their \axiomOp{outputAsFortran} operation. d02kef : (Matrix DoubleFloat,Integer,Integer,DoubleFloat,_ Integer,Integer,DoubleFloat,DoubleFloat,Matrix DoubleFloat,Integer,Integer,Union(fn:FileName,fp:Asp10(COEFFN)),Union(fn:FileName,fp:Asp80(BDYVAL)),FileName,FileName) -> Result ++ d02kef(xpoint,m,k,tol,maxfun,match,elam,delam,hmax,maxit,ifail,coeffn,bdyval,monit,report) ++ finds a specified eigenvalue of a regular singular second- ++ order Sturm-Liouville system on a finite or infinite range, using ++ a Pruefer transformation and a shooting method. It also reports ++ values of the eigenfunction and its derivatives. Provision is ++ made for discontinuities in the coefficient functions or their ++ derivatives. ++ See \downlink{Manual Page}{manpageXXd02kef}. ++ Files \spad{monit} and \spad{report} will be used to define the subroutines for the ++ MONIT and REPORT arguments. ++ See \downlink{Manual Page}{manpageXXd02gbf}. d02raf : (Integer,Integer,Integer,Integer,_ DoubleFloat,Integer,Integer,Integer,Integer,Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,Union(fn:FileName,fp:Asp41(FCN,JACOBF,JACEPS)),Union(fn:FileName,fp:Asp42(G,JACOBG,JACGEP))) -> Result ++ d02raf(n,mnp,numbeg,nummix,tol,init,iy,ijac,lwork,liwork,np,x,y,deleps,ifail,fcn,g) ++ solves the two-point boundary-value problem with general ++ boundary conditions for a system of ordinary differential ++ equations, using a deferred correction technique and Newton ++ iteration. ++ See \downlink{Manual Page}{manpageXXd02raf}. Implementation ==> add import Lisp import DoubleFloat import Any import Record import Integer import Matrix DoubleFloat import Boolean import NAGLinkSupportPackage import FortranPackage import Union(fn:FileName,fp:Asp7(FCN)) import Union(fn:FileName,fp:Asp8(OUTPUT)) import AnyFunctions1(DoubleFloat) import AnyFunctions1(Integer) import AnyFunctions1(String) import AnyFunctions1(Matrix DoubleFloat) d02bbf(xendArg:DoubleFloat,mArg:Integer,nArg:Integer,_ irelabArg:Integer,xArg:DoubleFloat,yArg:Matrix DoubleFloat,_ tolArg:DoubleFloat,ifailArg:Integer,fcnArg:Union(fn:FileName,fp:Asp7(FCN)),_ outputArg:Union(fn:FileName,fp:Asp8(OUTPUT))): Result == pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP if fcnArg case fn then outputAsFortran(fcnArg.fn) else outputAsFortran(fcnArg.fp) popFortranOutputStack()$FOP pushFortranOutputStack(outputFilename := aspFilename "output")$FOP if outputArg case fn then outputAsFortran(outputArg.fn) else outputAsFortran(outputArg.fp) popFortranOutputStack()$FOP [(invokeNagman([fcnFilename, outputFilename]$Lisp,_ "d02bbf",_ ["xend"::S,"m"::S,"n"::S,"irelab"::S,"x"::S_ ,"tol"::S,"ifail"::S,"fcn"::S,"output"::S,"result"::S,"y"::S,"w"::S]$Lisp,_ ["result"::S,"w"::S,"fcn"::S,"output"::S]$Lisp,_ [["double"::S,"xend"::S,["result"::S,"m"::S,"n"::S]$Lisp_ ,"x"::S,["y"::S,"n"::S]$Lisp,"tol"::S,["w"::S,"n"::S,7$Lisp]$Lisp,"fcn"::S,"output"::S]$Lisp_ ,["integer"::S,"m"::S,"n"::S,"irelab"::S,"ifail"::S_ ]$Lisp_ ]$Lisp,_ ["result"::S,"x"::S,"y"::S,"tol"::S,"ifail"::S]$Lisp,_ [([xendArg::Any,mArg::Any,nArg::Any,irelabArg::Any,xArg::Any,tolArg::Any,ifailArg::Any,yArg::Any ])_ @List Any]$Lisp)$Lisp)_ pretend List (Record(key:Symbol,entry:Any))]$Result d02bhf(xendArg:DoubleFloat,nArg:Integer,irelabArg:Integer,_ hmaxArg:DoubleFloat,xArg:DoubleFloat,yArg:Matrix DoubleFloat,_ tolArg:DoubleFloat,ifailArg:Integer,gArg:Union(fn:FileName,fp:Asp9(G)),_ fcnArg:Union(fn:FileName,fp:Asp7(FCN))): Result == pushFortranOutputStack(gFilename := aspFilename "g")$FOP if gArg case fn then outputAsFortran(gArg.fn) else outputAsFortran(gArg.fp) popFortranOutputStack()$FOP pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP if fcnArg case fn then outputAsFortran(fcnArg.fn) else outputAsFortran(fcnArg.fp) popFortranOutputStack()$FOP [(invokeNagman([gFilename,fcnFilename]$Lisp,_ "d02bhf",_ ["xend"::S,"n"::S,"irelab"::S,"hmax"::S,"x"::S_ ,"tol"::S,"ifail"::S,"g"::S,"fcn"::S,"y"::S,"w"::S]$Lisp,_ ["w"::S,"g"::S,"fcn"::S]$Lisp,_ [["double"::S,"xend"::S,"hmax"::S,"x"::S,["y"::S,"n"::S]$Lisp_ ,"tol"::S,["w"::S,"n"::S,7$Lisp]$Lisp,"g"::S,"fcn"::S]$Lisp_ ,["integer"::S,"n"::S,"irelab"::S,"ifail"::S_ ]$Lisp_ ]$Lisp,_ ["x"::S,"y"::S,"tol"::S,"ifail"::S]$Lisp,_ [([xendArg::Any,nArg::Any,irelabArg::Any,hmaxArg::Any,xArg::Any,tolArg::Any,ifailArg::Any,yArg::Any ])_ @List Any]$Lisp)$Lisp)_ pretend List (Record(key:Symbol,entry:Any))]$Result d02cjf(xendArg:DoubleFloat,mArg:Integer,nArg:Integer,_ tolArg:DoubleFloat,relabsArg:String,xArg:DoubleFloat,_ yArg:Matrix DoubleFloat,ifailArg:Integer,gArg:Union(fn:FileName,fp:Asp9(G)),_ fcnArg:Union(fn:FileName,fp:Asp7(FCN)),outputArg:Union(fn:FileName,fp:Asp8(OUTPUT))): Result == pushFortranOutputStack(gFilename := aspFilename "g")$FOP if gArg case fn then outputAsFortran(gArg.fn) else outputAsFortran(gArg.fp) popFortranOutputStack()$FOP pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP if fcnArg case fn then outputAsFortran(fcnArg.fn) else outputAsFortran(fcnArg.fp) popFortranOutputStack()$FOP pushFortranOutputStack(outputFilename := aspFilename "output")$FOP if outputArg case fn then outputAsFortran(outputArg.fn) else outputAsFortran(outputArg.fp) popFortranOutputStack()$FOP [(invokeNagman([gFilename,fcnFilename,outputFilename]$Lisp,_ "d02cjf",_ ["xend"::S,"m"::S,"n"::S,"tol"::S,"relabs"::S_ ,"x"::S,"ifail"::S,"g"::S,"fcn"::S,"output"::S_ ,"result"::S,"y"::S,"w"::S]$Lisp,_ ["result"::S,"w"::S,"g"::S,"fcn"::S,"output"::S]$Lisp,_ [["double"::S,"xend"::S,"tol"::S,["result"::S,"m"::S,"n"::S]$Lisp_ ,"x"::S,["y"::S,"n"::S]$Lisp,["w"::S,["+"::S,["*"::S,21$Lisp,"n"::S]$Lisp,28$Lisp]$Lisp]$Lisp,"g"::S_ ,"fcn"::S,"output"::S]$Lisp_ ,["integer"::S,"m"::S,"n"::S,"ifail"::S]$Lisp_ ,["character"::S,"relabs"::S]$Lisp_ ]$Lisp,_ ["result"::S,"x"::S,"y"::S,"ifail"::S]$Lisp,_ [([xendArg::Any,mArg::Any,nArg::Any,tolArg::Any,relabsArg::Any,xArg::Any,ifailArg::Any,yArg::Any ])_ @List Any]$Lisp)$Lisp)_ pretend List (Record(key:Symbol,entry:Any))]$Result d02ejf(xendArg:DoubleFloat,mArg:Integer,nArg:Integer,_ relabsArg:String,iwArg:Integer,xArg:DoubleFloat,_ yArg:Matrix DoubleFloat,tolArg:DoubleFloat,ifailArg:Integer,_ gArg:Union(fn:FileName,fp:Asp9(G)),fcnArg:Union(fn:FileName,fp:Asp7(FCN)),pedervArg:Union(fn:FileName,fp:Asp31(PEDERV)),_ outputArg:Union(fn:FileName,fp:Asp8(OUTPUT))): Result == pushFortranOutputStack(gFilename := aspFilename "g")$FOP if gArg case fn then outputAsFortran(gArg.fn) else outputAsFortran(gArg.fp) popFortranOutputStack()$FOP pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP if fcnArg case fn then outputAsFortran(fcnArg.fn) else outputAsFortran(fcnArg.fp) popFortranOutputStack()$FOP pushFortranOutputStack(pedervFilename := aspFilename "pederv")$FOP if pedervArg case fn then outputAsFortran(pedervArg.fn) else outputAsFortran(pedervArg.fp) popFortranOutputStack()$FOP pushFortranOutputStack(outputFilename := aspFilename "output")$FOP if outputArg case fn then outputAsFortran(outputArg.fn) else outputAsFortran(outputArg.fp) popFortranOutputStack()$FOP [(invokeNagman([gFilename,fcnFilename,pedervFilename,outputFilename]$Lisp,_ "d02ejf",_ ["xend"::S,"m"::S,"n"::S,"relabs"::S,"iw"::S_ ,"x"::S,"tol"::S,"ifail"::S,"g"::S,"fcn"::S_ ,"pederv"::S,"output"::S,"result"::S,"y"::S,"w"::S]$Lisp,_ ["result"::S,"w"::S,"g"::S,"fcn"::S,"pederv"::S,"output"::S]$Lisp,_ [["double"::S,"xend"::S,["result"::S,"m"::S,"n"::S]$Lisp_ ,"x"::S,["y"::S,"n"::S]$Lisp,"tol"::S,["w"::S,"iw"::S]$Lisp,"g"::S,"fcn"::S,"pederv"::S,"output"::S]$Lisp_ ,["integer"::S,"m"::S,"n"::S,"iw"::S,"ifail"::S_ ]$Lisp_ ,["character"::S,"relabs"::S]$Lisp_ ]$Lisp,_ ["result"::S,"x"::S,"y"::S,"tol"::S,"ifail"::S]$Lisp,_ [([xendArg::Any,mArg::Any,nArg::Any,relabsArg::Any,iwArg::Any,xArg::Any,tolArg::Any,ifailArg::Any,yArg::Any ])_ @List Any]$Lisp)$Lisp)_ pretend List (Record(key:Symbol,entry:Any))]$Result d02gaf(uArg:Matrix DoubleFloat,vArg:Matrix DoubleFloat,nArg:Integer,_ aArg:DoubleFloat,bArg:DoubleFloat,tolArg:DoubleFloat,_ mnpArg:Integer,lwArg:Integer,liwArg:Integer,_ xArg:Matrix DoubleFloat,npArg:Integer,ifailArg:Integer,_ fcnArg:Union(fn:FileName,fp:Asp7(FCN))): Result == pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP if fcnArg case fn then outputAsFortran(fcnArg.fn) else outputAsFortran(fcnArg.fp) popFortranOutputStack()$FOP [(invokeNagman([fcnFilename]$Lisp,_ "d02gaf",_ ["n"::S,"a"::S,"b"::S,"tol"::S,"mnp"::S_ ,"lw"::S,"liw"::S,"np"::S,"ifail"::S,"fcn"::S_ ,"u"::S,"v"::S,"y"::S,"x"::S,"w"::S_ ,"iw"::S]$Lisp,_ ["y"::S,"w"::S,"iw"::S,"fcn"::S]$Lisp,_ [["double"::S,["u"::S,"n"::S,2$Lisp]$Lisp,["v"::S,"n"::S,2$Lisp]$Lisp_ ,"a"::S,"b"::S,"tol"::S,["y"::S,"n"::S,"mnp"::S]$Lisp,["x"::S,"mnp"::S]$Lisp,["w"::S,"lw"::S]$Lisp_ ,"fcn"::S]$Lisp_ ,["integer"::S,"n"::S,"mnp"::S,"lw"::S,"liw"::S_ ,"np"::S,"ifail"::S,["iw"::S,"liw"::S]$Lisp]$Lisp_ ]$Lisp,_ ["y"::S,"x"::S,"np"::S,"ifail"::S]$Lisp,_ [([nArg::Any,aArg::Any,bArg::Any,tolArg::Any,mnpArg::Any,lwArg::Any,liwArg::Any,npArg::Any,ifailArg::Any,uArg::Any,vArg::Any,xArg::Any ])_ @List Any]$Lisp)$Lisp)_ pretend List (Record(key:Symbol,entry:Any))]$Result d02gbf(aArg:DoubleFloat,bArg:DoubleFloat,nArg:Integer,_ tolArg:DoubleFloat,mnpArg:Integer,lwArg:Integer,_ liwArg:Integer,cArg:Matrix DoubleFloat,dArg:Matrix DoubleFloat,_ gamArg:Matrix DoubleFloat,xArg:Matrix DoubleFloat,npArg:Integer,_ ifailArg:Integer,fcnfArg:Union(fn:FileName,fp:Asp77(FCNF)),fcngArg:Union(fn:FileName,fp:Asp78(FCNG))): Result == pushFortranOutputStack(fcnfFilename := aspFilename "fcnf")$FOP if fcnfArg case fn then outputAsFortran(fcnfArg.fn) else outputAsFortran(fcnfArg.fp) popFortranOutputStack()$FOP pushFortranOutputStack(fcngFilename := aspFilename "fcng")$FOP if fcngArg case fn then outputAsFortran(fcngArg.fn) else outputAsFortran(fcngArg.fp) popFortranOutputStack()$FOP [(invokeNagman([fcnfFilename,fcngFilename]$Lisp,_ "d02gbf",_ ["a"::S,"b"::S,"n"::S,"tol"::S,"mnp"::S_ ,"lw"::S,"liw"::S,"np"::S,"ifail"::S,"fcnf"::S_ ,"fcng"::S,"y"::S,"c"::S,"d"::S,"gam"::S,"x"::S_ ,"w"::S,"iw"::S]$Lisp,_ ["y"::S,"w"::S,"iw"::S,"fcnf"::S,"fcng"::S]$Lisp,_ [["double"::S,"a"::S,"b"::S,"tol"::S,["y"::S,"n"::S,"mnp"::S]$Lisp_ ,["c"::S,"n"::S,"n"::S]$Lisp,["d"::S,"n"::S,"n"::S]$Lisp,["gam"::S,"n"::S]$Lisp,["x"::S,"mnp"::S]$Lisp_ ,["w"::S,"lw"::S]$Lisp,"fcnf"::S,"fcng"::S]$Lisp_ ,["integer"::S,"n"::S,"mnp"::S,"lw"::S,"liw"::S_ ,"np"::S,"ifail"::S,["iw"::S,"liw"::S]$Lisp]$Lisp_ ]$Lisp,_ ["y"::S,"c"::S,"d"::S,"gam"::S,"x"::S,"np"::S,"ifail"::S]$Lisp,_ [([aArg::Any,bArg::Any,nArg::Any,tolArg::Any,mnpArg::Any,lwArg::Any,liwArg::Any,npArg::Any,ifailArg::Any,cArg::Any,dArg::Any,gamArg::Any,xArg::Any ])_ @List Any]$Lisp)$Lisp)_ pretend List (Record(key:Symbol,entry:Any))]$Result d02kef(xpointArg:Matrix DoubleFloat,mArg:Integer,kArg:Integer,_ tolArg:DoubleFloat,maxfunArg:Integer,matchArg:Integer,_ elamArg:DoubleFloat,delamArg:DoubleFloat,hmaxArg:Matrix DoubleFloat,_ maxitArg:Integer,ifailArg:Integer,coeffnArg:Union(fn:FileName,fp:Asp10(COEFFN)),_ bdyvalArg:Union(fn:FileName,fp:Asp80(BDYVAL))): Result == pushFortranOutputStack(coeffnFilename := aspFilename "coeffn")$FOP if coeffnArg case fn then outputAsFortran(coeffnArg.fn) else outputAsFortran(coeffnArg.fp) popFortranOutputStack()$FOP pushFortranOutputStack(bdyvalFilename := aspFilename "bdyval")$FOP if bdyvalArg case fn then outputAsFortran(bdyvalArg.fn) else outputAsFortran(bdyvalArg.fp) popFortranOutputStack()$FOP pushFortranOutputStack(monitFilename := aspFilename "monit")$FOP outputAsFortran()$Asp12(MONIT) popFortranOutputStack()$FOP pushFortranOutputStack(reportFilename := aspFilename "report")$FOP outputAsFortran()$Asp33(REPORT) popFortranOutputStack()$FOP [(invokeNagman([coeffnFilename,bdyvalFilename,monitFilename,reportFilename]$Lisp,_ "d02kef",_ ["m"::S,"k"::S,"tol"::S,"maxfun"::S,"match"::S_ ,"elam"::S,"delam"::S,"maxit"::S,"ifail"::S,"coeffn"::S_ ,"bdyval"::S,"monit"::S,"report"::S,"xpoint"::S,"hmax"::S]$Lisp,_ ["coeffn"::S,"bdyval"::S,"monit"::S,"report"::S]$Lisp,_ [["double"::S,["xpoint"::S,"m"::S]$Lisp,"tol"::S_ ,"elam"::S,"delam"::S,["hmax"::S,2$Lisp,"m"::S]$Lisp,"coeffn"::S,"bdyval"::S,"monit"::S,"report"::S]$Lisp_ ,["integer"::S,"m"::S,"k"::S,"maxfun"::S,"match"::S_ ,"maxit"::S,"ifail"::S]$Lisp_ ]$Lisp,_ ["match"::S,"elam"::S,"delam"::S,"hmax"::S,"maxit"::S,"ifail"::S]$Lisp,_ [([mArg::Any,kArg::Any,tolArg::Any,maxfunArg::Any,matchArg::Any,elamArg::Any,delamArg::Any,maxitArg::Any,ifailArg::Any,xpointArg::Any,hmaxArg::Any ])_ @List Any]$Lisp)$Lisp)_ pretend List (Record(key:Symbol,entry:Any))]$Result d02kef(xpointArg:Matrix DoubleFloat,mArg:Integer,kArg:Integer,_ tolArg:DoubleFloat,maxfunArg:Integer,matchArg:Integer,_ elamArg:DoubleFloat,delamArg:DoubleFloat,hmaxArg:Matrix DoubleFloat,_ maxitArg:Integer,ifailArg:Integer,coeffnArg:Union(fn:FileName,fp:Asp10(COEFFN)),_ bdyvalArg:Union(fn:FileName,fp:Asp80(BDYVAL)),monitArg:FileName,reportArg:FileName): Result == pushFortranOutputStack(coeffnFilename := aspFilename "coeffn")$FOP if coeffnArg case fn then outputAsFortran(coeffnArg.fn) else outputAsFortran(coeffnArg.fp) popFortranOutputStack()$FOP pushFortranOutputStack(bdyvalFilename := aspFilename "bdyval")$FOP if bdyvalArg case fn then outputAsFortran(bdyvalArg.fn) else outputAsFortran(bdyvalArg.fp) popFortranOutputStack()$FOP pushFortranOutputStack(monitFilename := aspFilename "monit")$FOP outputAsFortran(monitArg) popFortranOutputStack()$FOP pushFortranOutputStack(reportFilename := aspFilename "report")$FOP outputAsFortran(reportArg) popFortranOutputStack()$FOP [(invokeNagman([coeffnFilename,bdyvalFilename,monitFilename,reportFilename]$Lisp,_ "d02kef",_ ["m"::S,"k"::S,"tol"::S,"maxfun"::S,"match"::S_ ,"elam"::S,"delam"::S,"maxit"::S,"ifail"::S,"coeffn"::S_ ,"bdyval"::S,"monit"::S,"report"::S,"xpoint"::S,"hmax"::S]$Lisp,_ ["coeffn"::S,"bdyval"::S,"monit"::S,"report"::S]$Lisp,_ [["double"::S,["xpoint"::S,"m"::S]$Lisp,"tol"::S_ ,"elam"::S,"delam"::S,["hmax"::S,2$Lisp,"m"::S]$Lisp,"coeffn"::S,"bdyval"::S,"monit"::S,"report"::S]$Lisp_ ,["integer"::S,"m"::S,"k"::S,"maxfun"::S,"match"::S_ ,"maxit"::S,"ifail"::S]$Lisp_ ]$Lisp,_ ["match"::S,"elam"::S,"delam"::S,"hmax"::S,"maxit"::S,"ifail"::S]$Lisp,_ [([mArg::Any,kArg::Any,tolArg::Any,maxfunArg::Any,matchArg::Any,elamArg::Any,delamArg::Any,maxitArg::Any,ifailArg::Any,xpointArg::Any,hmaxArg::Any ])_ @List Any]$Lisp)$Lisp)_ pretend List (Record(key:Symbol,entry:Any))]$Result d02raf(nArg:Integer,mnpArg:Integer,numbegArg:Integer,_ nummixArg:Integer,tolArg:DoubleFloat,initArg:Integer,_ iyArg:Integer,ijacArg:Integer,lworkArg:Integer,_ liworkArg:Integer,npArg:Integer,xArg:Matrix DoubleFloat,_ yArg:Matrix DoubleFloat,delepsArg:DoubleFloat,ifailArg:Integer,_ fcnArg:Union(fn:FileName,fp:Asp41(FCN,JACOBF,JACEPS)),gArg:Union(fn:FileName,fp:Asp42(G,JACOBG,JACGEP))): Result == pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP if fcnArg case fn then outputAsFortran(fcnArg.fn) else outputAsFortran(fcnArg.fp) popFortranOutputStack()$FOP pushFortranOutputStack(gFilename := aspFilename "g")$FOP if gArg case fn then outputAsFortran(gArg.fn) else outputAsFortran(gArg.fp) popFortranOutputStack()$FOP [(invokeNagman([fcnFilename,gFilename]$Lisp,_ "d02raf",_ ["n"::S,"mnp"::S,"numbeg"::S,"nummix"::S,"tol"::S_ ,"init"::S,"iy"::S,"ijac"::S,"lwork"::S,"liwork"::S_ ,"np"::S,"deleps"::S,"ifail"::S,"fcn"::S,"g"::S_ ,"abt"::S,"x"::S,"y"::S,"work"::S,"iwork"::S_ ]$Lisp,_ ["abt"::S,"work"::S,"iwork"::S,"fcn"::S,"g"::S]$Lisp,_ [["double"::S,"tol"::S,["abt"::S,"n"::S]$Lisp_ ,["x"::S,"mnp"::S]$Lisp,["y"::S,"iy"::S,"mnp"::S]$Lisp,"deleps"::S,["work"::S,"lwork"::S]$Lisp,"fcn"::S,"g"::S]$Lisp_ ,["integer"::S,"n"::S,"mnp"::S,"numbeg"::S_ ,"nummix"::S,"init"::S,"iy"::S,"ijac"::S,"lwork"::S,"liwork"::S,"np"::S,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp]$Lisp_ ]$Lisp,_ ["abt"::S,"np"::S,"x"::S,"y"::S,"deleps"::S,"ifail"::S]$Lisp,_ [([nArg::Any,mnpArg::Any,numbegArg::Any,nummixArg::Any,tolArg::Any,initArg::Any,iyArg::Any,ijacArg::Any,lworkArg::Any,liworkArg::Any,npArg::Any,delepsArg::Any,ifailArg::Any,xArg::Any,yArg::Any ])_ @List Any]$Lisp)$Lisp)_ pretend List (Record(key:Symbol,entry:Any))]$Result @ \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}