Initial population.

1 files changed, 833 insertions, 0 deletions

diff --git a/src/algebra/s.spad.pamphlet b/src/algebra/s.spad.pamphlet
new file mode 100644
index 00000000..7da7e734
--- /dev/null
+++ b/src/algebra/s.spad.pamphlet
@@ -0,0 +1,833 @@
+\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}