TSpline5

class TSpline5 : public TSpline

    private:

              void BoundaryConditions(const char* opt, Int_t& beg, Int_t& end, const char*& cb1, const char*& ce1, const char*& cb2, const char*& ce2)
      virtual void BuildCoeff()
              void SetBoundaries(Double_t b1, Double_t e1, Double_t b2, Double_t e2, const char* cb1, const char* ce1, const char* cb2, const char* ce2)

    public:

              TSpline5 TSpline5()
              TSpline5 TSpline5(const char* title, Double_t* x, Double_t* y, Int_t n, const char* opt = 0, Double_t b1 = 0, Double_t e1 = 0, Double_t b2 = 0, Double_t e2 = 0)
              TSpline5 TSpline5(const char* title, Double_t xmin, Double_t xmax, Double_t* y, Int_t n, const char* opt = 0, Double_t b1 = 0, Double_t e1 = 0, Double_t b2 = 0, Double_t e2 = 0)
              TSpline5 TSpline5(const char* title, Double_t* x, TF1* func, Int_t n, const char* opt = 0, Double_t b1 = 0, Double_t e1 = 0, Double_t b2 = 0, Double_t e2 = 0)
              TSpline5 TSpline5(const char* title, Double_t xmin, Double_t xmax, TF1* func, Int_t n, const char* opt = 0, Double_t b1 = 0, Double_t e1 = 0, Double_t b2 = 0, Double_t e2 = 0)
              TSpline5 TSpline5(const char* title, TGraph* g, const char* opt = 0, Double_t b1 = 0, Double_t e1 = 0, Double_t b2 = 0, Double_t e2 = 0)
              TSpline5 TSpline5(TSpline5&)
          virtual void ~TSpline5()
        static TClass* Class()
      virtual Double_t Eval(Double_t x) const
                  void GetCoeff(Int_t i, Double_t& x, Double_t& y, Double_t& b, Double_t& c, Double_t& d, Double_t& e, Double_t& f)
          virtual void GetKnot(Int_t i, Double_t& x, Double_t& y) const
       virtual TClass* IsA() const
          virtual void ShowMembers(TMemberInspector& insp, char* parent)
          virtual void Streamer(TBuffer& b)
                  void StreamerNVirtual(TBuffer& b)
           static void Test()

  Data Members
    private:

      TSplinePoly5* fPoly  Array of polynomial terms

Class Description

                                                                      
 TSpline                                                              
                                                                      
 Base class for spline implementation containing the Draw/Paint       
 methods                                                              
                                                                      

 Quintic natural spline creator given an array of
 arbitrary knots in increasing abscissa order and
 possibly end point conditions

 Quintic natural spline creator given an array of
 arbitrary function values on equidistant n abscissa
 values from xmin to xmax and possibly end point conditions

 Quintic natural spline creator given an array of
 arbitrary abscissas in increasing order and a function
 to interpolate and possibly end point conditions

 Quintic natural spline creator given a function to be
 evaluated on n equidistand abscissa points between xmin
 and xmax and possibly end point conditions

 Quintic natural spline creator given a TGraph with
 abscissa in increasing order and possibly end
 point conditions

 Check the boundary conditions and the
 amount of extra double knots needed

 Set the boundary conditions at double/triple knots

 Evaluate spline polynomial

     algorithm 600, collected algorithms from acm.
     algorithm appeared in acm-trans. math. software, vol.9, no. 2,
     jun., 1983, p. 258-259.

     TSpline5 computes the coefficients of a quintic natural quintic spli
     s(x) with knots x(i) interpolating there to given function values:
               s(x(i)) = y(i)  for i = 1,2, ..., n.
     in each interval (x(i),x(i+1)) the spline function s(xx) is a
     polynomial of fifth degree:
     s(xx) = ((((f(i)*p+e(i))*p+d(i))*p+c(i))*p+b(i))*p+y(i)    (*)
           = ((((-f(i)*q+e(i+1))*q-d(i+1))*q+c(i+1))*q-b(i+1))*q+y(i+1)
     where  p = xx - x(i)  and  q = x(i+1) - xx.
     (note the first subscript in the second expression.)
     the different polynomials are pieced together so that s(x) and
     its derivatives up to s"" are continuous.

        input:

     n          number of data points, (at least three, i.e. n > 2)
     x(1:n)     the strictly increasing or decreasing sequence of
                knots.  the spacing must be such that the fifth power
                of x(i+1) - x(i) can be formed without overflow or
                underflow of exponents.
     y(1:n)     the prescribed function values at the knots.

        output:

     b,c,d,e,f  the computed spline coefficients as in (*).
         (1:n)  specifically
                b(i) = s'(x(i)), c(i) = s"(x(i))/2, d(i) = s"'(x(i))/6,
                e(i) = s""(x(i))/24,  f(i) = s""'(x(i))/120.
                f(n) is neither used nor altered.  the five arrays
                b,c,d,e,f must always be distinct.

        option:

     it is possible to specify values for the first and second
     derivatives of the spline function at arbitrarily many knots.
     this is done by relaxing the requirement that the sequence of
     knots be strictly increasing or decreasing.  specifically:

     if x(j) = x(j+1) then s(x(j)) = y(j) and s'(x(j)) = y(j+1),
     if x(j) = x(j+1) = x(j+2) then in addition s"(x(j)) = y(j+2).

     note that s""(x) is discontinuous at a double knot and, in
     addition, s"'(x) is discontinuous at a triple knot.  the
     subroutine assigns y(i) to y(i+1) in these cases and also to
     y(i+2) at a triple knot.  the representation (*) remains
     valid in each open interval (x(i),x(i+1)).  at a double knot,
     x(j) = x(j+1), the output coefficients have the following values:
       y(j) = s(x(j))          = y(j+1)
       b(j) = s'(x(j))         = b(j+1)
       c(j) = s"(x(j))/2       = c(j+1)
       d(j) = s"'(x(j))/6      = d(j+1)
       e(j) = s""(x(j)-0)/24     e(j+1) = s""(x(j)+0)/24
       f(j) = s""'(x(j)-0)/120   f(j+1) = s""'(x(j)+0)/120
     at a triple knot, x(j) = x(j+1) = x(j+2), the output
     coefficients have the following values:
       y(j) = s(x(j))         = y(j+1)    = y(j+2)
       b(j) = s'(x(j))        = b(j+1)    = b(j+2)
       c(j) = s"(x(j))/2      = c(j+1)    = c(j+2)
       d(j) = s"'((x(j)-0)/6    d(j+1) = 0  d(j+2) = s"'(x(j)+0)/6
       e(j) = s""(x(j)-0)/24    e(j+1) = 0  e(j+2) = s""(x(j)+0)/24
       f(j) = s""'(x(j)-0)/120  f(j+1) = 0  f(j+2) = s""'(x(j)+0)/120

 Test method for TSpline5


   n          number of data points.
   m          2*m-1 is order of spline.
                 m = 3 always for quintic spline.
   nn,nm1,mm,
   mm1,i,k,
   j,jj       temporary integer variables.
   z,p        temporary double precision variables.
   x[n]       the sequence of knots.
   y[n]       the prescribed function values at the knots.
   a[200][6]  two dimensional array whose columns are
                 the computed spline coefficients
   diff[5]    maximum values of differences of values and
                 derivatives to right and left of knots.
   com[5]     maximum values of coefficients.


   test of TSpline5 with nonequidistant knots and
      equidistant knots follows.

 Stream an object of class TSpline5.

Inline Functions

           TSpline5 TSpline5(const char* title, TGraph* g, const char* opt = 0, Double_t b1 = 0, Double_t e1 = 0, Double_t b2 = 0, Double_t e2 = 0)
               void GetCoeff(Int_t i, Double_t& x, Double_t& y, Double_t& b, Double_t& c, Double_t& d, Double_t& e, Double_t& f)
               void GetKnot(Int_t i, Double_t& x, Double_t& y) const
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void StreamerNVirtual(TBuffer& b)
           TSpline5 TSpline5(TSpline5&)
               void ~TSpline5()