\documentclass{article}
\usepackage{axiom}
\begin{document}
\title{\$SPAD/src/algebra d01.spad}
\author{Godfrey Nolan, Mike Dewar}
\maketitle
\begin{abstract}
\end{abstract}
\eject
\tableofcontents
\eject
\section{package NAGD01 NagIntegrationPackage}
<<package NAGD01 NagIntegrationPackage>>=
)abbrev package NAGD01 NagIntegrationPackage
++ Author: Godfrey Nolan and Mike Dewar
++ Date Created: Jan 1994
++ Date Last Updated: Thu May 12 17:44:37 1994
++Description:
++This package uses the NAG Library to calculate the numerical value of
++definite integrals in one or more dimensions and to evaluate
++weights and abscissae of integration rules.
++See \downlink{Manual Page}{manpageXXd01}.

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

  Exports ==> with
    d01ajf : (DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,_
	Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(F))) -> Result 
     ++ d01ajf(a,b,epsabs,epsrel,lw,liw,ifail,f)
     ++ is a general-purpose integrator which calculates an 
     ++ approximation to the integral of a function f(x) over a finite 
     ++ interval [a,b]:
     ++ See \downlink{Manual Page}{manpageXXd01ajf}.
    d01akf : (DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,_
	Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(F))) -> Result 
     ++ d01akf(a,b,epsabs,epsrel,lw,liw,ifail,f)
     ++ is an adaptive integrator, especially suited to 
     ++ oscillating, non-singular integrands, which calculates an 
     ++ approximation to the integral of a function f(x) over a finite 
     ++ interval [a,b]:
     ++ See \downlink{Manual Page}{manpageXXd01akf}.
    d01alf : (DoubleFloat,DoubleFloat,Integer,Matrix DoubleFloat,_
	DoubleFloat,DoubleFloat,Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(F))) -> Result 
     ++ d01alf(a,b,npts,points,epsabs,epsrel,lw,liw,ifail,f)
     ++ is a general purpose integrator which calculates an 
     ++ approximation to the integral of a function f(x) over a finite 
     ++ interval [a,b]:
     ++ See \downlink{Manual Page}{manpageXXd01alf}.
    d01amf : (DoubleFloat,Integer,DoubleFloat,DoubleFloat,_
	Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(F))) -> Result 
     ++ d01amf(bound,inf,epsabs,epsrel,lw,liw,ifail,f)
     ++ calculates an approximation to the integral of a function 
     ++ f(x) over an infinite or semi-infinite interval [a,b]:
     ++ See \downlink{Manual Page}{manpageXXd01amf}.
    d01anf : (DoubleFloat,DoubleFloat,DoubleFloat,Integer,_
	DoubleFloat,DoubleFloat,Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(G))) -> Result 
     ++ d01anf(a,b,omega,key,epsabs,epsrel,lw,liw,ifail,g)
     ++ calculates an approximation to the sine or the cosine 
     ++ transform of a function g over [a,b]:
     ++ See \downlink{Manual Page}{manpageXXd01anf}.
    d01apf : (DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,_
	Integer,DoubleFloat,DoubleFloat,Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(G))) -> Result 
     ++ d01apf(a,b,alfa,beta,key,epsabs,epsrel,lw,liw,ifail,g)
     ++ is an adaptive integrator which calculates an 
     ++ approximation to the integral of a function g(x)w(x) over a 
     ++ finite interval [a,b]:
     ++ See \downlink{Manual Page}{manpageXXd01apf}.
    d01aqf : (DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,_
	DoubleFloat,Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(G))) -> Result 
     ++ d01aqf(a,b,c,epsabs,epsrel,lw,liw,ifail,g)
     ++ calculates an approximation to the Hilbert transform of a 
     ++ function g(x) over [a,b]:
     ++ See \downlink{Manual Page}{manpageXXd01aqf}.
    d01asf : (DoubleFloat,DoubleFloat,Integer,DoubleFloat,_
	Integer,Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(G))) -> Result 
     ++ d01asf(a,omega,key,epsabs,limlst,lw,liw,ifail,g)
     ++ calculates an approximation to the sine or the cosine 
     ++ transform of a function g over [a,infty):
     ++ See \downlink{Manual Page}{manpageXXd01asf}.
    d01bbf : (DoubleFloat,DoubleFloat,Integer,Integer,_
	Integer,Integer) -> Result 
     ++ d01bbf(a,b,itype,n,gtype,ifail)
     ++ returns the weight appropriate to a 
     ++ Gaussian quadrature.
     ++ The formulae provided are Gauss-Legendre, Gauss-Rational, Gauss-
     ++ Laguerre and Gauss-Hermite.
     ++ See \downlink{Manual Page}{manpageXXd01bbf}.
    d01fcf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer,_
	DoubleFloat,Integer,Integer,Integer,Union(fn:FileName,fp:Asp4(FUNCTN))) -> Result 
     ++ d01fcf(ndim,a,b,maxpts,eps,lenwrk,minpts,ifail,functn)
     ++ attempts to evaluate a multi-dimensional integral (up to 
     ++ 15 dimensions), with constant and finite limits, to a specified 
     ++ relative accuracy, using an adaptive subdivision strategy.
     ++ See \downlink{Manual Page}{manpageXXd01fcf}.
    d01gaf : (Matrix DoubleFloat,Matrix DoubleFloat,Integer,Integer) -> Result 
     ++ d01gaf(x,y,n,ifail)
     ++ integrates a function which is specified numerically at 
     ++ four or more points, over the whole of its specified range, using
     ++ third-order finite-difference formulae with error estimates, 
     ++ according to a method due to Gill and Miller.
     ++ See \downlink{Manual Page}{manpageXXd01gaf}.
    d01gbf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer,_
	DoubleFloat,Integer,Integer,Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp4(FUNCTN))) -> Result 
     ++ d01gbf(ndim,a,b,maxcls,eps,lenwrk,mincls,wrkstr,ifail,functn)
     ++ returns an approximation to the integral of a function 
     ++ over a hyper-rectangular region, using a Monte Carlo method. An 
     ++ approximate relative error estimate is also returned. This 
     ++ routine is suitable for low accuracy work.
     ++ See \downlink{Manual Page}{manpageXXd01gbf}.
  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:Asp1(F))
    import AnyFunctions1(DoubleFloat)
    import AnyFunctions1(Integer)
    import AnyFunctions1(Matrix DoubleFloat)


    d01ajf(aArg:DoubleFloat,bArg:DoubleFloat,epsabsArg:DoubleFloat,_
	epsrelArg:DoubleFloat,lwArg:Integer,liwArg:Integer,_
	ifailArg:Integer,fArg:Union(fn:FileName,fp:Asp1(F))): Result == 
	pushFortranOutputStack(fFilename := aspFilename "f")$FOP
	if fArg case fn
		  then outputAsFortran(fArg.fn)
		  else outputAsFortran(fArg.fp)
	popFortranOutputStack()$FOP
	[(invokeNagman([fFilename]$Lisp,_
	"d01ajf",_
	["a"::S,"b"::S,"epsabs"::S,"epsrel"::S,"lw"::S_
	,"liw"::S,"result"::S,"abserr"::S,"ifail"::S,"f"::S_
	,"w"::S,"iw"::S]$Lisp,_
	["result"::S,"abserr"::S,"w"::S,"iw"::S,"f"::S]$Lisp,_
	[["double"::S,"a"::S,"b"::S,"epsabs"::S,"epsrel"::S_
	,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"f"::S]$Lisp_
	,["integer"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_
	,"ifail"::S]$Lisp_
	]$Lisp,_
	["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_
	[([aArg::Any,bArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    d01akf(aArg:DoubleFloat,bArg:DoubleFloat,epsabsArg:DoubleFloat,_
	epsrelArg:DoubleFloat,lwArg:Integer,liwArg:Integer,_
	ifailArg:Integer,fArg:Union(fn:FileName,fp:Asp1(F))): Result == 
	pushFortranOutputStack(fFilename := aspFilename "f")$FOP
	if fArg case fn
		  then outputAsFortran(fArg.fn)
		  else outputAsFortran(fArg.fp)
	popFortranOutputStack()$FOP
	[(invokeNagman([fFilename]$Lisp,_
	"d01akf",_
	["a"::S,"b"::S,"epsabs"::S,"epsrel"::S,"lw"::S_
	,"liw"::S,"result"::S,"abserr"::S,"ifail"::S,"f"::S_
	,"w"::S,"iw"::S]$Lisp,_
	["result"::S,"abserr"::S,"w"::S,"iw"::S,"f"::S]$Lisp,_
	[["double"::S,"a"::S,"b"::S,"epsabs"::S,"epsrel"::S_
	,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"f"::S]$Lisp_
	,["integer"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_
	,"ifail"::S]$Lisp_
	]$Lisp,_
	["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_
	[([aArg::Any,bArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    d01alf(aArg:DoubleFloat,bArg:DoubleFloat,nptsArg:Integer,_
	pointsArg:Matrix DoubleFloat,epsabsArg:DoubleFloat,epsrelArg:DoubleFloat,_
	lwArg:Integer,liwArg:Integer,ifailArg:Integer,_
	fArg:Union(fn:FileName,fp:Asp1(F))): Result == 
	pushFortranOutputStack(fFilename := aspFilename "f")$FOP
	if fArg case fn
		  then outputAsFortran(fArg.fn)
		  else outputAsFortran(fArg.fp)
	popFortranOutputStack()$FOP
	[(invokeNagman([fFilename]$Lisp,_
	"d01alf",_
	["a"::S,"b"::S,"npts"::S,"epsabs"::S,"epsrel"::S_
	,"lw"::S,"liw"::S,"result"::S,"abserr"::S,"ifail"::S_
	,"f"::S,"points"::S,"w"::S,"iw"::S]$Lisp,_
	["result"::S,"abserr"::S,"w"::S,"iw"::S,"f"::S]$Lisp,_
	[["double"::S,"a"::S,"b"::S,["points"::S,"*"::S]$Lisp_
	,"epsabs"::S,"epsrel"::S,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"f"::S]$Lisp_
	,["integer"::S,"npts"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_
	,"ifail"::S]$Lisp_
	]$Lisp,_
	["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_
	[([aArg::Any,bArg::Any,nptsArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any,pointsArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    d01amf(boundArg:DoubleFloat,infArg:Integer,epsabsArg:DoubleFloat,_
	epsrelArg:DoubleFloat,lwArg:Integer,liwArg:Integer,_
	ifailArg:Integer,fArg:Union(fn:FileName,fp:Asp1(F))): Result == 
	pushFortranOutputStack(fFilename := aspFilename "f")$FOP
	if fArg case fn
		  then outputAsFortran(fArg.fn)
		  else outputAsFortran(fArg.fp)
	popFortranOutputStack()$FOP
	[(invokeNagman([fFilename]$Lisp,_
	"d01amf",_
	["bound"::S,"inf"::S,"epsabs"::S,"epsrel"::S,"lw"::S_
	,"liw"::S,"result"::S,"abserr"::S,"ifail"::S,"f"::S_
	,"w"::S,"iw"::S]$Lisp,_
	["result"::S,"abserr"::S,"w"::S,"iw"::S,"f"::S]$Lisp,_
	[["double"::S,"bound"::S,"epsabs"::S,"epsrel"::S_
	,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"f"::S]$Lisp_
	,["integer"::S,"inf"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_
	,"ifail"::S]$Lisp_
	]$Lisp,_
	["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_
	[([boundArg::Any,infArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    d01anf(aArg:DoubleFloat,bArg:DoubleFloat,omegaArg:DoubleFloat,_
	keyArg:Integer,epsabsArg:DoubleFloat,epsrelArg:DoubleFloat,_
	lwArg:Integer,liwArg:Integer,ifailArg:Integer,_
	gArg:Union(fn:FileName,fp:Asp1(G))): Result == 
	pushFortranOutputStack(gFilename := aspFilename "g")$FOP
	if gArg case fn
		  then outputAsFortran(gArg.fn)
		  else outputAsFortran(gArg.fp)
	popFortranOutputStack()$FOP
	[(invokeNagman([gFilename]$Lisp,_
	"d01anf",_
	["a"::S,"b"::S,"omega"::S,"key"::S,"epsabs"::S_
	,"epsrel"::S,"lw"::S,"liw"::S,"result"::S,"abserr"::S_
	,"ifail"::S,"g"::S,"w"::S,"iw"::S]$Lisp,_
	["result"::S,"abserr"::S,"w"::S,"iw"::S,"g"::S]$Lisp,_
	[["double"::S,"a"::S,"b"::S,"omega"::S,"epsabs"::S_
	,"epsrel"::S,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"g"::S]$Lisp_
	,["integer"::S,"key"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_
	,"ifail"::S]$Lisp_
	]$Lisp,_
	["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_
	[([aArg::Any,bArg::Any,omegaArg::Any,keyArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    d01apf(aArg:DoubleFloat,bArg:DoubleFloat,alfaArg:DoubleFloat,_
	betaArg:DoubleFloat,keyArg:Integer,epsabsArg:DoubleFloat,_
	epsrelArg:DoubleFloat,lwArg:Integer,liwArg:Integer,_
	ifailArg:Integer,gArg:Union(fn:FileName,fp:Asp1(G))): Result == 
	pushFortranOutputStack(gFilename := aspFilename "g")$FOP
	if gArg case fn
		  then outputAsFortran(gArg.fn)
		  else outputAsFortran(gArg.fp)
	popFortranOutputStack()$FOP
	[(invokeNagman([gFilename]$Lisp,_
	"d01apf",_
	["a"::S,"b"::S,"alfa"::S,"beta"::S,"key"::S_
	,"epsabs"::S,"epsrel"::S,"lw"::S,"liw"::S,"result"::S_
	,"abserr"::S,"ifail"::S,"g"::S,"w"::S,"iw"::S]$Lisp,_
	["result"::S,"abserr"::S,"w"::S,"iw"::S,"g"::S]$Lisp,_
	[["double"::S,"a"::S,"b"::S,"alfa"::S,"beta"::S_
	,"epsabs"::S,"epsrel"::S,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"g"::S]$Lisp_
	,["integer"::S,"key"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_
	,"ifail"::S]$Lisp_
	]$Lisp,_
	["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_
	[([aArg::Any,bArg::Any,alfaArg::Any,betaArg::Any,keyArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    d01aqf(aArg:DoubleFloat,bArg:DoubleFloat,cArg:DoubleFloat,_
	epsabsArg:DoubleFloat,epsrelArg:DoubleFloat,lwArg:Integer,_
	liwArg:Integer,ifailArg:Integer,gArg:Union(fn:FileName,fp:Asp1(G))): Result == 
	pushFortranOutputStack(gFilename := aspFilename "g")$FOP
	if gArg case fn
		  then outputAsFortran(gArg.fn)
		  else outputAsFortran(gArg.fp)
	popFortranOutputStack()$FOP
	[(invokeNagman([gFilename]$Lisp,_
	"d01aqf",_
	["a"::S,"b"::S,"c"::S,"epsabs"::S,"epsrel"::S_
	,"lw"::S,"liw"::S,"result"::S,"abserr"::S,"ifail"::S_
	,"g"::S,"w"::S,"iw"::S]$Lisp,_
	["result"::S,"abserr"::S,"w"::S,"iw"::S,"g"::S]$Lisp,_
	[["double"::S,"a"::S,"b"::S,"c"::S,"epsabs"::S_
	,"epsrel"::S,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"g"::S]$Lisp_
	,["integer"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_
	,"ifail"::S]$Lisp_
	]$Lisp,_
	["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_
	[([aArg::Any,bArg::Any,cArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    d01asf(aArg:DoubleFloat,omegaArg:DoubleFloat,keyArg:Integer,_
	epsabsArg:DoubleFloat,limlstArg:Integer,lwArg:Integer,_
	liwArg:Integer,ifailArg:Integer,gArg:Union(fn:FileName,fp:Asp1(G))): Result == 
	pushFortranOutputStack(gFilename := aspFilename "g")$FOP
	if gArg case fn
		  then outputAsFortran(gArg.fn)
		  else outputAsFortran(gArg.fp)
	popFortranOutputStack()$FOP
	[(invokeNagman([gFilename]$Lisp,_
	"d01asf",_
	["a"::S,"omega"::S,"key"::S,"epsabs"::S,"limlst"::S_
	,"lw"::S,"liw"::S,"result"::S,"abserr"::S,"lst"::S_
	,"ifail"::S,"g"::S,"erlst"::S,"rslst"::S,"ierlst"::S,"iw"::S,"w"::S_
	]$Lisp,_
	["result"::S,"abserr"::S,"lst"::S,"erlst"::S,"rslst"::S,"ierlst"::S,"iw"::S,"w"::S,"g"::S]$Lisp,_
	[["double"::S,"a"::S,"omega"::S,"epsabs"::S_
	,"result"::S,"abserr"::S,["erlst"::S,"limlst"::S]$Lisp,["rslst"::S,"limlst"::S]$Lisp,["w"::S,"lw"::S]$Lisp,"g"::S]$Lisp_
	,["integer"::S,"key"::S,"limlst"::S,"lw"::S_
	,"liw"::S,"lst"::S,["ierlst"::S,"limlst"::S]$Lisp,["iw"::S,"liw"::S]$Lisp,"ifail"::S]$Lisp_
	]$Lisp,_
	["result"::S,"abserr"::S,"lst"::S,"erlst"::S,"rslst"::S,"ierlst"::S,"iw"::S,"ifail"::S]$Lisp,_
	[([aArg::Any,omegaArg::Any,keyArg::Any,epsabsArg::Any,limlstArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    d01bbf(aArg:DoubleFloat,bArg:DoubleFloat,itypeArg:Integer,_
	nArg:Integer,gtypeArg:Integer,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"d01bbf",_
	["a"::S,"b"::S,"itype"::S,"n"::S,"gtype"::S_
	,"ifail"::S,"weight"::S,"abscis"::S]$Lisp,_
	["weight"::S,"abscis"::S]$Lisp,_
	[["double"::S,"a"::S,"b"::S,["weight"::S,"n"::S]$Lisp_
	,["abscis"::S,"n"::S]$Lisp]$Lisp_
	,["integer"::S,"itype"::S,"n"::S,"gtype"::S_
	,"ifail"::S]$Lisp_
	]$Lisp,_
	["weight"::S,"abscis"::S,"ifail"::S]$Lisp,_
	[([aArg::Any,bArg::Any,itypeArg::Any,nArg::Any,gtypeArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    d01fcf(ndimArg:Integer,aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,_
	maxptsArg:Integer,epsArg:DoubleFloat,lenwrkArg:Integer,_
	minptsArg:Integer,ifailArg:Integer,functnArg:Union(fn:FileName,fp:Asp4(FUNCTN))): Result == 
	pushFortranOutputStack(functnFilename := aspFilename "functn")$FOP
	if functnArg case fn
		  then outputAsFortran(functnArg.fn)
		  else outputAsFortran(functnArg.fp)
	popFortranOutputStack()$FOP
	[(invokeNagman([functnFilename]$Lisp,_
	"d01fcf",_
	["ndim"::S,"maxpts"::S,"eps"::S,"lenwrk"::S,"acc"::S_
	,"finval"::S,"minpts"::S,"ifail"::S,"functn"::S,"a"::S,"b"::S,"wrkstr"::S]$Lisp,_
	["acc"::S,"finval"::S,"wrkstr"::S,"functn"::S]$Lisp,_
	[["double"::S,["a"::S,"ndim"::S]$Lisp,["b"::S,"ndim"::S]$Lisp_
	,"eps"::S,"acc"::S,"finval"::S,["wrkstr"::S,"lenwrk"::S]$Lisp,"functn"::S]$Lisp_
	,["integer"::S,"ndim"::S,"maxpts"::S,"lenwrk"::S_
	,"minpts"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["acc"::S,"finval"::S,"minpts"::S,"ifail"::S]$Lisp,_
	[([ndimArg::Any,maxptsArg::Any,epsArg::Any,lenwrkArg::Any,minptsArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    d01gaf(xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,nArg:Integer,_
	ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"d01gaf",_
	["n"::S,"ans"::S,"er"::S,"ifail"::S,"x"::S,"y"::S]$Lisp,_
	["ans"::S,"er"::S]$Lisp,_
	[["double"::S,["x"::S,"n"::S]$Lisp,["y"::S,"n"::S]$Lisp_
	,"ans"::S,"er"::S]$Lisp_
	,["integer"::S,"n"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["ans"::S,"er"::S,"ifail"::S]$Lisp,_
	[([nArg::Any,ifailArg::Any,xArg::Any,yArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    d01gbf(ndimArg:Integer,aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,_
	maxclsArg:Integer,epsArg:DoubleFloat,lenwrkArg:Integer,_
	minclsArg:Integer,wrkstrArg:Matrix DoubleFloat,ifailArg:Integer,_
	functnArg:Union(fn:FileName,fp:Asp4(FUNCTN))): Result == 
	pushFortranOutputStack(functnFilename := aspFilename "functn")$FOP
	if functnArg case fn
		  then outputAsFortran(functnArg.fn)
		  else outputAsFortran(functnArg.fp)
	popFortranOutputStack()$FOP
	[(invokeNagman([functnFilename]$Lisp,_
	"d01gbf",_
	["ndim"::S,"maxcls"::S,"eps"::S,"lenwrk"::S,"acc"::S_
	,"finest"::S,"mincls"::S,"ifail"::S,"functn"::S,"a"::S,"b"::S,"wrkstr"::S]$Lisp,_
	["acc"::S,"finest"::S,"functn"::S]$Lisp,_
	[["double"::S,["a"::S,"ndim"::S]$Lisp,["b"::S,"ndim"::S]$Lisp_
	,"eps"::S,"acc"::S,"finest"::S,["wrkstr"::S,"lenwrk"::S]$Lisp,"functn"::S]$Lisp_
	,["integer"::S,"ndim"::S,"maxcls"::S,"lenwrk"::S_
	,"mincls"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["acc"::S,"finest"::S,"mincls"::S,"wrkstr"::S,"ifail"::S]$Lisp,_
	[([ndimArg::Any,maxclsArg::Any,epsArg::Any,lenwrkArg::Any,minclsArg::Any,ifailArg::Any,aArg::Any,bArg::Any,wrkstrArg::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 NAGD01 NagIntegrationPackage>>
@
\eject
\begin{thebibliography}{99}
\bibitem{1} nothing
\end{thebibliography}
\end{document}