subroutine basis_function_b_val ( tdata, tval, yval )
!
!*******************************************************************************
!
!! BASIS_FUNCTION_B_VAL evaluates the B spline basis function.
!
!
! Discussion:
!
! The B spline basis function is a piecewise cubic which
! has the properties that:
!
! * it equals 2/3 at TDATA(3), 1/6 at TDATA(2) and TDATA(4);
! * it is 0 for TVAL <= TDATA(1) or TDATA(5) <= TVAL;
! * it is strictly increasing from TDATA(1) to TDATA(3),
! and strictly decreasing from TDATA(3) to TDATA(5);
! * the function and its first two derivatives are continuous
! at each node TDATA(I).
!
! Reference:
!
! Alan Davies and Philip Samuels,
! An Introduction to Computational Geometry for Curves and Surfaces,
! Clarendon Press, 1996.
!
! Modified:
!
! 06 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, real TDATA(5), the nodes associated with the basis function.
! The entries of TDATA are assumed to be distinct and increasing.
!
! Input, real TVAL, a point at which the B spline basis function is
! to be evaluated.
!
! Output, real YVAL, the value of the function at TVAL.
!
implicit none
!
integer, parameter :: ndata = 5
!
integer left
integer right
real tdata(ndata)
real tval
real u
real yval
!
if ( tval <= tdata(1) .or. tval >= tdata(ndata) ) then
yval = 0.0E+00
return
end if
!
! Find the interval [ TDATA(LEFT), TDATA(RIGHT) ] containing TVAL.
!
call rvec_bracket ( ndata, tdata, tval, left, right )
!
! U is the normalized coordinate of TVAL in this interval.
!
u = ( tval - tdata(left) ) / ( tdata(right) - tdata(left) )
!
! Now evaluate the function.
!
if ( tval < tdata(2) ) then
yval = u**3 / 6.0E+00
else if ( tval < tdata(3) ) then
yval = ( 1.0E+00 + 3.0E+00 * u + 3.0E+00 * u**2 - 3.0E+00 * u**3 ) / 6.0E+00
else if ( tval < tdata(4) ) then
yval = ( 4.0E+00 - 6.0E+00 * u**2 + 3.0E+00 * u**3 ) / 6.0E+00
else if ( tval < tdata(5) ) then
yval = ( 1.0E+00 - u )**3 / 6.0E+00
end if
return
end
subroutine basis_function_beta_val ( beta1, beta2, tdata, tval, yval )
!
!*******************************************************************************
!
!! BASIS_FUNCTION_BETA_VAL evaluates the beta spline basis function.
!
!
! Discussion:
!
! With BETA1 = 1 and BETA2 = 0, the beta spline basis function
! equals the B spline basis function.
!
! With BETA1 large, and BETA2 = 0, the beta spline basis function
! skews to the right, that is, its maximum increases, and occurs
! to the right of the center.
!
! With BETA1 = 1 and BETA2 large, the beta spline becomes more like
! a linear basis function; that is, its value in the outer two intervals
! goes to zero, and its behavior in the inner two intervals approaches
! a piecewise linear function that is 0 at the second node, 1 at the
! third, and 0 at the fourth.
!
! Reference:
!
! Alan Davies and Philip Samuels,
! An Introduction to Computational Geometry for Curves and Surfaces,
! Clarendon Press, 1996, page 129.
!
! Modified:
!
! 09 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, real BETA1, the skew or bias parameter.
! BETA1 = 1 for no skew or bias.
!
! Input, real BETA2, the tension parameter.
! BETA2 = 0 for no tension.
!
! Input, real TDATA(5), the nodes associated with the basis function.
! The entries of TDATA are assumed to be distinct and increasing.
!
! Input, real TVAL, a point at which the B spline basis function is
! to be evaluated.
!
! Output, real YVAL, the value of the function at TVAL.
!
implicit none
!
integer, parameter :: ndata = 5
!
real a
real b
real beta1
real beta2
real c
real d
integer left
integer right
real tdata(ndata)
real tval
real u
real yval
!
if ( tval <= tdata(1) .or. tval >= tdata(ndata) ) then
yval = 0.0E+00
return
end if
!
! Find the interval [ TDATA(LEFT), TDATA(RIGHT) ] containing TVAL.
!
call rvec_bracket ( ndata, tdata, tval, left, right )
!
! U is the normalized coordinate of TVAL in this interval.
!
u = ( tval - tdata(left) ) / ( tdata(right) - tdata(left) )
!
! Now evaluate the function.
!
if ( tval < tdata(2) ) then
yval = 2.0E+00 * u**3
else if ( tval < tdata(3) ) then
a = beta2 + 4.0E+00 * beta1 + 4.0E+00 * beta1**2 &
+ 6.0E+00 * ( 1.0E+00 - beta1**2 ) &
- 3.0E+00 * ( 2.0E+00 + beta2 + 2.0E+00 * beta1 ) &
+ 2.0E+00 * ( 1.0E+00 + beta2 + beta1 + beta1**2 )
b = - 6.0E+00 * ( 1.0E+00 - beta1**2 ) &
+ 6.0E+00 * ( 2.0E+00 + beta2 + 2.0E+00 * beta1 ) &
- 6.0E+00 * ( 1.0E+00 + beta2 + beta1 + beta1**2 )
c = - 3.0E+00 * ( 2.0E+00 + beta2 + 2.0E+00 * beta1 ) &
+ 6.0E+00 * ( 1.0E+00 + beta2 + beta1 + beta1**2 )
d = - 2.0E+00 * ( 1.0E+00 + beta2 + beta1 + beta1**2 )
yval = a + b * u + c * u**2 + d * u**3
else if ( tval < tdata(4) ) then
a = beta2 + 4.0E+00 * beta1 + 4.0E+00 * beta1**2
b = - 6.0E+00 * ( beta1 - beta1**3 )
c = - 3.0E+00 * ( beta2 + 2.0E+00 * beta1**2 + 2.0E+00 * beta1**3 )
d = 2.0E+00 * ( beta2 + beta1 + beta1**2 + beta1**3 )
yval = a + b * u + c * u**2 + d * u**3
else if ( tval < tdata(5) ) then
yval = 2.0E+00 * beta1**3 * ( 1.0E+00 - u )**3
end if
yval = yval / ( 2.0E+00 + beta2 + 4.0E+00 * beta1 + 4.0E+00 * beta1**2 &
+ 2.0E+00 * beta1**3 )
return
end
subroutine basis_matrix_b_uni ( mbasis )
!
!*******************************************************************************
!
!! BASIS_MATRIX_B_UNI sets up the uniform B spline basis matrix.
!
!
! Reference:
!
! Foley, van Dam, Feiner, Hughes,
! Computer Graphics: Principles and Practice,
! page 493.
!
! Modified:
!
! 05 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Output, real MBASIS(4,4), the basis matrix.
!
implicit none
!
real mbasis(4,4)
!
mbasis(1,1) = - 1.0E+00 / 6.0E+00
mbasis(1,2) = 3.0E+00 / 6.0E+00
mbasis(1,3) = - 3.0E+00 / 6.0E+00
mbasis(1,4) = 1.0E+00 / 6.0E+00
mbasis(2,1) = 3.0E+00 / 6.0E+00
mbasis(2,2) = - 6.0E+00 / 6.0E+00
mbasis(2,3) = 3.0E+00 / 6.0E+00
mbasis(2,4) = 0.0E+00
mbasis(3,1) = - 3.0E+00 / 6.0E+00
mbasis(3,2) = 0.0E+00
mbasis(3,3) = 3.0E+00 / 6.0E+00
mbasis(3,4) = 0.0E+00
mbasis(4,1) = 1.0E+00 / 6.0E+00
mbasis(4,2) = 4.0E+00 / 6.0E+00
mbasis(4,3) = 1.0E+00 / 6.0E+00
mbasis(4,4) = 0.0E+00
return
end
subroutine basis_matrix_beta_uni ( beta1, beta2, mbasis )
!
!*******************************************************************************
!
!! BASIS_MATRIX_BETA_UNI sets up the uniform beta spline basis matrix.
!
!
! Discussion:
!
! If BETA1 = 1 and BETA2 = 0, then the beta spline reduces to
! the B spline.
!
! Reference:
!
! Foley, van Dam, Feiner, Hughes,
! Computer Graphics: Principles and Practice,
! page 505.
!
! Modified:
!
! 03 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, real BETA1, the skew or bias parameter.
! BETA1 = 1 for no skew or bias.
!
! Input, real BETA2, the tension parameter.
! BETA2 = 0 for no tension.
!
! Output, real MBASIS(4,4), the basis matrix.
!
implicit none
!
real beta1
real beta2
real delta
integer i
integer j
real mbasis(4,4)
!
mbasis(1,1) = - 2.0E+00 * beta1**3
mbasis(1,2) = 2.0E+00 * ( beta2 + beta1**3 + beta1**2 + beta1 )
mbasis(1,3) = - 2.0E+00 * ( beta2 + beta1**2 + beta1 + 1.0E+00 )
mbasis(1,4) = 2.0E+00
mbasis(2,1) = 6.0E+00 * beta1**3
mbasis(2,2) = - 3.0E+00 * ( beta2 + 2.0E+00 * beta1**3 + 2.0E+00 * beta1**2 )
mbasis(2,3) = 3.0E+00 * ( beta2 + 2.0E+00 * beta1**2 )
mbasis(2,4) = 0.0E+00
mbasis(3,1) = - 6.0E+00 * beta1**3
mbasis(3,2) = 6.0E+00 * beta1 * ( beta1 - 1.0E+00 ) * ( beta1 + 1.0E+00 )
mbasis(3,3) = 6.0E+00 * beta1
mbasis(3,4) = 0.0E+00
mbasis(4,1) = 2.0E+00 * beta1**3
mbasis(4,2) = 4.0E+00 * beta1 * ( beta1 + 1.0E+00 ) + beta2
mbasis(4,3) = 2.0E+00
mbasis(4,4) = 0.0E+00
delta = beta2 + 2.0E+00 * beta1**3 + 4.0E+00 * beta1**2 &
+ 4.0E+00 * beta1 + 2.0E+00
mbasis(1:4,1:4) = mbasis(1:4,1:4) / delta
return
end
subroutine basis_matrix_bezier ( mbasis )
!
!*******************************************************************************
!
!! BASIS_MATRIX_BEZIER_UNI sets up the cubic Bezier spline basis matrix.
!
!
! Discussion:
!
! This basis matrix assumes that the data points are stored as
! ( P1, P2, P3, P4 ). P1 is the function value at T = 0, while
! P2 is used to approximate the derivative at T = 0 by
! dP/dt = 3 * ( P2 - P1 ). Similarly, P4 is the function value
! at T = 1, and P3 is used to approximate the derivative at T = 1
! by dP/dT = 3 * ( P4 - P3 ).
!
! Reference:
!
! Foley, van Dam, Feiner, Hughes,
! Computer Graphics: Principles and Practice,
! page 489.
!
! Modified:
!
! 05 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Output, real MBASIS(4,4), the basis matrix.
!
implicit none
!
real mbasis(4,4)
!
mbasis(1,1) = - 1.0E+00
mbasis(1,2) = 3.0E+00
mbasis(1,3) = - 3.0E+00
mbasis(1,4) = 1.0E+00
mbasis(2,1) = 3.0E+00
mbasis(2,2) = - 6.0E+00
mbasis(2,3) = 3.0E+00
mbasis(2,4) = 0.0E+00
mbasis(3,1) = - 3.0E+00
mbasis(3,2) = 3.0E+00
mbasis(3,3) = 0.0E+00
mbasis(3,4) = 0.0E+00
mbasis(4,1) = 1.0E+00
mbasis(4,2) = 0.0E+00
mbasis(4,3) = 0.0E+00
mbasis(4,4) = 0.0E+00
return
end
subroutine basis_matrix_hermite ( mbasis )
!
!*******************************************************************************
!
!! BASIS_MATRIX_HERMITE sets up the Hermite spline basis matrix.
!
!
! Discussion:
!
! This basis matrix assumes that the data points are stored as
! ( P1, P2, P1', P2' ), with P1 and P1' being the data value and
! the derivative dP/dT at T = 0, while P2 and P2' apply at T = 1.
!
! Reference:
!
! Foley, van Dam, Feiner, Hughes,
! Computer Graphics: Principles and Practice,
! page 484.
!
! Modified:
!
! 06 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Output, real MBASIS(4,4), the basis matrix.
!
implicit none
!
real mbasis(4,4)
!
mbasis(1,1) = 2.0E+00
mbasis(1,2) = - 2.0E+00
mbasis(1,3) = 1.0E+00
mbasis(1,4) = 1.0E+00
mbasis(2,1) = - 3.0E+00
mbasis(2,2) = 3.0E+00
mbasis(2,3) = - 2.0E+00
mbasis(2,4) = - 1.0E+00
mbasis(3,1) = 0.0E+00
mbasis(3,2) = 0.0E+00
mbasis(3,3) = 1.0E+00
mbasis(3,4) = 0.0E+00
mbasis(4,1) = 1.0E+00
mbasis(4,2) = 0.0E+00
mbasis(4,3) = 0.0E+00
mbasis(4,4) = 0.0E+00
return
end
subroutine basis_matrix_overhauser_nonuni ( alpha, beta, mbasis )
!
!*******************************************************************************
!
!! BASIS_MATRIX_OVERHAUSER_NONUNI sets up the nonuniform Overhauser spline basis matrix.
!
!
! Discussion:
!
! This basis matrix assumes that the data points P1, P2, P3 and
! P4 are not uniformly spaced in T, and that P2 corresponds to T = 0,
! and P3 to T = 1.
!
! Modified:
!
! 05 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, real ALPHA, BETA.
! ALPHA = | P2 - P1 | / ( | P3 - P2 | + | P2 - P1 | )
! BETA = | P3 - P2 | / ( | P4 - P3 | + | P3 - P2 | ).
!
! Output, real MBASIS(4,4), the basis matrix.
!
implicit none
!
real alpha
real beta
real mbasis(4,4)
!
mbasis(1,1) = - ( 1.0E+00 - alpha )**2 / alpha
mbasis(1,2) = beta + ( 1.0E+00 - alpha ) / alpha
mbasis(1,3) = alpha - 1.0E+00 / ( 1.0E+00 - beta )
mbasis(1,4) = beta**2 / ( 1.0E+00 - beta )
mbasis(2,1) = 2.0E+00 * ( 1.0E+00 - alpha )**2 / alpha
mbasis(2,2) = ( - 2.0E+00 * ( 1.0E+00 - alpha ) - alpha * beta ) / alpha
mbasis(2,3) = ( 2.0E+00 * ( 1.0E+00 - alpha ) &
- beta * ( 1.0E+00 - 2.0E+00 * alpha ) ) / ( 1.0E+00 - beta )
mbasis(2,4) = - beta**2 / ( 1.0E+00 - beta )
mbasis(3,1) = - ( 1.0E+00 - alpha )**2 / alpha
mbasis(3,2) = ( 1.0E+00 - 2.0E+00 * alpha ) / alpha
mbasis(3,3) = alpha
mbasis(3,4) = 0.0E+00
mbasis(4,1) = 0.0E+00
mbasis(4,2) = 1.0E+00
mbasis(4,3) = 0.0E+00
mbasis(4,4) = 0.0E+00
return
end
subroutine basis_matrix_overhauser_nul ( alpha, mbasis )
!
!*******************************************************************************
!
!! BASIS_MATRIX_OVERHAUSER_NUL sets up the left nonuniform Overhauser spline basis matrix.
!
!
! Discussion:
!
! This basis matrix assumes that the data points P1, P2, and
! P3 are not uniformly spaced in T, and that P1 corresponds to T = 0,
! and P2 to T = 1. (???)
!
! Modified:
!
! 27 August 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, real ALPHA.
! ALPHA = | P2 - P1 | / ( | P3 - P2 | + | P2 - P1 | )
!
! Output, real MBASIS(3,3), the basis matrix.
!
implicit none
!
real alpha
real mbasis(3,3)
!
mbasis(1,1) = 1.0E+00 / alpha
mbasis(1,2) = - 1.0E+00 / ( alpha * ( 1.0E+00 - alpha ) )
mbasis(1,3) = 1.0E+00 / ( 1.0E+00 - alpha )
mbasis(2,1) = - ( 1.0E+00 + alpha ) / alpha
mbasis(2,2) = 1.0E+00 / ( alpha * ( 1.0E+00 - alpha ) )
mbasis(2,3) = - alpha / ( 1.0E+00 - alpha )
mbasis(3,1) = 1.0E+00
mbasis(3,2) = 0.0E+00
mbasis(3,3) = 0.0E+00
return
end
subroutine basis_matrix_overhauser_nur ( beta, mbasis )
!
!*******************************************************************************
!
!! BASIS_MATRIX_OVERHAUSER_NUR sets up the right nonuniform Overhauser spline basis matrix.
!
!
! Discussion:
!
! This basis matrix assumes that the data points PN-2, PN-1, and
! PN are not uniformly spaced in T, and that PN-1 corresponds to T = 0,
! and PN to T = 1. (???)
!
! Modified:
!
! 27 August 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, real BETA.
! BETA = | P(N) - P(N-1) | / ( | P(N) - P(N-1) | + | P(N-1) - P(N-2) | )
!
! Output, real MBASIS(3,3), the basis matrix.
!
implicit none
!
real beta
real mbasis(3,3)
!
mbasis(1,1) = 1.0E+00 / beta
mbasis(1,2) = - 1.0E+00 / ( beta * ( 1.0E+00 - beta ) )
mbasis(1,3) = 1.0E+00 / ( 1.0E+00 - beta )
mbasis(2,1) = - ( 1.0E+00 + beta ) / beta
mbasis(2,2) = 1.0E+00 / ( beta * ( 1.0E+00 - beta ) )
mbasis(2,3) = - beta / ( 1.0E+00 - beta )
mbasis(3,1) = 1.0E+00
mbasis(3,2) = 0.0E+00
mbasis(3,3) = 0.0E+00
return
end
subroutine basis_matrix_overhauser_uni ( mbasis )
!
!*******************************************************************************
!
!! BASIS_MATRIX_OVERHAUSER_UNI sets up the uniform Overhauser spline basis matrix.
!
!
! Discussion:
!
! This basis matrix assumes that the data points P1, P2, P3 and
! P4 are uniformly spaced in T, and that P2 corresponds to T = 0,
! and P3 to T = 1.
!
! Reference:
!
! Foley, van Dam, Feiner, Hughes,
! Computer Graphics: Principles and Practice,
! page 505.
!
! Modified:
!
! 05 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Output, real MBASIS(4,4), the basis matrix.
!
implicit none
!
real mbasis(4,4)
!
mbasis(1,1) = - 1.0E+00 / 2.0E+00
mbasis(1,2) = 3.0E+00 / 2.0E+00
mbasis(1,3) = - 3.0E+00 / 2.0E+00
mbasis(1,4) = 1.0E+00 / 2.0E+00
mbasis(2,1) = 2.0E+00 / 2.0E+00
mbasis(2,2) = - 5.0E+00 / 2.0E+00
mbasis(2,3) = 4.0E+00 / 2.0E+00
mbasis(2,4) = - 1.0E+00 / 2.0E+00
mbasis(3,1) = - 1.0E+00 / 2.0E+00
mbasis(3,2) = 0.0E+00
mbasis(3,3) = 1.0E+00 / 2.0E+00
mbasis(3,4) = 0.0E+00
mbasis(4,1) = 0.0E+00
mbasis(4,2) = 2.0E+00 / 2.0E+00
mbasis(4,3) = 0.0E+00
mbasis(4,4) = 0.0E+00
return
end
subroutine basis_matrix_overhauser_uni_l ( mbasis )
!
!*******************************************************************************
!
!! BASIS_MATRIX_OVERHAUSER_UNI_L sets up the left uniform Overhauser spline basis matrix.
!
!
! Discussion:
!
! This basis matrix assumes that the data points P1, P2, and P3
! are not uniformly spaced in T, and that P1 corresponds to T = 0,
! and P2 to T = 1.
!
! Modified:
!
! 05 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Output, real MBASIS(3,3), the basis matrix.
!
implicit none
!
real mbasis(3,3)
!
mbasis(1,1) = 2.0E+00
mbasis(1,2) = - 4.0E+00
mbasis(1,3) = 2.0E+00
mbasis(2,1) = - 3.0E+00
mbasis(2,2) = 4.0E+00
mbasis(2,3) = - 1.0E+00
mbasis(3,1) = 1.0E+00
mbasis(3,2) = 0.0E+00
mbasis(3,3) = 0.0E+00
return
end
subroutine basis_matrix_overhauser_uni_r ( mbasis )
!
!*******************************************************************************
!
!! BASIS_MATRIX_OVERHAUSER_UNI_R sets up the right uniform Overhauser spline basis matrix.
!
!
! Discussion:
!
! This basis matrix assumes that the data points P(N-2), P(N-1),
! and P(N) are uniformly spaced in T, and that P(N-1) corresponds to
! T = 0, and P(N) to T = 1.
!
! Modified:
!
! 05 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Output, real MBASIS(3,3), the basis matrix.
!
implicit none
!
real mbasis(3,3)
!
mbasis(1,1) = 2.0E+00
mbasis(1,2) = - 4.0E+00
mbasis(1,3) = 2.0E+00
mbasis(2,1) = - 3.0E+00
mbasis(2,2) = 4.0E+00
mbasis(2,3) = - 1.0E+00
mbasis(3,1) = 1.0E+00
mbasis(3,2) = 0.0E+00
mbasis(3,3) = 0.0E+00
return
end
subroutine basis_matrix_tmp ( left, n, mbasis, ndata, tdata, ydata, tval, yval )
!
!*******************************************************************************
!
!! BASIS_MATRIX_TMP computes Q = T * MBASIS * P
!
!
! Discussion:
!
! YDATA is a vector of data values, most frequently the values of some
! function sampled at uniformly spaced points. MBASIS is the basis
! matrix for a particular kind of spline. T is a vector of the
! powers of the normalized difference between TVAL and the left
! endpoint of the interval.
!
! Modified:
!
! 06 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer LEFT, indicats that TVAL is in the interval
! [ TDATA(LEFT), TDATA(LEFT+1) ], or that this is the "nearest"
! interval to TVAL.
! For TVAL < TDATA(1), use LEFT = 1.
! For TVAL > TDATA(NDATA), use LEFT = NDATA - 1.
!
! Input, integer N, the order of the basis matrix.
!
! Input, real MBASIS(N,N), the basis matrix.
!
! Input, integer NDATA, the dimension of the vectors TDATA and YDATA.
!
! Input, real TDATA(NDATA), the abscissa values. This routine
! assumes that the TDATA values are uniformly spaced, with an
! increment of 1.0.
!
! Input, real YDATA(NDATA), the data values to be interpolated or
! approximated.
!
! Input, real TVAL, the value of T at which the spline is to be
! evaluated.
!
! Output, real YVAL, the value of the spline at TVAL.
!
implicit none
!
integer, parameter :: maxn = 4
integer n
integer ndata
!
real arg
integer first
integer i
integer j
integer left
real mbasis(n,n)
real tdata(ndata)
real temp
real tval
real tvec(maxn)
real ydata(ndata)
real yval
!
if ( left == 1 ) then
arg = 0.5 * ( tval - tdata(left) )
first = left
else if ( left < ndata - 1 ) then
arg = tval - tdata(left)
first = left - 1
else if ( left == ndata - 1 ) then
arg = 0.5E+00 * ( 1.0E+00 + tval - tdata(left) )
first = left - 1
end if
do i = 1, n - 1
tvec(i) = arg**( n - i )
end do
tvec(n) = 1.0E+00
yval = 0.0E+00
do j = 1, n
yval = yval + dot_product ( tvec(1:n), mbasis(1:n,j) ) &
* ydata(first - 1 + j)
end do
return
end
subroutine bc_val ( n, t, xcon, ycon, xval, yval )
!
!*******************************************************************************
!
!! BC_VAL evaluates a parameterized Bezier curve.
!
!
! Discussion:
!
! BC_VAL(T) is the value of a vector function of the form
!
! BC_VAL(T) = ( X(T), Y(T) )
!
! where
!
! X(T) = Sum (i = 0 to N) XCON(I) * BERN(I,N)(T)
! Y(T) = Sum (i = 0 to N) YCON(I) * BERN(I,N)(T)
!
! where BERN(I,N)(T) is the I-th Bernstein polynomial of order N
! defined on the interval [0,1], and where XCON(*) and YCON(*)
! are the coordinates of N+1 "control points".
!
! Modified:
!
! 02 March 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer N, the order of the Bezier curve, which
! must be at least 0.
!
! Input, real T, the point at which the Bezier curve should
! be evaluated. The best results are obtained within the interval
! [0,1] but T may be anywhere.
!
! Input, real XCON(0:N), YCON(0:N), the X and Y coordinates
! of the control points. The Bezier curve will pass through
! the points ( XCON(0), YCON(0) ) and ( XCON(N), YCON(N) ), but
! generally NOT through the other control points.
!
! Output, real XVAL, YVAL, the X and Y coordinates of the point
! on the Bezier curve corresponding to the given T value.
!
implicit none
!
integer n
!
real bval(0:n)
integer i
real t
real xcon(0:n)
real xval
real ycon(0:n)
real yval
!
call bp01 ( n, bval, t )
xval = dot_product ( xcon(0:n), bval(0:n) )
yval = dot_product ( ycon(0:n), bval(0:n) )
return
end
function bez_val ( n, x, a, b, y )
!
!*******************************************************************************
!
!! BEZ_VAL evaluates a Bezier function at a point.
!
!
! Discussion:
!
! The Bezier function has the form:
!
! BEZ(X) = Sum (i = 0 to N) Y(I) * BERN(N,I)( (X-A)/(B-A) )
!
! where BERN(N,I)(X) is the I-th Bernstein polynomial of order N
! defined on the interval [0,1], and Y(*) is a set of
! coefficients.
!
! If we define the N+1 equally spaced
!
! X(I) = ( (N-I)*A + I*B)/ N,
!
! for I = 0 to N, then the pairs ( X(I), Y(I) ) can be regarded as
! "control points".
!
! Modified:
!
! 02 March 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer N, the order of the Bezier function, which
! must be at least 0.
!
! Input, real X, the point at which the Bezier function should
! be evaluated. The best results are obtained within the interval
! [A,B] but X may be anywhere.
!
! Input, real A, B, the interval over which the Bezier function
! has been defined. This is the interval in which the control
! points have been set up. Note BEZ(A) = Y(0) and BEZ(B) = Y(N),
! although BEZ will not, in general pass through the other
! control points. A and B must not be equal.
!
! Input, real Y(0:N), a set of data defining the Y coordinates
! of the control points.
!
! Output, real BEZ_VAL, the value of the Bezier function at X.
!
implicit none
!
integer n
!
real a
real b
real bez_val
real bval(0:n)
integer i
integer ncopy
real x
real x01
real y(0:n)
!
if ( b - a == 0.0E+00 ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'BEZ_VAL - Fatal error!'
write ( *, '(a,g14.6)' ) ' Null interval, A = B = ', a
stop
end if
x01 = ( x - a ) / ( b - a )
ncopy = n
call bp01 ( ncopy, bval, x01 )
bez_val = dot_product ( y(0:n), bval(0:n) )
return
end
subroutine bp01 ( n, bern, x )
!
!*******************************************************************************
!
!! BP01 evaluates the Bernstein basis polynomials for [01,1] at a point X.
!
!
! Formula:
!
! BERN(N,I,X) = [N!/(I!*(N-I)!)] * (1-X)**(N-I) * X**I
!
! First values:
!
! B(0,0,X) = 1
!
! B(1,0,X) = 1-X
! B(1,1,X) = X
!
! B(2,0,X) = (1-X)**2
! B(2,1,X) = 2 * (1-X) * X
! B(2,2,X) = X**2
!
! B(3,0,X) = (1-X)**3
! B(3,1,X) = 3 * (1-X)**2 * X
! B(3,2,X) = 3 * (1-X) * X**2
! B(3,3,X) = X**3
!
! B(4,0,X) = (1-X)**4
! B(4,1,X) = 4 * (1-X)**3 * X
! B(4,2,X) = 6 * (1-X)**2 * X**2
! B(4,3,X) = 4 * (1-X) * X**3
! B(4,4,X) = X**4
!
! Special values:
!
! B(N,I,1/2) = C(N,K) / 2**N
!
! Modified:
!
! 12 January 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer N, the degree of the Bernstein basis polynomials.
! For any N greater than or equal to 0, there is a set of N+1 Bernstein
! basis polynomials, each of degree N, which form a basis for
! all polynomials on [0,1].
!
! Output, real BERN(0:N), the values of the N+1 Bernstein basis
! polynomials at X.
!
! Input, real X, the point at which the polynomials are to be
! evaluated.
!
implicit none
!
integer n
!
real bern(0:n)
integer i
integer j
real x
!
if ( n == 0 ) then
bern(0) = 1.0E+00
else if ( n > 0 ) then
bern(0) = 1.0E+00 - x
bern(1) = x
do i = 2, n
bern(i) = x * bern(i-1)
do j = i-1, 1, -1
bern(j) = x * bern(j-1) + ( 1.0E+00 - x ) * bern(j)
end do
bern(0) = ( 1.0E+00 - x ) * bern(0)
end do
end if
return
end
subroutine bp_approx ( n, a, b, ydata, xval, yval )
!
!*******************************************************************************
!
!! BP_APPROX evaluates the Bernstein polynomial for F(X) on [A,B].
!
!
! Formula:
!
! BERN(F)(X) = SUM ( 0 <= I <= N ) F(X(I)) * B_BASE(I,X)
!
! where
!
! X(I) = ( ( N - I ) * A + I * B ) / N
! B_BASE(I,X) is the value of the I-th Bernstein basis polynomial at X.
!
! Discussion:
!
! The Bernstein polynomial BERN(F) for F(X) is an approximant, not an
! interpolant; in other words, its value is not guaranteed to equal
! that of F at any particular point. However, for a fixed interval
! [A,B], if we let N increase, the Bernstein polynomial converges
! uniformly to F everywhere in [A,B], provided only that F is continuous.
! Even if F is not continuous, but is bounded, the polynomial converges
! pointwise to F(X) at all points of continuity. On the other hand,
! the convergence is quite slow compared to other interpolation
! and approximation schemes.
!
! Modified:
!
! 10 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer N, the degree of the Bernstein polynomial to be used.
!
! Input, real A, B, the endpoints of the interval on which the
! approximant is based. A and B should not be equal.
!
! Input, real YDATA(0:N), the data values at N+1 equally spaced points
! in [A,B]. If N = 0, then the evaluation point should be 0.5 * ( A + B).
! Otherwise, evaluation point I should be ( (N-I)*A + I*B ) / N ).
!
! Input, real XVAL, the point at which the Bernstein polynomial
! approximant is to be evaluated. XVAL does not have to lie in the
! interval [A,B].
!
! Output, real YVAL, the value of the Bernstein polynomial approximant
! for F, based in [A,B], evaluated at XVAL.
!
implicit none
!
integer n
!
real a
real b
real bvec(0:n)
integer i
real xval
real ydata(0:n)
real yval
!
! Evaluate the Bernstein basis polynomials at XVAL.
!
call bpab ( n, bvec, xval, a, b )
!
! Now compute the sum of YDATA(I) * BVEC(I).
!
yval = dot_product ( ydata(0:n), bvec(0:n) )
return
end
subroutine bpab ( n, bern, x, a, b )
!
!*******************************************************************************
!
!! BPAB evaluates the Bernstein basis polynomials for [A,B] at a point X.
!
!
! Formula:
!
! BERN(N,I,X) = [N!/(I!*(N-I)!)] * (B-X)**(N-I) * (X-A)**I / (B-A)**N
!
! First values:
!
! B(0,0,X) = 1
!
! B(1,0,X) = ( B-X ) / (B-A)
! B(1,1,X) = ( X-A ) / (B-A)
!
! B(2,0,X) = ( (B-X)**2 ) / (B-A)**2
! B(2,1,X) = ( 2 * (B-X) * (X-A) ) / (B-A)**2
! B(2,2,X) = ( (X-A)**2 ) / (B-A)**2
!
! B(3,0,X) = ( (B-X)**3 ) / (B-A)**3
! B(3,1,X) = ( 3 * (B-X)**2 * (X-A) ) / (B-A)**3
! B(3,2,X) = ( 3 * (B-X) * (X-A)**2 ) / (B-A)**3
! B(3,3,X) = ( (X-A)**3 ) / (B-A)**3
!
! B(4,0,X) = ( (B-X)**4 ) / (B-A)**4
! B(4,1,X) = ( 4 * (B-X)**3 * (X-A) ) / (B-A)**4
! B(4,2,X) = ( 6 * (B-X)**2 * (X-A)**2 ) / (B-A)**4
! B(4,3,X) = ( 4 * (B-X) * (X-A)**3 ) / (B-A)**4
! B(4,4,X) = ( (X-A)**4 ) / (B-A)**4
!
! Modified:
!
! 12 January 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer N, the degree of the Bernstein basis polynomials.
! For any N greater than or equal to 0, there is a set of N+1
! Bernstein basis polynomials, each of degree N, which form a basis
! for polynomials on [A,B].
!
! Output, real BERN(0:N), the values of the N+1 Bernstein basis
! polynomials at X.
!
! Input, real X, the point at which the polynomials are to be
! evaluated. X need not lie in the interval [A,B].
!
! Input, real A, B, the endpoints of the interval on which the
! polynomials are to be based. A and B should not be equal.
!
implicit none
!
integer n
!
real a
real b
real bern(0:n)
integer i
integer j
real x
!
if ( b == a ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'BPAB - Fatal error!'
write ( *, '(a,g14.6)' ) ' A = B = ', a
stop
end if
if ( n == 0 ) then
bern(0) = 1.0E+00
else if ( n > 0 ) then
bern(0) = ( b - x ) / ( b - a )
bern(1) = ( x - a ) / ( b - a )
do i = 2, n
bern(i) = ( x - a ) * bern(i-1) / ( b - a )
do j = i-1, 1, -1
bern(j) = ( ( b - x ) * bern(j) + ( x - a ) * bern(j-1) ) / ( b - a )
end do
bern(0) = ( b - x ) * bern(0) / ( b - a )
end do
end if
return
end
subroutine data_to_dif ( diftab, ntab, xtab, ytab )
!
!*******************************************************************************
!
!! DATA_TO_DIF sets up a divided difference table from raw data.
!
!
! Discussion:
!
! Space can be saved by using a single array for both the DIFTAB and
! YTAB dummy parameters. In that case, the divided difference table will
! overwrite the Y data without interfering with the computation.
!
! Modified:
!
! 11 April 2000
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Output, real DIFTAB(NTAB), the divided difference coefficients
! corresponding to the input (XTAB,YTAB).
!
! Input, integer NTAB, the number of pairs of points
! (XTAB(I),YTAB(I)) which are to be used as data. The
! number of entries to be used in DIFTAB, XTAB and YTAB.
!
! Input, real XTAB(NTAB), the X values at which data was taken.
! These values must be distinct.
!
! Input, real YTAB(NTAB), the corresponding Y values.
!
implicit none
!
integer ntab
!
real diftab(ntab)
integer i
integer j
logical rvec_distinct
real xtab(ntab)
real ytab(ntab)
!
if ( .not. rvec_distinct ( ntab, xtab ) ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'DATA_TO_DIF - Fatal error!'
write ( *, '(a)' ) ' Two entries of XTAB are equal!'
return
end if
!
! Copy the data values into DIFTAB.
!
diftab(1:ntab) = ytab(1:ntab)
!
! Compute the divided differences.
!
do i = 2, ntab
do j = ntab, i, -1
diftab(j) = ( diftab(j) - diftab(j-1) ) / ( xtab(j) - xtab(j+1-i) )
end do
end do
return
end
subroutine dif_val ( diftab, ntab, xtab, xval, yval )
!
!*******************************************************************************
!
!! DIF_VAL evaluates a divided difference polynomial at a point.
!
!
! Modified:
!
! 11 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, real DIFTAB(NTAB), the divided difference polynomial coefficients.
!
! Input, integer NTAB, the number of divided difference
! coefficients in DIFTAB, and the number of points XTAB.
!
! Input, real XTAB(NTAB), the X values upon which the
! divided difference polynomial is based.
!
! Input, real XVAL, a value of X at which the polynomial
! is to be evaluated.
!
! Output, real YVAL, the value of the polynomial at XVAL.
!
implicit none
!
integer ntab
!
real diftab(ntab)
integer i
real xtab(ntab)
real xval
real yval
!
yval = diftab(ntab)
do i = 1, ntab-1
yval = diftab(ntab-i) + ( xval - xtab(ntab-i) ) * yval
end do
return
end
subroutine least_set ( ntab, xtab, ytab, ndeg, ptab, array, eps, ierror )
!
!*******************************************************************************
!
!! LEAST_SET constructs the least squares polynomial approximation to data.
!
!
! Discussion:
!
! The routine LEAST_EVAL must be used to evaluate the approximation at a
! point.
!
! Modified:
!
! 20 November 2000
!
! Parameters:
!
! Input, integer NTAB, the number of data points.
!
! Input, real XTAB(NTAB), the X data. The values in XTAB
! should be distinct, and in increasing order.
!
! Input, real YTAB(NTAB), the Y data values corresponding
! to the X data in XTAB.
!
! Input, integer NDEG, the degree of the polynomial which the
! program is to use. NDEG must be at least 1, and less than or
! equal to NTAB-1.
!
! Output, real PTAB(NTAB). PTAB(I) is the value of the
! least squares polynomial at the point XTAB(I).
!
! Output, real ARRAY(2*NTAB+3*NDEG), an array containing data about
! the polynomial.
!
! Output, real EPS, the root-mean-square discrepancy of the
! polynomial fit.
!
! Output, integer IERROR, error flag.
! zero, no error occurred;
! nonzero, an error occurred, and the polynomial could not be computed.
!
implicit none
!
integer ndeg
integer ntab
!
real array(2*ntab+3*ndeg)
real eps
real error
integer i
integer i0l1
integer i1l1
integer ierror
integer it
integer k
integer mdeg
real ptab(ntab)
real rn0
real rn1
real s
real sum2
real xtab(ntab)
real y_sum
real ytab(ntab)
!
ierror = 0
!
! Check NDEG.
!
if ( ndeg < 1 ) then
ierror = 1
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'LEAST_SET - Fatal error!'
write ( *, '(a)' ) ' NDEG < 1.'
return
else if ( ndeg >= ntab ) then
ierror = 1
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'LEAST_SET - Fatal error!'
write ( *, '(a)' ) ' NDEG >= NTAB.'
return
end if
!
! Check that the abscissas are strictly increasing.
!
do i = 1, ntab-1
if ( xtab(i) >= xtab(i+1) ) then
ierror = 1
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'LEAST_SET - Fatal error!'
write ( *, '(a)' ) ' XTAB must be strictly increasing, but'
write ( *, '(a,i6,a,g14.6)' ) ' XTAB(', i, ') = ', xtab(i)
write ( *, '(a,i6,a,g14.6)' ) ' XTAB(', i+1, ') = ', xtab(i+1)
return
end if
end do
i0l1 = 3 * ndeg
i1l1 = 3 * ndeg + ntab
y_sum = sum ( ytab )
rn0 = ntab
array(2*ndeg) = y_sum / real ( ntab )
ptab(1:ntab) = y_sum / real ( ntab )
error = 0.0E+00
do i = 1, ntab
error = error + ( y_sum / real ( ntab ) - ytab(i) )**2
end do
if ( ndeg == 0 ) then
eps = sqrt ( error / real ( ntab ) )
return
end if
array(1) = sum ( xtab ) / real ( ntab )
s = 0.0E+00
sum2 = 0.0E+00
do i = 1, ntab
array(i1l1+i) = xtab(i) - array(1)
s = s + array(i1l1+i)**2
sum2 = sum2 + array(i1l1+i) * ( ytab(i) - ptab(i) )
end do
rn1 = s
array(2*ndeg+1) = sum2 / s
do i = 1, ntab
ptab(i) = ptab(i) + sum2 * array(i1l1+i) / s
end do
error = sum ( ( ptab(1:ntab) - ytab(1:ntab) )**2 )
if ( ndeg == 1 ) then
eps = sqrt ( error / real ( ntab ) )
return
end if
do i = 1, ntab
array(3*ndeg+i) = 1.0E+00
end do
mdeg = 2
k = 2
do
array(ndeg-1+k) = rn1 / rn0
sum2 = 0.0E+00
do i = 1, ntab
sum2 = sum2 + xtab(i) * array(i1l1+i)**2
end do
array(k) = sum2 / rn1
s = 0.0E+00
sum2 = 0.0E+00
do i = 1, ntab
array(i0l1+i) = ( xtab(i) - array(k) ) * array(i1l1+i) &
- array(ndeg-1+k) * array(i0l1+i)
s = s + array(i0l1+i)**2
sum2 = sum2 + array(i0l1+i) * ( ytab(i) - ptab(i) )
end do
rn0 = rn1
rn1 = s
it = i0l1
i0l1 = i1l1
i1l1 = it
array(2*ndeg+k) = sum2 / rn1
do i = 1, ntab
ptab(i) = ptab(i) + sum2 * array(i1l1+i) / rn1
end do
error = sum ( ( ptab(1:ntab) - ytab(1:ntab) )**2 )
if ( mdeg >= ndeg ) then
exit
end if
mdeg = mdeg + 1
k = k + 1
end do
eps = sqrt ( error / real ( ntab ) )
return
end
subroutine least_val ( x, ndeg, array, value )
!
!*******************************************************************************
!
!! LEAST_VAL evaluates a least squares polynomial defined by LEAST_SET.
!
!
! Modified:
!
! 01 March 1999
!
! Parameters:
!
! Input, real X, the point at which the polynomial is to be evaluated.
!
! Input, integer NDEG, the degree of the polynomial fit used.
! This is the value of NDEG as returned from LEAST_SET.
!
! Input, real ARRAY(*), an array of a certain dimension.
! See LEAST_SET for details on the size of ARRAY.
! ARRAY contains information about the polynomial, as set up by LEAST_SET.
!
! Output, real VALUE, the value of the polynomial at X.
!
implicit none
!
real array(*)
real dk
real dkp1
real dkp2
integer k
integer l
integer ndeg
real value
real x
!
if ( ndeg <= 0 ) then
value = array(2*ndeg)
else if ( ndeg == 1 ) then
value = array(2*ndeg) + array(2*ndeg+1) * ( x - array(1) )
else
dkp2 = array(3*ndeg)
dkp1 = array(3*ndeg-1) + ( x - array(ndeg) ) * dkp2
do l = 1, ndeg-2
k = ndeg - 1 - l
dk = array(2*ndeg+k) + ( x - array(k+1) ) * dkp1 - array(ndeg+1+k) * dkp2
dkp2 = dkp1
dkp1 = dk
end do
value = array(2*ndeg) + ( x - array(1) ) * dkp1 - array(ndeg+1) * dkp2
end if
return
end
subroutine parabola_val2 ( ndim, ndata, tdata, ydata, left, tval, yval )
!
!*******************************************************************************
!
!! PARABOLA_VAL2 evaluates a parabolic interpolant through tabular data.
!
!
! Discussion:
!
! This routine is a utility routine used by OVERHAUSER_SPLINE_VAL.
! It constructs the parabolic interpolant through the data in
! 3 consecutive entries of a table and evaluates this interpolant
! at a given abscissa value.
!
! Modified:
!
! 02 March 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer NDIM, the dimension of a single data point.
! NDIM must be at least 1.
!
! Input, integer NDATA, the number of data points.
! NDATA must be at least 3.
!
! Input, real TDATA(NDATA), the abscissas of the data points. The
! values in TDATA must be in strictly ascending order.
!
! Input, real YDATA(NDIM,NDATA), the data points corresponding to
! the abscissas.
!
! Input, integer LEFT, the location of the first of the three
! consecutive data points through which the parabolic interpolant
! must pass. 1 <= LEFT <= NDATA - 2.
!
! Input, real TVAL, the value of T at which the parabolic interpolant
! is to be evaluated. Normally, TDATA(1) <= TVAL <= T(NDATA), and
! the data will be interpolated. For TVAL outside this range,
! extrapolation will be used.
!
! Output, real YVAL(NDIM), the value of the parabolic interpolant at TVAL.
!
implicit none
!
integer ndata
integer ndim
!
real dif1
real dif2
integer i
integer left
real t1
real t2
real t3
real tval
real tdata(ndata)
real ydata(ndim,ndata)
real y1
real y2
real y3
real yval(ndim)
!
! Check.
!
if ( left < 1 .or. left > ndata-2 ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'PARABOLA_VAL2 - Fatal error!'
write ( *, '(a)' ) ' LEFT < 1 or LEFT > NDATA-2.'
stop
end if
if ( ndim < 1 ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'PARABOLA_VAL2 - Fatal error!'
write ( *, '(a)' ) ' NDIM < 1.'
stop
end if
!
! Copy out the three abscissas.
!
t1 = tdata(left)
t2 = tdata(left+1)
t3 = tdata(left+2)
if ( t1 >= t2 .or. t2 >= t3 ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'PARABOLA_VAL2 - Fatal error!'
write ( *, '(a)' ) ' T1 >= T2 or T2 >= T3.'
stop
end if
!
! Construct and evaluate a parabolic interpolant for the data
! in each dimension.
!
do i = 1, ndim
y1 = ydata(i,left)
y2 = ydata(i,left+1)
y3 = ydata(i,left+2)
dif1 = ( y2 - y1 ) / ( t2 - t1 )
dif2 = ( ( y3 - y1 ) / ( t3 - t1 ) &
- ( y2 - y1 ) / ( t2 - t1 ) ) / ( t3 - t2 )
yval(i) = y1 + ( tval - t1 ) * ( dif1 + ( tval - t2 ) * dif2 )
end do
return
end
subroutine r_random ( rlo, rhi, r )
!
!*******************************************************************************
!
!! R_RANDOM returns a random real in a given range.
!
!
! Modified:
!
! 06 April 2001
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, real RLO, RHI, the minimum and maximum values.
!
! Output, real R, the randomly chosen value.
!
implicit none
!
real r
real rhi
real rlo
real t
!
! Pick T, a random number in (0,1).
!
call random_number ( harvest = t )
!
! Set R in ( RLO, RHI ).
!
r = ( 1.0E+00 - t ) * rlo + t * rhi
return
end
subroutine r_swap ( x, y )
!
!*******************************************************************************
!
!! R_SWAP swaps two real values.
!
!
! Modified:
!
! 01 May 2000
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input/output, real X, Y. On output, the values of X and
! Y have been interchanged.
!
implicit none
!
real x
real y
real z
!
z = x
x = y
y = z
return
end
subroutine rvec_bracket ( n, x, xval, left, right )
!
!*******************************************************************************
!
!! RVEC_BRACKET searches a sorted array for successive brackets of a value.
!
!
! Discussion:
!
! If the values in the vector are thought of as defining intervals
! on the real line, then this routine searches for the interval
! nearest to or containing the given value.
!
! Modified:
!
! 06 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer N, length of input array.
!
! Input, real X(N), an array sorted into ascending order.
!
! Input, real XVAL, a value to be bracketed.
!
! Output, integer LEFT, RIGHT, the results of the search.
! Either:
! XVAL < X(1), when LEFT = 1, RIGHT = 2;
! XVAL > X(N), when LEFT = N-1, RIGHT = N;
! or
! X(LEFT) <= XVAL <= X(RIGHT).
!
implicit none
!
integer n
!
integer i
integer left
integer right
real x(n)
real xval
!
do i = 2, n - 1
if ( xval < x(i) ) then
left = i - 1
right = i
return
end if
end do
left = n - 1
right = n
return
end
subroutine rvec_bracket3 ( n, t, tval, left )
!
!*******************************************************************************
!
!! RVEC_BRACKET3 finds the interval containing or nearest a given value.
!
!
! Discussion:
!
! The routine always returns the index LEFT of the sorted array
! T with the property that either
! * T is contained in the interval [ T(LEFT), T(LEFT+1) ], or
! * T < T(LEFT) = T(1), or
! * T > T(LEFT+1) = T(N).
!
! The routine is useful for interpolation problems, where
! the abscissa must be located within an interval of data
! abscissas for interpolation, or the "nearest" interval
! to the (extreme) abscissa must be found so that extrapolation
! can be carried out.
!
! Modified:
!
! 05 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer N, length of the input array.
!
! Input, real T(N), an array sorted into ascending order.
!
! Input, real TVAL, a value to be bracketed by entries of T.
!
! Input/output, integer LEFT.
!
! On input, if 1 <= LEFT <= N-1, LEFT is taken as a suggestion for the
! interval [ T(LEFT), T(LEFT+1) ] in which TVAL lies. This interval
! is searched first, followed by the appropriate interval to the left
! or right. After that, a binary search is used.
!
! On output, LEFT is set so that the interval [ T(LEFT), T(LEFT+1) ]
! is the closest to TVAL; it either contains TVAL, or else TVAL
! lies outside the interval [ T(1), T(N) ].
!
implicit none
!
integer n
!
integer high
integer left
integer low
integer mid
real t(n)
real tval
!
! Check the input data.
!
if ( n < 2 ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'RVEC_BRACKET3 - Fatal error!'
write ( *, '(a)' ) ' N must be at least 2.'
stop
end if
!
! If LEFT is not between 1 and N-1, set it to the middle value.
!
if ( left < 1 .or. left > n - 1 ) then
left = ( n + 1 ) / 2
end if
!
! CASE 1: TVAL < T(LEFT):
! Search for TVAL in [T(I), T(I+1)] for intervals I = 1 to LEFT-1.
!
if ( tval < t(left) ) then
if ( left == 1 ) then
return
else if ( left == 2 ) then
left = 1
return
else if ( tval >= t(left-1) ) then
left = left - 1
return
else if ( tval <= t(2) ) then
left = 1
return
end if
!
! ...Binary search for TVAL in [T(I), T(I+1)] for intervals I = 2 to LEFT-2.
!
low = 2
high = left - 2
do
if ( low == high ) then
left = low
return
end if
mid = ( low + high + 1 ) / 2
if ( tval >= t(mid) ) then
low = mid
else
high = mid - 1
end if
end do
!
! CASE2: T(LEFT+1) < TVAL:
! Search for TVAL in {T(I),T(I+1)] for intervals I = LEFT+1 to N-1.
!
else if ( tval > t(left+1) ) then
if ( left == n - 1 ) then
return
else if ( left == n - 2 ) then
left = left + 1
return
else if ( tval <= t(left+2) ) then
left = left + 1
return
else if ( tval >= t(n-1) ) then
left = n - 1
return
end if
!
! ...Binary search for TVAL in [T(I), T(I+1)] for intervals I = LEFT+2 to N-2.
!
low = left + 2
high = n - 2
do
if ( low == high ) then
left = low
return
end if
mid = ( low + high + 1 ) / 2
if ( tval >= t(mid) ) then
low = mid
else
high = mid - 1
end if
end do
!
! CASE3: T(LEFT) <= TVAL <= T(LEFT+1):
! T is in [T(LEFT), T(LEFT+1)], as the user said it might be.
!
else
end if
return
end
function rvec_distinct ( n, x )
!
!*******************************************************************************
!
!! RVEC_DISTINCT is true if the entries in a real vector are distinct.
!
!
! Modified:
!
! 16 September 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer N, the number of entries in the vector.
!
! Input, real X(N), the vector to be checked.
!
! Output, logical RVEC_DISTINCT is .TRUE. if all N elements of X
! are distinct.
!
implicit none
!
integer n
!
integer i
integer j
logical rvec_distinct
real x(n)
!
rvec_distinct = .false.
do i = 2, n
do j = 1, i - 1
if ( x(i) == x(j) ) then
return
end if
end do
end do
rvec_distinct = .true.
return
end
subroutine rvec_even ( alo, ahi, n, a )
!
!*******************************************************************************
!
!! RVEC_EVEN returns N real values, evenly spaced between ALO and AHI.
!
!
! Modified:
!
! 31 October 2000
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, real ALO, AHI, the low and high values.
!
! Input, integer N, the number of values.
!
! Output, real A(N), N evenly spaced values.
! Normally, A(1) = ALO and A(N) = AHI.
! However, if N = 1, then A(1) = 0.5*(ALO+AHI).
!
implicit none
!
integer n
!
real a(n)
real ahi
real alo
integer i
!
if ( n == 1 ) then
a(1) = 0.5E+00 * ( alo + ahi )
else
do i = 1, n
a(i) = ( real ( n - i ) * alo + real ( i - 1 ) * ahi ) / real ( n - 1 )
end do
end if
return
end
subroutine rvec_order_type ( n, a, order )
!
!*******************************************************************************
!
!! RVEC_ORDER_TYPE determines if a real array is (non)strictly ascending/descending.
!
!
! Modified:
!
! 20 July 2000
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer N, the number of entries of the array.
!
! Input, real A(N), the array to be checked.
!
! Output, integer ORDER, order indicator:
! -1, no discernable order;
! 0, all entries are equal;
! 1, ascending order;
! 2, strictly ascending order;
! 3, descending order;
! 4, strictly descending order.
!
implicit none
!
integer n
!
real a(n)
integer i
integer order
!
! Search for the first value not equal to A(1).
!
i = 1
do
i = i + 1
if ( i > n ) then
order = 0
return
end if
if ( a(i) > a(1) ) then
if ( i == 2 ) then
order = 2
else
order = 1
end if
exit
else if ( a(i) < a(1) ) then
if ( i == 2 ) then
order = 4
else
order = 3
end if
exit
end if
end do
!
! Now we have a "direction". Examine subsequent entries.
!
do
i = i + 1
if ( i > n ) then
exit
end if
if ( order == 1 ) then
if ( a(i) < a(i-1) ) then
order = -1
exit
end if
else if ( order == 2 ) then
if ( a(i) < a(i-1) ) then
order = -1
exit
else if ( a(i) == a(i-1) ) then
order = 1
end if
else if ( order == 3 ) then
if ( a(i) > a(i-1) ) then
order = -1
exit
end if
else if ( order == 4 ) then
if ( a(i) > a(i-1) ) then
order = -1
exit
else if ( a(i) == a(i-1) ) then
order = 3
end if
end if
end do
return
end
subroutine rvec_print ( n, a, title )
!
!*******************************************************************************
!
!! RVEC_PRINT prints a real vector.
!
!
! Modified:
!
! 16 December 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer N, the number of components of the vector.
!
! Input, real A(N), the vector to be printed.
!
! Input, character ( len = * ) TITLE, a title to be printed first.
! TITLE may be blank.
!
implicit none
!
integer n
!
real a(n)
integer i
character ( len = * ) title
!
if ( title /= ' ' ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) trim ( title )
end if
write ( *, '(a)' ) ' '
do i = 1, n
write ( *, '(i6,g14.6)' ) i, a(i)
end do
return
end
subroutine rvec_random ( alo, ahi, n, a )
!
!*******************************************************************************
!
!! RVEC_RANDOM returns a random real vector in a given range.
!
!
! Modified:
!
! 04 February 2001
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, real ALO, AHI, the range allowed for the entries.
!
! Input, integer N, the number of entries in the vector.
!
! Output, real A(N), the vector of randomly chosen values.
!
implicit none
!
integer n
!
real a(n)
real ahi
real alo
integer i
!
do i = 1, n
call r_random ( alo, ahi, a(i) )
end do
return
end
subroutine rvec_sort_bubble_a ( n, a )
!
!*******************************************************************************
!
!! RVEC_SORT_BUBBLE_A ascending sorts a real array using bubble sort.
!
!
! Discussion:
!
! Bubble sort is simple to program, but inefficient. It should not
! be used for large arrays.
!
! Modified:
!
! 01 February 2001
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer N, the number of entries in the array.
!
! Input/output, real A(N).
! On input, an unsorted array.
! On output, the array has been sorted.
!
implicit none
!
integer n
!
real a(n)
integer i
integer j
!
do i = 1, n-1
do j = i+1, n
if ( a(i) > a(j) ) then
call r_swap ( a(i), a(j) )
end if
end do
end do
return
end
subroutine s3_fs ( a1, a2, a3, n, b, x )
!
!*******************************************************************************
!
!! S3_FS factors and solves a tridiagonal linear system.
!
!
! Note:
!
! This algorithm requires that each diagonal entry be nonzero.
!
! Modified:
!
! 05 December 1998
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input/output, real A1(2:N), A2(1:N), A3(1:N-1).
! On input, the nonzero diagonals of the linear system.
! On output, the data in these vectors has been overwritten
! by factorization information.
!
! Input, integer N, the order of the linear system.
!
! Input/output, real B(N).
! On input, B contains the right hand side of the linear system.
! On output, B has been overwritten by factorization information.
!
! Output, real X(N), the solution of the linear system.
!
implicit none
!
integer n
!
real a1(2:n)
real a2(1:n)
real a3(1:n-1)
real b(n)
integer i
real x(n)
real xmult
!
! The diagonal entries can't be zero.
!
do i = 1, n
if ( a2(i) == 0.0E+00 ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'S3_FS - Fatal error!'
write ( *, '(a,i6,a)' ) ' A2(', i, ') = 0.'
return
end if
end do
do i = 2, n-1
xmult = a1(i) / a2(i-1)
a2(i) = a2(i) - xmult * a3(i-1)
b(i) = b(i) - xmult * b(i-1)
end do
xmult = a1(n) / a2(n-1)
a2(n) = a2(n) - xmult * a3(n-1)
x(n) = ( b(n) - xmult * b(n-1) ) / a2(n)
do i = n-1, 1, -1
x(i) = ( b(i) - a3(i) * x(i+1) ) / a2(i)
end do
return
end
subroutine sgtsl ( n, c, d, e, b, info )
!
!*******************************************************************************
!
!! SGTSL solves a general tridiagonal linear system.
!
!
! Reference:
!
! Dongarra, Moler, Bunch and Stewart,
! LINPACK User's Guide,
! SIAM, (Society for Industrial and Applied Mathematics),
! 3600 University City Science Center,
! Philadelphia, PA, 19104-2688.
! ISBN 0-89871-172-X
!
! Modified:
!
! 31 October 2001
!
! Parameters:
!
! Input, integer N, the order of the tridiagonal matrix.
!
! Input/output, real C(N), contains the subdiagonal of the tridiagonal
! matrix in entries C(2:N). On output, C is destroyed.
!
! Input/output, real D(N). On input, the diagonal of the matrix.
! On output, D is destroyed.
!
! Input/output, real E(N), contains the superdiagonal of the tridiagonal
! matrix in entries E(1:N-1). On output E is destroyed.
!
! Input/output, real B(N). On input, the right hand side. On output,
! the solution.
!
! Output, integer INFO, error flag.
! 0, normal value.
! K, the K-th element of the diagonal becomes exactly zero. The
! subroutine returns if this error condition is detected.
!
implicit none
!
integer n
!
real b(n)
real c(n)
real d(n)
real e(n)
integer info
integer k
real t
!
info = 0
c(1) = d(1)
if ( n >= 2 ) then
d(1) = e(1)
e(1) = 0.0E+00
e(n) = 0.0E+00
do k = 1, n - 1
!
! Find the larger of the two rows, and interchange if necessary.
!
if ( abs ( c(k+1) ) >= abs ( c(k) ) ) then
call r_swap ( c(k), c(k+1) )
call r_swap ( d(k), d(k+1) )
call r_swap ( e(k), e(k+1) )
call r_swap ( b(k), b(k+1) )
end if
!
! Fail if no nonzero pivot could be found.
!
if ( c(k) == 0.0E+00 ) then
info = k
return
end if
!
! Zero elements.
!
t = -c(k+1) / c(k)
c(k+1) = d(k+1) + t * d(k)
d(k+1) = e(k+1) + t * e(k)
e(k+1) = 0.0E+00
b(k+1) = b(k+1) + t * b(k)
end do
end if
if ( c(n) == 0.0E+00 ) then
info = n
return
end if
!
! Back solve.
!
b(n) = b(n) / c(n)
if ( n > 1 ) then
b(n-1) = ( b(n-1) - d(n-1) * b(n) ) / c(n-1)
do k = n-2, 1, -1
b(k) = ( b(k) - d(k) * b(k+1) - e(k) * b(k+2) ) / c(k)
end do
end if
return
end
subroutine spline_b_val ( ndata, tdata, ydata, tval, yval )
!
!*******************************************************************************
!
!! SPLINE_B_VAL evaluates a cubic B spline approximant.
!
!
! Discussion:
!
! The cubic B spline will approximate the data, but is not
! designed to interpolate it.
!
! In effect, two "phantom" data values are appended to the data,
! so that the spline will interpolate the first and last data values.
!
! Modified:
!
! 07 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer NDATA, the number of data values.
!
! Input, real TDATA(NDATA), the abscissas of the data.
!
! Input, real YDATA(NDATA), the data values.
!
! Input, real TVAL, a point at which the spline is to be evaluated.
!
! Output, real YVAL, the value of the function at TVAL.
!
implicit none
!
integer ndata
!
real bval
integer left
integer right
real tdata(ndata)
real tval
real u
real ydata(ndata)
real yval
!
! Find the nearest interval [ TDATA(LEFT), TDATA(RIGHT) ] to TVAL.
!
call rvec_bracket ( ndata, tdata, tval, left, right )
!
! Evaluate the 5 nonzero B spline basis functions in the interval,
! weighted by their corresponding data values.
!
u = ( tval - tdata(left) ) / ( tdata(right) - tdata(left) )
yval = 0.0E+00
!
! B function associated with node LEFT - 1, (or "phantom node"),
! evaluated in its 4th interval.
!
bval = ( 1.0E+00 - 3.0E+00 * u + 3.0E+00 * u**2 - u**3 ) / 6.0E+00
if ( left-1 > 0 ) then
yval = yval + ydata(left-1) * bval
else
yval = yval + ( 2.0E+00 * ydata(1) - ydata(2) ) * bval
end if
!
! B function associated with node LEFT,
! evaluated in its third interval.
!
bval = ( 4.0E+00 - 6.0E+00 * u**2 + 3.0E+00 * u**3 ) / 6.0E+00
yval = yval + ydata(left) * bval
!
! B function associated with node RIGHT,
! evaluated in its second interval.
!
bval = ( 1.0E+00 + 3.0E+00 * u + 3.0E+00 * u**2 - 3.0E+00 * u**3 ) / 6.0E+00
yval = yval + ydata(right) * bval
!
! B function associated with node RIGHT+1, (or "phantom node"),
! evaluated in its first interval.
!
bval = u**3 / 6.0E+00
if ( right+1 <= ndata ) then
yval = yval + ydata(right+1) * bval
else
yval = yval + ( 2.0E+00 * ydata(ndata) - ydata(ndata-1) ) * bval
end if
return
end
subroutine spline_beta_val ( beta1, beta2, ndata, tdata, ydata, tval, yval )
!
!*******************************************************************************
!
!! SPLINE_BETA_VAL evaluates a cubic beta spline approximant.
!
!
! Discussion:
!
! The cubic beta spline will approximate the data, but is not
! designed to interpolate it.
!
! If BETA1 = 1 and BETA2 = 0, the cubic beta spline will be the
! same as the cubic B spline approximant.
!
! With BETA1 = 1 and BETA2 large, the beta spline becomes more like
! a linear spline.
!
! In effect, two "phantom" data values are appended to the data,
! so that the spline will interpolate the first and last data values.
!
! Modified:
!
! 12 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, real BETA1, the skew or bias parameter.
! BETA1 = 1 for no skew or bias.
!
! Input, real BETA2, the tension parameter.
! BETA2 = 0 for no tension.
!
! Input, integer NDATA, the number of data values.
!
! Input, real TDATA(NDATA), the abscissas of the data.
!
! Input, real YDATA(NDATA), the data values.
!
! Input, real TVAL, a point at which the spline is to be evaluated.
!
! Output, real YVAL, the value of the function at TVAL.
!
implicit none
!
integer ndata
!
real a
real b
real beta1
real beta2
real bval
real c
real d
real delta
integer left
integer right
real tdata(ndata)
real tval
real u
real ydata(ndata)
real yval
!
! Find the nearest interval [ TDATA(LEFT), TDATA(RIGHT) ] to TVAL.
!
call rvec_bracket ( ndata, tdata, tval, left, right )
!
! Evaluate the 5 nonzero beta spline basis functions in the interval,
! weighted by their corresponding data values.
!
u = ( tval - tdata(left) ) / ( tdata(right) - tdata(left) )
delta = 2.0E+00 + beta2 + 4.0E+00 * beta1 + 4.0E+00 * beta1**2 &
+ 2.0E+00 * beta1**3
yval = 0.0E+00
!
! Beta function associated with node LEFT - 1, (or "phantom node"),
! evaluated in its 4th interval.
!
bval = ( 2.0E+00 * beta1**3 * ( 1.0E+00 - u )**3 ) / delta
if ( left-1 > 0 ) then
yval = yval + ydata(left-1) * bval
else
yval = yval + ( 2.0E+00 * ydata(1) - ydata(2) ) * bval
end if
!
! Beta function associated with node LEFT,
! evaluated in its third interval.
!
a = beta2 + 4.0E+00 * beta1 + 4.0E+00 * beta1**2
b = - 6.0E+00 * beta1 * ( 1.0E+00 - beta1 ) * ( 1.0E+00 + beta1 )
c = - 3.0E+00 * ( beta2 + 2.0E+00 * beta1**2 + 2.0E+00 * beta1**3 )
d = 2.0E+00 * ( beta2 + beta1 + beta1**2 + beta1**3 )
bval = ( a + u * ( b + u * ( c + u * d ) ) ) / delta
yval = yval + ydata(left) * bval
!
! Beta function associated with node RIGHT,
! evaluated in its second interval.
!
a = 2.0E+00
b = 6.0E+00 * beta1
c = 3.0E+00 * beta2 + 6.0E+00 * beta1**2
d = - 2.0E+00 * ( 1.0E+00 + beta2 + beta1 + beta1**2 )
bval = ( a + u * ( b + u * ( c + u * d ) ) ) / delta
yval = yval + ydata(right) * bval
!
! Beta function associated with node RIGHT+1, (or "phantom node"),
! evaluated in its first interval.
!
bval = 2.0E+00 * u**3 / delta
if ( right+1 <= ndata ) then
yval = yval + ydata(right+1) * bval
else
yval = yval + ( 2.0E+00 * ydata(ndata) - ydata(ndata-1) ) * bval
end if
return
end
subroutine spline_constant_val ( ndata, tdata, ydata, tval, yval )
!
!*******************************************************************************
!
!! SPLINE_CONSTANT_VAL evaluates a piecewise constant spline at a point.
!
!
! Discussion:
!
! NDATA-1 points TDATA define NDATA intervals, with the first
! and last being semi-infinite.
!
! The value of the spline anywhere in interval I is YDATA(I).
!
! Modified:
!
! 16 November 2001
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer NDATA, the number of data points defining the spline.
!
! Input, real TDATA(NDATA-1), the breakpoints. The values of TDATA should
! be distinct and increasing.
!
! Input, YDATA(NDATA), the values of the spline in the intervals
! defined by the breakpoints.
!
! Input, real TVAL, the point at which the spline is to be evaluated.
!
! Output, real YVAL, the value of the spline at TVAL.
!
implicit none
!
integer ndata
!
integer i
real tdata(ndata-1)
real tval
real ydata(ndata)
real yval
!
do i = 1, ndata-1
if ( tval <= tdata(i) ) then
yval = ydata(i)
return
end if
end do
yval = ydata(ndata)
return
end
subroutine spline_cubic_set ( n, t, y, ibcbeg, ybcbeg, ibcend, ybcend, ypp )
!
!*******************************************************************************
!
!! SPLINE_CUBIC_SET computes the second derivatives of a cubic spline.
!
!
! Discussion:
!
! For data interpolation, the user must call SPLINE_CUBIC_SET to
! determine the second derivative data, passing in the data to be
! interpolated, and the desired boundary conditions.
!
! The data to be interpolated, plus the SPLINE_CUBIC_SET output,
! defines the spline. The user may then call SPLINE_CUBIC_VAL to
! evaluate the spline at any point.
!
! The cubic spline is a piecewise cubic polynomial. The intervals
! are determined by the "knots" or abscissas of the data to be
! interpolated. The cubic spline has continous first and second
! derivatives over the entire interval of interpolation.
!
! For any point T in the interval T(IVAL), T(IVAL+1), the form of
! the spline is
!
! SPL(T) = A(IVAL)
! + B(IVAL) * ( T - T(IVAL) )
! + C(IVAL) * ( T - T(IVAL) )**2
! + D(IVAL) * ( T - T(IVAL) )**3
!
! If we assume that we know the values Y(*) and YPP(*), which represent
! the values and second derivatives of the spline at each knot, then
! the coefficients can be computed as:
!
! A(IVAL) = Y(IVAL)
! B(IVAL) = ( Y(IVAL+1) - Y(IVAL) ) / ( T(IVAL+1) - T(IVAL) )
! - ( YPP(IVAL+1) + 2 * YPP(IVAL) ) * ( T(IVAL+1) - T(IVAL) ) / 6
! C(IVAL) = YPP(IVAL) / 2
! D(IVAL) = ( YPP(IVAL+1) - YPP(IVAL) ) / ( 6 * ( T(IVAL+1) - T(IVAL) ) )
!
! Since the first derivative of the spline is
!
! SPL'(T) = B(IVAL)
! + 2 * C(IVAL) * ( T - T(IVAL) )
! + 3 * D(IVAL) * ( T - T(IVAL) )**2,
!
! the requirement that the first derivative be continuous at interior
! knot I results in a total of N-2 equations, of the form:
!
! B(IVAL-1) + 2 C(IVAL-1) * (T(IVAL)-T(IVAL-1))
! + 3 * D(IVAL-1) * (T(IVAL) - T(IVAL-1))**2 = B(IVAL)
!
! or, setting H(IVAL) = T(IVAL+1) - T(IVAL)
!
! ( Y(IVAL) - Y(IVAL-1) ) / H(IVAL-1)
! - ( YPP(IVAL) + 2 * YPP(IVAL-1) ) * H(IVAL-1) / 6
! + YPP(IVAL-1) * H(IVAL-1)
! + ( YPP(IVAL) - YPP(IVAL-1) ) * H(IVAL-1) / 2
! =
! ( Y(IVAL+1) - Y(IVAL) ) / H(IVAL)
! - ( YPP(IVAL+1) + 2 * YPP(IVAL) ) * H(IVAL) / 6
!
! or
!
! YPP(IVAL-1) * H(IVAL-1) + 2 * YPP(IVAL) * ( H(IVAL-1) + H(IVAL) )
! + YPP(IVAL) * H(IVAL)
! =
! 6 * ( Y(IVAL+1) - Y(IVAL) ) / H(IVAL)
! - 6 * ( Y(IVAL) - Y(IVAL-1) ) / H(IVAL-1)
!
! Boundary conditions must be applied at the first and last knots.
! The resulting tridiagonal system can be solved for the YPP values.
!
! Modified:
!
! 20 November 2000
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer N, the number of data points; N must be at least 2.
!
! Input, real T(N), the points where data is specified.
! The values should be distinct, and increasing.
!
! Input, real Y(N), the data values to be interpolated.
!
! Input, integer IBCBEG, the left boundary condition flag:
!
! 0: the spline should be a quadratic over the first interval;
! 1: the first derivative at the left endpoint should be YBCBEG;
! 2: the second derivative at the left endpoint should be YBCBEG.
!
! Input, real YBCBEG, the left boundary value, if needed.
!
! Input, integer IBCEND, the right boundary condition flag:
!
! 0: the spline should be a quadratic over the last interval;
! 1: the first derivative at the right endpoint should be YBCEND;
! 2: the second derivative at the right endpoint should be YBCEND.
!
! Input, real YBCEND, the right boundary value, if needed.
!
! Output, real YPP(N), the second derivatives of the cubic spline.
!
implicit none
!
integer n
!
real diag(n)
integer i
integer ibcbeg
integer ibcend
real sub(2:n)
real sup(1:n-1)
real t(n)
real y(n)
real ybcbeg
real ybcend
real ypp(n)
!
! Check.
!
if ( n <= 1 ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'SPLINE_CUBIC_SET - Fatal error!'
write ( *, '(a)' ) ' The number of knots must be at least 2.'
write ( *, '(a,i6)' ) ' The input value of N = ', n
stop
end if
do i = 1, n-1
if ( t(i) >= t(i+1) ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'SPLINE_CUBIC_SET - Fatal error!'
write ( *, '(a)' ) ' The knots must be strictly increasing, but'
write ( *, '(a,i6,a,g14.6)' ) ' T(', i,') = ', t(i)
write ( *, '(a,i6,a,g14.6)' ) ' T(',i+1,') = ', t(i+1)
stop
end if
end do
!
! Set the first equation.
!
if ( ibcbeg == 0 ) then
ypp(1) = 0.0E+00
diag(1) = 1.0E+00
sup(1) = -1.0E+00
else if ( ibcbeg == 1 ) then
ypp(1) = ( y(2) - y(1) ) / ( t(2) - t(1) ) - ybcbeg
diag(1) = ( t(2) - t(1) ) / 3.0E+00
sup(1) = ( t(2) - t(1) ) / 6.0E+00
else if ( ibcbeg == 2 ) then
ypp(1) = ybcbeg
diag(1) = 1.0E+00
sup(1) = 0.0E+00
else
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'SPLINE_CUBIC_SET - Fatal error!'
write ( *, '(a)' ) ' The boundary flag IBCBEG must be 0, 1 or 2.'
write ( *, '(a,i6)' ) ' The input value is IBCBEG = ', ibcbeg
stop
end if
!
! Set the intermediate equations.
!
do i = 2, n-1
ypp(i) = ( y(i+1) - y(i) ) / ( t(i+1) - t(i) ) &
- ( y(i) - y(i-1) ) / ( t(i) - t(i-1) )
sub(i) = ( t(i) - t(i-1) ) / 6.0E+00
diag(i) = ( t(i+1) - t(i-1) ) / 3.0E+00
sup(i) = ( t(i+1) - t(i) ) / 6.0E+00
end do
!
! Set the last equation.
!
if ( ibcend == 0 ) then
ypp(n) = 0.0E+00
sub(n) = -1.0E+00
diag(n) = 1.0E+00
else if ( ibcend == 1 ) then
ypp(n) = ybcend - ( y(n) - y(n-1) ) / ( t(n) - t(n-1) )
sub(n) = ( t(n) - t(n-1) ) / 6.0E+00
diag(n) = ( t(n) - t(n-1) ) / 3.0E+00
else if ( ibcend == 2 ) then
ypp(n) = ybcend
sub(n) = 0.0E+00
diag(n) = 1.0E+00
else
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'SPLINE_CUBIC_SET - Fatal error!'
write ( *, '(a)' ) ' The boundary flag IBCEND must be 0, 1 or 2.'
write ( *, '(a,i6)' ) ' The input value is IBCEND = ', ibcend
stop
end if
!
! Special case:
! N = 2, IBCBEG = IBCEND = 0.
!
if ( n == 2 .and. ibcbeg == 0 .and. ibcend == 0 ) then
ypp(1) = 0.0E+00
ypp(2) = 0.0E+00
!
! Solve the linear system.
!
else
call s3_fs ( sub, diag, sup, n, ypp, ypp )
end if
return
end
subroutine spline_cubic_val ( n, t, y, ypp, tval, yval, ypval, yppval )
!
!*******************************************************************************
!
!! SPLINE_CUBIC_VAL evaluates a cubic spline at a specific point.
!
!
! Discussion:
!
! SPLINE_CUBIC_SET must have already been called to define the
! values of YPP.
!
! For any point T in the interval T(IVAL), T(IVAL+1), the form of
! the spline is
!
! SPL(T) = A
! + B * ( T - T(IVAL) )
! + C * ( T - T(IVAL) )**2
! + D * ( T - T(IVAL) )**3
!
! Here:
! A = Y(IVAL)
! B = ( Y(IVAL+1) - Y(IVAL) ) / ( T(IVAL+1) - T(IVAL) )
! - ( YPP(IVAL+1) + 2 * YPP(IVAL) ) * ( T(IVAL+1) - T(IVAL) ) / 6
! C = YPP(IVAL) / 2
! D = ( YPP(IVAL+1) - YPP(IVAL) ) / ( 6 * ( T(IVAL+1) - T(IVAL) ) )
!
! Modified:
!
! 20 November 2000
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer N, the number of data values.
!
! Input, real T(N), the knot values.
!
! Input, real Y(N), the data values at the knots.
!
! Input, real YPP(N), the second derivatives of the spline at the knots.
!
! Input, real TVAL, a point, typically between T(1) and T(N), at
! which the spline is to be evalulated. If TVAL lies outside
! this range, extrapolation is used.
!
! Output, real YVAL, YPVAL, YPPVAL, the value of the spline, and
! its first two derivatives at TVAL.
!
implicit none
!
integer n
!
real dt
real h
integer left
integer right
real t(n)
real tval
real y(n)
real ypp(n)
real yppval
real ypval
real yval
!
! Determine the interval [T(LEFT), T(RIGHT)] that contains TVAL.
! Values below T(1) or above T(N) use extrapolation.
!
call rvec_bracket ( n, t, tval, left, right )
!
! Evaluate the polynomial.
!
dt = tval - t(left)
h = t(right) - t(left)
yval = y(left) &
+ dt * ( ( y(right) - y(left) ) / h &
- ( ypp(right) / 6.0E+00 + ypp(left) / 3.0E+00 ) * h &
+ dt * ( 0.5E+00 * ypp(left) &
+ dt * ( ( ypp(right) - ypp(left) ) / ( 6.0E+00 * h ) ) ) )
ypval = ( y(right) - y(left) ) / h &
- ( ypp(right) / 6.0E+00 + ypp(left) / 3.0E+00 ) * h &
+ dt * ( ypp(left) &
+ dt * ( 0.5E+00 * ( ypp(right) - ypp(left) ) / h ) )
yppval = ypp(left) + dt * ( ypp(right) - ypp(left) ) / h
return
end
subroutine spline_cubic_val2 ( n, t, y, ypp, left, tval, yval, ypval, yppval )
!
!*******************************************************************************
!
!! SPLINE_CUBIC_VAL2 evaluates a cubic spline at a specific point.
!
!
! Discussion:
!
! This routine is a modification of SPLINE_CUBIC_VAL; it allows the
! user to speed up the code by suggesting the appropriate T interval
! to search first.
!
! SPLINE_CUBIC_SET must have already been called to define the
! values of YPP.
!
! In the LEFT interval, let RIGHT = LEFT+1. The form of the spline is
!
! SPL(T) =
! A
! + B * ( T - T(LEFT) )
! + C * ( T - T(LEFT) )**2
! + D * ( T - T(LEFT) )**3
!
! Here:
! A = Y(LEFT)
! B = ( Y(RIGHT) - Y(LEFT) ) / ( T(RIGHT) - T(LEFT) )
! - ( YPP(RIGHT) + 2 * YPP(LEFT) ) * ( T(RIGHT) - T(LEFT) ) / 6
! C = YPP(LEFT) / 2
! D = ( YPP(RIGHT) - YPP(LEFT) ) / ( 6 * ( T(RIGHT) - T(LEFT) ) )
!
! Modified:
!
! 20 November 2000
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer N, the number of knots.
!
! Input, real T(N), the knot values.
!
! Input, real Y(N), the data values at the knots.
!
! Input, real YPP(N), the second derivatives of the spline at
! the knots.
!
! Input/output, integer LEFT, the suggested T interval to search.
! LEFT should be between 1 and N-1. If LEFT is not in this range,
! then its value will be ignored. On output, LEFT is set to the
! actual interval in which TVAL lies.
!
! Input, real TVAL, a point, typically between T(1) and T(N), at
! which the spline is to be evalulated. If TVAL lies outside
! this range, extrapolation is used.
!
! Output, real YVAL, YPVAL, YPPVAL, the value of the spline, and
! its first two derivatives at TVAL.
!
implicit none
!
integer n
!
real dt
real h
integer left
integer right
real t(n)
real tval
real y(n)
real ypp(n)
real yppval
real ypval
real yval
!
! Determine the interval [T(LEFT), T(RIGHT)] that contains TVAL.
!
! What you want from RVEC_BRACKET3 is that TVAL is to be computed
! by the data in interval {T(LEFT), T(RIGHT)].
!
left = 0
call rvec_bracket3 ( n, t, tval, left )
right = left + 1
!
! In the interval LEFT, the polynomial is in terms of a normalized
! coordinate ( DT / H ) between 0 and 1.
!
dt = tval - t(left)
h = t(right) - t(left)
yval = y(left) + dt * ( ( y(right) - y(left) ) / h &
- ( ypp(right) / 6.0E+00 + ypp(left) / 3.0E+00 ) * h &
+ dt * ( 0.5E+00 * ypp(left) &
+ dt * ( ( ypp(right) - ypp(left) ) / ( 6.0E+00 * h ) ) ) )
ypval = ( y(right) - y(left) ) / h &
- ( ypp(right) / 6.0E+00 + ypp(left) / 3.0E+00 ) * h &
+ dt * ( ypp(left) &
+ dt * ( 0.5E+00 * ( ypp(right) - ypp(left) ) / h ) )
yppval = ypp(left) + dt * ( ypp(right) - ypp(left) ) / h
return
end
subroutine spline_hermite_set ( ndata, tdata, c )
!
!*************************************************************************
!
!! SPLINE_HERMITE_SET sets up a piecewise cubic Hermite interpolant.
!
!
! Reference:
!
! Conte and de Boor,
! Algorithm CALCCF,
! Elementary Numerical Analysis,
! 1973, page 235.
!
! Modified:
!
! 06 April 1999
!
! Parameters:
!
! Input, integer NDATA, the number of data points.
! NDATA must be at least 2.
!
! Input, real TDATA(NDATA), the abscissas of the data points.
! The entries of TDATA are assumed to be strictly increasing.
!
! Input/output, real C(4,NDATA).
!
! On input, C(1,I) and C(2,I) should contain the value of the
! function and its derivative at TDATA(I), for I = 1 to NDATA.
! These values will not be changed by this routine.
!
! On output, C(3,I) and C(4,I) contain the quadratic
! and cubic coefficients of the Hermite polynomial
! in the interval (TDATA(I), TDATA(I+1)), for I=1 to NDATA-1.
! C(3,NDATA) and C(4,NDATA) are set to 0.
!
! In the interval (TDATA(I), TDATA(I+1)), the interpolating Hermite
! polynomial is given by
!
! SVAL(TVAL) = C(1,I)
! + ( TVAL - TDATA(I) ) * ( C(2,I)
! + ( TVAL - TDATA(I) ) * ( C(3,I)
! + ( TVAL - TDATA(I) ) * C(4,I) ) )
!
implicit none
!
integer ndata
!
real c(4,ndata)
real divdif1
real divdif3
real dt
integer i
real tdata(ndata)
!
do i = 1, ndata-1
dt = tdata(i+1) - tdata(i)
divdif1 = ( c(1,i+1) - c(1,i) ) / dt
divdif3 = c(2,i) + c(2,i+1) - 2.0E+00 * divdif1
c(3,i) = ( divdif1 - c(2,i) - divdif3 ) / dt
c(4,i) = divdif3 / dt**2
end do
c(3,ndata) = 0.0E+00
c(4,ndata) = 0.0E+00
return
end
subroutine spline_hermite_val ( ndata, tdata, c, tval, sval )
!
!*************************************************************************
!
!! SPLINE_HERMITE_VAL evaluates a piecewise cubic Hermite interpolant.
!
!
! Discussion:
!
! SPLINE_HERMITE_SET must be called first, to set up the
! spline data from the raw function and derivative data.
!
! Reference:
!
! Conte and de Boor,
! Algorithm PCUBIC,
! Elementary Numerical Analysis,
! 1973, page 234.
!
! Modified:
!
! 06 April 1999
!
! Parameters:
!
! Input, integer NDATA, the number of data points.
! NDATA is assumed to be at least 2.
!
! Input, real TDATA(NDATA), the abscissas of the data points.
! The entries of TDATA are assumed to be strictly increasing.
!
! Input, real C(4,NDATA), contains the data computed by
! SPLINE_HERMITE_SET.
!
! Input, real TVAL, the point where the interpolant is to
! be evaluated.
!
! Output, real SVAL, the value of the interpolant at TVAL.
!
implicit none
!
integer ndata
!
real c(4,ndata)
real dt
integer left
integer right
real sval
real tdata(ndata)
real tval
!
! Find the interval [ TDATA(LEFT), TDATA(RIGHT) ] that contains
! or is nearest to TVAL.
!
call rvec_bracket ( ndata, tdata, tval, left, right )
!
! Evaluate the cubic polynomial.
!
dt = tval - tdata(left)
sval = c(1,left) + dt * ( c(2,left) + dt * ( c(3,left) + dt * c(4,left) ) )
return
end
subroutine spline_linear_int ( ndata, tdata, ydata, a, b, int_val )
!
!*******************************************************************************
!
!! SPLINE_LINEAR_INT evaluates the integral of a linear spline.
!
!
! Modified:
!
! 01 November 2001
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer NDATA, the number of data points defining the spline.
!
! Input, real TDATA(NDATA), YDATA(NDATA), the values of the independent
! and dependent variables at the data points. The values of TDATA should
! be distinct and increasing.
!
! Input, real A, B, the interval over which the integral is desired.
!
! Output, real INT_VAL, the value of the integral.
!
implicit none
!
integer ndata
!
real a
real a_copy
integer a_left
integer a_right
real b
real b_copy
integer b_left
integer b_right
integer i_left
real int_val
real tdata(ndata)
real tval
real ydata(ndata)
real yp
real yval
!
int_val = 0.0E+00
if ( a == b ) then
return
end if
a_copy = min ( a, b )
b_copy = max ( a, b )
!
! Find the interval [ TDATA(A_LEFT), TDATA(A_RIGHT) ] that contains, or is
! nearest to, A.
!
call rvec_bracket ( ndata, tdata, a_copy, a_left, a_right )
!
! Find the interval [ TDATA(B_LEFT), TDATA(B_RIGHT) ] that contains, or is
! nearest to, B.
!
call rvec_bracket ( ndata, tdata, b_copy, b_left, b_right )
!
! If A and B are in the same interval...
!
if ( a_left == b_left ) then
tval = ( a_copy + b_copy ) / 2.0E+00
yp = ( ydata(a_right) - ydata(a_left) ) / &
( tdata(a_right) - tdata(a_left) )
yval = ydata(a_left) + ( tval - tdata(a_left) ) * yp
int_val = yval * ( b_copy - a_copy )
return
end if
!
! Otherwise, integrate from:
!
! A to TDATA(A_RIGHT),
! TDATA(A_RIGHT) to TDATA(A_RIGHT+1),...
! TDATA(B_LEFT-1) to TDATA(B_LEFT),
! TDATA(B_LEFT) to B.
!
! Use the fact that the integral of a linear function is the
! value of the function at the midpoint times the width of the interval.
!
tval = ( a_copy + tdata(a_right) ) / 2.0E+00
yp = ( ydata(a_right) - ydata(a_left) ) / &
( tdata(a_right) - tdata(a_left) )
yval = ydata(a_left) + ( tval - tdata(a_left) ) * yp
int_val = int_val + yval * ( tdata(a_right) - a_copy )
do i_left = a_right, b_left - 1
tval = ( tdata(i_left+1) + tdata(i_left) ) / 2.0E+00
yp = ( ydata(i_left+1) - ydata(i_left) ) / &
( tdata(i_left+1) - tdata(i_left) )
yval = ydata(i_left) + ( tval - tdata(i_left) ) * yp
int_val = int_val + yval * ( tdata(i_left + 1) - tdata(i_left) )
end do
tval = ( tdata(b_left) + b_copy ) / 2.0E+00
yp = ( ydata(b_right) - ydata(b_left) ) / &
( tdata(b_right) - tdata(b_left) )
yval = ydata(b_left) + ( tval - tdata(b_left) ) * yp
int_val = int_val + yval * ( b_copy - tdata(b_left) )
if ( b < a ) then
int_val = - int_val
end if
return
end
subroutine spline_linear_intset ( int_n, int_x, int_v, data_n, data_x, data_y )
!
!*******************************************************************************
!
!! SPLINE_LINEAR_INTSET sets a linear spline with given integral properties.
!
!
! Discussion:
!
! The user has in mind an interval, divided by INT_N+1 points into
! INT_N intervals. A linear spline is to be constructed,
! with breakpoints at the centers of each interval, and extending
! continuously to the left of the first and right of the last
! breakpoints. The constraint on the linear spline is that it is
! required that it have a given integral value over each interval.
!
! A tridiagonal linear system of equations is solved for the
! values of the spline at the breakpoints.
!
! Modified:
!
! 02 November 2001
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer INT_N, the number of intervals.
!
! Input, real INT_X(INT_N+1), the points that define the intervals.
! Interval I lies between INT_X(I) and INT_X(I+1).
!
! Input, real INT_V(INT_N), the desired value of the integral of the
! linear spline over each interval.
!
! Output, integer DATA_N, the number of data points defining the spline.
! (This is the same as INT_N).
!
! Output, real DATA_X(DATA_N), DATA_Y(DATA_N), the values of the independent
! and dependent variables at the data points. The values of DATA_X are
! the interval midpoints. The values of DATA_Y are determined in such
! a way that the exact integral of the linear spline over interval I
! is equal to INT_V(I).
!
implicit none
!
integer int_n
!
real c(int_n)
real d(int_n)
integer data_n
real data_x(int_n)
real data_y(int_n)
real e(int_n)
integer info
real int_v(int_n)
real int_x(int_n+1)
!
! Set up the easy stuff.
!
data_n = int_n
data_x(1:data_n) = 0.5E+00 * ( int_x(1:data_n) + int_x(2:data_n+1) )
!
! Set up C, D, E, the coefficients of the linear system.
!
c(1) = 0.0E+00
c(2:data_n-1) = 1.0 &
- ( 0.5 * ( data_x(2:data_n-1) + int_x(2:data_n-1) ) &
- data_x(1:data_n-2) ) &
/ ( data_x(2:data_n-1) - data_x(1:data_n-2) )
c(data_n) = 0.0E+00
d(1) = int_x(2) - int_x(1)
d(2:data_n-1) = 1.0 &
+ ( 0.5 * ( data_x(2:data_n-1) + int_x(2:data_n-1) ) &
- data_x(1:data_n-2) ) &
/ ( data_x(2:data_n-1) - data_x(1:data_n-2) ) &
- ( 0.5 * ( data_x(2:data_n-1) + int_x(3:data_n) ) - data_x(2:data_n-1) ) &
/ ( data_x(3:data_n) - data_x(2:data_n-1) )
d(data_n) = int_x(data_n+1) - int_x(data_n)
e(1) = 0.0E+00
e(2:data_n-1) = ( 0.5 * ( data_x(2:data_n-1) + int_x(3:data_n) ) &
- data_x(2:data_n-1) ) / ( data_x(3:data_n) - data_x(2:data_n-1) )
e(data_n) = 0.0E+00
!
! Set up DATA_Y, which begins as the right hand side of the linear system.
!
data_y(1) = int_v(1)
data_y(2:data_n-1) = 2.0E+00 * int_v(2:data_n-1) &
/ ( int_x(3:int_n) - int_x(2:int_n-1) )
data_y(data_n) = int_v(data_n)
!
! Solve the linear system.
!
call sgtsl ( data_n, c, d, e, data_y, info )
if ( info /= 0 ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'SPLINE_LINEAR_INTSET - Fatal error!'
write ( *, '(a)' ) ' The linear system is singular.'
stop
end if
return
end
subroutine spline_linear_val ( ndata, tdata, ydata, tval, yval, ypval )
!
!*******************************************************************************
!
!! SPLINE_LINEAR_VAL evaluates a linear spline at a specific point.
!
!
! Discussion:
!
! Because of the extremely simple form of the linear spline,
! the raw data points ( TDATA(I), YDATA(I)) can be used directly to
! evaluate the spline at any point. No processing of the data
! is required.
!
! Modified:
!
! 06 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer NDATA, the number of data points defining the spline.
!
! Input, real TDATA(NDATA), YDATA(NDATA), the values of the independent
! and dependent variables at the data points. The values of TDATA should
! be distinct and increasing.
!
! Input, real TVAL, the point at which the spline is to be evaluated.
!
! Output, real YVAL, YPVAL, the value of the spline and its first
! derivative dYdT at TVAL. YPVAL is not reliable if TVAL is exactly
! equal to TDATA(I) for some I.
!
implicit none
!
integer ndata
!
integer left
integer right
real tdata(ndata)
real tval
real ydata(ndata)
real ypval
real yval
!
! Find the interval [ TDATA(LEFT), TDATA(RIGHT) ] that contains, or is
! nearest to, TVAL.
!
call rvec_bracket ( ndata, tdata, tval, left, right )
!
! Now evaluate the piecewise linear function.
!
ypval = ( ydata(right) - ydata(left) ) / ( tdata(right) - tdata(left) )
yval = ydata(left) + ( tval - tdata(left) ) * ypval
return
end
subroutine spline_overhauser_nonuni_val ( ndata, tdata, ydata, tval, yval )
!
!*******************************************************************************
!
!! SPLINE_OVERHAUSER_NONUNI_VAL evaluates the nonuniform Overhauser spline.
!
!
! Discussion:
!
! The nonuniformity refers to the fact that the abscissas values
! need not be uniformly spaced.
!
! Diagnostics:
!
! The values of ALPHA and BETA have to be properly assigned.
! The basis matrices for the first and last interval have to
! be computed.
!
! Modified:
!
! 06 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer NDATA, the number of data points.
!
! Input, real TDATA(NDATA), the abscissas of the data points.
! The values of TDATA are assumed to be distinct and increasing.
!
! Input, real YDATA(NDATA), the data values.
!
! Input, real TVAL, the value where the spline is to
! be evaluated.
!
! Output, real YVAL, the value of the spline at TVAL.
!
implicit none
!
integer ndata
!
real alpha
real beta
integer left
real mbasis(4,4)
real mbasis_l(3,3)
real mbasis_r(3,3)
integer right
real tdata(ndata)
real tval
real ydata(ndata)
real yval
!
! Find the nearest interval [ TDATA(LEFT), TDATA(RIGHT) ] to TVAL.
!
call rvec_bracket ( ndata, tdata, tval, left, right )
!
! Evaluate the spline in the given interval.
!
if ( left == 1 ) then
alpha = 1.0E+00
call basis_matrix_overhauser_nul ( alpha, mbasis_l )
call basis_matrix_tmp ( 1, 3, mbasis_l, ndata, tdata, ydata, tval, yval )
else if ( left < ndata-1 ) then
alpha = 1.0E+00
beta = 1.0E+00
call basis_matrix_overhauser_nonuni ( alpha, beta, mbasis )
call basis_matrix_tmp ( left, 4, mbasis, ndata, tdata, ydata, tval, yval )
else if ( left == ndata-1 ) then
beta = 1.0E+00
call basis_matrix_overhauser_nur ( beta, mbasis_r )
call basis_matrix_tmp ( left, 3, mbasis_r, ndata, tdata, ydata, tval, yval )
end if
return
end
subroutine spline_overhauser_uni_val ( ndata, tdata, ydata, tval, yval )
!
!*******************************************************************************
!
!! SPLINE_OVERHAUSER_UNI_VAL evaluates the uniform Overhauser spline.
!
!
! Modified:
!
! 06 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer NDATA, the number of data points.
!
! Input, real TDATA(NDATA), the abscissas of the data points.
! The values of TDATA are assumed to be distinct and increasing.
! This routine also assumes that the values of TDATA are uniformly
! spaced; for instance, TDATA(1) = 10, TDATA(2) = 11, TDATA(3) = 12...
!
! Input, real YDATA(NDATA), the data values.
!
! Input, real TVAL, the value where the spline is to
! be evaluated.
!
! Output, real YVAL, the value of the spline at TVAL.
!
implicit none
!
integer ndata
!
integer left
real mbasis(4,4)
real mbasis_l(3,3)
real mbasis_r(3,3)
integer right
real tdata(ndata)
real tval
real ydata(ndata)
real yval
!
! Find the nearest interval [ TDATA(LEFT), TDATA(RIGHT) ] to TVAL.
!
call rvec_bracket ( ndata, tdata, tval, left, right )
!
! Evaluate the spline in the given interval.
!
if ( left == 1 ) then
call basis_matrix_overhauser_uni_l ( mbasis_l )
call basis_matrix_tmp ( 1, 3, mbasis_l, ndata, tdata, ydata, tval, yval )
else if ( left < ndata-1 ) then
call basis_matrix_overhauser_uni ( mbasis )
call basis_matrix_tmp ( left, 4, mbasis, ndata, tdata, ydata, tval, yval )
else if ( left == ndata-1 ) then
call basis_matrix_overhauser_uni_r ( mbasis_r )
call basis_matrix_tmp ( left, 3, mbasis_r, ndata, tdata, ydata, tval, yval )
end if
return
end
subroutine spline_overhauser_val ( ndim, ndata, tdata, ydata, tval, yval )
!
!*******************************************************************************
!
!! SPLINE_OVERHAUSER_VAL evaluates an Overhauser spline.
!
!
! Discussion:
!
! Over the first and last intervals, the Overhauser spline is a
! quadratic. In the intermediate intervals, it is a piecewise cubic.
! The Overhauser spline is also known as the Catmull-Rom spline.
!
! Reference:
!
! H Brewer and D Anderson,
! Visual Interaction with Overhauser Curves and Surfaces,
! SIGGRAPH 77, pages 132-137.
!
! E Catmull and R Rom,
! A Class of Local Interpolating Splines,
! in Computer Aided Geometric Design,
! edited by R Barnhill and R Reisenfeld,
! Academic Press, 1974, pages 317-326.
!
! David Rogers and Alan Adams,
! Mathematical Elements of Computer Graphics,
! McGraw Hill, 1990, Second Edition, pages 278-289.
!
! Modified:
!
! 08 April 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer NDIM, the dimension of a single data point.
! NDIM must be at least 1. There is an internal limit on NDIM,
! called MAXDIM, which is presently set to 5.
!
! Input, integer NDATA, the number of data points.
! NDATA must be at least 3.
!
! Input, real TDATA(NDATA), the abscissas of the data points. The
! values in TDATA must be in strictly ascending order.
!
! Input, real YDATA(NDIM,NDATA), the data points corresponding to
! the abscissas.
!
! Input, real TVAL, the abscissa value at which the spline
! is to be evaluated. Normally, TDATA(1) <= TVAL <= T(NDATA), and
! the data will be interpolated. For TVAL outside this range,
! extrapolation will be used.
!
! Output, real YVAL(NDIM), the value of the spline at TVAL.
!
implicit none
!
integer, parameter :: MAXDIM = 5
integer ndata
integer ndim
!
integer i
integer left
integer order
integer right
real tdata(ndata)
real tval
real ydata(ndim,ndata)
real yl(MAXDIM)
real yr(MAXDIM)
real yval(ndim)
!
! Check.
!
call rvec_order_type ( ndata, tdata, order )
if ( order /= 2 ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'SPLINE_OVERHAUSER_VAL - Fatal error!'
write ( *, '(a)' ) ' The data abscissas are not strictly ascending.'
stop
end if
if ( ndata < 3 ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'SPLINE_OVERHAUSER_VAL - Fatal error!'
write ( *, '(a)' ) ' NDATA < 3.'
stop
end if
if ( ndim < 1 ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'SPLINE_OVERHAUSER_VAL - Fatal error!'
write ( *, '(a)' ) ' NDIM < 1.'
stop
end if
if ( ndim > maxdim ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'SPLINE_OVERHAUSER_VAL - Fatal error!'
write ( *, '(a)' ) ' NDIM > MAXDIM.'
stop
end if
!
! Locate the abscissa interval T(LEFT), T(LEFT+1) nearest to or
! containing TVAL.
!
call rvec_bracket ( ndata, tdata, tval, left, right )
!
! Evaluate the "left hand" quadratic defined at T(LEFT-1), T(LEFT), T(RIGHT).
!
if ( left-1 > 0 ) then
call parabola_val2 ( ndim, ndata, tdata, ydata, left-1, tval, yl )
end if
!
! Evaluate the "right hand" quadratic defined at T(LEFT), T(RIGHT), T(RIGHT+1).
!
if ( right+1 <= ndata ) then
call parabola_val2 ( ndim, ndata, tdata, ydata, left, tval, yr )
end if
!
! Average the quadratics.
!
if ( left == 1 ) then
yval(1:ndim) = yr(1:ndim)
else if ( right < ndata ) then
yval(1:ndim) = ( ( tdata(right) - tval ) * yl(1:ndim) &
+ ( tval - tdata(left) ) * yr(1:ndim) ) / ( tdata(right) - tdata(left) )
else
yval(1:ndim) = yl(1:ndim)
end if
return
end
subroutine spline_quadratic_val ( ndata, tdata, ydata, tval, yval, ypval )
!
!*******************************************************************************
!
!! SPLINE_QUADRATIC_VAL evaluates a quadratic spline at a specific point.
!
!
! Discussion:
!
! Because of the simple form of a piecewise quadratic spline,
! the raw data points ( TDATA(I), YDATA(I)) can be used directly to
! evaluate the spline at any point. No processing of the data
! is required.
!
! Modified:
!
! 24 October 1999
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! Input, integer NDATA, the number of data points defining the spline.
! NDATA should be odd.
!
! Input, real TDATA(NDATA), YDATA(NDATA), the values of the independent
! and dependent variables at the data points. The values of TDATA should
! be distinct and increasing.
!
! Input, real TVAL, the point at which the spline is to be evaluated.
!
! Output, real YVAL, YPVAL, the value of the spline and its first
! derivative dYdT at TVAL. YPVAL is not reliable if TVAL is exactly
! equal to TDATA(I) for some I.
!
implicit none
!
integer ndata
!
real dif1
real dif2
integer left
integer right
real t1
real t2
real t3
real tdata(ndata)
real tval
real y1
real y2
real y3
real ydata(ndata)
real ypval
real yval
!
if ( mod ( ndata, 3 ) == 0 ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'SPLINE_QUADRATIC_VAL - Fatal error!'
write ( *, '(a)' ) ' NDATA must be odd.'
stop
end if
!
! Find the interval [ TDATA(LEFT), TDATA(RIGHT) ] that contains, or is
! nearest to, TVAL.
!
call rvec_bracket ( ndata, tdata, tval, left, right )
!
! Force LEFT to be odd.
!
if ( mod ( left, 2 ) == 0 ) then
left = left - 1
end if
!
! Copy out the three abscissas.
!
t1 = tdata(left)
t2 = tdata(left+1)
t3 = tdata(left+2)
if ( t1 >= t2 .or. t2 >= t3 ) then
write ( *, '(a)' ) ' '
write ( *, '(a)' ) 'SPLINE_QUADRATIC_VAL - Fatal error!'
write ( *, '(a)' ) ' T1 >= T2 or T2 >= T3.'
stop
end if
!
! Construct and evaluate a parabolic interpolant for the data
! in each dimension.
!
y1 = ydata(left)
y2 = ydata(left+1)
y3 = ydata(left+2)
dif1 = ( y2 - y1 ) / ( t2 - t1 )
dif2 = ( ( y3 - y1 ) / ( t3 - t1 ) &
- ( y2 - y1 ) / ( t2 - t1 ) ) / ( t3 - t2 )
yval = y1 + ( tval - t1 ) * ( dif1 + ( tval - t2 ) * dif2 )
ypval = dif1 + dif2 * ( 2.0E+00 * tval - t1 - t2 )
return
end
subroutine timestamp ( )
!
!*******************************************************************************
!
!! TIMESTAMP prints the current YMDHMS date as a time stamp.
!
!
! Example:
!
! May 31 2001 9:45:54.872 AM
!
! Modified:
!
! 31 May 2001
!
! Author:
!
! John Burkardt
!
! Parameters:
!
! None
!
implicit none
!
character ( len = 8 ) ampm
integer d
character ( len = 8 ) date
integer h
integer m
integer mm
character ( len = 9 ), parameter, dimension(12) :: month = (/ &
'January ', 'February ', 'March ', 'April ', &
'May ', 'June ', 'July ', 'August ', &
'September', 'October ', 'November ', 'December ' /)
integer n
integer s
character ( len = 10 ) time
integer values(8)
integer y
character ( len = 5 ) zone
!
call date_and_time ( date, time, zone, values )
y = values(1)
m = values(2)
d = values(3)
h = values(5)
n = values(6)
s = values(7)
mm = values(8)
if ( h < 12 ) then
ampm = 'AM'
else if ( h == 12 ) then
if ( n == 0 .and. s == 0 ) then
ampm = 'Noon'
else
ampm = 'PM'
end if
else
h = h - 12
if ( h < 12 ) then
ampm = 'PM'
else if ( h == 12 ) then
if ( n == 0 .and. s == 0 ) then
ampm = 'Midnight'
else
ampm = 'AM'
end if
end if
end if
write ( *, '(a,1x,i2,1x,i4,2x,i2,a1,i2.2,a1,i2.2,a1,i3.3,1x,a)' ) &
trim ( month(m) ), d, y, h, ':', n, ':', s, '.', mm, trim ( ampm )
return
end
