\documentclass{article}
\usepackage{axiom}
\begin{document}
\title{\$SPAD/src/algebra e01.spad}
\author{Godfrey Nolan, Mike Dewar}
\maketitle
\begin{abstract}
\end{abstract}
\eject
\tableofcontents
\eject
\section{package NAGE01 NagInterpolationPackage}
<<package NAGE01 NagInterpolationPackage>>=
)abbrev package NAGE01 NagInterpolationPackage
++ Author: Godfrey Nolan and Mike Dewar
++ Date Created: Jan 1994
++ Date Last Updated: Thu May 12 17:44:53 1994
++Description:
++This package uses the NAG Library to calculate the interpolation of a function of
++one or two variables. When provided with the value of the
++function (and possibly one or more of its lowest-order
++derivatives) at each of a number of values of the variable(s),
++the routines provide either an interpolating function or an
++interpolated value. For some of the interpolating functions,
++there are supporting routines to evaluate, differentiate or
++integrate them.
++See \downlink{Manual Page}{manpageXXe01}.


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

  Exports ==> with
    e01baf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer,_
	Integer,Integer) -> Result 
     ++ e01baf(m,x,y,lck,lwrk,ifail)
     ++ determines a cubic spline to a given set of 
     ++ data.
     ++ See \downlink{Manual Page}{manpageXXe01baf}.
    e01bef : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result 
     ++ e01bef(n,x,f,ifail)
     ++ computes a monotonicity-preserving piecewise cubic Hermite
     ++ interpolant to a set of data points.
     ++ See \downlink{Manual Page}{manpageXXe01bef}.
    e01bff : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_
	Integer,Matrix DoubleFloat,Integer) -> Result 
     ++ e01bff(n,x,f,d,m,px,ifail)
     ++ evaluates a piecewise cubic Hermite interpolant at a set 
     ++ of points.
     ++ See \downlink{Manual Page}{manpageXXe01bff}.
    e01bgf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_
	Integer,Matrix DoubleFloat,Integer) -> Result 
     ++ e01bgf(n,x,f,d,m,px,ifail)
     ++ evaluates a piecewise cubic Hermite interpolant and its 
     ++ first derivative at a set of points.
     ++ See \downlink{Manual Page}{manpageXXe01bgf}.
    e01bhf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_
	DoubleFloat,DoubleFloat,Integer) -> Result 
     ++ e01bhf(n,x,f,d,a,b,ifail)
     ++ evaluates the definite integral of a piecewise cubic 
     ++ Hermite interpolant over the interval [a,b].
     ++ See \downlink{Manual Page}{manpageXXe01bhf}.
    e01daf : (Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,_
	Matrix DoubleFloat,Integer) -> Result 
     ++ e01daf(mx,my,x,y,f,ifail)
     ++ computes a bicubic spline interpolating surface through a 
     ++ set of data values, given on a rectangular grid in the x-y plane.
     ++ See \downlink{Manual Page}{manpageXXe01daf}.
    e01saf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_
	Integer) -> Result 
     ++ e01saf(m,x,y,f,ifail)
     ++ generates a two-dimensional surface interpolating a set of
     ++ scattered data points, using the method of Renka and Cline.
     ++ See \downlink{Manual Page}{manpageXXe01saf}.
    e01sbf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_
	Matrix Integer,Matrix DoubleFloat,DoubleFloat,DoubleFloat,Integer) -> Result 
     ++ e01sbf(m,x,y,f,triang,grads,px,py,ifail)
     ++ evaluates at a given point the two-dimensional interpolant
     ++ function computed by E01SAF.
     ++ See \downlink{Manual Page}{manpageXXe01sbf}.
    e01sef : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_
	Integer,Integer,DoubleFloat,DoubleFloat,Integer) -> Result 
     ++ e01sef(m,x,y,f,nw,nq,rnw,rnq,ifail)
     ++ generates a two-dimensional surface interpolating a set of
     ++ scattered data points, using a modified Shepard method.
     ++ See \downlink{Manual Page}{manpageXXe01sef}.
    e01sff : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_
	DoubleFloat,Matrix DoubleFloat,DoubleFloat,DoubleFloat,Integer) -> Result 
     ++ e01sff(m,x,y,f,rnw,fnodes,px,py,ifail)
     ++ evaluates at a given point the two-dimensional 
     ++ interpolating function computed by E01SEF.
     ++ See \downlink{Manual Page}{manpageXXe01sff}.
  Implementation ==> add

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


    e01baf(mArg:Integer,xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_
	lckArg:Integer,lwrkArg:Integer,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"e01baf",_
	["m"::S,"lck"::S,"lwrk"::S,"ifail"::S,"x"::S,"y"::S,"lamda"::S,"c"::S,"wrk"::S_
	]$Lisp,_
	["lamda"::S,"c"::S,"wrk"::S]$Lisp,_
	[["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_
	,["lamda"::S,"lck"::S]$Lisp,["c"::S,"lck"::S]$Lisp,["wrk"::S,"lwrk"::S]$Lisp]$Lisp_
	,["integer"::S,"m"::S,"lck"::S,"lwrk"::S,"ifail"::S_
	]$Lisp_
	]$Lisp,_
	["lamda"::S,"c"::S,"ifail"::S]$Lisp,_
	[([mArg::Any,lckArg::Any,lwrkArg::Any,ifailArg::Any,xArg::Any,yArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    e01bef(nArg:Integer,xArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,_
	ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"e01bef",_
	["n"::S,"ifail"::S,"x"::S,"f"::S,"d"::S]$Lisp,_
	["d"::S]$Lisp,_
	[["double"::S,["x"::S,"n"::S]$Lisp,["f"::S,"n"::S]$Lisp_
	,["d"::S,"n"::S]$Lisp]$Lisp_
	,["integer"::S,"n"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["d"::S,"ifail"::S]$Lisp,_
	[([nArg::Any,ifailArg::Any,xArg::Any,fArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    e01bff(nArg:Integer,xArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,_
	dArg:Matrix DoubleFloat,mArg:Integer,pxArg:Matrix DoubleFloat,_
	ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"e01bff",_
	["n"::S,"m"::S,"ifail"::S,"x"::S,"f"::S,"d"::S,"px"::S,"pf"::S_
	]$Lisp,_
	["pf"::S]$Lisp,_
	[["double"::S,["x"::S,"n"::S]$Lisp,["f"::S,"n"::S]$Lisp_
	,["d"::S,"n"::S]$Lisp,["px"::S,"m"::S]$Lisp,["pf"::S,"m"::S]$Lisp]$Lisp_
	,["integer"::S,"n"::S,"m"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["pf"::S,"ifail"::S]$Lisp,_
	[([nArg::Any,mArg::Any,ifailArg::Any,xArg::Any,fArg::Any,dArg::Any,pxArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    e01bgf(nArg:Integer,xArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,_
	dArg:Matrix DoubleFloat,mArg:Integer,pxArg:Matrix DoubleFloat,_
	ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"e01bgf",_
	["n"::S,"m"::S,"ifail"::S,"x"::S,"f"::S,"d"::S,"px"::S,"pf"::S_
	,"pd"::S]$Lisp,_
	["pf"::S,"pd"::S]$Lisp,_
	[["double"::S,["x"::S,"n"::S]$Lisp,["f"::S,"n"::S]$Lisp_
	,["d"::S,"n"::S]$Lisp,["px"::S,"m"::S]$Lisp,["pf"::S,"m"::S]$Lisp,["pd"::S,"m"::S]$Lisp]$Lisp_
	,["integer"::S,"n"::S,"m"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["pf"::S,"pd"::S,"ifail"::S]$Lisp,_
	[([nArg::Any,mArg::Any,ifailArg::Any,xArg::Any,fArg::Any,dArg::Any,pxArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    e01bhf(nArg:Integer,xArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,_
	dArg:Matrix DoubleFloat,aArg:DoubleFloat,bArg:DoubleFloat,_
	ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"e01bhf",_
	["n"::S,"a"::S,"b"::S,"pint"::S,"ifail"::S_
	,"x"::S,"f"::S,"d"::S]$Lisp,_
	["pint"::S]$Lisp,_
	[["double"::S,["x"::S,"n"::S]$Lisp,["f"::S,"n"::S]$Lisp_
	,["d"::S,"n"::S]$Lisp,"a"::S,"b"::S,"pint"::S]$Lisp_
	,["integer"::S,"n"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["pint"::S,"ifail"::S]$Lisp,_
	[([nArg::Any,aArg::Any,bArg::Any,ifailArg::Any,xArg::Any,fArg::Any,dArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    e01daf(mxArg:Integer,myArg:Integer,xArg:Matrix DoubleFloat,_
	yArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"e01daf",_
	["mx"::S,"my"::S,"px"::S,"py"::S,"ifail"::S_
	,"x"::S,"y"::S,"f"::S,"lamda"::S,"mu"::S_
	,"c"::S,"wrk"::S]$Lisp,_
	["px"::S,"py"::S,"lamda"::S,"mu"::S,"c"::S,"wrk"::S]$Lisp,_
	[["double"::S,["x"::S,"mx"::S]$Lisp,["y"::S,"my"::S]$Lisp_
	,["f"::S,["*"::S,"mx"::S,"my"::S]$Lisp]$Lisp,["lamda"::S,["+"::S,"mx"::S,4$Lisp]$Lisp]$Lisp,["mu"::S,["+"::S,"mx"::S,4$Lisp]$Lisp]$Lisp_
	,["c"::S,["*"::S,"mx"::S,"my"::S]$Lisp]$Lisp,["wrk"::S,["*"::S,["+"::S,"mx"::S,6$Lisp]$Lisp,["+"::S,"my"::S,6$Lisp]$Lisp]$Lisp]$Lisp_
	]$Lisp_
	,["integer"::S,"mx"::S,"my"::S,"px"::S,"py"::S_
	,"ifail"::S]$Lisp_
	]$Lisp,_
	["px"::S,"py"::S,"lamda"::S,"mu"::S,"c"::S,"ifail"::S]$Lisp,_
	[([mxArg::Any,myArg::Any,ifailArg::Any,xArg::Any,yArg::Any,fArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    e01saf(mArg:Integer,xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_
	fArg:Matrix DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"e01saf",_
	["m"::S,"ifail"::S,"x"::S,"y"::S,"f"::S,"triang"::S,"grads"::S_
	]$Lisp,_
	["triang"::S,"grads"::S]$Lisp,_
	[["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_
	,["f"::S,"m"::S]$Lisp,["grads"::S,2$Lisp,"m"::S]$Lisp]$Lisp_
	,["integer"::S,"m"::S,["triang"::S,["*"::S,7$Lisp,"m"::S]$Lisp]$Lisp_
	,"ifail"::S]$Lisp_
	]$Lisp,_
	["triang"::S,"grads"::S,"ifail"::S]$Lisp,_
	[([mArg::Any,ifailArg::Any,xArg::Any,yArg::Any,fArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    e01sbf(mArg:Integer,xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_
	fArg:Matrix DoubleFloat,triangArg:Matrix Integer,gradsArg:Matrix DoubleFloat,_
	pxArg:DoubleFloat,pyArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"e01sbf",_
	["m"::S,"px"::S,"py"::S,"pf"::S,"ifail"::S_
	,"x"::S,"y"::S,"f"::S,"triang"::S,"grads"::S_
	]$Lisp,_
	["pf"::S]$Lisp,_
	[["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_
	,["f"::S,"m"::S]$Lisp,["grads"::S,2$Lisp,"m"::S]$Lisp,"px"::S,"py"::S,"pf"::S]$Lisp_
	,["integer"::S,"m"::S,["triang"::S,["*"::S,7$Lisp,"m"::S]$Lisp]$Lisp_
	,"ifail"::S]$Lisp_
	]$Lisp,_
	["pf"::S,"ifail"::S]$Lisp,_
	[([mArg::Any,pxArg::Any,pyArg::Any,ifailArg::Any,xArg::Any,yArg::Any,fArg::Any,triangArg::Any,gradsArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    e01sef(mArg:Integer,xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_
	fArg:Matrix DoubleFloat,nwArg:Integer,nqArg:Integer,_
	rnwArg:DoubleFloat,rnqArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"e01sef",_
	["m"::S,"nw"::S,"nq"::S,"minnq"::S,"rnw"::S_
	,"rnq"::S,"ifail"::S,"x"::S,"y"::S,"f"::S,"fnodes"::S,"wrk"::S_
	]$Lisp,_
	["fnodes"::S,"minnq"::S,"wrk"::S]$Lisp,_
	[["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_
	,["f"::S,"m"::S]$Lisp,["fnodes"::S,["*"::S,5$Lisp,"m"::S]$Lisp]$Lisp,"rnw"::S,"rnq"::S,["wrk"::S,["*"::S,6$Lisp,"m"::S]$Lisp]$Lisp_
	]$Lisp_
	,["integer"::S,"m"::S,"nw"::S,"nq"::S,"minnq"::S_
	,"ifail"::S]$Lisp_
	]$Lisp,_
	["fnodes"::S,"minnq"::S,"rnw"::S,"rnq"::S,"ifail"::S]$Lisp,_
	[([mArg::Any,nwArg::Any,nqArg::Any,rnwArg::Any,rnqArg::Any,ifailArg::Any,xArg::Any,yArg::Any,fArg::Any ])_
	@List Any]$Lisp)$Lisp)_
	pretend List (Record(key:Symbol,entry:Any))]$Result

    e01sff(mArg:Integer,xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_
	fArg:Matrix DoubleFloat,rnwArg:DoubleFloat,fnodesArg:Matrix DoubleFloat,_
	pxArg:DoubleFloat,pyArg:DoubleFloat,ifailArg:Integer): Result == 
	[(invokeNagman(NIL$Lisp,_
	"e01sff",_
	["m"::S,"rnw"::S,"px"::S,"py"::S,"pf"::S_
	,"ifail"::S,"x"::S,"y"::S,"f"::S,"fnodes"::S]$Lisp,_
	["pf"::S]$Lisp,_
	[["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_
	,["f"::S,"m"::S]$Lisp,"rnw"::S,["fnodes"::S,["*"::S,5$Lisp,"m"::S]$Lisp]$Lisp,"px"::S,"py"::S,"pf"::S]$Lisp_
	,["integer"::S,"m"::S,"ifail"::S]$Lisp_
	]$Lisp,_
	["pf"::S,"ifail"::S]$Lisp,_
	[([mArg::Any,rnwArg::Any,pxArg::Any,pyArg::Any,ifailArg::Any,xArg::Any,yArg::Any,fArg::Any,fnodesArg::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 NAGE01 NagInterpolationPackage>>
@
\eject
\begin{thebibliography}{99}
\bibitem{1} nothing
\end{thebibliography}
\end{document}