bspline_sub_module – bspline-fortran

Description

Multidimensional (1D-6D) B-spline interpolation of data on a regular grid. Basic pure subroutine interface.

Notes

This module is based on the B-spline and spline routines from [1]. The original Fortran 77 routines were converted to free-form source. Some of them are relatively unchanged from the originals, but some have been extensively refactored. In addition, new routines for 1d, 4d, 5d, and 6d interpolation were also created (these are simply extensions of the same algorithm into higher dimensions).

References

DBSPLIN and DTENSBS from the NIST Core Math Library. Original code is public domain.
Carl de Boor, "A Practical Guide to Splines", Springer-Verlag, New York, 1978.
Carl de Boor, Efficient Computer Manipulation of Tensor Products, ACM Transactions on Mathematical Software, Vol. 5 (1979), p. 173-182.
D.E. Amos, "Computation with Splines and B-Splines", SAND78-1968, Sandia Laboratories, March, 1979.
Carl de Boor, Package for calculating with B-splines, SIAM Journal on Numerical Analysis 14, 3 (June 1977), p. 441-472.
D.E. Amos, "Quadrature subroutines for splines and B-splines", Report SAND79-1825, Sandia Laboratories, December 1979.

Uses

- iso_fortran_env
- bspline_kinds_module
Help

Graph Key

Nodes of different colours represent the following:

Solid arrows point from a submodule to the (sub)module which it is descended from. Dashed arrows point from a module or program unit to modules which it uses.

Used by

Help

Graph Key

Nodes of different colours represent the following:

Solid arrows point from a submodule to the (sub)module which it is descended from. Dashed arrows point from a module or program unit to modules which it uses.

Variables

Type	Visibility	Attributes		Name		Initial
integer(kind=ip),	public,	parameter	::	bspline_order_linear	=	2_ip	spline order `k` parameter (for input to the `db*ink` routines) [order = polynomial degree + 1]
integer(kind=ip),	public,	parameter	::	bspline_order_quadratic	=	3_ip	spline order `k` parameter (for input to the `db*ink` routines) [order = polynomial degree + 1]
integer(kind=ip),	public,	parameter	::	bspline_order_cubic	=	4_ip	spline order `k` parameter (for input to the `db*ink` routines) [order = polynomial degree + 1]
integer(kind=ip),	public,	parameter	::	bspline_order_quartic	=	5_ip	spline order `k` parameter (for input to the `db*ink` routines) [order = polynomial degree + 1]
integer(kind=ip),	public,	parameter	::	bspline_order_quintic	=	6_ip	spline order `k` parameter (for input to the `db*ink` routines) [order = polynomial degree + 1]
integer(kind=ip),	public,	parameter	::	bspline_order_hexic	=	7_ip	spline order `k` parameter (for input to the `db*ink` routines) [order = polynomial degree + 1]
integer(kind=ip),	public,	parameter	::	bspline_order_heptic	=	8_ip	spline order `k` parameter (for input to the `db*ink` routines) [order = polynomial degree + 1]
integer(kind=ip),	public,	parameter	::	bspline_order_octic	=	9_ip	spline order `k` parameter (for input to the `db*ink` routines) [order = polynomial degree + 1]
real(kind=wp),	private,	parameter	::	root_ftol	=	100.0_wp*epsilon(1.0_wp)	relative tolerance on $\|s(x)-a\|$ in db1root (scaled by the largest of $\|a\|$ and the coefficient magnitudes): a value below it is treated as zero
real(kind=wp),	private,	parameter	::	root_xtol	=	64.0_wp*epsilon(1.0_wp)	relative tolerance for duplicate roots in db1root (scaled by the width of the domain, see root_dup_tol)
real(kind=wp),	private,	parameter	::	gl8_x1	=	0.1834346424956498049394761423601839806667578129129737823171884736992044742215421141160682237111233537452676587642867666089196012523876865683788569995160663568104475551617138501966385810764205532370882654749492812314961247764619363562770645716456613159405134052985058171969174306064445289638150514997832_wp	8-point Gauss-Legendre abscissa 1
real(kind=wp),	private,	parameter	::	gl8_x2	=	0.5255324099163289858177390491892463490419642431203928577508570992724548207685612725239614001936319820619096829248252608507108793766638779939805395303668253631119018273032402360060717470006127901479587576756241288895336619643528330825624263470540184224603688817537938539658502113876953598879150514997832_wp	8-point Gauss-Legendre abscissa 2
real(kind=wp),	private,	parameter	::	gl8_x3	=	0.7966664774136267395915539364758304368371717316159648320701702950392173056764730921471519272957259390191974534530973092653656494917010859602772562074621689676153935016290342325645582634205301545856060095727342603557415761265140428851957341933710803722783136113628137267630651413319993338002150514997832_wp	8-point Gauss-Legendre abscissa 3
real(kind=wp),	private,	parameter	::	gl8_x4	=	0.960289856497536231683560868569472990428235234301452038271639777372424897743419284439438959263312268310424392817294176210238958155217128547937364220490969970043398261832663734680878126355334692786735966348087059754254760392931853386656813286884261347489628923208763998895240977248938732425615051499783203_wp	8-point Gauss-Legendre abscissa 4
real(kind=wp),	private,	parameter	::	gl8_w1	=	0.3626837833783619829651504492771956121941460398943305405248230675666867347239066773243660420848285095502587699262967065529258215569895173844995576007862076842778350382862546305771007553373269714714894268328780431822779077846722965535548199601402487767505928976560993309027632737537826127502150514997832_wp	8-point Gauss-Legendre weight 1
real(kind=wp),	private,	parameter	::	gl8_w2	=	0.3137066458778872873379622019866013132603289990027349376902639450749562719421734969616980762339285560494275746410778086162472468322655616056890624276469758994622503118776562559463287222021520431626467794721603822601295276898652509723185157998353156062419751736972560423953923732838789657919150514997832_wp	8-point Gauss-Legendre weight 2
real(kind=wp),	private,	parameter	::	gl8_w3	=	0.2223810344533744705443559944262408844301308700512495647259092892936168145704490408536531423771979278421592661012122181231114375798525722419381826674532090577908613289536840402789398648876004385697202157482063253247195590228631570651319965589733545440605952819880671616779621183704306688233150514997832_wp	8-point Gauss-Legendre weight 3
real(kind=wp),	private,	parameter	::	gl8_w4	=	0.1012285362903762591525313543099621901153940910516849570590036980647401787634707848602827393040450065581543893314132667077154940308923487678731973041136073584690533208824050731976306575729205467961435779467552492328730055025992954089946676810510810729468366466585774650346143712142008566866150514997832_wp	8-point Gauss-Legendre weight 4

Interfaces

public interface db1ink

1D initialization routines.

private pure subroutine db1ink_default(x, nx, fcn, kx, iknot, tx, bcoef, iflag)

Determines the parameters of a function that interpolates the one-dimensional gridded data $[x(i),\mathrm{fcn}(i)] ~\mathrm{for}~ i=1,..,n_x$ The interpolating function and its derivatives may subsequently be evaluated by the function db1val.

History

Jacob Williams, 10/30/2015 : Created 1D routine.

Arguments

Type	Intent	Attributes		Name
real(kind=wp),	intent(in),	dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nx	Number of $x$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	fcn	`(nx)` array of function values to interpolate. `fcn(i)` should contain the function value at the point `x(i)`
integer(kind=ip),	intent(in)		::	kx	The order of spline pieces in $x$ ( $2 \le k_x < n_x$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	iknot	knot sequence flag: Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant: Read more…
real(kind=wp),	intent(out),	dimension(:)	::	bcoef	`(nx)` array of coefficients of the b-spline interpolant.
integer(kind=ip),	intent(out)		::	iflag	status flag: Read more…

private pure subroutine db1ink_alt(x, nx, fcn, kx, ibcl, ibcr, fbcl, fbcr, kntopt, tx, bcoef, iflag)

Alternate version of db1ink_default, where the boundary conditions can be specified.

History

Jacob Williams, 9/4/2018 : created this routine.

private pure subroutine db1ink_alt_2(x, nx, fcn, kx, ibcl, ibcr, fbcl, fbcr, tleft, tright, tx, bcoef, iflag)

Alternate version of db1ink_alt, where the first and last kx-1 knots are specified by the user.

History

Jacob Williams, 9/4/2018 : created this routine.

private pure subroutine db1ink_multi(x, nx, fcn, kx, iknot, tx, bcoef, iflag)

Multiple-output version of db1ink: interpolates nf functions on the same grid, with the same knots. The last dimension of fcn and bcoef is the output index. Evaluate them with db1val (multiple-output version).

Arguments

Type	Intent	Attributes		Name
real(kind=wp),	intent(in),	dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nx	Number of $x$ abcissae
real(kind=wp),	intent(in),	dimension(:,:)	::	fcn	`(nx,nf)` array of function values to interpolate: `fcn(i1,j)` is output `j` at grid point (`x(i1)`)
integer(kind=ip),	intent(in)		::	kx	The order of spline pieces in $x$
integer(kind=ip),	intent(in)		::	iknot	knot sequence flag (see db1ink_default)
real(kind=wp),	intent(inout),	dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction
real(kind=wp),	intent(out),	dimension(:,:)	::	bcoef	`(nx,nf)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag (see db1ink_default), or 6001 if `fcn` and `bcoef` do not have the same number of outputs (or it is zero)

public interface db1val

1D evaluation routines.

private pure subroutine db1val_default(xval, idx, tx, nx, kx, bcoef, f, iflag, inbvx, w0, extrap)

Evaluates the tensor product piecewise polynomial interpolant constructed by the routine db1ink or one of its derivatives at the point xval.

To evaluate the interpolant itself, set idx=0, to evaluate the first partial with respect to x, set idx=1, and so on.

db1val returns 0.0 if (xval,yval) is out of range. that is, if

   xval < tx(1) .or. xval > tx(nx+kx)

if the knots tx were chosen by db1ink, then this is equivalent to:

   xval < x(1) .or. xval > x(nx)+epsx

where

   epsx = 0.1*(x(nx)-x(nx-1))

The input quantities tx, nx, kx, and bcoef should be unchanged since the last call of db1ink.

History

Jacob Williams, 10/30/2015 : Created 1D routine.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	xval	$x$ coordinate of evaluation point.
integer(kind=ip),	intent(in)			::	idx	$x$ derivative of piecewise polynomial to evaluate.
real(kind=wp),	intent(in),		dimension(nx+kx)	::	tx	sequence of knots defining the piecewise polynomial in the $x$ direction. (same as in last call to db1ink)
integer(kind=ip),	intent(in)			::	nx	the number of interpolation points in $x$ . (same as in last call to db1ink)
integer(kind=ip),	intent(in)			::	kx	order of polynomial pieces in $x$ . (same as in last call to db1ink)
real(kind=wp),	intent(in),		dimension(nx)	::	bcoef	the b-spline coefficients computed by db1ink.
real(kind=wp),	intent(out)			::	f	interpolated value
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
integer(kind=ip),	intent(inout)			::	inbvx	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
real(kind=wp),	intent(inout),		dimension(3_ip*kx)	::	w0	work array
logical,	intent(in),	optional		::	extrap	if extrapolation is allowed (if not present, default is False)

private pure subroutine db1val_alt(xval, idx, tx, nx, n, kx, bcoef, f, iflag, inbvx, w0, extrap)

Alternate version of db1val_default for use with db1ink_alt and db1ink_alt_2.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	xval	$x$ coordinate of evaluation point.
integer(kind=ip),	intent(in)			::	idx	$x$ derivative of piecewise polynomial to evaluate.
real(kind=wp),	intent(in),		dimension(n+kx)	::	tx	sequence of knots defining the piecewise polynomial in the $x$ direction.
integer(kind=ip),	intent(in)			::	nx	the number of interpolation points in $x$ .
integer(kind=ip),	intent(in)			::	n	length of `bcoef`: `nx+2`
integer(kind=ip),	intent(in)			::	kx	order of polynomial pieces in $x$ . (same as in last call to db1ink)
real(kind=wp),	intent(in),		dimension(n)	::	bcoef	the b-spline coefficients computed by db1ink.
real(kind=wp),	intent(out)			::	f	interpolated value
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
integer(kind=ip),	intent(inout)			::	inbvx	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
real(kind=wp),	intent(inout),		dimension(3_ip*kx)	::	w0	work array
logical,	intent(in),	optional		::	extrap	if extrapolation is allowed (if not present, default is False)

private pure subroutine db1val_multi(xval, idx, tx, nx, kx, bcoef, f, iflag, inbvx, extrap)

Multiple-output version of db1val: evaluates all nf outputs of a spline from db1ink (multiple-output version) at one point. The interval search and the basis functions in each direction are only computed once, for all of the outputs.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	xval	$x$ coordinate of evaluation point.
integer(kind=ip),	intent(in)			::	idx	$x$ derivative of piecewise polynomial to evaluate.
real(kind=wp),	intent(in),		dimension(nx+kx)	::	tx	knots in the $x$ direction.
integer(kind=ip),	intent(in)			::	nx	the number of interpolation points in $x$ .
integer(kind=ip),	intent(in)			::	kx	order of polynomial pieces in $x$ .
real(kind=wp),	intent(in),		dimension(:,:)	::	bcoef	`(nx,nf)` b-spline coefficients from db1ink (multiple-output version).
real(kind=wp),	intent(out),		dimension(:)	::	f	`(nf)` interpolated values of the outputs
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
integer(kind=ip),	intent(inout)			::	inbvx	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
logical,	intent(in),	optional		::	extrap	if extrapolation is allowed (if not present, default is False)

public interface db2ink

2D initialization routines.

private pure subroutine db2ink_default(x, nx, y, ny, fcn, kx, ky, iknot, tx, ty, bcoef, iflag)

Determines the parameters of a function that interpolates the two-dimensional gridded data $[x(i),y(j),\mathrm{fcn}(i,j)] ~\mathrm{for}~ i=1,..,n_x ~\mathrm{and}~ j=1,..,n_y$ The interpolating function and its derivatives may subsequently be evaluated by the function db2val.

The interpolating function is a piecewise polynomial function represented as a tensor product of one-dimensional b-splines. the form of this function is

$s(x,y) = \sum_{i=1}^{n_x} \sum_{j=1}^{n_y} a_{ij} u_i(x) v_j(y)$

where the functions $u_i$ and $v_j$ are one-dimensional b-spline basis functions. the coefficients $a_{ij}$ are chosen so that

$s(x(i),y(j)) = \mathrm{fcn}(i,j) ~\mathrm{for}~ i=1,..,n_x ~\mathrm{and}~ j=1,..,n_y$

Note that for each fixed value of $y$ , $s(x,y)$ is a piecewise polynomial function of $x$ alone, and for each fixed value of $x$ , $s(x,y)$ is a piecewise polynomial function of $y$ alone. in one dimension a piecewise polynomial may be created by partitioning a given interval into subintervals and defining a distinct polynomial piece on each one. the points where adjacent subintervals meet are called knots. each of the functions $u_i$ and $v_j$ above is a piecewise polynomial.

Users of db2ink choose the order (degree+1) of the polynomial pieces used to define the piecewise polynomial in each of the $x$ and $y$ directions (kx and ky). users also may define their own knot sequence in $x$ and $y$ separately (tx and ty). if iflag=0, however, db2ink will choose sequences of knots that result in a piecewise polynomial interpolant with kx-2 continuous partial derivatives in $x$ and ky-2 continuous partial derivatives in $y$ . (kx knots are taken near each endpoint in the $x$ direction, not-a-knot end conditions are used, and the remaining knots are placed at data points if kx is even or at midpoints between data points if kx is odd. the $y$ direction is treated similarly.)

After a call to db2ink, all information necessary to define the interpolating function are contained in the parameters nx, ny, kx, ky, tx, ty, and bcoef. These quantities should not be altered until after the last call of the evaluation routine db2val.

History

Boisvert, Ronald, NBS : 25 may 1982 : Author of original routine.
JEC : 000330 modified array declarations.
Jacob Williams, 2/24/2015 : extensive refactoring of CMLIB routine.

Arguments

Type	Intent	Attributes		Name
real(kind=wp),	intent(in),	dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nx	Number of $x$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	ny	Number of $y$ abcissae
real(kind=wp),	intent(in),	dimension(:,:)	::	fcn	`(nx,ny)` matrix of function values to interpolate. `fcn(i,j)` should contain the function value at the point (`x(i)`,`y(j)`)
integer(kind=ip),	intent(in)		::	kx	The order of spline pieces in $x$ ( $2 \le k_x < n_x$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	ky	The order of spline pieces in $y$ ( $2 \le k_y < n_y$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	iknot	knot sequence flag: Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(out),	dimension(:,:)	::	bcoef	`(nx,ny)` matrix of coefficients of the b-spline interpolant.
integer(kind=ip),	intent(out)		::	iflag	Read more…

private pure subroutine db2ink_multi(x, nx, y, ny, fcn, kx, ky, iknot, tx, ty, bcoef, iflag)

Multiple-output version of db2ink: interpolates nf functions on the same grid, with the same knots. The last dimension of fcn and bcoef is the output index. Evaluate them with db2val (multiple-output version).

Arguments

Type	Intent	Attributes		Name
real(kind=wp),	intent(in),	dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nx	Number of $x$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	ny	Number of $y$ abcissae
real(kind=wp),	intent(in),	dimension(:,:,:)	::	fcn	`(nx,ny,nf)` array of function values to interpolate: `fcn(i1,i2,j)` is output `j` at grid point (`x(i1)`,`y(i2)`)
integer(kind=ip),	intent(in)		::	kx	The order of spline pieces in $x$
integer(kind=ip),	intent(in)		::	ky	The order of spline pieces in $y$
integer(kind=ip),	intent(in)		::	iknot	knot sequence flag (see db2ink_default)
real(kind=wp),	intent(inout),	dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction
real(kind=wp),	intent(inout),	dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction
real(kind=wp),	intent(out),	dimension(:,:,:)	::	bcoef	`(nx,ny,nf)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag (see db2ink_default), or 6001 if `fcn` and `bcoef` do not have the same number of outputs (or it is zero)

public interface db2val

2D evaluation routines.

private pure subroutine db2val_default(xval, yval, idx, idy, tx, ty, nx, ny, kx, ky, bcoef, f, iflag, inbvx, inbvy, iloy, w1, w0, extrap)

Evaluates the tensor product piecewise polynomial interpolant constructed by the routine db2ink or one of its derivatives at the point (xval,yval).

To evaluate the interpolant itself, set idx=idy=0, to evaluate the first partial with respect to x, set idx=1,idy=0, and so on.

db2val returns 0.0 if (xval,yval) is out of range. that is, if

   xval < tx(1) .or. xval > tx(nx+kx) .or.
   yval < ty(1) .or. yval > ty(ny+ky)

if the knots tx and ty were chosen by db2ink, then this is equivalent to:

   xval < x(1) .or. xval > x(nx)+epsx .or.
   yval < y(1) .or. yval > y(ny)+epsy

where

   epsx = 0.1*(x(nx)-x(nx-1))
   epsy = 0.1*(y(ny)-y(ny-1))

The input quantities tx, ty, nx, ny, kx, ky, and bcoef should be unchanged since the last call of db2ink.

History

Boisvert, Ronald, NBS : 25 may 1982 : Author of original routine.
JEC : 000330 modified array declarations.
Jacob Williams, 2/24/2015 : extensive refactoring of CMLIB routine.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	xval	$x$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	yval	$y$ coordinate of evaluation point.
integer(kind=ip),	intent(in)			::	idx	$x$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idy	$y$ derivative of piecewise polynomial to evaluate.
real(kind=wp),	intent(in),		dimension(nx+kx)	::	tx	sequence of knots defining the piecewise polynomial in the $x$ direction. (same as in last call to db2ink)
real(kind=wp),	intent(in),		dimension(ny+ky)	::	ty	sequence of knots defining the piecewise polynomial in the $y$ direction. (same as in last call to db2ink)
integer(kind=ip),	intent(in)			::	nx	the number of interpolation points in $x$ . (same as in last call to db2ink)
integer(kind=ip),	intent(in)			::	ny	the number of interpolation points in $y$ . (same as in last call to db2ink)
integer(kind=ip),	intent(in)			::	kx	order of polynomial pieces in $x$ . (same as in last call to db2ink)
integer(kind=ip),	intent(in)			::	ky	order of polynomial pieces in $y$ . (same as in last call to db2ink)
real(kind=wp),	intent(in),		dimension(nx,ny)	::	bcoef	the b-spline coefficients computed by db2ink.
real(kind=wp),	intent(out)			::	f	interpolated value
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
integer(kind=ip),	intent(inout)			::	inbvx	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	inbvy	not used (kept for backward compatibility)
integer(kind=ip),	intent(inout)			::	iloy	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
real(kind=wp),	intent(inout),		dimension(ky)	::	w1	work array
real(kind=wp),	intent(inout),		dimension(3_ip*max(kx,ky))	::	w0	not used (kept for backward compatibility)
logical,	intent(in),	optional		::	extrap	if extrapolation is allowed (if not present, default is False)

private pure subroutine db2val_multi(xval, yval, idx, idy, tx, ty, nx, ny, kx, ky, bcoef, f, iflag, inbvx, iloy, w1, extrap)

Multiple-output version of db2val: evaluates all nf outputs of a spline from db2ink (multiple-output version) at one point. The interval search and the basis functions in each direction are only computed once, for all of the outputs.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	xval	$x$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	yval	$y$ coordinate of evaluation point.
integer(kind=ip),	intent(in)			::	idx	$x$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idy	$y$ derivative of piecewise polynomial to evaluate.
real(kind=wp),	intent(in),		dimension(nx+kx)	::	tx	knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(ny+ky)	::	ty	knots in the $y$ direction.
integer(kind=ip),	intent(in)			::	nx	the number of interpolation points in $x$ .
integer(kind=ip),	intent(in)			::	ny	the number of interpolation points in $y$ .
integer(kind=ip),	intent(in)			::	kx	order of polynomial pieces in $x$ .
integer(kind=ip),	intent(in)			::	ky	order of polynomial pieces in $y$ .
real(kind=wp),	intent(in),		dimension(:,:,:)	::	bcoef	`(nx,ny,nf)` b-spline coefficients from db2ink (multiple-output version).
real(kind=wp),	intent(out),		dimension(:)	::	f	`(nf)` interpolated values of the outputs
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
integer(kind=ip),	intent(inout)			::	inbvx	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloy	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
real(kind=wp),	intent(inout),		dimension(ky)	::	w1	work array of dimension `(ky)`
logical,	intent(in),	optional		::	extrap	if extrapolation is allowed (if not present, default is False)

public interface db3ink

3D initialization routines.

private pure subroutine db3ink_default(x, nx, y, ny, z, nz, fcn, kx, ky, kz, iknot, tx, ty, tz, bcoef, iflag)

Determines the parameters of a function that interpolates the three-dimensional gridded data $[x(i),y(j),z(k),\mathrm{fcn}(i,j,k)] ~\mathrm{for}~ i=1,..,n_x ~\mathrm{and}~ j=1,..,n_y, ~\mathrm{and}~ k=1,..,n_z$ The interpolating function and its derivatives may subsequently be evaluated by the function db3val.

The interpolating function is a piecewise polynomial function represented as a tensor product of one-dimensional b-splines. the form of this function is $s(x,y,z) = \sum_{i=1}^{n_x} \sum_{j=1}^{n_y} \sum_{k=1}^{n_z} a_{ijk} u_i(x) v_j(y) w_k(z)$

where the functions $u_i$ , $v_j$ , and $w_k$ are one-dimensional b- spline basis functions. the coefficients $a_{ijk}$ are chosen so that:

$s(x(i),y(j),z(k)) = \mathrm{fcn}(i,j,k) ~\mathrm{for}~ i=1,..,n_x , j=1,..,n_y , k=1,..,n_z$

Note that for fixed values of $y$ and $z$ $s(x,y,z)$ is a piecewise polynomial function of $x$ alone, for fixed values of $x$ and $z$ $s(x,y,z)$ is a piecewise polynomial function of $y$ alone, and for fixed values of $x$ and $y$ $s(x,y,z)$ is a function of $z$ alone. in one dimension a piecewise polynomial may be created by partitioning a given interval into subintervals and defining a distinct polynomial piece on each one. the points where adjacent subintervals meet are called knots. each of the functions $u_i$ , $v_j$ , and $w_k$ above is a piecewise polynomial.

Users of db3ink choose the order (degree+1) of the polynomial pieces used to define the piecewise polynomial in each of the $x$ , $y$ , and $z$ directions (kx, ky, and kz). users also may define their own knot sequence in $x$ , $y$ , $z$ separately (tx, ty, and tz). if iflag=0, however, db3ink will choose sequences of knots that result in a piecewise polynomial interpolant with kx-2 continuous partial derivatives in $x$ , ky-2 continuous partial derivatives in $y$ , and kz-2 continuous partial derivatives in $z$ . (kx knots are taken near each endpoint in $x$ , not-a-knot end conditions are used, and the remaining knots are placed at data points if kx is even or at midpoints between data points if kx is odd. the $y$ and $z$ directions are treated similarly.)

After a call to db3ink, all information necessary to define the interpolating function are contained in the parameters nx, ny, nz, kx, ky, kz, tx, ty, tz, and bcoef. these quantities should not be altered until after the last call of the evaluation routine db3val.

History

Boisvert, Ronald, NBS : 25 may 1982 : Author of original routine.
JEC : 000330 modified array declarations.
Jacob Williams, 2/24/2015 : extensive refactoring of CMLIB routine.

Arguments

Type	Intent	Attributes		Name
real(kind=wp),	intent(in),	dimension(:)	::	x	`(nx)` array of $x$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	nx	number of $x$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:)	::	y	`(ny)` array of $y$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	ny	number of $y$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:)	::	z	`(nz)` array of $z$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	nz	number of $z$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:,:,:)	::	fcn	`(nx,ny,nz)` matrix of function values to interpolate. `fcn(i,j,k)` should contain the function value at the point (`x(i)`,`y(j)`,`z(k)`)
integer(kind=ip),	intent(in)		::	kx	The order of spline pieces in $x$ ( $2 \le k_x < n_x$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	ky	The order of spline pieces in $y$ ( $2 \le k_y < n_y$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	kz	the order of spline pieces in $z$ ( $2 \le k_z < n_z$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	iknot	knot sequence flag: Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(out),	dimension(:,:,:)	::	bcoef	`(nx,ny,nz)` matrix of coefficients of the b-spline interpolant.
integer(kind=ip),	intent(out)		::	iflag	Read more…

private pure subroutine db3ink_multi(x, nx, y, ny, z, nz, fcn, kx, ky, kz, iknot, tx, ty, tz, bcoef, iflag)

Multiple-output version of db3ink: interpolates nf functions on the same grid, with the same knots. The last dimension of fcn and bcoef is the output index. Evaluate them with db3val (multiple-output version).

Arguments

Type	Intent	Attributes		Name
real(kind=wp),	intent(in),	dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nx	Number of $x$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	ny	Number of $y$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nz	Number of $z$ abcissae
real(kind=wp),	intent(in),	dimension(:,:,:,:)	::	fcn	`(nx,ny,nz,nf)` array of function values to interpolate: `fcn(i1,i2,i3,j)` is output `j` at grid point (`x(i1)`,`y(i2)`,`z(i3)`)
integer(kind=ip),	intent(in)		::	kx	The order of spline pieces in $x$
integer(kind=ip),	intent(in)		::	ky	The order of spline pieces in $y$
integer(kind=ip),	intent(in)		::	kz	The order of spline pieces in $z$
integer(kind=ip),	intent(in)		::	iknot	knot sequence flag (see db3ink_default)
real(kind=wp),	intent(inout),	dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction
real(kind=wp),	intent(inout),	dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction
real(kind=wp),	intent(inout),	dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction
real(kind=wp),	intent(out),	dimension(:,:,:,:)	::	bcoef	`(nx,ny,nz,nf)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag (see db3ink_default), or 6001 if `fcn` and `bcoef` do not have the same number of outputs (or it is zero)

public interface db3val

3D evaluation routines.

private pure subroutine db3val_default(xval, yval, zval, idx, idy, idz, tx, ty, tz, nx, ny, nz, kx, ky, kz, bcoef, f, iflag, inbvx, inbvy, inbvz, iloy, iloz, w2, w1, w0, extrap)

Evaluates the tensor product piecewise polynomial interpolant constructed by the routine db3ink or one of its derivatives at the point (xval,yval,zval).

To evaluate the interpolant itself, set idx=idy=idz=0, to evaluate the first partial with respect to x, set idx=1,idy=idz=0, and so on.

db3val returns 0.0 if (xval,yval,zval) is out of range. that is,

 xval<tx(1) .or. xval>tx(nx+kx) .or.
 yval<ty(1) .or. yval>ty(ny+ky) .or.
 zval<tz(1) .or. zval>tz(nz+kz)

if the knots tx, ty, and tz were chosen by db3ink, then this is equivalent to

 xval<x(1) .or. xval>x(nx)+epsx .or.
 yval<y(1) .or. yval>y(ny)+epsy .or.
 zval<z(1) .or. zval>z(nz)+epsz

where

 epsx = 0.1*(x(nx)-x(nx-1))
 epsy = 0.1*(y(ny)-y(ny-1))
 epsz = 0.1*(z(nz)-z(nz-1))

The input quantities tx, ty, tz, nx, ny, nz, kx, ky, kz, and bcoef should remain unchanged since the last call of db3ink.

History

Boisvert, Ronald, NBS : 25 may 1982 : Author of original routine.
JEC : 000330 modified array declarations.
Jacob Williams, 2/24/2015 : extensive refactoring of CMLIB routine.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	xval	$x$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	yval	$y$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	zval	$z$ coordinate of evaluation point.
integer(kind=ip),	intent(in)			::	idx	$x$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idy	$y$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idz	$z$ derivative of piecewise polynomial to evaluate.
real(kind=wp),	intent(in),		dimension(nx+kx)	::	tx	sequence of knots defining the piecewise polynomial in the $x$ direction. (same as in last call to db3ink)
real(kind=wp),	intent(in),		dimension(ny+ky)	::	ty	sequence of knots defining the piecewise polynomial in the $y$ direction. (same as in last call to db3ink)
real(kind=wp),	intent(in),		dimension(nz+kz)	::	tz	sequence of knots defining the piecewise polynomial in the $z$ direction. (same as in last call to db3ink)
integer(kind=ip),	intent(in)			::	nx	the number of interpolation points in $x$ . (same as in last call to db3ink)
integer(kind=ip),	intent(in)			::	ny	the number of interpolation points in $y$ . (same as in last call to db3ink)
integer(kind=ip),	intent(in)			::	nz	the number of interpolation points in $z$ . (same as in last call to db3ink)
integer(kind=ip),	intent(in)			::	kx	order of polynomial pieces in $z$ . (same as in last call to db3ink)
integer(kind=ip),	intent(in)			::	ky	order of polynomial pieces in $y$ . (same as in last call to db3ink)
integer(kind=ip),	intent(in)			::	kz	order of polynomial pieces in $z$ . (same as in last call to db3ink)
real(kind=wp),	intent(in),		dimension(nx,ny,nz)	::	bcoef	the b-spline coefficients computed by db3ink.
real(kind=wp),	intent(out)			::	f	interpolated value
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
integer(kind=ip),	intent(inout)			::	inbvx	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	inbvy	not used (kept for backward compatibility)
integer(kind=ip),	intent(inout)			::	inbvz	not used (kept for backward compatibility)
integer(kind=ip),	intent(inout)			::	iloy	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloz	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
real(kind=wp),	intent(inout),		dimension(ky,kz)	::	w2	work array
real(kind=wp),	intent(inout),		dimension(kz)	::	w1	work array
real(kind=wp),	intent(inout),		dimension(3_ip*max(kx,ky,kz))	::	w0	not used (kept for backward compatibility)
logical,	intent(in),	optional		::	extrap	if extrapolation is allowed (if not present, default is False)

private pure subroutine db3val_multi(xval, yval, zval, idx, idy, idz, tx, ty, tz, nx, ny, nz, kx, ky, kz, bcoef, f, iflag, inbvx, iloy, iloz, w2, w1, extrap)

Multiple-output version of db3val: evaluates all nf outputs of a spline from db3ink (multiple-output version) at one point. The interval search and the basis functions in each direction are only computed once, for all of the outputs.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	xval	$x$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	yval	$y$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	zval	$z$ coordinate of evaluation point.
integer(kind=ip),	intent(in)			::	idx	$x$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idy	$y$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idz	$z$ derivative of piecewise polynomial to evaluate.
real(kind=wp),	intent(in),		dimension(nx+kx)	::	tx	knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(ny+ky)	::	ty	knots in the $y$ direction.
real(kind=wp),	intent(in),		dimension(nz+kz)	::	tz	knots in the $z$ direction.
integer(kind=ip),	intent(in)			::	nx	the number of interpolation points in $x$ .
integer(kind=ip),	intent(in)			::	ny	the number of interpolation points in $y$ .
integer(kind=ip),	intent(in)			::	nz	the number of interpolation points in $z$ .
integer(kind=ip),	intent(in)			::	kx	order of polynomial pieces in $x$ .
integer(kind=ip),	intent(in)			::	ky	order of polynomial pieces in $y$ .
integer(kind=ip),	intent(in)			::	kz	order of polynomial pieces in $z$ .
real(kind=wp),	intent(in),		dimension(:,:,:,:)	::	bcoef	`(nx,ny,nz,nf)` b-spline coefficients from db3ink (multiple-output version).
real(kind=wp),	intent(out),		dimension(:)	::	f	`(nf)` interpolated values of the outputs
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
integer(kind=ip),	intent(inout)			::	inbvx	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloy	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloz	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
real(kind=wp),	intent(inout),		dimension(ky,kz)	::	w2	work array of dimension `(ky,kz)`
real(kind=wp),	intent(inout),		dimension(kz)	::	w1	work array of dimension `(kz)`
logical,	intent(in),	optional		::	extrap	if extrapolation is allowed (if not present, default is False)

public interface db4ink

4D initialization routines.

private pure subroutine db4ink_default(x, nx, y, ny, z, nz, q, nq, fcn, kx, ky, kz, kq, iknot, tx, ty, tz, tq, bcoef, iflag)

Determines the parameters of a function that interpolates the four-dimensional gridded data $[x(i),y(j),z(k),q(l),\mathrm{fcn}(i,j,k,l)] ~\mathrm{for}~ i=1,..,n_x ~\mathrm{and}~ j=1,..,n_y, ~\mathrm{and}~ k=1,..,n_z, ~\mathrm{and}~ l=1,..,n_q$ The interpolating function and its derivatives may subsequently be evaluated by the function db4val.

See db3ink header for more details.

History

Jacob Williams, 2/24/2015 : Created this routine.

Arguments

Type	Intent	Attributes		Name
real(kind=wp),	intent(in),	dimension(:)	::	x	`(nx)` array of $x$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	nx	number of $x$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:)	::	y	`(ny)` array of $y$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	ny	number of $y$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:)	::	z	`(nz)` array of $z$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	nz	number of $z$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:)	::	q	`(nq)` array of $q$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	nq	number of $q$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:,:,:,:)	::	fcn	`(nx,ny,nz,nq)` matrix of function values to interpolate. `fcn(i,j,k,q)` should contain the function value at the point (`x(i)`,`y(j)`,`z(k)`,`q(l)`)
integer(kind=ip),	intent(in)		::	kx	the order of spline pieces in $x$ ( $2 \le k_x < n_x$ ). (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	ky	the order of spline pieces in $y$ ( $2 \le k_y < n_y$ ). (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	kz	the order of spline pieces in $z$ ( $2 \le k_z < n_z$ ). (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	kq	the order of spline pieces in $q$ ( $2 \le k_q < n_q$ ). (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	iknot	knot sequence flag: Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	tx	The `(nx+kx)` knots in the x direction for the spline interpolant. Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	ty	The `(ny+ky)` knots in the y direction for the spline interpolant. Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	tz	The `(nz+kz)` knots in the z direction for the spline interpolant. Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	tq	The `(nq+kq)` knots in the q direction for the spline interpolant. Read more…
real(kind=wp),	intent(out),	dimension(:,:,:,:)	::	bcoef	`(nx,ny,nz,nq)` matrix of coefficients of the b-spline interpolant.
integer(kind=ip),	intent(out)		::	iflag	Read more…

private pure subroutine db4ink_multi(x, nx, y, ny, z, nz, q, nq, fcn, kx, ky, kz, kq, iknot, tx, ty, tz, tq, bcoef, iflag)

Multiple-output version of db4ink: interpolates nf functions on the same grid, with the same knots. The last dimension of fcn and bcoef is the output index. Evaluate them with db4val (multiple-output version).

Arguments

Type	Intent	Attributes		Name
real(kind=wp),	intent(in),	dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nx	Number of $x$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	ny	Number of $y$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nz	Number of $z$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nq	Number of $q$ abcissae
real(kind=wp),	intent(in),	dimension(:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nf)` array of function values to interpolate: `fcn(i1,i2,i3,i4,j)` is output `j` at grid point (`x(i1)`,`y(i2)`,`z(i3)`,`q(i4)`)
integer(kind=ip),	intent(in)		::	kx	The order of spline pieces in $x$
integer(kind=ip),	intent(in)		::	ky	The order of spline pieces in $y$
integer(kind=ip),	intent(in)		::	kz	The order of spline pieces in $z$
integer(kind=ip),	intent(in)		::	kq	The order of spline pieces in $q$
integer(kind=ip),	intent(in)		::	iknot	knot sequence flag (see db4ink_default)
real(kind=wp),	intent(inout),	dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction
real(kind=wp),	intent(inout),	dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction
real(kind=wp),	intent(inout),	dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction
real(kind=wp),	intent(inout),	dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction
real(kind=wp),	intent(out),	dimension(:,:,:,:,:)	::	bcoef	`(nx,ny,nz,nq,nf)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag (see db4ink_default), or 6001 if `fcn` and `bcoef` do not have the same number of outputs (or it is zero)

public interface db4val

4D evaluation routines.

private pure subroutine db4val_default(xval, yval, zval, qval, idx, idy, idz, idq, tx, ty, tz, tq, nx, ny, nz, nq, kx, ky, kz, kq, bcoef, f, iflag, inbvx, inbvy, inbvz, inbvq, iloy, iloz, iloq, w3, w2, w1, w0, extrap)

Evaluates the tensor product piecewise polynomial interpolant constructed by the routine db4ink or one of its derivatives at the point (xval,yval,zval,qval).

To evaluate the interpolant itself, set idx=idy=idz=idq=0, to evaluate the first partial with respect to x, set idx=1,idy=idz=idq=0, and so on.

See db3val header for more information.

History

Jacob Williams, 2/24/2015 : Created this routine.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	xval	$x$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	yval	$y$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	zval	$z$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	qval	$q$ coordinate of evaluation point.
integer(kind=ip),	intent(in)			::	idx	$x$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idy	$y$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idz	$z$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idq	$q$ derivative of piecewise polynomial to evaluate.
real(kind=wp),	intent(in),		dimension(nx+kx)	::	tx	sequence of knots defining the piecewise polynomial in the $x$ direction. (same as in last call to db4ink)
real(kind=wp),	intent(in),		dimension(ny+ky)	::	ty	sequence of knots defining the piecewise polynomial in the $y$ direction. (same as in last call to db4ink)
real(kind=wp),	intent(in),		dimension(nz+kz)	::	tz	sequence of knots defining the piecewise polynomial in the $z$ direction. (same as in last call to db4ink)
real(kind=wp),	intent(in),		dimension(nq+kq)	::	tq	sequence of knots defining the piecewise polynomial in the $q$ direction. (same as in last call to db4ink)
integer(kind=ip),	intent(in)			::	nx	the number of interpolation points in $x$ . (same as in last call to db4ink)
integer(kind=ip),	intent(in)			::	ny	the number of interpolation points in $y$ . (same as in last call to db4ink)
integer(kind=ip),	intent(in)			::	nz	the number of interpolation points in $z$ . (same as in last call to db4ink)
integer(kind=ip),	intent(in)			::	nq	the number of interpolation points in $q$ . (same as in last call to db4ink)
integer(kind=ip),	intent(in)			::	kx	order of polynomial pieces in $x$ . (same as in last call to db4ink)
integer(kind=ip),	intent(in)			::	ky	order of polynomial pieces in $y$ . (same as in last call to db4ink)
integer(kind=ip),	intent(in)			::	kz	order of polynomial pieces in $z$ . (same as in last call to db4ink)
integer(kind=ip),	intent(in)			::	kq	order of polynomial pieces in $q$ . (same as in last call to db4ink)
real(kind=wp),	intent(in),		dimension(nx,ny,nz,nq)	::	bcoef	the b-spline coefficients computed by db4ink.
real(kind=wp),	intent(out)			::	f	interpolated value
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
integer(kind=ip),	intent(inout)			::	inbvx	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	inbvy	not used (kept for backward compatibility)
integer(kind=ip),	intent(inout)			::	inbvz	not used (kept for backward compatibility)
integer(kind=ip),	intent(inout)			::	inbvq	not used (kept for backward compatibility)
integer(kind=ip),	intent(inout)			::	iloy	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloz	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloq	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
real(kind=wp),	intent(inout),		dimension(ky,kz,kq)	::	w3	work array
real(kind=wp),	intent(inout),		dimension(kz,kq)	::	w2	work array
real(kind=wp),	intent(inout),		dimension(kq)	::	w1	work array
real(kind=wp),	intent(inout),		dimension(3_ip*max(kx,ky,kz,kq))	::	w0	not used (kept for backward compatibility)
logical,	intent(in),	optional		::	extrap	if extrapolation is allowed (if not present, default is False)

private pure subroutine db4val_multi(xval, yval, zval, qval, idx, idy, idz, idq, tx, ty, tz, tq, nx, ny, nz, nq, kx, ky, kz, kq, bcoef, f, iflag, inbvx, iloy, iloz, iloq, w3, w2, w1, extrap)

Multiple-output version of db4val: evaluates all nf outputs of a spline from db4ink (multiple-output version) at one point. The interval search and the basis functions in each direction are only computed once, for all of the outputs.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	xval	$x$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	yval	$y$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	zval	$z$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	qval	$q$ coordinate of evaluation point.
integer(kind=ip),	intent(in)			::	idx	$x$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idy	$y$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idz	$z$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idq	$q$ derivative of piecewise polynomial to evaluate.
real(kind=wp),	intent(in),		dimension(nx+kx)	::	tx	knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(ny+ky)	::	ty	knots in the $y$ direction.
real(kind=wp),	intent(in),		dimension(nz+kz)	::	tz	knots in the $z$ direction.
real(kind=wp),	intent(in),		dimension(nq+kq)	::	tq	knots in the $q$ direction.
integer(kind=ip),	intent(in)			::	nx	the number of interpolation points in $x$ .
integer(kind=ip),	intent(in)			::	ny	the number of interpolation points in $y$ .
integer(kind=ip),	intent(in)			::	nz	the number of interpolation points in $z$ .
integer(kind=ip),	intent(in)			::	nq	the number of interpolation points in $q$ .
integer(kind=ip),	intent(in)			::	kx	order of polynomial pieces in $x$ .
integer(kind=ip),	intent(in)			::	ky	order of polynomial pieces in $y$ .
integer(kind=ip),	intent(in)			::	kz	order of polynomial pieces in $z$ .
integer(kind=ip),	intent(in)			::	kq	order of polynomial pieces in $q$ .
real(kind=wp),	intent(in),		dimension(:,:,:,:,:)	::	bcoef	`(nx,ny,nz,nq,nf)` b-spline coefficients from db4ink (multiple-output version).
real(kind=wp),	intent(out),		dimension(:)	::	f	`(nf)` interpolated values of the outputs
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
integer(kind=ip),	intent(inout)			::	inbvx	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloy	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloz	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloq	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
real(kind=wp),	intent(inout),		dimension(ky,kz,kq)	::	w3	work array of dimension `(ky,kz,kq)`
real(kind=wp),	intent(inout),		dimension(kz,kq)	::	w2	work array of dimension `(kz,kq)`
real(kind=wp),	intent(inout),		dimension(kq)	::	w1	work array of dimension `(kq)`
logical,	intent(in),	optional		::	extrap	if extrapolation is allowed (if not present, default is False)

public interface db5ink

5D initialization routines.

private pure subroutine db5ink_default(x, nx, y, ny, z, nz, q, nq, r, nr, fcn, kx, ky, kz, kq, kr, iknot, tx, ty, tz, tq, tr, bcoef, iflag)

Determines the parameters of a function that interpolates the five-dimensional gridded data:

$[x(i),y(j),z(k),q(l),r(m),\mathrm{fcn}(i,j,k,l,m)]$

for:

$i=1,..,n_x ~\mathrm{and}~ j=1,..,n_y, ~\mathrm{and}~ k=1,..,n_z, ~\mathrm{and}~ l=1,..,n_q, ~\mathrm{and}~ m=1,..,n_r$

The interpolating function and its derivatives may subsequently be evaluated by the function db5val.

See db3ink header for more details.

History

Jacob Williams, 2/24/2015 : Created this routine.

Arguments

Type	Intent	Attributes		Name
real(kind=wp),	intent(in),	dimension(:)	::	x	`(nx)` array of $x$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	nx	number of $x$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:)	::	y	`(ny)` array of $y$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	ny	number of $y$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:)	::	z	`(nz)` array of $z$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	nz	number of $z$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:)	::	q	`(nq)` array of $q$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	nq	number of $q$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:)	::	r	`(nr)` array of $r$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	nr	number of $r$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr)` matrix of function values to interpolate. `fcn(i,j,k,q,r)` should contain the function value at the point (`x(i)`,`y(j)`,`z(k)`,`q(l)`,`r(m)`)
integer(kind=ip),	intent(in)		::	kx	the order of spline pieces in $x$ ( $2 \le k_x < n_x$ ). (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	ky	the order of spline pieces in $y$ ( $2 \le k_y < n_y$ ). (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	kz	the order of spline pieces in $z$ ( $2 \le k_z < n_z$ ). (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	kq	the order of spline pieces in $q$ ( $2 \le k_q < n_q$ ). (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	kr	the order of spline pieces in $r$ ( $2 \le k_r < n_r$ ). (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	iknot	knot sequence flag: Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(out),	dimension(:,:,:,:,:)	::	bcoef	`(nx,ny,nz,nq,nr)` matrix of coefficients of the b-spline interpolant.
integer(kind=ip),	intent(out)		::	iflag	Read more…

private pure subroutine db5ink_multi(x, nx, y, ny, z, nz, q, nq, r, nr, fcn, kx, ky, kz, kq, kr, iknot, tx, ty, tz, tq, tr, bcoef, iflag)

Multiple-output version of db5ink: interpolates nf functions on the same grid, with the same knots. The last dimension of fcn and bcoef is the output index. Evaluate them with db5val (multiple-output version).

Arguments

Type	Intent	Attributes		Name
real(kind=wp),	intent(in),	dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nx	Number of $x$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	ny	Number of $y$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nz	Number of $z$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nq	Number of $q$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nr	Number of $r$ abcissae
real(kind=wp),	intent(in),	dimension(:,:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr,nf)` array of function values to interpolate: `fcn(i1,i2,i3,i4,i5,j)` is output `j` at grid point (`x(i1)`,`y(i2)`,`z(i3)`,`q(i4)`,`r(i5)`)
integer(kind=ip),	intent(in)		::	kx	The order of spline pieces in $x$
integer(kind=ip),	intent(in)		::	ky	The order of spline pieces in $y$
integer(kind=ip),	intent(in)		::	kz	The order of spline pieces in $z$
integer(kind=ip),	intent(in)		::	kq	The order of spline pieces in $q$
integer(kind=ip),	intent(in)		::	kr	The order of spline pieces in $r$
integer(kind=ip),	intent(in)		::	iknot	knot sequence flag (see db5ink_default)
real(kind=wp),	intent(inout),	dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction
real(kind=wp),	intent(inout),	dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction
real(kind=wp),	intent(inout),	dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction
real(kind=wp),	intent(inout),	dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction
real(kind=wp),	intent(inout),	dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction
real(kind=wp),	intent(out),	dimension(:,:,:,:,:,:)	::	bcoef	`(nx,ny,nz,nq,nr,nf)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag (see db5ink_default), or 6001 if `fcn` and `bcoef` do not have the same number of outputs (or it is zero)

public interface db5val

5D evaluation routines.

private pure subroutine db5val_default(xval, yval, zval, qval, rval, idx, idy, idz, idq, idr, tx, ty, tz, tq, tr, nx, ny, nz, nq, nr, kx, ky, kz, kq, kr, bcoef, f, iflag, inbvx, inbvy, inbvz, inbvq, inbvr, iloy, iloz, iloq, ilor, w4, w3, w2, w1, w0, extrap)

Evaluates the tensor product piecewise polynomial interpolant constructed by the routine db5ink or one of its derivatives at the point (xval,yval,zval,qval,rval).

To evaluate the interpolant itself, set idx=idy=idz=idq=idr=0, to evaluate the first partial with respect to x, set idx=1,idy=idz=idq=idr=0, and so on.

See db3val header for more information.

History

Jacob Williams, 2/24/2015 : Created this routine.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	xval	$x$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	yval	$y$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	zval	$z$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	qval	$q$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	rval	$r$ coordinate of evaluation point.
integer(kind=ip),	intent(in)			::	idx	$x$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idy	$y$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idz	$z$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idq	$q$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idr	$r$ derivative of piecewise polynomial to evaluate.
real(kind=wp),	intent(in),		dimension(nx+kx)	::	tx	sequence of knots defining the piecewise polynomial in the $x$ direction. (same as in last call to db5ink)
real(kind=wp),	intent(in),		dimension(ny+ky)	::	ty	sequence of knots defining the piecewise polynomial in the $y$ direction. (same as in last call to db5ink)
real(kind=wp),	intent(in),		dimension(nz+kz)	::	tz	sequence of knots defining the piecewise polynomial in the $z$ direction. (same as in last call to db5ink)
real(kind=wp),	intent(in),		dimension(nq+kq)	::	tq	sequence of knots defining the piecewise polynomial in the $q$ direction. (same as in last call to db5ink)
real(kind=wp),	intent(in),		dimension(nr+kr)	::	tr	sequence of knots defining the piecewise polynomial in the $r$ direction. (same as in last call to db5ink)
integer(kind=ip),	intent(in)			::	nx	the number of interpolation points in $x$ . (same as in last call to db5ink)
integer(kind=ip),	intent(in)			::	ny	the number of interpolation points in $y$ . (same as in last call to db5ink)
integer(kind=ip),	intent(in)			::	nz	the number of interpolation points in $z$ . (same as in last call to db5ink)
integer(kind=ip),	intent(in)			::	nq	the number of interpolation points in $q$ . (same as in last call to db5ink)
integer(kind=ip),	intent(in)			::	nr	the number of interpolation points in $r$ . (same as in last call to db5ink)
integer(kind=ip),	intent(in)			::	kx	order of polynomial pieces in $x$ . (same as in last call to db5ink)
integer(kind=ip),	intent(in)			::	ky	order of polynomial pieces in $y$ . (same as in last call to db5ink)
integer(kind=ip),	intent(in)			::	kz	order of polynomial pieces in $z$ . (same as in last call to db5ink)
integer(kind=ip),	intent(in)			::	kq	order of polynomial pieces in $q$ . (same as in last call to db5ink)
integer(kind=ip),	intent(in)			::	kr	order of polynomial pieces in $r$ . (same as in last call to db5ink)
real(kind=wp),	intent(in),		dimension(nx,ny,nz,nq,nr)	::	bcoef	the b-spline coefficients computed by db5ink.
real(kind=wp),	intent(out)			::	f	interpolated value
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
integer(kind=ip),	intent(inout)			::	inbvx	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	inbvy	not used (kept for backward compatibility)
integer(kind=ip),	intent(inout)			::	inbvz	not used (kept for backward compatibility)
integer(kind=ip),	intent(inout)			::	inbvq	not used (kept for backward compatibility)
integer(kind=ip),	intent(inout)			::	inbvr	not used (kept for backward compatibility)
integer(kind=ip),	intent(inout)			::	iloy	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloz	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloq	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	ilor	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
real(kind=wp),	intent(inout),		dimension(ky,kz,kq,kr)	::	w4	work array
real(kind=wp),	intent(inout),		dimension(kz,kq,kr)	::	w3	work array
real(kind=wp),	intent(inout),		dimension(kq,kr)	::	w2	work array
real(kind=wp),	intent(inout),		dimension(kr)	::	w1	work array
real(kind=wp),	intent(inout),		dimension(3_ip*max(kx,ky,kz,kq,kr))	::	w0	not used (kept for backward compatibility)
logical,	intent(in),	optional		::	extrap	if extrapolation is allowed (if not present, default is False)

private pure subroutine db5val_multi(xval, yval, zval, qval, rval, idx, idy, idz, idq, idr, tx, ty, tz, tq, tr, nx, ny, nz, nq, nr, kx, ky, kz, kq, kr, bcoef, f, iflag, inbvx, iloy, iloz, iloq, ilor, w4, w3, w2, w1, extrap)

Multiple-output version of db5val: evaluates all nf outputs of a spline from db5ink (multiple-output version) at one point. The interval search and the basis functions in each direction are only computed once, for all of the outputs.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	xval	$x$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	yval	$y$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	zval	$z$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	qval	$q$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	rval	$r$ coordinate of evaluation point.
integer(kind=ip),	intent(in)			::	idx	$x$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idy	$y$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idz	$z$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idq	$q$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idr	$r$ derivative of piecewise polynomial to evaluate.
real(kind=wp),	intent(in),		dimension(nx+kx)	::	tx	knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(ny+ky)	::	ty	knots in the $y$ direction.
real(kind=wp),	intent(in),		dimension(nz+kz)	::	tz	knots in the $z$ direction.
real(kind=wp),	intent(in),		dimension(nq+kq)	::	tq	knots in the $q$ direction.
real(kind=wp),	intent(in),		dimension(nr+kr)	::	tr	knots in the $r$ direction.
integer(kind=ip),	intent(in)			::	nx	the number of interpolation points in $x$ .
integer(kind=ip),	intent(in)			::	ny	the number of interpolation points in $y$ .
integer(kind=ip),	intent(in)			::	nz	the number of interpolation points in $z$ .
integer(kind=ip),	intent(in)			::	nq	the number of interpolation points in $q$ .
integer(kind=ip),	intent(in)			::	nr	the number of interpolation points in $r$ .
integer(kind=ip),	intent(in)			::	kx	order of polynomial pieces in $x$ .
integer(kind=ip),	intent(in)			::	ky	order of polynomial pieces in $y$ .
integer(kind=ip),	intent(in)			::	kz	order of polynomial pieces in $z$ .
integer(kind=ip),	intent(in)			::	kq	order of polynomial pieces in $q$ .
integer(kind=ip),	intent(in)			::	kr	order of polynomial pieces in $r$ .
real(kind=wp),	intent(in),		dimension(:,:,:,:,:,:)	::	bcoef	`(nx,ny,nz,nq,nr,nf)` b-spline coefficients from db5ink (multiple-output version).
real(kind=wp),	intent(out),		dimension(:)	::	f	`(nf)` interpolated values of the outputs
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
integer(kind=ip),	intent(inout)			::	inbvx	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloy	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloz	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloq	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	ilor	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
real(kind=wp),	intent(inout),		dimension(ky,kz,kq,kr)	::	w4	work array of dimension `(ky,kz,kq,kr)`
real(kind=wp),	intent(inout),		dimension(kz,kq,kr)	::	w3	work array of dimension `(kz,kq,kr)`
real(kind=wp),	intent(inout),		dimension(kq,kr)	::	w2	work array of dimension `(kq,kr)`
real(kind=wp),	intent(inout),		dimension(kr)	::	w1	work array of dimension `(kr)`
logical,	intent(in),	optional		::	extrap	if extrapolation is allowed (if not present, default is False)

public interface db6ink

6D initialization routines.

private pure subroutine db6ink_default(x, nx, y, ny, z, nz, q, nq, r, nr, s, ns, fcn, kx, ky, kz, kq, kr, ks, iknot, tx, ty, tz, tq, tr, ts, bcoef, iflag)

Determines the parameters of a function that interpolates the six-dimensional gridded data:

$[x(i),y(j),z(k),q(l),r(m),s(n),\mathrm{fcn}(i,j,k,l,m,n)]$

for:

$i=1,..,n_x, j=1,..,n_y, k=1,..,n_z, l=1,..,n_q, m=1,..,n_r, n=1,..,n_s$

the interpolating function and its derivatives may subsequently be evaluated by the function db6val.

See db3ink header for more details.

History

Jacob Williams, 2/24/2015 : Created this routine.

Arguments

Type	Intent	Attributes		Name
real(kind=wp),	intent(in),	dimension(:)	::	x	`(nx)` array of $x$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	nx	number of $x$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:)	::	y	`(ny)` array of $y$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	ny	number of $y$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:)	::	z	`(nz)` array of $z$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	nz	number of $z$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:)	::	q	`(nq)` array of $q$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	nq	number of $q$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:)	::	r	`(nr)` array of $r$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	nr	number of $r$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:)	::	s	`(ns)` array of $s$ abcissae. must be strictly increasing.
integer(kind=ip),	intent(in)		::	ns	number of $s$ abcissae ( $\ge 3$ )
real(kind=wp),	intent(in),	dimension(:,:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr,ns)` matrix of function values to interpolate. `fcn(i,j,k,q,r,s)` should contain the function value at the point (`x(i)`,`y(j)`,`z(k)`,`q(l)`,`r(m)`,`s(n)`)
integer(kind=ip),	intent(in)		::	kx	the order of spline pieces in $x$ ( $2 \le k_x < n_x$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	ky	the order of spline pieces in $y$ ( $2 \le k_y < n_y$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	kz	the order of spline pieces in $z$ ( $2 \le k_z < n_z$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	kq	the order of spline pieces in $q$ ( $2 \le k_q < n_q$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	kr	the order of spline pieces in $r$ ( $2 \le k_r < n_r$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	ks	the order of spline pieces in $s$ ( $2 \le k_s < n_s$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)		::	iknot	knot sequence flag: Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	ts	The `(ns+ks)` knots in the $s$ direction for the spline interpolant. Read more…
real(kind=wp),	intent(out),	dimension(:,:,:,:,:,:)	::	bcoef	`(nx,ny,nz,nq,nr,ns)` matrix of coefficients of the b-spline interpolant.
integer(kind=ip),	intent(out)		::	iflag	Read more…

private pure subroutine db6ink_multi(x, nx, y, ny, z, nz, q, nq, r, nr, s, ns, fcn, kx, ky, kz, kq, kr, ks, iknot, tx, ty, tz, tq, tr, ts, bcoef, iflag)

Multiple-output version of db6ink: interpolates nf functions on the same grid, with the same knots. The last dimension of fcn and bcoef is the output index. Evaluate them with db6val (multiple-output version).

Arguments

Type	Intent	Attributes		Name
real(kind=wp),	intent(in),	dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nx	Number of $x$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	ny	Number of $y$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nz	Number of $z$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nq	Number of $q$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	nr	Number of $r$ abcissae
real(kind=wp),	intent(in),	dimension(:)	::	s	`(ns)` array of $s$ abcissae. Must be strictly increasing.
integer(kind=ip),	intent(in)		::	ns	Number of $s$ abcissae
real(kind=wp),	intent(in),	dimension(:,:,:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr,ns,nf)` array of function values to interpolate: `fcn(i1,i2,i3,i4,i5,i6,j)` is output `j` at grid point (`x(i1)`,`y(i2)`,`z(i3)`,`q(i4)`,`r(i5)`,`s(i6)`)
integer(kind=ip),	intent(in)		::	kx	The order of spline pieces in $x$
integer(kind=ip),	intent(in)		::	ky	The order of spline pieces in $y$
integer(kind=ip),	intent(in)		::	kz	The order of spline pieces in $z$
integer(kind=ip),	intent(in)		::	kq	The order of spline pieces in $q$
integer(kind=ip),	intent(in)		::	kr	The order of spline pieces in $r$
integer(kind=ip),	intent(in)		::	ks	The order of spline pieces in $s$
integer(kind=ip),	intent(in)		::	iknot	knot sequence flag (see db6ink_default)
real(kind=wp),	intent(inout),	dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction
real(kind=wp),	intent(inout),	dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction
real(kind=wp),	intent(inout),	dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction
real(kind=wp),	intent(inout),	dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction
real(kind=wp),	intent(inout),	dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction
real(kind=wp),	intent(inout),	dimension(:)	::	ts	The `(ns+ks)` knots in the $s$ direction
real(kind=wp),	intent(out),	dimension(:,:,:,:,:,:,:)	::	bcoef	`(nx,ny,nz,nq,nr,ns,nf)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag (see db6ink_default), or 6001 if `fcn` and `bcoef` do not have the same number of outputs (or it is zero)

public interface db6val

6D evaluation routines.

private pure subroutine db6val_default(xval, yval, zval, qval, rval, sval, idx, idy, idz, idq, idr, ids, tx, ty, tz, tq, tr, ts, nx, ny, nz, nq, nr, ns, kx, ky, kz, kq, kr, ks, bcoef, f, iflag, inbvx, inbvy, inbvz, inbvq, inbvr, inbvs, iloy, iloz, iloq, ilor, ilos, w5, w4, w3, w2, w1, w0, extrap)

Evaluates the tensor product piecewise polynomial interpolant constructed by the routine db6ink or one of its derivatives at the point (xval,yval,zval,qval,rval,sval).

To evaluate the interpolant itself, set idx=idy=idz=idq=idr=ids=0, to evaluate the first partial with respect to x, set idx=1,idy=idz=idq=idr=ids=0, and so on.

See db3val header for more information.

History

Jacob Williams, 2/24/2015 : Created this routine.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	xval	$x$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	yval	$y$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	zval	$z$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	qval	$q$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	rval	$r$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	sval	$s$ coordinate of evaluation point.
integer(kind=ip),	intent(in)			::	idx	$x$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idy	$y$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idz	$z$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idq	$q$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idr	$r$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	ids	$s$ derivative of piecewise polynomial to evaluate.
real(kind=wp),	intent(in),		dimension(nx+kx)	::	tx	sequence of knots defining the piecewise polynomial in the $x$ direction. (same as in last call to db6ink)
real(kind=wp),	intent(in),		dimension(ny+ky)	::	ty	sequence of knots defining the piecewise polynomial in the $y$ direction. (same as in last call to db6ink)
real(kind=wp),	intent(in),		dimension(nz+kz)	::	tz	sequence of knots defining the piecewise polynomial in the $z$ direction. (same as in last call to db6ink)
real(kind=wp),	intent(in),		dimension(nq+kq)	::	tq	sequence of knots defining the piecewise polynomial in the $q$ direction. (same as in last call to db6ink)
real(kind=wp),	intent(in),		dimension(nr+kr)	::	tr	sequence of knots defining the piecewise polynomial in the $r$ direction. (same as in last call to db6ink)
real(kind=wp),	intent(in),		dimension(ns+ks)	::	ts	sequence of knots defining the piecewise polynomial in the $s$ direction. (same as in last call to db6ink)
integer(kind=ip),	intent(in)			::	nx	the number of interpolation points in $x$ . (same as in last call to db6ink)
integer(kind=ip),	intent(in)			::	ny	the number of interpolation points in $y$ . (same as in last call to db6ink)
integer(kind=ip),	intent(in)			::	nz	the number of interpolation points in $z$ . (same as in last call to db6ink)
integer(kind=ip),	intent(in)			::	nq	the number of interpolation points in $q$ . (same as in last call to db6ink)
integer(kind=ip),	intent(in)			::	nr	the number of interpolation points in $r$ . (same as in last call to db6ink)
integer(kind=ip),	intent(in)			::	ns	the number of interpolation points in $s$ . (same as in last call to db6ink)
integer(kind=ip),	intent(in)			::	kx	order of polynomial pieces in $x$ . (same as in last call to db6ink)
integer(kind=ip),	intent(in)			::	ky	order of polynomial pieces in $y$ . (same as in last call to db6ink)
integer(kind=ip),	intent(in)			::	kz	order of polynomial pieces in $z$ . (same as in last call to db6ink)
integer(kind=ip),	intent(in)			::	kq	order of polynomial pieces in $q$ . (same as in last call to db6ink)
integer(kind=ip),	intent(in)			::	kr	order of polynomial pieces in $r$ . (same as in last call to db6ink)
integer(kind=ip),	intent(in)			::	ks	order of polynomial pieces in $s$ . (same as in last call to db6ink)
real(kind=wp),	intent(in),		dimension(nx,ny,nz,nq,nr,ns)	::	bcoef	the b-spline coefficients computed by db6ink.
real(kind=wp),	intent(out)			::	f	interpolated value
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
integer(kind=ip),	intent(inout)			::	inbvx	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	inbvy	not used (kept for backward compatibility)
integer(kind=ip),	intent(inout)			::	inbvz	not used (kept for backward compatibility)
integer(kind=ip),	intent(inout)			::	inbvq	not used (kept for backward compatibility)
integer(kind=ip),	intent(inout)			::	inbvr	not used (kept for backward compatibility)
integer(kind=ip),	intent(inout)			::	inbvs	not used (kept for backward compatibility)
integer(kind=ip),	intent(inout)			::	iloy	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloz	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloq	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	ilor	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	ilos	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
real(kind=wp),	intent(inout),		dimension(ky,kz,kq,kr,ks)	::	w5	work array
real(kind=wp),	intent(inout),		dimension(kz,kq,kr,ks)	::	w4	work array
real(kind=wp),	intent(inout),		dimension(kq,kr,ks)	::	w3	work array
real(kind=wp),	intent(inout),		dimension(kr,ks)	::	w2	work array
real(kind=wp),	intent(inout),		dimension(ks)	::	w1	work array
real(kind=wp),	intent(inout),		dimension(3_ip*max(kx,ky,kz,kq,kr,ks))	::	w0	not used (kept for backward compatibility)
logical,	intent(in),	optional		::	extrap	if extrapolation is allowed (if not present, default is False)

private pure subroutine db6val_multi(xval, yval, zval, qval, rval, sval, idx, idy, idz, idq, idr, ids, tx, ty, tz, tq, tr, ts, nx, ny, nz, nq, nr, ns, kx, ky, kz, kq, kr, ks, bcoef, f, iflag, inbvx, iloy, iloz, iloq, ilor, ilos, w5, w4, w3, w2, w1, extrap)

Multiple-output version of db6val: evaluates all nf outputs of a spline from db6ink (multiple-output version) at one point. The interval search and the basis functions in each direction are only computed once, for all of the outputs.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	xval	$x$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	yval	$y$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	zval	$z$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	qval	$q$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	rval	$r$ coordinate of evaluation point.
real(kind=wp),	intent(in)			::	sval	$s$ coordinate of evaluation point.
integer(kind=ip),	intent(in)			::	idx	$x$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idy	$y$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idz	$z$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idq	$q$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	idr	$r$ derivative of piecewise polynomial to evaluate.
integer(kind=ip),	intent(in)			::	ids	$s$ derivative of piecewise polynomial to evaluate.
real(kind=wp),	intent(in),		dimension(nx+kx)	::	tx	knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(ny+ky)	::	ty	knots in the $y$ direction.
real(kind=wp),	intent(in),		dimension(nz+kz)	::	tz	knots in the $z$ direction.
real(kind=wp),	intent(in),		dimension(nq+kq)	::	tq	knots in the $q$ direction.
real(kind=wp),	intent(in),		dimension(nr+kr)	::	tr	knots in the $r$ direction.
real(kind=wp),	intent(in),		dimension(ns+ks)	::	ts	knots in the $s$ direction.
integer(kind=ip),	intent(in)			::	nx	the number of interpolation points in $x$ .
integer(kind=ip),	intent(in)			::	ny	the number of interpolation points in $y$ .
integer(kind=ip),	intent(in)			::	nz	the number of interpolation points in $z$ .
integer(kind=ip),	intent(in)			::	nq	the number of interpolation points in $q$ .
integer(kind=ip),	intent(in)			::	nr	the number of interpolation points in $r$ .
integer(kind=ip),	intent(in)			::	ns	the number of interpolation points in $s$ .
integer(kind=ip),	intent(in)			::	kx	order of polynomial pieces in $x$ .
integer(kind=ip),	intent(in)			::	ky	order of polynomial pieces in $y$ .
integer(kind=ip),	intent(in)			::	kz	order of polynomial pieces in $z$ .
integer(kind=ip),	intent(in)			::	kq	order of polynomial pieces in $q$ .
integer(kind=ip),	intent(in)			::	kr	order of polynomial pieces in $r$ .
integer(kind=ip),	intent(in)			::	ks	order of polynomial pieces in $s$ .
real(kind=wp),	intent(in),		dimension(:,:,:,:,:,:,:)	::	bcoef	`(nx,ny,nz,nq,nr,ns,nf)` b-spline coefficients from db6ink (multiple-output version).
real(kind=wp),	intent(out),		dimension(:)	::	f	`(nf)` interpolated values of the outputs
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
integer(kind=ip),	intent(inout)			::	inbvx	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloy	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloz	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	iloq	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	ilor	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
integer(kind=ip),	intent(inout)			::	ilos	initialization parameter which must be set to 1 the first time this routine is called, and must not be changed by the user.
real(kind=wp),	intent(inout),		dimension(ky,kz,kq,kr,ks)	::	w5	work array of dimension `(ky,kz,kq,kr,ks)`
real(kind=wp),	intent(inout),		dimension(kz,kq,kr,ks)	::	w4	work array of dimension `(kz,kq,kr,ks)`
real(kind=wp),	intent(inout),		dimension(kq,kr,ks)	::	w3	work array of dimension `(kq,kr,ks)`
real(kind=wp),	intent(inout),		dimension(kr,ks)	::	w2	work array of dimension `(kr,ks)`
real(kind=wp),	intent(inout),		dimension(ks)	::	w1	work array of dimension `(ks)`
logical,	intent(in),	optional		::	extrap	if extrapolation is allowed (if not present, default is False)

Abstract Interfaces

abstract interface

public function b1fqad_func(x) result(f)

interface for the input function in dbfqad

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	x

Return Value real(kind=wp)

f(x)

Functions

private pure function in_flat_region(t, c, n, k, a, ftol, x) result(inside)

Returns true if x is inside a region where the spline is equal to a (to within ftol). The ends of such a region are not inside. Used by db1root.

Arguments

Type	Intent	Attributes		Name
real(kind=wp),	intent(in),	dimension(n+k)	::	t	knot array
real(kind=wp),	intent(in),	dimension(n)	::	c	b-spline coefficient array
integer(kind=ip),	intent(in)		::	n	number of b-spline coefficients
integer(kind=ip),	intent(in)		::	k	order of the b-spline
real(kind=wp),	intent(in)		::	a	the value to solve for
real(kind=wp),	intent(in)		::	ftol	tolerance on $\|s(x)-a\|$
real(kind=wp),	intent(in)		::	x	the point to check

Return Value logical

true if x is inside a region where $s(x) = a$ (to within ftol)

private pure function root_dup_tol(x1, x2) result(tol)

Tolerance for removing duplicate roots in db1root: two roots closer than this are the same root (found twice, e.g. at a knot).

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	x1	left end of the domain: `t(k)`
real(kind=wp),	intent(in)			::	x2	right end of the domain: `t(n+1)`

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in)			::	x	the value to check
real(kind=wp),	intent(in),		dimension(:)	::	t	the knot vector
integer(kind=ip),	intent(in)			::	i	1=x, 2=y, 3=z, 4=q, 5=r, 6=s
logical,	intent(in),	optional		::	extrap	if extrapolation is allowed (if not present, default is False)

Type	Intent	Optional		Name
real(kind=wp),	intent(in)		::	x	variable value
real(kind=wp),	intent(in)		::	tmin	first knot vector element for b-splines
real(kind=wp),	intent(in)		::	tmax	last knot vector element for b-splines
logical,	intent(in),	optional	::	extrap	if extrapolation is allowed (if not present, default is False)

Type	Intent	Attributes		Name
procedure(b1fqad_func)			::	fun	external function of one argument for the integrand `bf(x)=fun(x)*dbvalu(tx,bcoef,nx,kx,id,x,inbv,work)`
real(kind=wp),	intent(in),	dimension(nx+kx)	::	tx	knot array
real(kind=wp),	intent(in),	dimension(nx)	::	bcoef	b-spline coefficient array
integer(kind=ip),	intent(in)		::	nx	length of coefficient array
integer(kind=ip),	intent(in)		::	kx	order of b-spline, `kx >= 1`
integer(kind=ip),	intent(in)		::	idx	order of the spline derivative, `0 <= idx <= k-1` `idx=0` gives the spline function
real(kind=wp),	intent(in)		::	x1	left point of quadrature interval in `t(k) <= x <= t(n+1)`
real(kind=wp),	intent(in)		::	x2	right point of quadrature interval in `t(k) <= x <= t(n+1)`
real(kind=wp),	intent(in)		::	tol	desired accuracy for the quadrature, suggest `10*dtol < tol <= 0.1` where `dtol` is the maximum of `1.0e-300` and real(wp) unit roundoff for the machine
real(kind=wp),	intent(out)		::	f	integral of `bf(x)` on `(x1,x2)`
integer(kind=ip),	intent(out)		::	iflag	status flag: Read more…
real(kind=wp),	intent(inout),	dimension(3_ip*kx)	::	w0	work array for dbfqad

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(inout),		dimension(:), allocatable	::	x	the array
real(kind=wp),	intent(in)			::	tol	duplicate tolerance

Type	Intent	Attributes		Name
real(kind=wp),	intent(inout),	dimension(nroww,nrow)	::	w	work array. See header for details.
integer(kind=ip),	intent(in)		::	nroww	row dimension of the work array w. must be >= nbandl + 1 + nbandu.
integer(kind=ip),	intent(in)		::	nrow	matrix order
integer(kind=ip),	intent(in)		::	nbandl	number of bands of a below the main diagonal
integer(kind=ip),	intent(in)		::	nbandu	number of bands of a above the main diagonal
integer(kind=ip),	intent(out)		::	iflag	indicating success(=1) or failure (=2)

Type	Intent	Attributes		Name
real(kind=wp),	intent(in),	dimension(*)	::	t	knot vector of length `n+k`, where `n` = number of b-spline basis functions `n` = sum of knot multiplicities-`k` dimension `t(ileft+jhigh)`
integer(kind=ip),	intent(in)		::	jhigh	order of b-spline, `1 <= jhigh <= k`
integer(kind=ip),	intent(in)		::	k	highest possible order
integer(kind=ip),	intent(in)		::	index	index = 1 gives basis functions of order `jhigh` = 2 denotes previous entry with `work`, `iwork` values saved for subsequent calls to dbspvn.
real(kind=wp),	intent(in)		::	x	argument of basis functions, `t(k) <= x <= t(n+1)`
integer(kind=ip),	intent(in)		::	ileft	largest integer such that `t(ileft) <= x < t(ileft+1)`
real(kind=wp),	intent(out),	dimension(k)	::	vnikx	vector of length `k` for spline values.
real(kind=wp),	intent(inout),	dimension(*)	::	work	a work vector of length `2*k`
integer(kind=ip),	intent(inout)		::	iwork	a work parameter. both `work` and `iwork` contain information necessary to continue for `index = 2`. when `index = 1` exclusively, these are scratch variables and can be used for other purposes.
integer(kind=ip),	intent(out)		::	iflag	Read more…

Type	Intent	Attributes		Name
real(kind=wp),	intent(inout),	dimension(2_ip*ml+mu+1_ip,n)	::	abd	IN: the matrix in band storage. OUT: its LU factorization.
integer(kind=ip),	intent(in)		::	n	order of the matrix
integer(kind=ip),	intent(in)		::	ml	number of diagonals below the main diagonal
integer(kind=ip),	intent(in)		::	mu	number of diagonals above the main diagonal
integer(kind=ip),	intent(out),	dimension(n)	::	ipvt	pivot indices
real(kind=wp),	intent(in)		::	tol	a pivot with `abs(u(k,k)) <= tol` is treated as zero (`tol=0` gives the original LINPACK behavior)
integer(kind=ip),	intent(out)		::	info	0 if successful, otherwise `k` if `u(k,k)` is zero (the matrix is singular)

Type	Intent	Attributes		Name
procedure(b1fqad_func)			::	fun	name of external function of one argument which multiplies dbvalu.
real(kind=wp),	intent(in),	dimension(:)	::	xt	knot array for dbvalu
real(kind=wp),	intent(in),	dimension(n)	::	bc	b-coefficient array for dbvalu
integer(kind=ip),	intent(in)		::	n	number of b-coefficients for dbvalu
integer(kind=ip),	intent(in)		::	kk	order of the spline, `kk>=1`
integer(kind=ip),	intent(in)		::	id	Order of the spline derivative, `0<=id<=kk-1`
real(kind=wp),	intent(in)		::	a	lower limit of integral
real(kind=wp),	intent(in)		::	b	upper limit of integral (may be less than `a`)
integer(kind=ip),	intent(inout)		::	inbv	initialization parameter for dbvalu
real(kind=wp),	intent(inout)		::	err	IN: is a requested pseudorelative error tolerance. normally pick a value of `abs(err)<1e-3`. `ans` will normally have no more error than `abs(err)` times the integral of the absolute value of `fun(x)*[[dbvalu]]()`. Read more…
real(kind=wp),	intent(out)		::	ans	computed value of integral
integer(kind=ip),	intent(out)		::	iflag	a status code: Read more…
real(kind=wp),	intent(inout),	dimension(:)	::	work	work vector of length `3*k` for dbvalu

bspline_sub_module Module

Contents

Variables

Interfaces

Abstract Interfaces

Functions

Subroutines

Description

Notes

See also

References

Uses

Used by

Variables

Interfaces

public interface db1ink

private pure subroutine db1ink_default(x, nx, fcn, kx, iknot, tx, bcoef, iflag)

History

Arguments

private pure subroutine db1ink_alt(x, nx, fcn, kx, ibcl, ibcr, fbcl, fbcr, kntopt, tx, bcoef, iflag)

History

See also

Arguments

private pure subroutine db1ink_alt_2(x, nx, fcn, kx, ibcl, ibcr, fbcl, fbcr, tleft, tright, tx, bcoef, iflag)

History

See also

Arguments

private pure subroutine db1ink_multi(x, nx, fcn, kx, iknot, tx, bcoef, iflag)

Arguments

public interface db1val

private pure subroutine db1val_default(xval, idx, tx, nx, kx, bcoef, f, iflag, inbvx, w0, extrap)

History

Arguments

private pure subroutine db1val_alt(xval, idx, tx, nx, n, kx, bcoef, f, iflag, inbvx, w0, extrap)

Arguments

private pure subroutine db1val_multi(xval, idx, tx, nx, kx, bcoef, f, iflag, inbvx, extrap)

Arguments

public interface db2ink

private pure subroutine db2ink_default(x, nx, y, ny, fcn, kx, ky, iknot, tx, ty, bcoef, iflag)

History

Arguments

private pure subroutine db2ink_multi(x, nx, y, ny, fcn, kx, ky, iknot, tx, ty, bcoef, iflag)

Arguments

public interface db2val

private pure subroutine db2val_default(xval, yval, idx, idy, tx, ty, nx, ny, kx, ky, bcoef, f, iflag, inbvx, inbvy, iloy, w1, w0, extrap)

History

Arguments

private pure subroutine db2val_multi(xval, yval, idx, idy, tx, ty, nx, ny, kx, ky, bcoef, f, iflag, inbvx, iloy, w1, extrap)

Arguments

public interface db3ink

private pure subroutine db3ink_default(x, nx, y, ny, z, nz, fcn, kx, ky, kz, iknot, tx, ty, tz, bcoef, iflag)

History

Arguments

private pure subroutine db3ink_multi(x, nx, y, ny, z, nz, fcn, kx, ky, kz, iknot, tx, ty, tz, bcoef, iflag)

Arguments

public interface db3val

private pure subroutine db3val_default(xval, yval, zval, idx, idy, idz, tx, ty, tz, nx, ny, nz, kx, ky, kz, bcoef, f, iflag, inbvx, inbvy, inbvz, iloy, iloz, w2, w1, w0, extrap)

History

Arguments

private pure subroutine db3val_multi(xval, yval, zval, idx, idy, idz, tx, ty, tz, nx, ny, nz, kx, ky, kz, bcoef, f, iflag, inbvx, iloy, iloz, w2, w1, extrap)

Arguments

public interface db4ink

private pure subroutine db4ink_default(x, nx, y, ny, z, nz, q, nq, fcn, kx, ky, kz, kq, iknot, tx, ty, tz, tq, bcoef, iflag)

History

Arguments

private pure subroutine db4ink_multi(x, nx, y, ny, z, nz, q, nq, fcn, kx, ky, kz, kq, iknot, tx, ty, tz, tq, bcoef, iflag)

Arguments

public interface db4val

private pure subroutine db4val_default(xval, yval, zval, qval, idx, idy, idz, idq, tx, ty, tz, tq, nx, ny, nz, nq, kx, ky, kz, kq, bcoef, f, iflag, inbvx, inbvy, inbvz, inbvq, iloy, iloz, iloq, w3, w2, w1, w0, extrap)

History

Arguments

private pure subroutine db4val_multi(xval, yval, zval, qval, idx, idy, idz, idq, tx, ty, tz, tq, nx, ny, nz, nq, kx, ky, kz, kq, bcoef, f, iflag, inbvx, iloy, iloz, iloq, w3, w2, w1, extrap)

Arguments

public interface db5ink

private pure subroutine db5ink_default(x, nx, y, ny, z, nz, q, nq, r, nr, fcn, kx, ky, kz, kq, kr, iknot, tx, ty, tz, tq, tr, bcoef, iflag)

History

Arguments

private pure subroutine db5ink_multi(x, nx, y, ny, z, nz, q, nq, r, nr, fcn, kx, ky, kz, kq, kr, iknot, tx, ty, tz, tq, tr, bcoef, iflag)

Arguments

public interface db5val