\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} <>= )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} <>= --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}