\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}
<<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}
<<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 NAGD02 NagOrdinaryDifferentialEquationsPackage>>
@
\eject
\begin{thebibliography}{99}
\bibitem{1} nothing
\end{thebibliography}
\end{document}