path: root/src/algebra/s.spad.pamphlet

\documentclass{article}
\usepackage{axiom}
\begin{document}
\title{\$SPAD/src/algebra s.spad}
\author{Godfrey Nolan, Mike Dewar}
\maketitle
\begin{abstract}
\end{abstract}
\eject
\tableofcontents
\eject
\section{package NAGS NagSpecialFunctionsPackage}
<<package NAGS NagSpecialFunctionsPackage>>=
)abbrev package NAGS NagSpecialFunctionsPackage
++ Author: Godfrey Nolan and Mike Dewar
++ Date Created: Jan 1994
++ Date Last Updated: Thu May 12 17:45:44 1994
++Description:
++This package uses the NAG Library to compute some commonly
++occurring physical and mathematical functions.
++See \downlink{Manual Page}{manpageXXs}.
NagSpecialFunctionsPackage(): Exports == Implementation where
  S ==> Symbol
  FOP ==> FortranOutputStackPackage

  Exports ==> with
    s01eaf : (Complex DoubleFloat,Integer) -> Result 
     ++ s01eaf(z,ifail)
     ++ S01EAF evaluates the exponential function exp(z) , for complex z.
     ++ See \downlink{Manual Page}{manpageXXs01eaf}.
    s13aaf : (DoubleFloat,Integer) -> Result 
     ++ s13aaf(x,ifail)
     ++ returns the value of the exponential integral 
     ++  E (x), via the routine name.
     ++   1
     ++ See \downlink{Manual Page}{manpageXXs13aaf}.
    s13acf : (DoubleFloat,Integer) -> Result 
     ++ s13acf(x,ifail)
     ++ returns the value of the cosine integral
     ++ See \downlink{Manual Page}{manpageXXs13acf}.
    s13adf : (DoubleFloat,Integer) -> Result 
     ++ s13adf(x,ifail)
     ++ returns the value of the sine integral
     ++ See \downlink{Manual Page}{manpageXXs13adf}.
    s14aaf : (DoubleFloat,Integer) -> Result 
     ++ s14aaf(x,ifail) returns the value of the Gamma function (Gamma)(x), via 
     ++ the routine name.
     ++ See \downlink{Manual Page}{manpageXXs14aaf}.
    s14abf : (DoubleFloat,Integer) -> Result 
     ++ s14abf(x,ifail) returns a value for the log, ln(Gamma(x)), via 
     ++ the routine name.
     ++ See \downlink{Manual Page}{manpageXXs14abf}.
    s14baf : (DoubleFloat,DoubleFloat,DoubleFloat,Integer) -> Result 
     ++ s14baf(a,x,tol,ifail)
     ++ computes values for the incomplete gamma functions P(a,x) 
     ++ and Q(a,x).
     ++ See \downlink{Manual Page}{manpageXXs14baf}.
    s15adf : (DoubleFloat,Integer) -> Result 
     ++ s15adf(x,ifail)
     ++ returns the value of the complementary error function, 
     ++ erfc(x), via the routine name.
     ++ See \downlink{Manual Page}{manpageXXs15adf}.
    s15aef : (DoubleFloat,Integer) -> Result 
     ++ s15aef(x,ifail)
     ++ returns the value of the error function erf(x), via the 
     ++ routine name.
     ++ See \downlink{Manual Page}{manpageXXs15aef}.
    s17acf : (DoubleFloat,Integer) -> Result 
     ++ s17acf(x,ifail)
     ++ returns the value of the Bessel Function 
     ++  Y (x), via the routine name.
     ++   0
     ++ See \downlink{Manual Page}{manpageXXs17acf}.
    s17adf : (DoubleFloat,Integer) -> Result 
     ++ s17adf(x,ifail)
     ++ returns the value of the Bessel Function
     ++  Y (x), via the routine name.
     ++   1
     ++ See \downlink{Manual Page}{manpageXXs17adf}.
    s17aef : (DoubleFloat,Integer) -> Result 
     ++ s17aef(x,ifail)
     ++ returns the value of the Bessel Function 
     ++  J (x), via the routine name.
     ++   0
     ++ See \downlink{Manual Page}{manpageXXs17aef}.
    s17aff : (DoubleFloat,Integer) -> Result 
     ++ s17aff(x,ifail)
     ++ returns the value of the Bessel Function 
     ++  J (x), via the routine name.
     ++   1
     ++ See \downlink{Manual Page}{manpageXXs17aff}.
    s17agf : (DoubleFloat,Integer) -> Result 
     ++ s17agf(x,ifail)
     ++ returns a value for the Airy function, Ai(x), via the 
     ++ routine name.
     ++ See \downlink{Manual Page}{manpageXXs17agf}.
    s17ahf : (DoubleFloat,Integer) -> Result 
     ++ s17ahf(x,ifail)
     ++ returns a value of the Airy function, Bi(x), via the 
     ++ routine name.
     ++ See \downlink{Manual Page}{manpageXXs17ahf}.
    s17ajf : (DoubleFloat,Integer) -> Result 
     ++ s17ajf(x,ifail)
     ++ returns a value of the derivative of the Airy function 
     ++ Ai(x), via the routine name.
     ++ See \downlink{Manual Page}{manpageXXs17ajf}.
    s17akf : (DoubleFloat,Integer) -> Result 
     ++ s17akf(x,ifail)
     ++ returns a value for the derivative of the Airy function 
     ++ Bi(x), via the routine name.
     ++ See \downlink{Manual Page}{manpageXXs17akf}.
    s17dcf : (DoubleFloat,Complex DoubleFloat,Integer,String,_
	Integer) -> Result 
     ++ s17dcf(fnu,z,n,scale,ifail)
     ++ returns a sequence of values for the Bessel functions 
     ++  Y      (z) for complex z, non-negative (nu) and n=0,1,...,N-1, 
     ++   (nu)+n                                                       
     ++ with an option for exponential scaling.
     ++ See \downlink{Manual Page}{manpageXXs17dcf}.
    s17def : (DoubleFloat,Complex DoubleFloat,Integer,String,_
	Integer) -> Result 
     ++ s17def(fnu,z,n,scale,ifail)
     ++ returns a sequence of values for the Bessel functions 
     ++  J      (z) for complex z, non-negative (nu) and n=0,1,...,N-1, 
     ++   (nu)+n                                                       
     ++ with an option for exponential scaling.
     ++ See \downlink{Manual Page}{manpageXXs17def}.
    s17dgf : (String,Complex DoubleFloat,String,Integer) -> Result 
     ++ s17dgf(deriv,z,scale,ifail)
     ++ returns the value of the Airy function Ai(z) or its 
     ++ derivative Ai'(z) for complex z, with an option for exponential 
     ++ scaling.
     ++ See \downlink{Manual Page}{manpageXXs17dgf}.
    s17dhf : (String,Complex DoubleFloat,String,Integer) -> Result 
     ++ s17dhf(deriv,z,scale,ifail)
     ++ returns the value of the Airy function Bi(z) or its 
     ++ derivative Bi'(z) for complex z, with an option for exponential 
     ++ scaling.
     ++ See \downlink{Manual Page}{manpageXXs17dhf}.
    s17dlf : (Integer,DoubleFloat,Complex DoubleFloat,Integer,_
	String,Integer) -> Result 
     ++ s17dlf(m,fnu,z,n,scale,ifail)
     ++ returns a sequence of values for the Hankel functions 
     ++   (1)           (2)                                           
     ++  H      (z) or H      (z) for complex z, non-negative (nu) and 
     ++   (nu)+n        (nu)+n                                        
     ++ n=0,1,...,N-1, with an option for exponential scaling.
     ++ See \downlink{Manual Page}{manpageXXs17dlf}.
    s18acf : (DoubleFloat,Integer) -> Result 
     ++ s18acf(x,ifail)
     ++ returns the value of the modified Bessel Function 
     ++  K (x), via the routine name.
     ++   0    
     ++ See \downlink{Manual Page}{manpageXXs18acf}.
    s18adf : (DoubleFloat,Integer) -> Result 
     ++ s18adf(x,ifail)
     ++ returns the value of the modified Bessel Function 
     ++  K (x), via the routine name.
     ++   1    
     ++ See \downlink{Manual Page}{manpageXXs18adf}.
    s18aef : (DoubleFloat,Integer) -> Result 
     ++ s18aef(x,ifail)
     ++ returns the value of the modified Bessel Function 
     ++  I (x), via the routine name.
     ++   0    
     ++ See \downlink{Manual Page}{manpageXXs18aef}.
    s18aff : (DoubleFloat,Integer) -> Result 
     ++ s18aff(x,ifail)
     ++ returns a value for the modified Bessel Function 
     ++  I (x), via the routine name.
     ++   1    
     ++ See \downlink{Manual Page}{manpageXXs18aff}.
    s18dcf : (DoubleFloat,Complex DoubleFloat,Integer,String,_
	Integer) -> Result 
     ++ s18dcf(fnu,z,n,scale,ifail)
     ++ returns a sequence of values for the modified Bessel functions
     ++  K      (z) for complex z, non-negative (nu) and 
     ++   (nu)+n                                        
     ++ n=0,1,...,N-1, with an option for exponential scaling.
     ++ See \downlink{Manual Page}{manpageXXs18dcf}.
    s18def : (DoubleFloat,Complex DoubleFloat,Integer,String,_
	Integer) -> Result 
     ++ s18def(fnu,z,n,scale,ifail)
     ++ returns a sequence of values for the modified Bessel functions
     ++  I      (z) for complex z, non-negative (nu) and 
     ++   (nu)+n                                        
     ++ n=0,1,...,N-1, with an option for exponential scaling.
     ++ See \downlink{Manual Page}{manpageXXs18def}.
    s19aaf : (DoubleFloat,Integer) -> Result 
     ++ s19aaf(x,ifail)
     ++ returns a value for the Kelvin function ber(x) via the 
     ++ routine name.
     ++ See \downlink{Manual Page}{manpageXXs19aaf}.
    s19abf : (DoubleFloat,Integer) -> Result 
     ++ s19abf(x,ifail)
     ++ returns a value for the Kelvin function bei(x) via the 
     ++ routine name.
     ++ See \downlink{Manual Page}{manpageXXs19abf}.
    s19acf : (DoubleFloat,Integer) -> Result 
     ++ s19acf(x,ifail)
     ++ returns a value for the Kelvin function ker(x), via the 
     ++ routine name.
     ++ See \downlink{Manual Page}{manpageXXs19acf}.
    s19adf : (DoubleFloat,Integer) -> Result 
     ++ s19adf(x,ifail)
     ++ returns a value for the Kelvin function kei(x) via the 
     ++ routine name.
     ++ See \downlink{Manual Page}{manpageXXs19adf}.
    s20acf : (DoubleFloat,Integer) -> Result 
     ++ s20acf(x,ifail)
     ++ returns a value for the Fresnel Integral S(x), via the 
     ++ routine name.
     ++ See \downlink{Manual Page}{manpageXXs20acf}.
    s20adf : (DoubleFloat,Integer) -> Result 
     ++ s20adf(x,ifail)
     ++ returns a value for the Fresnel Integral C(x), via the 
     ++ routine name.
     ++ See \downlink{Manual Page}{manpageXXs20adf}.
    s21baf : (DoubleFloat,DoubleFloat,Integer) -> Result 
     ++ s21baf(x,y,ifail)
     ++ returns a value of an elementary integral, which occurs as
     ++ a degenerate case of an elliptic integral of the first kind, via 
     ++ the routine name.
     ++ See \downlink{Manual Page}{manpageXXs21baf}.
    s21bbf : (DoubleFloat,DoubleFloat,DoubleFloat,Integer) -> Result 
     ++ s21bbf(x,y,z,ifail)
     ++ returns a value of the symmetrised elliptic integral of 
     ++ the first kind, via the routine name.
     ++ See \downlink{Manual Page}{manpageXXs21bbf}.
    s21bcf : (DoubleFloat,DoubleFloat,DoubleFloat,Integer) -> Result 
     ++ s21bcf(x,y,z,ifail)
     ++ returns a value of the symmetrised elliptic integral of 
     ++ the second kind, via the routine name.
     ++ See \downlink{Manual Page}{manpageXXs21bcf}.
    s21bdf : (DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,_
	Integer) -> Result 
     ++ s21bdf(x,y,z,r,ifail)
     ++ returns a value of the symmetrised elliptic integral of 
     ++ the third kind, via the routine name.
     ++ See \downlink{Manual Page}{manpageXXs21bdf}.
  Implementation ==> add

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


    s01eaf(zArg:Complex DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s01eaf",_
	["z"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["integer"::S,"ifail"::S]$Lisp_
	,["double complex"::S,"s01eafResult"::S,"z"::S]$Lisp_
	]$Lisp,_
	["s01eafResult"::S,"ifail"::S]$Lisp,_
	[([zArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s13aaf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s13aaf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s13aafResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s13aafResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s13acf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s13acf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s13acfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s13acfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s13adf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s13adf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s13adfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s13adfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s14aaf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s14aaf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s14aafResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s14aafResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s14abf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s14abf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s14abfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s14abfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s14baf(aArg:DoubleFloat,xArg:DoubleFloat,tolArg:DoubleFloat,_
	ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s14baf",_
	["a"::S,"x"::S,"tol"::S,"p"::S,"q"::S_
	,"ifail"::S]$Lisp,_
	["p"::S,"q"::S]$Lisp,_
	[["double"::S,"a"::S,"x"::S,"tol"::S,"p"::S_
	,"q"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["p"::S,"q"::S,"ifail"::S]$Lisp,_
	[([aArg::Any,xArg::Any,tolArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s15adf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s15adf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s15adfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s15adfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s15aef(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s15aef",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s15aefResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s15aefResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s17acf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s17acf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s17acfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s17acfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s17adf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s17adf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s17adfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s17adfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s17aef(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s17aef",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s17aefResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s17aefResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s17aff(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s17aff",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s17affResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s17affResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s17agf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s17agf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s17agfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s17agfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s17ahf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s17ahf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s17ahfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s17ahfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s17ajf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s17ajf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s17ajfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s17ajfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s17akf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s17akf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s17akfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s17akfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result


    s17dcf(fnuArg:DoubleFloat,zArg:Complex DoubleFloat,nArg:Integer,_
	scaleArg:String,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s17dcf",_
	["fnu"::S,"z"::S,"n"::S,"scale"::S,"nz"::S_
	,"ifail"::S,"cy"::S,"cwrk"::S]$Lisp,_
	["cy"::S,"nz"::S,"cwrk"::S]$Lisp,_
	[["double"::S,"fnu"::S]$Lisp_
	,["integer"::S,"n"::S,"nz"::S,"ifail"::S]$Lisp_
	,["character"::S,"scale"::S]$Lisp_
	,["double complex"::S,"z"::S,["cy"::S,"n"::S]$Lisp,["cwrk"::S,"n"::S]$Lisp]$Lisp_
	]$Lisp,_
	["cy"::S,"nz"::S,"ifail"::S]$Lisp,_
	[([fnuArg::Any,zArg::Any,nArg::Any,scaleArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s17def(fnuArg:DoubleFloat,zArg:Complex DoubleFloat,nArg:Integer,_
	scaleArg:String,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s17def",_
	["fnu"::S,"z"::S,"n"::S,"scale"::S,"nz"::S_
	,"ifail"::S,"cy"::S]$Lisp,_
	["cy"::S,"nz"::S]$Lisp,_
	[["double"::S,"fnu"::S]$Lisp_
	,["integer"::S,"n"::S,"nz"::S,"ifail"::S]$Lisp_
	,["character"::S,"scale"::S]$Lisp_
	,["double complex"::S,"z"::S,["cy"::S,"n"::S]$Lisp]$Lisp_
	]$Lisp,_
	["cy"::S,"nz"::S,"ifail"::S]$Lisp,_
	[([fnuArg::Any,zArg::Any,nArg::Any,scaleArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s17dgf(derivArg:String,zArg:Complex DoubleFloat,scaleArg:String,_
	ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s17dgf",_
	["deriv"::S,"z"::S,"scale"::S,"ai"::S,"nz"::S_
	,"ifail"::S]$Lisp,_
	["ai"::S,"nz"::S]$Lisp,_
	[["integer"::S,"nz"::S,"ifail"::S]$Lisp_
	,["character"::S,"deriv"::S,"scale"::S]$Lisp_
	,["double complex"::S,"z"::S,"ai"::S]$Lisp_
	]$Lisp,_
	["ai"::S,"nz"::S,"ifail"::S]$Lisp,_
	[([derivArg::Any,zArg::Any,scaleArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s17dhf(derivArg:String,zArg:Complex DoubleFloat,scaleArg:String,_
	ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s17dhf",_
	["deriv"::S,"z"::S,"scale"::S,"bi"::S,"ifail"::S_
	]$Lisp,_
	["bi"::S]$Lisp,_
	[["integer"::S,"ifail"::S]$Lisp_
	,["character"::S,"deriv"::S,"scale"::S]$Lisp_
	,["double complex"::S,"z"::S,"bi"::S]$Lisp_
	]$Lisp,_
	["bi"::S,"ifail"::S]$Lisp,_
	[([derivArg::Any,zArg::Any,scaleArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s17dlf(mArg:Integer,fnuArg:DoubleFloat,zArg:Complex DoubleFloat,_
	nArg:Integer,scaleArg:String,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s17dlf",_
	["m"::S,"fnu"::S,"z"::S,"n"::S,"scale"::S_
	,"nz"::S,"ifail"::S,"cy"::S]$Lisp,_
	["cy"::S,"nz"::S]$Lisp,_
	[["double"::S,"fnu"::S]$Lisp_
	,["integer"::S,"m"::S,"n"::S,"nz"::S,"ifail"::S_
	]$Lisp_
	,["character"::S,"scale"::S]$Lisp_
	,["double complex"::S,"z"::S,["cy"::S,"n"::S]$Lisp]$Lisp_
	]$Lisp,_
	["cy"::S,"nz"::S,"ifail"::S]$Lisp,_
	[([mArg::Any,fnuArg::Any,zArg::Any,nArg::Any,scaleArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s18acf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s18acf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s18acfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s18acfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s18adf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s18adf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s18adfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s18adfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s18aef(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s18aef",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s18aefResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s18aefResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s18aff(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s18aff",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s18affResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s18affResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s18dcf(fnuArg:DoubleFloat,zArg:Complex DoubleFloat,nArg:Integer,_
	scaleArg:String,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s18dcf",_
	["fnu"::S,"z"::S,"n"::S,"scale"::S,"nz"::S_
	,"ifail"::S,"cy"::S]$Lisp,_
	["cy"::S,"nz"::S]$Lisp,_
	[["double"::S,"fnu"::S]$Lisp_
	,["integer"::S,"n"::S,"nz"::S,"ifail"::S]$Lisp_
	,["character"::S,"scale"::S]$Lisp_
	,["double complex"::S,"z"::S,["cy"::S,"n"::S]$Lisp]$Lisp_
	]$Lisp,_
	["cy"::S,"nz"::S,"ifail"::S]$Lisp,_
	[([fnuArg::Any,zArg::Any,nArg::Any,scaleArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s18def(fnuArg:DoubleFloat,zArg:Complex DoubleFloat,nArg:Integer,_
	scaleArg:String,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s18def",_
	["fnu"::S,"z"::S,"n"::S,"scale"::S,"nz"::S_
	,"ifail"::S,"cy"::S]$Lisp,_
	["cy"::S,"nz"::S]$Lisp,_
	[["double"::S,"fnu"::S]$Lisp_
	,["integer"::S,"n"::S,"nz"::S,"ifail"::S]$Lisp_
	,["character"::S,"scale"::S]$Lisp_
	,["double complex"::S,"z"::S,["cy"::S,"n"::S]$Lisp]$Lisp_
	]$Lisp,_
	["cy"::S,"nz"::S,"ifail"::S]$Lisp,_
	[([fnuArg::Any,zArg::Any,nArg::Any,scaleArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s19aaf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s19aaf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s19aafResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s19aafResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s19abf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s19abf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s19abfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s19abfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s19acf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s19acf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s19acfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s19acfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s19adf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s19adf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s19adfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s19adfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s20acf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s20acf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s20acfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s20acfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s20adf(xArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s20adf",_
	["x"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s20adfResult"::S,"x"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s20adfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s21baf(xArg:DoubleFloat,yArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s21baf",_
	["x"::S,"y"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s21bafResult"::S,"x"::S,"y"::S_
	]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s21bafResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,yArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s21bbf(xArg:DoubleFloat,yArg:DoubleFloat,zArg:DoubleFloat,_
	ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s21bbf",_
	["x"::S,"y"::S,"z"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s21bbfResult"::S,"x"::S,"y"::S_
	,"z"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s21bbfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,yArg::Any,zArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s21bcf(xArg:DoubleFloat,yArg:DoubleFloat,zArg:DoubleFloat,_
	ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s21bcf",_
	["x"::S,"y"::S,"z"::S,"ifail"::S]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s21bcfResult"::S,"x"::S,"y"::S_
	,"z"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s21bcfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,yArg::Any,zArg::Any,ifailArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    s21bdf(xArg:DoubleFloat,yArg:DoubleFloat,zArg:DoubleFloat,_
	rArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"s21bdf",_
	["x"::S,"y"::S,"z"::S,"r"::S,"ifail"::S_
	]$Lisp,_
	[]$Lisp,_
	[["double"::S,"s21bdfResult"::S,"x"::S,"y"::S_
	,"z"::S,"r"::S]$Lisp_
	,["integer"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["s21bdfResult"::S,"ifail"::S]$Lisp,_
	[([xArg::Any,yArg::Any,zArg::Any,rArg::Any,ifailArg::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 NAGS NagSpecialFunctionsPackage>>
@
\eject
\begin{thebibliography}{99}
\bibitem{1} nothing
\end{thebibliography}
\end{document}