bspline_oo_module – bspline-fortran

Object-oriented style wrappers to bspline_sub_module. This module provides classes (bspline_1d, bspline_2d, bspline_3d, bspline_4d, bspline_5d, and bspline_6d) which can be used instead of the main subroutine interface.

Uses

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),	private,	parameter	::	int_size	=	storage_size(1_ip, kind=ip)	size of a default integer [bits]
integer(kind=ip),	private,	parameter	::	logical_size	=	storage_size(.true., kind=ip)	size of a default logical [bits]
integer(kind=ip),	private,	parameter	::	real_size	=	storage_size(1.0_wp, kind=ip)	size of a `real(wp)` [bits]

Interfaces

public interface bspline_1d

Constructor for bspline_1d

private pure elemental function bspline_1d_constructor_empty() result(me)

It returns an empty bspline_1d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.

Arguments
None
Return Value type(bspline_1d)

private pure function bspline_1d_constructor_auto_knots(x, fcn, kx, extrap) result(me)

Constructor for a bspline_1d type (auto knots). This is a wrapper for initialize_1d_auto_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
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)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_1d)

private pure function bspline_1d_constructor_specify_knots(x, fcn, kx, tx, extrap) result(me)

Constructor for a bspline_1d type (user-specified knots). This is a wrapper for initialize_1d_specify_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
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)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_1d)

public interface bspline_2d

Constructor for bspline_2d

private elemental function bspline_2d_constructor_empty() result(me)

It returns an empty bspline_2d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.

Arguments
None
Return Value type(bspline_2d)

private pure function bspline_2d_constructor_auto_knots(x, y, fcn, kx, ky, extrap) result(me)

Constructor for a bspline_2d type (auto knots). This is a wrapper for initialize_2d_auto_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
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)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_2d)

private pure function bspline_2d_constructor_specify_knots(x, y, fcn, kx, ky, tx, ty, extrap) result(me)

Constructor for a bspline_2d type (user-specified knots). This is a wrapper for initialize_2d_specify_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
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)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Must be non-decreasing.
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_2d)

public interface bspline_3d

Constructor for bspline_3d

private elemental function bspline_3d_constructor_empty() result(me)

It returns an empty bspline_3d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.

Arguments
None
Return Value type(bspline_3d)

private pure function bspline_3d_constructor_auto_knots(x, y, z, fcn, kx, ky, kz, extrap) result(me)

Constructor for a bspline_3d type (auto knots). This is a wrapper for initialize_3d_auto_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
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)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_3d)

private pure function bspline_3d_constructor_specify_knots(x, y, z, fcn, kx, ky, kz, tx, ty, tz, extrap) result(me)

Constructor for a bspline_3d type (user-specified knots). This is a wrapper for initialize_3d_specify_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
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)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction for the spline interpolant. Must be non-decreasing.
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_3d)

public interface bspline_4d

Constructor for bspline_4d

private elemental function bspline_4d_constructor_empty() result(me)

It returns an empty bspline_4d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.

Arguments
None
Return Value type(bspline_4d)

private pure function bspline_4d_constructor_auto_knots(x, y, z, q, fcn, kx, ky, kz, kq, extrap) result(me)

Constructor for a bspline_4d type (auto knots). This is a wrapper for initialize_4d_auto_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:)	::	fcn	`(nx,ny,nz,nq)` matrix of function values to interpolate. `fcn(i,j,k,l)` 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)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_4d)

private pure function bspline_4d_constructor_specify_knots(x, y, z, q, fcn, kx, ky, kz, kq, tx, ty, tz, tq, extrap) result(me)

Constructor for a bspline_4d type (user-specified knots). This is a wrapper for initialize_4d_specify_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:)	::	fcn	`(nx,ny,nz,nq)` matrix of function values to interpolate. `fcn(i,j,k,l)` 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)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction for the spline interpolant. Must be non-decreasing.
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_4d)

public interface bspline_5d

Constructor for bspline_5d

private elemental function bspline_5d_constructor_empty() result(me)

It returns an empty bspline_5d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.

Arguments
None
Return Value type(bspline_5d)

private pure function bspline_5d_constructor_auto_knots(x, y, z, q, r, fcn, kx, ky, kz, kq, kr, extrap) result(me)

Constructor for a bspline_5d type (auto knots). This is a wrapper for initialize_5d_auto_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr)` matrix of function values to interpolate. `fcn(i,j,k,l,m)` 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)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_5d)

private pure function bspline_5d_constructor_specify_knots(x, y, z, q, r, fcn, kx, ky, kz, kq, kr, tx, ty, tz, tq, tr, extrap) result(me)

Constructor for a bspline_5d type (user-specified knots). This is a wrapper for initialize_5d_specify_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr)` matrix of function values to interpolate. `fcn(i,j,k,l,m)` 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)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction for the spline interpolant. Must be non-decreasing.
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_5d)

public interface bspline_6d

Constructor for bspline_6d

private elemental function bspline_6d_constructor_empty() result(me)

It returns an empty bspline_6d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.

Arguments
None
Return Value type(bspline_6d)

private pure function bspline_6d_constructor_auto_knots(x, y, z, q, r, s, fcn, kx, ky, kz, kq, kr, ks, extrap) result(me)

Constructor for a bspline_6d type (auto knots). This is a wrapper for initialize_6d_auto_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	s	`(ns)` array of $s$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr,ns)` matrix of function values to interpolate. `fcn(i,j,k,l,m,n)` 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 $z$ ( $2 \le k_z < n_z$ ) (order = polynomial degree + 1)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_6d)

private pure function bspline_6d_constructor_specify_knots(x, y, z, q, r, s, fcn, kx, ky, kz, kq, kr, ks, tx, ty, tz, tq, tr, ts, extrap) result(me)

Constructor for a bspline_6d type (user-specified knots). This is a wrapper for initialize_6d_specify_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	s	`(ns)` array of $s$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr,ns)` matrix of function values to interpolate. `fcn(i,j,k,l,m,n)` 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 $z$ ( $2 \le k_z < n_z$ ) (order = polynomial degree + 1)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ts	The `(ns+ks)` knots in the $s$ direction for the spline interpolant. Must be non-decreasing.
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_6d)

Abstract Interfaces

abstract interface

private pure function size_func(me) result(s)

interface for size routines

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_class),	intent(in)			::	me

Return Value integer(kind=ip)

size of the structure in bits

abstract interface

private pure subroutine destroy_func(me)

interface for bspline destructor routines

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_class),	intent(inout)			::	me

Derived Types

type, public, abstract :: bspline_class

Base class for the b-spline types

Components

Type	Visibility		Name		Initial
integer(kind=ip),	private	::	inbvx	=	1_ip	internal variable used by dbvalu for efficient processing
integer(kind=ip),	private	::	iflag	=	1_ip	saved `iflag` from the list routine call.
logical,	private	::	initialized	=	.false.	true if the class is initialized and ready to use
logical,	private	::	extrap	=	.false.	if true, then extrapolation is allowed during evaluation
integer(kind=ip),	private	::	nf	=	0_ip	number of outputs (the last dimension of `bcoef`)

Type-Bound Procedures

procedure, private, non_overridable :: destroy_base	destructor for the abstract type
procedure, private, non_overridable :: set_extrap_flag	internal routine to set the `extrap` flag
procedure(destroy_func), public, deferred :: destroy	destructor
procedure(size_func), public, deferred :: size_of	size of the structure in bits
procedure, public, non_overridable :: status_ok	returns true if the last `iflag` status code was `=0`.
procedure, public, non_overridable :: status_message => get_bspline_status_message	retrieve the last status message
procedure, public, non_overridable :: clear_flag => clear_bspline_flag	to reset the `iflag` saved in the class.
procedure, public, non_overridable :: number_of_outputs	number of outputs (functions) of the spline

type, public, extends(bspline_class) :: bspline_1d

Class for 1d b-spline interpolation.

Components

Type	Visibility	Attributes		Name		Initial
integer(kind=ip),	private		::	nx	=	0_ip	Number of $x$ abcissae
integer(kind=ip),	private		::	kx	=	0_ip	The order of spline pieces in $x$
real(kind=wp),	private,	dimension(:,:), allocatable	::	bcoef			array of coefficients of the b-spline interpolant (the last dimension is the output index)
real(kind=wp),	private,	dimension(:), allocatable	::	tx			The knots in the $x$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	work_val_1			[[db1val] work array of dimension `3*kx`

Constructor

Constructor for bspline_1d

private pure, elemental function bspline_1d_constructor_empty ()	It returns an empty bspline_1d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.
private pure function bspline_1d_constructor_auto_knots (x, fcn, kx, extrap)	Constructor for a bspline_1d type (auto knots). This is a wrapper for initialize_1d_auto_knots.
private pure function bspline_1d_constructor_specify_knots (x, fcn, kx, tx, extrap)	Constructor for a bspline_1d type (user-specified knots). This is a wrapper for initialize_1d_specify_knots.

Finalizations Procedures

final :: finalize_1d

Type-Bound Procedures

procedure, public, non_overridable :: status_ok	returns true if the last `iflag` status code was `=0`.
procedure, public, non_overridable :: status_message => get_bspline_status_message	retrieve the last status message
procedure, public, non_overridable :: clear_flag => clear_bspline_flag	to reset the `iflag` saved in the class.
procedure, public, non_overridable :: number_of_outputs	number of outputs (functions) of the spline
generic, public :: initialize => initialize_1d_auto_knots, initialize_1d_specify_knots, initialize_1d_auto_knots_multi, initialize_1d_specify_knots_multi
procedure, private :: initialize_1d_auto_knots_multi
procedure, private :: initialize_1d_specify_knots_multi
procedure, private :: initialize_1d_auto_knots
procedure, private :: initialize_1d_specify_knots
generic, public :: evaluate => evaluate_1d, evaluate_1d_multi
procedure, private :: evaluate_1d
procedure, private :: evaluate_1d_multi
procedure, public :: destroy => destroy_1d
procedure, public :: size_of => size_1d
generic, public :: initialize_from_coefficients => initialize_from_coefficients_1d, initialize_from_coefficients_1d_multi
procedure, private :: initialize_from_coefficients_1d
procedure, private :: initialize_from_coefficients_1d_multi
procedure, public :: get_knots => get_knots_1d
generic, public :: get_coefficients => get_coefficients_1d, get_coefficients_1d_multi
procedure, private :: get_coefficients_1d
procedure, private :: get_coefficients_1d_multi
procedure, public :: control_points => control_points_1d
procedure, public :: integral => integral_1d
procedure, public :: fintegral => fintegral_1d
procedure, public :: roots => roots_1d
procedure, public :: inverse => inverse_1d
procedure, public :: minimum => minimum_1d
procedure, public :: maximum => maximum_1d

type, public, extends(bspline_class) :: bspline_2d

Class for 2d b-spline interpolation.

Components

Type	Visibility	Attributes		Name		Initial
integer(kind=ip),	private		::	nx	=	0_ip	Number of $x$ abcissae
integer(kind=ip),	private		::	ny	=	0_ip	Number of $y$ abcissae
integer(kind=ip),	private		::	kx	=	0_ip	The order of spline pieces in $x$
integer(kind=ip),	private		::	ky	=	0_ip	The order of spline pieces in $y$
real(kind=wp),	private,	dimension(:,:,:), allocatable	::	bcoef			array of coefficients of the b-spline interpolant (the last dimension is the output index)
real(kind=wp),	private,	dimension(:), allocatable	::	tx			The knots in the $x$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	ty			The knots in the $y$ direction for the spline interpolant
integer(kind=ip),	private		::	inbvy	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	iloy	=	1_ip	internal variable used for efficient processing
real(kind=wp),	private,	dimension(:), allocatable	::	work_val_1			[[db2val] work array of dimension `ky`
real(kind=wp),	private,	dimension(:), allocatable	::	work_val_2			[[db2val] work array of dimension `3_ip*max(kx,ky)`

Constructor

Constructor for bspline_2d

private elemental function bspline_2d_constructor_empty ()	It returns an empty bspline_2d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.
private pure function bspline_2d_constructor_auto_knots (x, y, fcn, kx, ky, extrap)	Constructor for a bspline_2d type (auto knots). This is a wrapper for initialize_2d_auto_knots.
private pure function bspline_2d_constructor_specify_knots (x, y, fcn, kx, ky, tx, ty, extrap)	Constructor for a bspline_2d type (user-specified knots). This is a wrapper for initialize_2d_specify_knots.

Finalizations Procedures

final :: finalize_2d

Type-Bound Procedures

procedure, public, non_overridable :: status_ok	returns true if the last `iflag` status code was `=0`.
procedure, public, non_overridable :: status_message => get_bspline_status_message	retrieve the last status message
procedure, public, non_overridable :: clear_flag => clear_bspline_flag	to reset the `iflag` saved in the class.
procedure, public, non_overridable :: number_of_outputs	number of outputs (functions) of the spline
generic, public :: initialize => initialize_2d_auto_knots, initialize_2d_specify_knots, initialize_2d_auto_knots_multi, initialize_2d_specify_knots_multi
procedure, private :: initialize_2d_auto_knots_multi
procedure, private :: initialize_2d_specify_knots_multi
procedure, private :: initialize_2d_auto_knots
procedure, private :: initialize_2d_specify_knots
generic, public :: evaluate => evaluate_2d, evaluate_2d_multi
procedure, private :: evaluate_2d
procedure, private :: evaluate_2d_multi
procedure, public :: destroy => destroy_2d
procedure, public :: size_of => size_2d
generic, public :: initialize_from_coefficients => initialize_from_coefficients_2d, initialize_from_coefficients_2d_multi
procedure, private :: initialize_from_coefficients_2d
procedure, private :: initialize_from_coefficients_2d_multi
procedure, public :: get_knots => get_knots_2d
generic, public :: get_coefficients => get_coefficients_2d, get_coefficients_2d_multi
procedure, private :: get_coefficients_2d
procedure, private :: get_coefficients_2d_multi

type, public, extends(bspline_class) :: bspline_3d

Class for 3d b-spline interpolation.

Components

Type	Visibility	Attributes		Name		Initial
integer(kind=ip),	private		::	nx	=	0_ip	Number of $x$ abcissae
integer(kind=ip),	private		::	ny	=	0_ip	Number of $y$ abcissae
integer(kind=ip),	private		::	nz	=	0_ip	Number of $z$ abcissae
integer(kind=ip),	private		::	kx	=	0_ip	The order of spline pieces in $x$
integer(kind=ip),	private		::	ky	=	0_ip	The order of spline pieces in $y$
integer(kind=ip),	private		::	kz	=	0_ip	The order of spline pieces in $z$
real(kind=wp),	private,	dimension(:,:,:,:), allocatable	::	bcoef			array of coefficients of the b-spline interpolant (the last dimension is the output index)
real(kind=wp),	private,	dimension(:), allocatable	::	tx			The knots in the $x$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	ty			The knots in the $y$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	tz			The knots in the $z$ direction for the spline interpolant
integer(kind=ip),	private		::	inbvy	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	inbvz	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	iloy	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	iloz	=	1_ip	internal variable used for efficient processing
real(kind=wp),	private,	dimension(:,:), allocatable	::	work_val_1			[[db3val] work array of dimension `ky,kz`
real(kind=wp),	private,	dimension(:), allocatable	::	work_val_2			[[db3val] work array of dimension `kz`
real(kind=wp),	private,	dimension(:), allocatable	::	work_val_3			[[db3val] work array of dimension `3_ip*max(kx,ky,kz)`

Constructor

Constructor for bspline_3d

private elemental function bspline_3d_constructor_empty ()	It returns an empty bspline_3d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.
private pure function bspline_3d_constructor_auto_knots (x, y, z, fcn, kx, ky, kz, extrap)	Constructor for a bspline_3d type (auto knots). This is a wrapper for initialize_3d_auto_knots.
private pure function bspline_3d_constructor_specify_knots (x, y, z, fcn, kx, ky, kz, tx, ty, tz, extrap)	Constructor for a bspline_3d type (user-specified knots). This is a wrapper for initialize_3d_specify_knots.

Finalizations Procedures

final :: finalize_3d

Type-Bound Procedures

procedure, public, non_overridable :: status_ok	returns true if the last `iflag` status code was `=0`.
procedure, public, non_overridable :: status_message => get_bspline_status_message	retrieve the last status message
procedure, public, non_overridable :: clear_flag => clear_bspline_flag	to reset the `iflag` saved in the class.
procedure, public, non_overridable :: number_of_outputs	number of outputs (functions) of the spline
generic, public :: initialize => initialize_3d_auto_knots, initialize_3d_specify_knots, initialize_3d_auto_knots_multi, initialize_3d_specify_knots_multi
procedure, private :: initialize_3d_auto_knots_multi
procedure, private :: initialize_3d_specify_knots_multi
procedure, private :: initialize_3d_auto_knots
procedure, private :: initialize_3d_specify_knots
generic, public :: evaluate => evaluate_3d, evaluate_3d_multi
procedure, private :: evaluate_3d
procedure, private :: evaluate_3d_multi
procedure, public :: destroy => destroy_3d
procedure, public :: size_of => size_3d
generic, public :: initialize_from_coefficients => initialize_from_coefficients_3d, initialize_from_coefficients_3d_multi
procedure, private :: initialize_from_coefficients_3d
procedure, private :: initialize_from_coefficients_3d_multi
procedure, public :: get_knots => get_knots_3d
generic, public :: get_coefficients => get_coefficients_3d, get_coefficients_3d_multi
procedure, private :: get_coefficients_3d
procedure, private :: get_coefficients_3d_multi

type, public, extends(bspline_class) :: bspline_4d

Class for 4d b-spline interpolation.

Components

Type	Visibility	Attributes		Name		Initial
integer(kind=ip),	private		::	nx	=	0_ip	Number of $x$ abcissae
integer(kind=ip),	private		::	ny	=	0_ip	Number of $y$ abcissae
integer(kind=ip),	private		::	nz	=	0_ip	Number of $z$ abcissae
integer(kind=ip),	private		::	nq	=	0_ip	Number of $q$ abcissae
integer(kind=ip),	private		::	kx	=	0_ip	The order of spline pieces in $x$
integer(kind=ip),	private		::	ky	=	0_ip	The order of spline pieces in $y$
integer(kind=ip),	private		::	kz	=	0_ip	The order of spline pieces in $z$
integer(kind=ip),	private		::	kq	=	0_ip	The order of spline pieces in $q$
real(kind=wp),	private,	dimension(:,:,:,:,:), allocatable	::	bcoef			array of coefficients of the b-spline interpolant (the last dimension is the output index)
real(kind=wp),	private,	dimension(:), allocatable	::	tx			The knots in the $x$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	ty			The knots in the $y$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	tz			The knots in the $z$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	tq			The knots in the $q$ direction for the spline interpolant
integer(kind=ip),	private		::	inbvy	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	inbvz	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	inbvq	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	iloy	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	iloz	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	iloq	=	1_ip	internal variable used for efficient processing
real(kind=wp),	private,	dimension(:,:,:), allocatable	::	work_val_1			db4val work array of dimension `ky,kz,kq`
real(kind=wp),	private,	dimension(:,:), allocatable	::	work_val_2			db4val work array of dimension `kz,kq`
real(kind=wp),	private,	dimension(:), allocatable	::	work_val_3			db4val work array of dimension `kq`
real(kind=wp),	private,	dimension(:), allocatable	::	work_val_4			db4val work array of dimension `3_ip*max(kx,ky,kz,kq)`

Constructor

Constructor for bspline_4d

private elemental function bspline_4d_constructor_empty ()	It returns an empty bspline_4d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.
private pure function bspline_4d_constructor_auto_knots (x, y, z, q, fcn, kx, ky, kz, kq, extrap)	Constructor for a bspline_4d type (auto knots). This is a wrapper for initialize_4d_auto_knots.
private pure function bspline_4d_constructor_specify_knots (x, y, z, q, fcn, kx, ky, kz, kq, tx, ty, tz, tq, extrap)	Constructor for a bspline_4d type (user-specified knots). This is a wrapper for initialize_4d_specify_knots.

Finalizations Procedures

final :: finalize_4d

Type-Bound Procedures

procedure, public, non_overridable :: status_ok	returns true if the last `iflag` status code was `=0`.
procedure, public, non_overridable :: status_message => get_bspline_status_message	retrieve the last status message
procedure, public, non_overridable :: clear_flag => clear_bspline_flag	to reset the `iflag` saved in the class.
procedure, public, non_overridable :: number_of_outputs	number of outputs (functions) of the spline
generic, public :: initialize => initialize_4d_auto_knots, initialize_4d_specify_knots, initialize_4d_auto_knots_multi, initialize_4d_specify_knots_multi
procedure, private :: initialize_4d_auto_knots_multi
procedure, private :: initialize_4d_specify_knots_multi
procedure, private :: initialize_4d_auto_knots
procedure, private :: initialize_4d_specify_knots
generic, public :: evaluate => evaluate_4d, evaluate_4d_multi
procedure, private :: evaluate_4d
procedure, private :: evaluate_4d_multi
procedure, public :: destroy => destroy_4d
procedure, public :: size_of => size_4d
generic, public :: initialize_from_coefficients => initialize_from_coefficients_4d, initialize_from_coefficients_4d_multi
procedure, private :: initialize_from_coefficients_4d
procedure, private :: initialize_from_coefficients_4d_multi
procedure, public :: get_knots => get_knots_4d
generic, public :: get_coefficients => get_coefficients_4d, get_coefficients_4d_multi
procedure, private :: get_coefficients_4d
procedure, private :: get_coefficients_4d_multi

type, public, extends(bspline_class) :: bspline_5d

Class for 5d b-spline interpolation.

Components

Type	Visibility	Attributes		Name		Initial
integer(kind=ip),	private		::	nx	=	0_ip	Number of $x$ abcissae
integer(kind=ip),	private		::	ny	=	0_ip	Number of $y$ abcissae
integer(kind=ip),	private		::	nz	=	0_ip	Number of $z$ abcissae
integer(kind=ip),	private		::	nq	=	0_ip	Number of $q$ abcissae
integer(kind=ip),	private		::	nr	=	0_ip	Number of $r$ abcissae
integer(kind=ip),	private		::	kx	=	0_ip	The order of spline pieces in $x$
integer(kind=ip),	private		::	ky	=	0_ip	The order of spline pieces in $y$
integer(kind=ip),	private		::	kz	=	0_ip	The order of spline pieces in $z$
integer(kind=ip),	private		::	kq	=	0_ip	The order of spline pieces in $q$
integer(kind=ip),	private		::	kr	=	0_ip	The order of spline pieces in $r$
real(kind=wp),	private,	dimension(:,:,:,:,:,:), allocatable	::	bcoef			array of coefficients of the b-spline interpolant (the last dimension is the output index)
real(kind=wp),	private,	dimension(:), allocatable	::	tx			The knots in the $x$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	ty			The knots in the $y$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	tz			The knots in the $z$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	tq			The knots in the $q$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	tr			The knots in the $r$ direction for the spline interpolant
integer(kind=ip),	private		::	inbvy	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	inbvz	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	inbvq	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	inbvr	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	iloy	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	iloz	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	iloq	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	ilor	=	1_ip	internal variable used for efficient processing
real(kind=wp),	private,	dimension(:,:,:,:), allocatable	::	work_val_1			db5val work array of dimension `ky,kz,kq,kr`
real(kind=wp),	private,	dimension(:,:,:), allocatable	::	work_val_2			db5val work array of dimension `kz,kq,kr`
real(kind=wp),	private,	dimension(:,:), allocatable	::	work_val_3			db5val work array of dimension `kq,kr`
real(kind=wp),	private,	dimension(:), allocatable	::	work_val_4			db5val work array of dimension `kr`
real(kind=wp),	private,	dimension(:), allocatable	::	work_val_5			db5val work array of dimension `3_ip*max(kx,ky,kz,kq,kr)`

Constructor

Constructor for bspline_5d

private elemental function bspline_5d_constructor_empty ()	It returns an empty bspline_5d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.
private pure function bspline_5d_constructor_auto_knots (x, y, z, q, r, fcn, kx, ky, kz, kq, kr, extrap)	Constructor for a bspline_5d type (auto knots). This is a wrapper for initialize_5d_auto_knots.
private pure function bspline_5d_constructor_specify_knots (x, y, z, q, r, fcn, kx, ky, kz, kq, kr, tx, ty, tz, tq, tr, extrap)	Constructor for a bspline_5d type (user-specified knots). This is a wrapper for initialize_5d_specify_knots.

Finalizations Procedures

final :: finalize_5d

Type-Bound Procedures

procedure, public, non_overridable :: status_ok	returns true if the last `iflag` status code was `=0`.
procedure, public, non_overridable :: status_message => get_bspline_status_message	retrieve the last status message
procedure, public, non_overridable :: clear_flag => clear_bspline_flag	to reset the `iflag` saved in the class.
procedure, public, non_overridable :: number_of_outputs	number of outputs (functions) of the spline
generic, public :: initialize => initialize_5d_auto_knots, initialize_5d_specify_knots, initialize_5d_auto_knots_multi, initialize_5d_specify_knots_multi
procedure, private :: initialize_5d_auto_knots_multi
procedure, private :: initialize_5d_specify_knots_multi
procedure, private :: initialize_5d_auto_knots
procedure, private :: initialize_5d_specify_knots
generic, public :: evaluate => evaluate_5d, evaluate_5d_multi
procedure, private :: evaluate_5d
procedure, private :: evaluate_5d_multi
procedure, public :: destroy => destroy_5d
procedure, public :: size_of => size_5d
generic, public :: initialize_from_coefficients => initialize_from_coefficients_5d, initialize_from_coefficients_5d_multi
procedure, private :: initialize_from_coefficients_5d
procedure, private :: initialize_from_coefficients_5d_multi
procedure, public :: get_knots => get_knots_5d
generic, public :: get_coefficients => get_coefficients_5d, get_coefficients_5d_multi
procedure, private :: get_coefficients_5d
procedure, private :: get_coefficients_5d_multi

type, public, extends(bspline_class) :: bspline_6d

Class for 6d b-spline interpolation.

Components

Type	Visibility	Attributes		Name		Initial
integer(kind=ip),	private		::	nx	=	0_ip	Number of $x$ abcissae
integer(kind=ip),	private		::	ny	=	0_ip	Number of $y$ abcissae
integer(kind=ip),	private		::	nz	=	0_ip	Number of $z$ abcissae
integer(kind=ip),	private		::	nq	=	0_ip	Number of $q$ abcissae
integer(kind=ip),	private		::	nr	=	0_ip	Number of $r$ abcissae
integer(kind=ip),	private		::	ns	=	0_ip	Number of $s$ abcissae
integer(kind=ip),	private		::	kx	=	0_ip	The order of spline pieces in $x$
integer(kind=ip),	private		::	ky	=	0_ip	The order of spline pieces in $y$
integer(kind=ip),	private		::	kz	=	0_ip	The order of spline pieces in $z$
integer(kind=ip),	private		::	kq	=	0_ip	The order of spline pieces in $q$
integer(kind=ip),	private		::	kr	=	0_ip	The order of spline pieces in $r$
integer(kind=ip),	private		::	ks	=	0_ip	The order of spline pieces in $s$
real(kind=wp),	private,	dimension(:,:,:,:,:,:,:), allocatable	::	bcoef			array of coefficients of the b-spline interpolant (the last dimension is the output index)
real(kind=wp),	private,	dimension(:), allocatable	::	tx			The knots in the $x$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	ty			The knots in the $y$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	tz			The knots in the $z$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	tq			The knots in the $q$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	tr			The knots in the $r$ direction for the spline interpolant
real(kind=wp),	private,	dimension(:), allocatable	::	ts			The knots in the $s$ direction for the spline interpolant
integer(kind=ip),	private		::	inbvy	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	inbvz	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	inbvq	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	inbvr	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	inbvs	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	iloy	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	iloz	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	iloq	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	ilor	=	1_ip	internal variable used for efficient processing
integer(kind=ip),	private		::	ilos	=	1_ip	internal variable used for efficient processing
real(kind=wp),	private,	dimension(:,:,:,:,:), allocatable	::	work_val_1			db6val work array of dimension `ky,kz,kq,kr,ks`
real(kind=wp),	private,	dimension(:,:,:,:), allocatable	::	work_val_2			db6val work array of dimension `kz,kq,kr,ks`
real(kind=wp),	private,	dimension(:,:,:), allocatable	::	work_val_3			db6val work array of dimension `kq,kr,ks`
real(kind=wp),	private,	dimension(:,:), allocatable	::	work_val_4			db6val work array of dimension `kr,ks`
real(kind=wp),	private,	dimension(:), allocatable	::	work_val_5			db6val work array of dimension `ks`
real(kind=wp),	private,	dimension(:), allocatable	::	work_val_6			db6val work array of dimension `3_ip*max(kx,ky,kz,kq,kr,ks)`

Constructor

Constructor for bspline_6d

private elemental function bspline_6d_constructor_empty ()	It returns an empty bspline_6d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.
private pure function bspline_6d_constructor_auto_knots (x, y, z, q, r, s, fcn, kx, ky, kz, kq, kr, ks, extrap)	Constructor for a bspline_6d type (auto knots). This is a wrapper for initialize_6d_auto_knots.
private pure function bspline_6d_constructor_specify_knots (x, y, z, q, r, s, fcn, kx, ky, kz, kq, kr, ks, tx, ty, tz, tq, tr, ts, extrap)	Constructor for a bspline_6d type (user-specified knots). This is a wrapper for initialize_6d_specify_knots.

Finalizations Procedures

final :: finalize_6d

Type-Bound Procedures

procedure, public, non_overridable :: status_ok	returns true if the last `iflag` status code was `=0`.
procedure, public, non_overridable :: status_message => get_bspline_status_message	retrieve the last status message
procedure, public, non_overridable :: clear_flag => clear_bspline_flag	to reset the `iflag` saved in the class.
procedure, public, non_overridable :: number_of_outputs	number of outputs (functions) of the spline
generic, public :: initialize => initialize_6d_auto_knots, initialize_6d_specify_knots, initialize_6d_auto_knots_multi, initialize_6d_specify_knots_multi
procedure, private :: initialize_6d_auto_knots_multi
procedure, private :: initialize_6d_specify_knots_multi
procedure, private :: initialize_6d_auto_knots
procedure, private :: initialize_6d_specify_knots
generic, public :: evaluate => evaluate_6d, evaluate_6d_multi
procedure, private :: evaluate_6d
procedure, private :: evaluate_6d_multi
procedure, public :: destroy => destroy_6d
procedure, public :: size_of => size_6d
generic, public :: initialize_from_coefficients => initialize_from_coefficients_6d, initialize_from_coefficients_6d_multi
procedure, private :: initialize_from_coefficients_6d
procedure, private :: initialize_from_coefficients_6d_multi
procedure, public :: get_knots => get_knots_6d
generic, public :: get_coefficients => get_coefficients_6d, get_coefficients_6d_multi
procedure, private :: get_coefficients_6d
procedure, private :: get_coefficients_6d_multi

Functions

private pure function number_of_outputs(me) result(nf)

Returns the number of outputs (functions of the same inputs) of the spline: 1 for a spline initialized with a single function, and nf for one initialized with nf functions (the last dimension of fcn). Returns 0 if the class is not initialized.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_class),	intent(in)			::	me	the spline

Return Value integer(kind=ip)

number of outputs

private elemental function status_ok(me) result(ok)

This routines returns true if the iflag code from the last routine called was =0. Maybe of the routines have output iflag variables, so they can be checked explicitly, or this routine can be used.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_class),	intent(in)			::	me

Return Value logical

private pure function get_bspline_status_message(me, iflag) result(msg)

Get the status message from a bspline_class routine call.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_class),	intent(in)			::	me
integer(kind=ip),	intent(in),	optional		::	iflag	the corresponding status code

Return Value character(len=:), allocatable

status message associated with the flag

private pure function size_1d(me) result(s)

Actual size of a bspline_1d structure in bits.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_1d),	intent(in)			::	me

Return Value integer(kind=ip)

size of the structure in bits

private pure function size_2d(me) result(s)

Actual size of a bspline_2d structure in bits.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_2d),	intent(in)			::	me

Return Value integer(kind=ip)

size of the structure in bits

private pure function size_3d(me) result(s)

Actual size of a bspline_3d structure in bits.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_3d),	intent(in)			::	me

Return Value integer(kind=ip)

size of the structure in bits

private pure function size_4d(me) result(s)

Actual size of a bspline_4d structure in bits.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_4d),	intent(in)			::	me

Return Value integer(kind=ip)

size of the structure in bits

private pure function size_5d(me) result(s)

Actual size of a bspline_5d structure in bits.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_5d),	intent(in)			::	me

Return Value integer(kind=ip)

size of the structure in bits

private pure function size_6d(me) result(s)

Actual size of a bspline_6d structure in bits.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_6d),	intent(in)			::	me

Return Value integer(kind=ip)

size of the structure in bits

private pure elemental function bspline_1d_constructor_empty() result(me)

It returns an empty bspline_1d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.

Arguments

None

Return Value type(bspline_1d)

private pure function bspline_1d_constructor_auto_knots(x, fcn, kx, extrap) result(me)

Constructor for a bspline_1d type (auto knots). This is a wrapper for initialize_1d_auto_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
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)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_1d)

private pure function bspline_1d_constructor_specify_knots(x, fcn, kx, tx, extrap) result(me)

Constructor for a bspline_1d type (user-specified knots). This is a wrapper for initialize_1d_specify_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
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)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_1d)

private elemental function bspline_2d_constructor_empty() result(me)

It returns an empty bspline_2d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.

Arguments

None

Return Value type(bspline_2d)

private pure function bspline_2d_constructor_auto_knots(x, y, fcn, kx, ky, extrap) result(me)

Constructor for a bspline_2d type (auto knots). This is a wrapper for initialize_2d_auto_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
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)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_2d)

private pure function bspline_2d_constructor_specify_knots(x, y, fcn, kx, ky, tx, ty, extrap) result(me)

Constructor for a bspline_2d type (user-specified knots). This is a wrapper for initialize_2d_specify_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
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)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Must be non-decreasing.
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_2d)

private elemental function bspline_3d_constructor_empty() result(me)

It returns an empty bspline_3d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.

Arguments

None

Return Value type(bspline_3d)

private pure function bspline_3d_constructor_auto_knots(x, y, z, fcn, kx, ky, kz, extrap) result(me)

Constructor for a bspline_3d type (auto knots). This is a wrapper for initialize_3d_auto_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
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)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_3d)

private pure function bspline_3d_constructor_specify_knots(x, y, z, fcn, kx, ky, kz, tx, ty, tz, extrap) result(me)

Constructor for a bspline_3d type (user-specified knots). This is a wrapper for initialize_3d_specify_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
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)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction for the spline interpolant. Must be non-decreasing.
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_3d)

private elemental function bspline_4d_constructor_empty() result(me)

It returns an empty bspline_4d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.

Arguments

None

Return Value type(bspline_4d)

private pure function bspline_4d_constructor_auto_knots(x, y, z, q, fcn, kx, ky, kz, kq, extrap) result(me)

Constructor for a bspline_4d type (auto knots). This is a wrapper for initialize_4d_auto_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:)	::	fcn	`(nx,ny,nz,nq)` matrix of function values to interpolate. `fcn(i,j,k,l)` 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)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_4d)

private pure function bspline_4d_constructor_specify_knots(x, y, z, q, fcn, kx, ky, kz, kq, tx, ty, tz, tq, extrap) result(me)

Constructor for a bspline_4d type (user-specified knots). This is a wrapper for initialize_4d_specify_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:)	::	fcn	`(nx,ny,nz,nq)` matrix of function values to interpolate. `fcn(i,j,k,l)` 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)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction for the spline interpolant. Must be non-decreasing.
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_4d)

private elemental function bspline_5d_constructor_empty() result(me)

It returns an empty bspline_5d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.

Arguments

None

Return Value type(bspline_5d)

private pure function bspline_5d_constructor_auto_knots(x, y, z, q, r, fcn, kx, ky, kz, kq, kr, extrap) result(me)

Constructor for a bspline_5d type (auto knots). This is a wrapper for initialize_5d_auto_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr)` matrix of function values to interpolate. `fcn(i,j,k,l,m)` 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)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_5d)

private pure function bspline_5d_constructor_specify_knots(x, y, z, q, r, fcn, kx, ky, kz, kq, kr, tx, ty, tz, tq, tr, extrap) result(me)

Constructor for a bspline_5d type (user-specified knots). This is a wrapper for initialize_5d_specify_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr)` matrix of function values to interpolate. `fcn(i,j,k,l,m)` 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)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction for the spline interpolant. Must be non-decreasing.
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_5d)

private elemental function bspline_6d_constructor_empty() result(me)

It returns an empty bspline_6d type. Note that INITIALIZE still needs to be called before it can be used. Not really that useful except perhaps in some OpenMP applications.

Arguments

None

Return Value type(bspline_6d)

private pure function bspline_6d_constructor_auto_knots(x, y, z, q, r, s, fcn, kx, ky, kz, kq, kr, ks, extrap) result(me)

Constructor for a bspline_6d type (auto knots). This is a wrapper for initialize_6d_auto_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	s	`(ns)` array of $s$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr,ns)` matrix of function values to interpolate. `fcn(i,j,k,l,m,n)` 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 $z$ ( $2 \le k_z < n_z$ ) (order = polynomial degree + 1)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_6d)

private pure function bspline_6d_constructor_specify_knots(x, y, z, q, r, s, fcn, kx, ky, kz, kq, kr, ks, tx, ty, tz, tq, tr, ts, extrap) result(me)

Constructor for a bspline_6d type (user-specified knots). This is a wrapper for initialize_6d_specify_knots.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	s	`(ns)` array of $s$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr,ns)` matrix of function values to interpolate. `fcn(i,j,k,l,m,n)` 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 $z$ ( $2 \le k_z < n_z$ ) (order = polynomial degree + 1)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ts	The `(ns+ks)` knots in the $s$ direction for the spline interpolant. Must be non-decreasing.
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

Return Value type(bspline_6d)

Subroutines

private elemental subroutine clear_bspline_flag(me)

This sets the iflag variable in the class to 0 (which indicates that everything is OK). It can be used after an error is encountered.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_class),	intent(inout)			::	me

private pure subroutine destroy_base(me)

Destructor for contents of the base bspline_class class. (this routine is called by the extended classes).

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_class),	intent(inout)			::	me

private pure subroutine destroy_1d(me)

Destructor for bspline_1d class.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_1d),	intent(inout)			::	me

private pure subroutine destroy_2d(me)

Destructor for bspline_2d class.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_2d),	intent(inout)			::	me

private pure subroutine destroy_3d(me)

Destructor for bspline_3d class.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_3d),	intent(inout)			::	me

private pure subroutine destroy_4d(me)

Destructor for bspline_4d class.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_4d),	intent(inout)			::	me

private pure subroutine destroy_5d(me)

Destructor for bspline_5d class.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_5d),	intent(inout)			::	me

private pure subroutine destroy_6d(me)

Destructor for bspline_6d class.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_6d),	intent(inout)			::	me

private pure elemental subroutine finalize_1d(me)

Finalizer for bspline_1d class. Just a wrapper for destroy_1d.

Arguments

Type	Intent	Optional	Attributes		Name
type(bspline_1d),	intent(inout)			::	me

private pure elemental subroutine finalize_2d(me)

Finalizer for bspline_2d class. Just a wrapper for destroy_2d.

Arguments

Type	Intent	Optional	Attributes		Name
type(bspline_2d),	intent(inout)			::	me

private pure elemental subroutine finalize_3d(me)

Finalizer for bspline_3d class. Just a wrapper for destroy_3d.

Arguments

Type	Intent	Optional	Attributes		Name
type(bspline_3d),	intent(inout)			::	me

private pure elemental subroutine finalize_4d(me)

Finalizer for bspline_4d class. Just a wrapper for destroy_4d.

Arguments

Type	Intent	Optional	Attributes		Name
type(bspline_4d),	intent(inout)			::	me

private pure elemental subroutine finalize_5d(me)

Finalizer for bspline_5d class. Just a wrapper for destroy_5d.

Arguments

Type	Intent	Optional	Attributes		Name
type(bspline_5d),	intent(inout)			::	me

private pure elemental subroutine finalize_6d(me)

Finalizer for bspline_6d class. Just a wrapper for destroy_6d.

Arguments

Type	Intent	Optional	Attributes		Name
type(bspline_6d),	intent(inout)			::	me

private pure subroutine set_extrap_flag(me, extrap)

Sets the extrap flag in the class.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_class),	intent(inout)			::	me
logical,	intent(in),	optional		::	extrap	if not present, then False is used

private pure subroutine initialize_1d_auto_knots(me, x, fcn, kx, iflag, extrap)

Initialize a bspline_1d type (with automatically-computed knots). This is a wrapper for db1ink.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_1d),	intent(inout)			::	me
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
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(out)			::	iflag	status flag (see db1ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine initialize_1d_specify_knots(me, x, fcn, kx, tx, iflag, extrap)

Initialize a bspline_1d type (with user-specified knots). This is a wrapper for db1ink.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_1d),	intent(inout)			::	me
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
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)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
integer(kind=ip),	intent(out)			::	iflag	status flag (see db1ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine evaluate_1d(me, xval, idx, f, iflag)

Evaluate a bspline_1d interpolate. This is a wrapper for db1val.

Arguments

Type	Intent		Name
class(bspline_1d),	intent(inout)	::	me
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(out)	::	f	interpolated value
integer(kind=ip),	intent(out)	::	iflag	status flag (see db1val)

private pure subroutine integral_1d(me, x1, x2, f, iflag)

Evaluate a bspline_1d definite integral. This is a wrapper for db1sqad.

Arguments

Type	Intent		Name
class(bspline_1d),	intent(inout)	::	me
real(kind=wp),	intent(in)	::	x1	left point of interval
real(kind=wp),	intent(in)	::	x2	right point of interval
real(kind=wp),	intent(out)	::	f	integral of the b-spline over $[x_1, x_2]$
integer(kind=ip),	intent(out)	::	iflag	status flag (see db1sqad)

private subroutine fintegral_1d(me, fun, idx, x1, x2, tol, f, iflag)

Evaluate a bspline_1d definite integral. This is a wrapper for db1fqad.

Arguments

Type	Intent		Name
class(bspline_1d),	intent(inout)	::	me
procedure(b1fqad_func)		::	fun	external function of one argument for the integrand `bf(x)=fun(x)*dbvalu(tx,bcoef,nx,kx,idx,x,inbv)`
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 interval
real(kind=wp),	intent(in)	::	x2	right point of interval
real(kind=wp),	intent(in)	::	tol	desired accuracy for the quadrature
real(kind=wp),	intent(out)	::	f	integral of `bf(x)` over $[x_1, x_2]$
integer(kind=ip),	intent(out)	::	iflag	status flag (see db1sqad)

private pure subroutine roots_1d(me, a, x, iflag)

All the roots of $s(x) = a$ for a bspline_1d. This is a wrapper for db1root.

Arguments

Type	Intent	Attributes		Name
class(bspline_1d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(in)		::	a	the value to solve for
real(kind=wp),	intent(out),	dimension(:), allocatable	::	x	the roots, in increasing order (size 0 if there are none)
integer(kind=ip),	intent(out)		::	iflag	status flag (see db1root)

private pure subroutine inverse_1d(me, y, x, iflag)

The unique $x$ with $s(x) = y$ for a bspline_1d (for example, a monotonic spline). This is a wrapper for db1root.

Arguments

Type	Intent		Name
class(bspline_1d),	intent(inout)	::	me	the spline
real(kind=wp),	intent(in)	::	y	the spline value
real(kind=wp),	intent(out)	::	x	the solution of $s(x) = y$
integer(kind=ip),	intent(out)	::	iflag	status flag (see db1root)

private pure subroutine minimum_1d(me, xmin, fmin, iflag, xa, xb)

The global minimum of a bspline_1d on $[x_a, x_b]$ (the whole spline domain if xa and xb are not present). This is a wrapper for db1min.

Arguments

Type	Intent	Optional		Name
class(bspline_1d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out)		::	xmin	location of the minimum
real(kind=wp),	intent(out)		::	fmin	minimum value
integer(kind=ip),	intent(out)		::	iflag	status flag (see db1min)
real(kind=wp),	intent(in),	optional	::	xa	left end of the interval (default `tx(kx)`)
real(kind=wp),	intent(in),	optional	::	xb	right end of the interval (default `tx(nx+1)`)

private pure subroutine maximum_1d(me, xmax, fmax, iflag, xa, xb)

The global maximum of a bspline_1d on $[x_a, x_b]$ (the whole spline domain if xa and xb are not present). This is a wrapper for db1max.

Arguments

Type	Intent	Optional		Name
class(bspline_1d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out)		::	xmax	location of the maximum
real(kind=wp),	intent(out)		::	fmax	maximum value
integer(kind=ip),	intent(out)		::	iflag	status flag (see db1max)
real(kind=wp),	intent(in),	optional	::	xa	left end of the interval (default `tx(kx)`)
real(kind=wp),	intent(in),	optional	::	xb	right end of the interval (default `tx(nx+1)`)

private pure subroutine get_interval_1d(me, xa, xb, x1, x2)

The interval for minimum_1d and maximum_1d (the whole spline domain by default).

Arguments

Type	Intent	Optional		Name
class(bspline_1d),	intent(in)		::	me	the spline
real(kind=wp),	intent(in),	optional	::	xa	left end of the interval
real(kind=wp),	intent(in),	optional	::	xb	right end of the interval
real(kind=wp),	intent(out)		::	x1	`xa`, or `tx(kx)` if not present
real(kind=wp),	intent(out)		::	x2	`xb`, or `tx(nx+1)` if not present

private pure subroutine initialize_2d_auto_knots(me, x, y, fcn, kx, ky, iflag, extrap)

Initialize a bspline_2d type (with automatically-computed knots). This is a wrapper for db2ink.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_2d),	intent(inout)			::	me
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
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(out)			::	iflag	status flag (see db2ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine initialize_2d_specify_knots(me, x, y, fcn, kx, ky, tx, ty, iflag, extrap)

Initialize a bspline_2d type (with user-specified knots). This is a wrapper for db2ink.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_2d),	intent(inout)			::	me
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
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)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Must be non-decreasing.
integer(kind=ip),	intent(out)			::	iflag	status flag (see db2ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine evaluate_2d(me, xval, yval, idx, idy, f, iflag)

Evaluate a bspline_2d interpolate. This is a wrapper for db2val.

Arguments

Type	Intent		Name
class(bspline_2d),	intent(inout)	::	me
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(out)	::	f	interpolated value
integer(kind=ip),	intent(out)	::	iflag	status flag (see db2val)

private pure subroutine initialize_3d_auto_knots(me, x, y, z, fcn, kx, ky, kz, iflag, extrap)

Initialize a bspline_3d type (with automatically-computed knots). This is a wrapper for db3ink.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_3d),	intent(inout)			::	me
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
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(out)			::	iflag	status flag (see db3ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine initialize_3d_specify_knots(me, x, y, z, fcn, kx, ky, kz, tx, ty, tz, iflag, extrap)

Initialize a bspline_3d type (with user-specified knots). This is a wrapper for db3ink.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_3d),	intent(inout)			::	me
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
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)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction for the spline interpolant. Must be non-decreasing.
integer(kind=ip),	intent(out)			::	iflag	status flag (see db3ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine evaluate_3d(me, xval, yval, zval, idx, idy, idz, f, iflag)

Evaluate a bspline_3d interpolate. This is a wrapper for db3val.

Arguments

Type	Intent		Name
class(bspline_3d),	intent(inout)	::	me
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(out)	::	f	interpolated value
integer(kind=ip),	intent(out)	::	iflag	status flag (see db3val)

private pure subroutine initialize_4d_auto_knots(me, x, y, z, q, fcn, kx, ky, kz, kq, iflag, extrap)

Initialize a bspline_4d type (with automatically-computed knots). This is a wrapper for db4ink.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_4d),	intent(inout)			::	me
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:)	::	fcn	`(nx,ny,nz,nq)` matrix of function values to interpolate. `fcn(i,j,k,l)` 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(out)			::	iflag	status flag (see db4ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine initialize_4d_specify_knots(me, x, y, z, q, fcn, kx, ky, kz, kq, tx, ty, tz, tq, iflag, extrap)

Initialize a bspline_4d type (with user-specified knots). This is a wrapper for db4ink.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_4d),	intent(inout)			::	me
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:)	::	fcn	`(nx,ny,nz,nq)` matrix of function values to interpolate. `fcn(i,j,k,l)` 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)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction for the spline interpolant. Must be non-decreasing.
integer(kind=ip),	intent(out)			::	iflag	status flag (see db4ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine evaluate_4d(me, xval, yval, zval, qval, idx, idy, idz, idq, f, iflag)

Evaluate a bspline_4d interpolate. This is a wrapper for db4val.

Arguments

Type	Intent		Name
class(bspline_4d),	intent(inout)	::	me
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(out)	::	f	interpolated value
integer(kind=ip),	intent(out)	::	iflag	status flag (see db4val)

private pure subroutine initialize_5d_auto_knots(me, x, y, z, q, r, fcn, kx, ky, kz, kq, kr, iflag, extrap)

Initialize a bspline_5d type (with automatically-computed knots). This is a wrapper for db5ink.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_5d),	intent(inout)			::	me
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr)` matrix of function values to interpolate. `fcn(i,j,k,l,m)` 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(out)			::	iflag	status flag (see db5ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine initialize_5d_specify_knots(me, x, y, z, q, r, fcn, kx, ky, kz, kq, kr, tx, ty, tz, tq, tr, iflag, extrap)

Initialize a bspline_5d type (with user-specified knots). This is a wrapper for db5ink.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_5d),	intent(inout)			::	me
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr)` matrix of function values to interpolate. `fcn(i,j,k,l,m)` 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)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction for the spline interpolant. Must be non-decreasing.
integer(kind=ip),	intent(out)			::	iflag	status flag (see db5ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine evaluate_5d(me, xval, yval, zval, qval, rval, idx, idy, idz, idq, idr, f, iflag)

Evaluate a bspline_5d interpolate. This is a wrapper for db5val.

Arguments

Type	Intent		Name
class(bspline_5d),	intent(inout)	::	me
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(out)	::	f	interpolated value
integer(kind=ip),	intent(out)	::	iflag	status flag (see db5val)

private pure subroutine initialize_6d_auto_knots(me, x, y, z, q, r, s, fcn, kx, ky, kz, kq, kr, ks, iflag, extrap)

Initialize a bspline_6d type (with automatically-computed knots). This is a wrapper for db6ink.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_6d),	intent(inout)			::	me
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	s	`(ns)` array of $s$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr,ns)` matrix of function values to interpolate. `fcn(i,j,k,l,m,n)` 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 $z$ ( $2 \le k_z < n_z$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(out)			::	iflag	status flag (see db6ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine initialize_6d_specify_knots(me, x, y, z, q, r, s, fcn, kx, ky, kz, kq, kr, ks, tx, ty, tz, tq, tr, ts, iflag, extrap)

Initialize a bspline_6d type (with user-specified knots). This is a wrapper for db6ink.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_6d),	intent(inout)			::	me
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	s	`(ns)` array of $s$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr,ns)` matrix of function values to interpolate. `fcn(i,j,k,l,m,n)` 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 $z$ ( $2 \le k_z < n_z$ ) (order = polynomial degree + 1)
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction for the spline interpolant. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ts	The `(ns+ks)` knots in the $s$ direction for the spline interpolant. Must be non-decreasing.
integer(kind=ip),	intent(out)			::	iflag	status flag (see db6ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine evaluate_6d(me, xval, yval, zval, qval, rval, sval, idx, idy, idz, idq, idr, ids, f, iflag)

Evaluate a bspline_6d interpolate. This is a wrapper for db6val.

Arguments

Type	Intent		Name
class(bspline_6d),	intent(inout)	::	me
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(out)	::	f	interpolated value
integer(kind=ip),	intent(out)	::	iflag	status flag (see db6val)

private pure subroutine check_knot_vectors_sizes(nx, ny, nz, nq, nr, ns, kx, ky, kz, kq, kr, ks, tx, ty, tz, tq, tr, ts, iflag)

Error checks for the user-specified knot vector sizes.

Arguments

Type	Intent	Optional	Attributes		Name
integer(kind=ip),	intent(in),	optional		::	nx
integer(kind=ip),	intent(in),	optional		::	ny
integer(kind=ip),	intent(in),	optional		::	nz
integer(kind=ip),	intent(in),	optional		::	nq
integer(kind=ip),	intent(in),	optional		::	nr
integer(kind=ip),	intent(in),	optional		::	ns
integer(kind=ip),	intent(in),	optional		::	kx
integer(kind=ip),	intent(in),	optional		::	ky
integer(kind=ip),	intent(in),	optional		::	kz
integer(kind=ip),	intent(in),	optional		::	kq
integer(kind=ip),	intent(in),	optional		::	kr
integer(kind=ip),	intent(in),	optional		::	ks
real(kind=wp),	intent(in),	optional,	dimension(:)	::	tx
real(kind=wp),	intent(in),	optional,	dimension(:)	::	ty
real(kind=wp),	intent(in),	optional,	dimension(:)	::	tz
real(kind=wp),	intent(in),	optional,	dimension(:)	::	tq
real(kind=wp),	intent(in),	optional,	dimension(:)	::	tr
real(kind=wp),	intent(in),	optional,	dimension(:)	::	ts
integer(kind=ip),	intent(out)			::	iflag	0 if everything is OK

private pure subroutine initialize_from_coefficients_1d(me, tx, bcoef, kx, iflag, extrap)

Initialize a bspline_1d type directly from its knots and b-spline coefficients (for example, those saved from another object with get_knots and get_coefficients), without interpolating any data.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_1d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	bcoef	`(nx)` array of b-spline coefficients
integer(kind=ip),	intent(in)			::	kx	The order of spline pieces in $x$ ( $1 \le k_x \le n_x$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine get_knots_1d(me, tx, iflag)

Returns the knot vectors of a bspline_1d.

Arguments

Type	Intent	Attributes		Name
class(bspline_1d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:), allocatable	::	tx	the `(nx+kx)` knots in the $x$ direction
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine get_coefficients_1d(me, bcoef, iflag)

Returns the b-spline coefficients of a bspline_1d. These are the values of the control points (see greville_abscissae for their locations).

Arguments

Type	Intent	Attributes		Name
class(bspline_1d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:), allocatable	::	bcoef	`(nx)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine initialize_from_coefficients_2d(me, tx, ty, bcoef, kx, ky, iflag, extrap)

Initialize a bspline_2d type directly from its knots and b-spline coefficients (for example, those saved from another object with get_knots and get_coefficients), without interpolating any data.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_2d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:,:)	::	bcoef	`(nx,ny)` array of b-spline coefficients
integer(kind=ip),	intent(in)			::	kx	The order of spline pieces in $x$ ( $1 \le k_x \le n_x$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)			::	ky	The order of spline pieces in $y$ ( $1 \le k_y \le n_y$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine get_knots_2d(me, tx, ty, iflag)

Returns the knot vectors of a bspline_2d.

Arguments

Type	Intent	Attributes		Name
class(bspline_2d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:), allocatable	::	tx	the `(nx+kx)` knots in the $x$ direction
real(kind=wp),	intent(out),	dimension(:), allocatable	::	ty	the `(ny+ky)` knots in the $y$ direction
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine get_coefficients_2d(me, bcoef, iflag)

Returns the b-spline coefficients of a bspline_2d. These are the values of the control points (see greville_abscissae for their locations).

Arguments

Type	Intent	Attributes		Name
class(bspline_2d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:,:), allocatable	::	bcoef	`(nx,ny)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine initialize_from_coefficients_3d(me, tx, ty, tz, bcoef, kx, ky, kz, iflag, extrap)

Initialize a bspline_3d type directly from its knots and b-spline coefficients (for example, those saved from another object with get_knots and get_coefficients), without interpolating any data.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_3d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:,:,:)	::	bcoef	`(nx,ny,nz)` array of b-spline coefficients
integer(kind=ip),	intent(in)			::	kx	The order of spline pieces in $x$ ( $1 \le k_x \le n_x$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)			::	ky	The order of spline pieces in $y$ ( $1 \le k_y \le n_y$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)			::	kz	The order of spline pieces in $z$ ( $1 \le k_z \le n_z$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine get_knots_3d(me, tx, ty, tz, iflag)

Returns the knot vectors of a bspline_3d.

Arguments

Type	Intent	Attributes		Name
class(bspline_3d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:), allocatable	::	tx	the `(nx+kx)` knots in the $x$ direction
real(kind=wp),	intent(out),	dimension(:), allocatable	::	ty	the `(ny+ky)` knots in the $y$ direction
real(kind=wp),	intent(out),	dimension(:), allocatable	::	tz	the `(nz+kz)` knots in the $z$ direction
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine get_coefficients_3d(me, bcoef, iflag)

Returns the b-spline coefficients of a bspline_3d. These are the values of the control points (see greville_abscissae for their locations).

Arguments

Type	Intent	Attributes		Name
class(bspline_3d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:,:,:), allocatable	::	bcoef	`(nx,ny,nz)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine initialize_from_coefficients_4d(me, tx, ty, tz, tq, bcoef, kx, ky, kz, kq, iflag, extrap)

Initialize a bspline_4d type directly from its knots and b-spline coefficients (for example, those saved from another object with get_knots and get_coefficients), without interpolating any data.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_4d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:)	::	bcoef	`(nx,ny,nz,nq)` array of b-spline coefficients
integer(kind=ip),	intent(in)			::	kx	The order of spline pieces in $x$ ( $1 \le k_x \le n_x$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)			::	ky	The order of spline pieces in $y$ ( $1 \le k_y \le n_y$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)			::	kz	The order of spline pieces in $z$ ( $1 \le k_z \le n_z$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)			::	kq	The order of spline pieces in $q$ ( $1 \le k_q \le n_q$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine get_knots_4d(me, tx, ty, tz, tq, iflag)

Returns the knot vectors of a bspline_4d.

Arguments

Type	Intent	Attributes		Name
class(bspline_4d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:), allocatable	::	tx	the `(nx+kx)` knots in the $x$ direction
real(kind=wp),	intent(out),	dimension(:), allocatable	::	ty	the `(ny+ky)` knots in the $y$ direction
real(kind=wp),	intent(out),	dimension(:), allocatable	::	tz	the `(nz+kz)` knots in the $z$ direction
real(kind=wp),	intent(out),	dimension(:), allocatable	::	tq	the `(nq+kq)` knots in the $q$ direction
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine get_coefficients_4d(me, bcoef, iflag)

Returns the b-spline coefficients of a bspline_4d. These are the values of the control points (see greville_abscissae for their locations).

Arguments

Type	Intent	Attributes		Name
class(bspline_4d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:,:,:,:), allocatable	::	bcoef	`(nx,ny,nz,nq)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine initialize_from_coefficients_5d(me, tx, ty, tz, tq, tr, bcoef, kx, ky, kz, kq, kr, iflag, extrap)

Initialize a bspline_5d type directly from its knots and b-spline coefficients (for example, those saved from another object with get_knots and get_coefficients), without interpolating any data.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_5d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:)	::	bcoef	`(nx,ny,nz,nq,nr)` array of b-spline coefficients
integer(kind=ip),	intent(in)			::	kx	The order of spline pieces in $x$ ( $1 \le k_x \le n_x$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)			::	ky	The order of spline pieces in $y$ ( $1 \le k_y \le n_y$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)			::	kz	The order of spline pieces in $z$ ( $1 \le k_z \le n_z$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)			::	kq	The order of spline pieces in $q$ ( $1 \le k_q \le n_q$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)			::	kr	The order of spline pieces in $r$ ( $1 \le k_r \le n_r$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine get_knots_5d(me, tx, ty, tz, tq, tr, iflag)

Returns the knot vectors of a bspline_5d.

Arguments

Type	Intent	Attributes		Name
class(bspline_5d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:), allocatable	::	tx	the `(nx+kx)` knots in the $x$ direction
real(kind=wp),	intent(out),	dimension(:), allocatable	::	ty	the `(ny+ky)` knots in the $y$ direction
real(kind=wp),	intent(out),	dimension(:), allocatable	::	tz	the `(nz+kz)` knots in the $z$ direction
real(kind=wp),	intent(out),	dimension(:), allocatable	::	tq	the `(nq+kq)` knots in the $q$ direction
real(kind=wp),	intent(out),	dimension(:), allocatable	::	tr	the `(nr+kr)` knots in the $r$ direction
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine get_coefficients_5d(me, bcoef, iflag)

Returns the b-spline coefficients of a bspline_5d. These are the values of the control points (see greville_abscissae for their locations).

Arguments

Type	Intent	Attributes		Name
class(bspline_5d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:,:,:,:,:), allocatable	::	bcoef	`(nx,ny,nz,nq,nr)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine initialize_from_coefficients_6d(me, tx, ty, tz, tq, tr, ts, bcoef, kx, ky, kz, kq, kr, ks, iflag, extrap)

Initialize a bspline_6d type directly from its knots and b-spline coefficients (for example, those saved from another object with get_knots and get_coefficients), without interpolating any data.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_6d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:)	::	ts	The `(ns+ks)` knots in the $s$ direction. Must be non-decreasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:,:)	::	bcoef	`(nx,ny,nz,nq,nr,ns)` array of b-spline coefficients
integer(kind=ip),	intent(in)			::	kx	The order of spline pieces in $x$ ( $1 \le k_x \le n_x$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)			::	ky	The order of spline pieces in $y$ ( $1 \le k_y \le n_y$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)			::	kz	The order of spline pieces in $z$ ( $1 \le k_z \le n_z$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)			::	kq	The order of spline pieces in $q$ ( $1 \le k_q \le n_q$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)			::	kr	The order of spline pieces in $r$ ( $1 \le k_r \le n_r$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(in)			::	ks	The order of spline pieces in $s$ ( $1 \le k_s \le n_s$ ) (order = polynomial degree + 1)
integer(kind=ip),	intent(out)			::	iflag	status flag: Read more…
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine get_knots_6d(me, tx, ty, tz, tq, tr, ts, iflag)

Returns the knot vectors of a bspline_6d.

Arguments

Type	Intent	Attributes		Name
class(bspline_6d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:), allocatable	::	tx	the `(nx+kx)` knots in the $x$ direction
real(kind=wp),	intent(out),	dimension(:), allocatable	::	ty	the `(ny+ky)` knots in the $y$ direction
real(kind=wp),	intent(out),	dimension(:), allocatable	::	tz	the `(nz+kz)` knots in the $z$ direction
real(kind=wp),	intent(out),	dimension(:), allocatable	::	tq	the `(nq+kq)` knots in the $q$ direction
real(kind=wp),	intent(out),	dimension(:), allocatable	::	tr	the `(nr+kr)` knots in the $r$ direction
real(kind=wp),	intent(out),	dimension(:), allocatable	::	ts	the `(ns+ks)` knots in the $s$ direction
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine get_coefficients_6d(me, bcoef, iflag)

Returns the b-spline coefficients of a bspline_6d. These are the values of the control points (see greville_abscissae for their locations).

Arguments

Type	Intent	Attributes		Name
class(bspline_6d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:,:,:,:,:,:), allocatable	::	bcoef	`(nx,ny,nz,nq,nr,ns)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine initialize_1d_auto_knots_multi(me, x, fcn, kx, iflag, extrap)

Initialize a bspline_1d type with multiple outputs: nf functions of the same inputs, on the same grid. The last dimension of fcn is the output index. This is a wrapper for db1ink (multiple-output version).

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_1d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:)	::	fcn	`(nx,nf)` array of function values to interpolate (the last dimension is the output index)
integer(kind=ip),	intent(in)			::	kx	The order of spline pieces in $x$
integer(kind=ip),	intent(out)			::	iflag	status flag (see db1ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine initialize_1d_specify_knots_multi(me, x, fcn, kx, tx, iflag, extrap)

Initialize a bspline_1d type with multiple outputs: nf functions of the same inputs, on the same grid (with user-specified knots). The last dimension of fcn is the output index. This is a wrapper for db1ink (multiple-output version).

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_1d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:)	::	fcn	`(nx,nf)` array of function values to interpolate (the last dimension is the output index)
integer(kind=ip),	intent(in)			::	kx	The order of spline pieces in $x$
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction.
integer(kind=ip),	intent(out)			::	iflag	status flag (see db1ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine evaluate_1d_multi(me, xval, idx, f, iflag)

Evaluate all the outputs of a bspline_1d with multiple outputs. This is a wrapper for db1val (multiple-output version).

Arguments

Type	Intent	Attributes		Name
class(bspline_1d),	intent(inout)		::	me	the spline
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(out),	dimension(:)	::	f	`(nf)` interpolated values of the outputs (see number_of_outputs)
integer(kind=ip),	intent(out)		::	iflag	status flag (see db1val)

private pure subroutine initialize_from_coefficients_1d_multi(me, tx, bcoef, kx, iflag, extrap)

Initialize a bspline_1d type with multiple outputs directly from its knots and b-spline coefficients. The last dimension of bcoef is the output index.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_1d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(:,:)	::	bcoef	`(nx,nf)` array of b-spline coefficients
integer(kind=ip),	intent(in)			::	kx	The order of spline pieces in $x$
integer(kind=ip),	intent(out)			::	iflag	status flag (see initialize_from_coefficients_1d), or 6005 if `bcoef` has no outputs
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine get_coefficients_1d_multi(me, bcoef, iflag)

Returns the b-spline coefficients of a bspline_1d with any number of outputs. The last dimension of bcoef is the output index.

Arguments

Type	Intent	Attributes		Name
class(bspline_1d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:,:), allocatable	::	bcoef	`(nx,nf)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine initialize_2d_auto_knots_multi(me, x, y, fcn, kx, ky, iflag, extrap)

Initialize a bspline_2d type with multiple outputs: nf functions of the same inputs, on the same grid. The last dimension of fcn is the output index. This is a wrapper for db2ink (multiple-output version).

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_2d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:)	::	fcn	`(nx,ny,nf)` array of function values to interpolate (the last dimension is the output index)
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(out)			::	iflag	status flag (see db2ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine initialize_2d_specify_knots_multi(me, x, y, fcn, kx, ky, tx, ty, iflag, extrap)

Initialize a bspline_2d type with multiple outputs: nf functions of the same inputs, on the same grid (with user-specified knots). The last dimension of fcn is the output index. This is a wrapper for db2ink (multiple-output version).

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_2d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:)	::	fcn	`(nx,ny,nf)` array of function values to interpolate (the last dimension is the output index)
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$
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction.
integer(kind=ip),	intent(out)			::	iflag	status flag (see db2ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine evaluate_2d_multi(me, xval, yval, idx, idy, f, iflag)

Evaluate all the outputs of a bspline_2d with multiple outputs. This is a wrapper for db2val (multiple-output version).

Arguments

Type	Intent	Attributes		Name
class(bspline_2d),	intent(inout)		::	me	the spline
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(out),	dimension(:)	::	f	`(nf)` interpolated values of the outputs (see number_of_outputs)
integer(kind=ip),	intent(out)		::	iflag	status flag (see db2val)

private pure subroutine initialize_from_coefficients_2d_multi(me, tx, ty, bcoef, kx, ky, iflag, extrap)

Initialize a bspline_2d type with multiple outputs directly from its knots and b-spline coefficients. The last dimension of bcoef is the output index.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_2d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction.
real(kind=wp),	intent(in),		dimension(:,:,:)	::	bcoef	`(nx,ny,nf)` array of b-spline coefficients
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(out)			::	iflag	status flag (see initialize_from_coefficients_2d), or 6005 if `bcoef` has no outputs
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine get_coefficients_2d_multi(me, bcoef, iflag)

Returns the b-spline coefficients of a bspline_2d with any number of outputs. The last dimension of bcoef is the output index.

Arguments

Type	Intent	Attributes		Name
class(bspline_2d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:,:,:), allocatable	::	bcoef	`(nx,ny,nf)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine initialize_3d_auto_knots_multi(me, x, y, z, fcn, kx, ky, kz, iflag, extrap)

Initialize a bspline_3d type with multiple outputs: nf functions of the same inputs, on the same grid. The last dimension of fcn is the output index. This is a wrapper for db3ink (multiple-output version).

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_3d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:)	::	fcn	`(nx,ny,nz,nf)` array of function values to interpolate (the last dimension is the output index)
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(out)			::	iflag	status flag (see db3ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine initialize_3d_specify_knots_multi(me, x, y, z, fcn, kx, ky, kz, tx, ty, tz, iflag, extrap)

Initialize a bspline_3d type with multiple outputs: nf functions of the same inputs, on the same grid (with user-specified knots). The last dimension of fcn is the output index. This is a wrapper for db3ink (multiple-output version).

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_3d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:)	::	fcn	`(nx,ny,nz,nf)` array of function values to interpolate (the last dimension is the output index)
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$
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction.
integer(kind=ip),	intent(out)			::	iflag	status flag (see db3ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine evaluate_3d_multi(me, xval, yval, zval, idx, idy, idz, f, iflag)

Evaluate all the outputs of a bspline_3d with multiple outputs. This is a wrapper for db3val (multiple-output version).

Arguments

Type	Intent	Attributes		Name
class(bspline_3d),	intent(inout)		::	me	the spline
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(out),	dimension(:)	::	f	`(nf)` interpolated values of the outputs (see number_of_outputs)
integer(kind=ip),	intent(out)		::	iflag	status flag (see db3val)

private pure subroutine initialize_from_coefficients_3d_multi(me, tx, ty, tz, bcoef, kx, ky, kz, iflag, extrap)

Initialize a bspline_3d type with multiple outputs directly from its knots and b-spline coefficients. The last dimension of bcoef is the output index.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_3d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction.
real(kind=wp),	intent(in),		dimension(:,:,:,:)	::	bcoef	`(nx,ny,nz,nf)` array of b-spline coefficients
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(out)			::	iflag	status flag (see initialize_from_coefficients_3d), or 6005 if `bcoef` has no outputs
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine get_coefficients_3d_multi(me, bcoef, iflag)

Returns the b-spline coefficients of a bspline_3d with any number of outputs. The last dimension of bcoef is the output index.

Arguments

Type	Intent	Attributes		Name
class(bspline_3d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:,:,:,:), allocatable	::	bcoef	`(nx,ny,nz,nf)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine initialize_4d_auto_knots_multi(me, x, y, z, q, fcn, kx, ky, kz, kq, iflag, extrap)

Initialize a bspline_4d type with multiple outputs: nf functions of the same inputs, on the same grid. The last dimension of fcn is the output index. This is a wrapper for db4ink (multiple-output version).

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_4d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nf)` array of function values to interpolate (the last dimension is the output index)
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(out)			::	iflag	status flag (see db4ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine initialize_4d_specify_knots_multi(me, x, y, z, q, fcn, kx, ky, kz, kq, tx, ty, tz, tq, iflag, extrap)

Initialize a bspline_4d type with multiple outputs: nf functions of the same inputs, on the same grid (with user-specified knots). The last dimension of fcn is the output index. This is a wrapper for db4ink (multiple-output version).

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_4d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nf)` array of function values to interpolate (the last dimension is the output index)
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$
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction.
integer(kind=ip),	intent(out)			::	iflag	status flag (see db4ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine evaluate_4d_multi(me, xval, yval, zval, qval, idx, idy, idz, idq, f, iflag)

Evaluate all the outputs of a bspline_4d with multiple outputs. This is a wrapper for db4val (multiple-output version).

Arguments

Type	Intent	Attributes		Name
class(bspline_4d),	intent(inout)		::	me	the spline
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(out),	dimension(:)	::	f	`(nf)` interpolated values of the outputs (see number_of_outputs)
integer(kind=ip),	intent(out)		::	iflag	status flag (see db4val)

private pure subroutine initialize_from_coefficients_4d_multi(me, tx, ty, tz, tq, bcoef, kx, ky, kz, kq, iflag, extrap)

Initialize a bspline_4d type with multiple outputs directly from its knots and b-spline coefficients. The last dimension of bcoef is the output index.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_4d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:)	::	bcoef	`(nx,ny,nz,nq,nf)` array of b-spline coefficients
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(out)			::	iflag	status flag (see initialize_from_coefficients_4d), or 6005 if `bcoef` has no outputs
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine get_coefficients_4d_multi(me, bcoef, iflag)

Returns the b-spline coefficients of a bspline_4d with any number of outputs. The last dimension of bcoef is the output index.

Arguments

Type	Intent	Attributes		Name
class(bspline_4d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:,:,:,:,:), allocatable	::	bcoef	`(nx,ny,nz,nq,nf)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine initialize_5d_auto_knots_multi(me, x, y, z, q, r, fcn, kx, ky, kz, kq, kr, iflag, extrap)

Initialize a bspline_5d type with multiple outputs: nf functions of the same inputs, on the same grid. The last dimension of fcn is the output index. This is a wrapper for db5ink (multiple-output version).

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_5d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr,nf)` array of function values to interpolate (the last dimension is the output index)
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(out)			::	iflag	status flag (see db5ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine initialize_5d_specify_knots_multi(me, x, y, z, q, r, fcn, kx, ky, kz, kq, kr, tx, ty, tz, tq, tr, iflag, extrap)

Initialize a bspline_5d type with multiple outputs: nf functions of the same inputs, on the same grid (with user-specified knots). The last dimension of fcn is the output index. This is a wrapper for db5ink (multiple-output version).

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_5d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr,nf)` array of function values to interpolate (the last dimension is the output index)
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$
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction.
integer(kind=ip),	intent(out)			::	iflag	status flag (see db5ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine evaluate_5d_multi(me, xval, yval, zval, qval, rval, idx, idy, idz, idq, idr, f, iflag)

Evaluate all the outputs of a bspline_5d with multiple outputs. This is a wrapper for db5val (multiple-output version).

Arguments

Type	Intent	Attributes		Name
class(bspline_5d),	intent(inout)		::	me	the spline
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(out),	dimension(:)	::	f	`(nf)` interpolated values of the outputs (see number_of_outputs)
integer(kind=ip),	intent(out)		::	iflag	status flag (see db5val)

private pure subroutine initialize_from_coefficients_5d_multi(me, tx, ty, tz, tq, tr, bcoef, kx, ky, kz, kq, kr, iflag, extrap)

Initialize a bspline_5d type with multiple outputs directly from its knots and b-spline coefficients. The last dimension of bcoef is the output index.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_5d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:,:)	::	bcoef	`(nx,ny,nz,nq,nr,nf)` array of b-spline coefficients
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(out)			::	iflag	status flag (see initialize_from_coefficients_5d), or 6005 if `bcoef` has no outputs
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine get_coefficients_5d_multi(me, bcoef, iflag)

Returns the b-spline coefficients of a bspline_5d with any number of outputs. The last dimension of bcoef is the output index.

Arguments

Type	Intent	Attributes		Name
class(bspline_5d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:,:,:,:,:,:), allocatable	::	bcoef	`(nx,ny,nz,nq,nr,nf)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine initialize_6d_auto_knots_multi(me, x, y, z, q, r, s, fcn, kx, ky, kz, kq, kr, ks, iflag, extrap)

Initialize a bspline_6d type with multiple outputs: nf functions of the same inputs, on the same grid. The last dimension of fcn is the output index. This is a wrapper for db6ink (multiple-output version).

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_6d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	s	`(ns)` array of $s$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr,ns,nf)` array of function values to interpolate (the last dimension is the output index)
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(out)			::	iflag	status flag (see db6ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine initialize_6d_specify_knots_multi(me, x, y, z, q, r, s, fcn, kx, ky, kz, kq, kr, ks, tx, ty, tz, tq, tr, ts, iflag, extrap)

Initialize a bspline_6d type with multiple outputs: nf functions of the same inputs, on the same grid (with user-specified knots). The last dimension of fcn is the output index. This is a wrapper for db6ink (multiple-output version).

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_6d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	x	`(nx)` array of $x$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	y	`(ny)` array of $y$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	z	`(nz)` array of $z$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	q	`(nq)` array of $q$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	r	`(nr)` array of $r$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:)	::	s	`(ns)` array of $s$ abcissae. Must be strictly increasing.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:,:,:)	::	fcn	`(nx,ny,nz,nq,nr,ns,nf)` array of function values to interpolate (the last dimension is the output index)
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$
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	ts	The `(ns+ks)` knots in the $s$ direction.
integer(kind=ip),	intent(out)			::	iflag	status flag (see db6ink)
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine evaluate_6d_multi(me, xval, yval, zval, qval, rval, sval, idx, idy, idz, idq, idr, ids, f, iflag)

Evaluate all the outputs of a bspline_6d with multiple outputs. This is a wrapper for db6val (multiple-output version).

Arguments

Type	Intent	Attributes		Name
class(bspline_6d),	intent(inout)		::	me	the spline
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(out),	dimension(:)	::	f	`(nf)` interpolated values of the outputs (see number_of_outputs)
integer(kind=ip),	intent(out)		::	iflag	status flag (see db6val)

private pure subroutine initialize_from_coefficients_6d_multi(me, tx, ty, tz, tq, tr, ts, bcoef, kx, ky, kz, kq, kr, ks, iflag, extrap)

Initialize a bspline_6d type with multiple outputs directly from its knots and b-spline coefficients. The last dimension of bcoef is the output index.

Arguments

Type	Intent	Optional	Attributes		Name
class(bspline_6d),	intent(inout)			::	me	the spline
real(kind=wp),	intent(in),		dimension(:)	::	tx	The `(nx+kx)` knots in the $x$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	ty	The `(ny+ky)` knots in the $y$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tz	The `(nz+kz)` knots in the $z$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tq	The `(nq+kq)` knots in the $q$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	tr	The `(nr+kr)` knots in the $r$ direction.
real(kind=wp),	intent(in),		dimension(:)	::	ts	The `(ns+ks)` knots in the $s$ direction.
real(kind=wp),	intent(in),		dimension(:,:,:,:,:,:,:)	::	bcoef	`(nx,ny,nz,nq,nr,ns,nf)` array of b-spline coefficients
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(out)			::	iflag	status flag (see initialize_from_coefficients_6d), or 6005 if `bcoef` has no outputs
logical,	intent(in),	optional		::	extrap	if true, then extrapolation is allowed (default is false)

private pure subroutine get_coefficients_6d_multi(me, bcoef, iflag)

Returns the b-spline coefficients of a bspline_6d with any number of outputs. The last dimension of bcoef is the output index.

Arguments

Type	Intent	Attributes		Name
class(bspline_6d),	intent(inout)		::	me	the spline
real(kind=wp),	intent(out),	dimension(:,:,:,:,:,:,:), allocatable	::	bcoef	`(nx,ny,nz,nq,nr,ns,nf)` array of b-spline coefficients
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine control_points_1d(me, x, y, iflag)

The control points of a bspline_1d: the Greville abscissae (see greville_abscissae) and the b-spline coefficients.

Arguments

Type	Intent	Attributes		Name
class(bspline_1d),	intent(inout)		::	me
real(kind=wp),	intent(out),	dimension(:), allocatable	::	x	`(nx)` locations of the control points (the Greville abscissae)
real(kind=wp),	intent(out),	dimension(:), allocatable	::	y	`(nx)` values of the control points (the b-spline coefficients)
integer(kind=ip),	intent(out)		::	iflag	status flag: 0 if no errors, 1 if the class is not initialized

private pure subroutine check_coefficients(n, k, t, iflag)

Check the knots and coefficients for one direction in the initialize_from_coefficients methods.

Arguments

Type	Intent	Attributes		Name
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),	dimension(:)	::	t	knot vector
integer(kind=ip),	intent(out)		::	iflag	status flag (0 if everything is OK)

bspline_oo_module Module

Contents

Variables

Interfaces

Abstract Interfaces

Derived Types

Functions

Subroutines

Uses

Used by

Variables

Interfaces

public interface bspline_1d

private pure elemental function bspline_1d_constructor_empty() result(me)

Arguments

Return Value type(bspline_1d)

private pure function bspline_1d_constructor_auto_knots(x, fcn, kx, extrap) result(me)

Arguments

Return Value type(bspline_1d)

private pure function bspline_1d_constructor_specify_knots(x, fcn, kx, tx, extrap) result(me)

Arguments

Return Value type(bspline_1d)

public interface bspline_2d

private elemental function bspline_2d_constructor_empty() result(me)

Arguments

Return Value type(bspline_2d)

private pure function bspline_2d_constructor_auto_knots(x, y, fcn, kx, ky, extrap) result(me)

Arguments

Return Value type(bspline_2d)

private pure function bspline_2d_constructor_specify_knots(x, y, fcn, kx, ky, tx, ty, extrap) result(me)

Arguments

Return Value type(bspline_2d)

public interface bspline_3d

private elemental function bspline_3d_constructor_empty() result(me)

Arguments

Return Value type(bspline_3d)

private pure function bspline_3d_constructor_auto_knots(x, y, z, fcn, kx, ky, kz, extrap) result(me)

Arguments

Return Value type(bspline_3d)

private pure function bspline_3d_constructor_specify_knots(x, y, z, fcn, kx, ky, kz, tx, ty, tz, extrap) result(me)

Arguments

Return Value type(bspline_3d)

public interface bspline_4d

private elemental function bspline_4d_constructor_empty() result(me)

Arguments

Return Value type(bspline_4d)

private pure function bspline_4d_constructor_auto_knots(x, y, z, q, fcn, kx, ky, kz, kq, extrap) result(me)

Arguments

Return Value type(bspline_4d)

private pure function bspline_4d_constructor_specify_knots(x, y, z, q, fcn, kx, ky, kz, kq, tx, ty, tz, tq, extrap) result(me)

Arguments

Return Value type(bspline_4d)

public interface bspline_5d

private elemental function bspline_5d_constructor_empty() result(me)

Arguments

Return Value type(bspline_5d)

private pure function bspline_5d_constructor_auto_knots(x, y, z, q, r, fcn, kx, ky, kz, kq, kr, extrap) result(me)

Arguments

Return Value type(bspline_5d)

private pure function bspline_5d_constructor_specify_knots(x, y, z, q, r, fcn, kx, ky, kz, kq, kr, tx, ty, tz, tq, tr, extrap) result(me)

Arguments

Return Value type(bspline_5d)

public interface bspline_6d

private elemental function bspline_6d_constructor_empty() result(me)

Arguments

Return Value type(bspline_6d)

private pure function bspline_6d_constructor_auto_knots(x, y, z, q, r, s, fcn, kx, ky, kz, kq, kr, ks, extrap) result(me)

Arguments

Return Value type(bspline_6d)

private pure function bspline_6d_constructor_specify_knots(x, y, z, q, r, s, fcn, kx, ky, kz, kq, kr, ks, tx, ty, tz, tq, tr, ts, extrap) result(me)

Arguments

Return Value type(bspline_6d)

Abstract Interfaces

abstract interface

private pure function size_func(me) result(s)

Arguments

Return Value integer(kind=ip)

abstract interface

private pure subroutine destroy_func(me)

Arguments