The trapezium method is a classic technique for approximating the definite integral of a function

Figure 8.2. The area under the curve between f (x) and the x-axis.

In the trapezium method, the x interval in a ≤ x ≤ b is divided into m equal-width subintervals, each with width h. A straight line is connected from (x_i, f (x_i)) to (x_i+1, f (x_i+1)) in the subinterval [x_i, x_i+1], and this forms a trapezium with f (x_i) and f (x_i+1) as the parallel sides whose distance between them is h. The area under the curve in this subinterval is then approximated as the area of the trapezium, given as

Equation 8.13. 

With m subintervals,

Equation 8.6. 

Equation (8.6) gives the trapezium method for finding the definite integral of a function f (x) in the interval from x = a to x = b with m equal subintervals. The method is illustrated in Figure 8.3 using four equal subintervals. From the figure, it is clear that

Figure 8.3. The trapezium method with four subintervals.

Equation 8.15. 

Example 8.2. Find

Solution. In this problem, m = 9, x₀ = 0, and x_m = 3. The width of each subinterval is

Therefore,

The trapezium method uses a straight line approximation on two successive f (x) values in the subintervals for evaluating

The accuracy of the trapezium method can be improved by replacing the straight line with a quadratic function. This idea makes sense as a quadratic curve lies closer to the real curve in the given function than a straight line. Since a quadratic function requires three points for interpolation, the method suggests pairs of two subintervals in the approximation. The approach is called the Simpson method.

As the Simpson method requires two subintervals in each pair, the total number of subintervals in the given interval must be an even number. Consider the subintervals [x_i, x_i+1] and [x_i+1, x_i+2], which involve the points, (x_i, f (x_i)), (x_i+1, f (x_i+1)), and (x_i+2, f (x_i+2)). Figure 8.4 shows this scenario with the dotted curve as the quadratic approximation to the real curve. This curve has an equation given by

Equation 8.16. 

Figure 8.4. Quadratic polynomial fitting on two subintervals in the Simpson's method.

where a₀, a₁, and a₂ are the constants that are to be determined. The quadratic curve interpolates (x_i, y _i), (x_{i +1}, y_i+1) and (x_{i +2}, y_i+2). This produces a system of linear equations, given as

Equation 8.17. 

The above system is solved to produce the Simpson's formula, given by

Equation 8.7. 

Equation (8.7) can be extended into the case of m even subintervals for x = x₀ to x = x _m. The total area is found as a sum of m/2 subareas, where each subarea combines two subintervals. Applying Equation (8.7), we obtain the Simpson's method for m subintervals, as follows:

Equation 8.8. 

Example 8.3. Find

Solution. In this problem, m = 9, x₀ = 0, x _m = 3, and

Equation 8.20. 

An extension to the Simpson's method is the Simpson's 3/8 method. In this method, three subintervals are combined to produce one subarea based on a cubic polynomial. This approach requires four points for each subarea, and therefore, it provides a more accurate approximation to the problem. With three subintervals for each subarea, the total number of subintervals in the Simpson's 3/8 method becomes a multiple of three.

Interpolation over four points for each subarea in the Simpson's 3/8 method produces a system of four linear equations. The interpolating curve is a cubic polynomial given by

Equation 8.21. 

where a₀, a₁, and a₂ are constants. The above curve interpolates (x_i, y _i), (x_{i +1}, y_i+1), (x_{i +2}, y_i+2), and (x_{i +3}, y_i+3) to produce an approximated subarea, given by

Equation 8.9. 

With m subintervals, Equation (8.9) can be extended to produce

Equation 8.10. 

Example 8.4. Find

Solution. In this problem, m = 9, x₀ = 0, x _m = 3, and

Equation 8.24. 

The three methods outlined above are applicable to problems whose data are normally given in discrete form. Quite often data are given in the form of a function f (x) whose integral is difficult to find. A method called the Gaussian quadrature specializes in tackling this kind of problem. The method is based on an approximation on Legendre polynomials.

A Legendre polynomial of degree n is given in the form of an ordinary differential equation of order n, as follows:

Equation 8.11. 

Table 8.2 lists some Legendre polynomials of lower degrees. Legendre polynomials have the characteristics of being orthogonal over x ɛ (−1, 1) and satisfy

Equation 8.26. 

where δ_mn is the Kronecker delta, which is 1 if m = n, and 0 otherwise.

The Gaussian quadrature method consists of two major steps. First, the integral

Equation 8.12. 

where g(t) is a new function that is continuous in −1 ≤ t ≤ 1. It can be verified that substituting x = a and x = b into the linear equation produces t = −1 and t = 1, respectively. The transformation preserves the area under the curve in

Equation 8.28. 

Figure 8.5. Transformation from

to

in the Gauss-Legendre method.

The integral becomes

Equation 8.29. 

This gives the relationship between the f (x) and g (t) as

Equation 8.13. 

The second step in this method consists of an approximation to the integral

Equation 8.14. 

The above equation is called the n-point Gauss quadrature, where n is an integer number greater than 1. The constant w_i is called the weight, whereas t_i is the argument in the quadrature. The argument t_i in Equation (8.14) is actually a root of the Legendre polynomial given in Table 8.1.

Equation (8.14) suggests the original problem is approximated as a sum of n quadratures whose weights and arguments are determined from the quadrature properties. The weights and arguments of some of the Gaussian quadrature are tabulated in Table 8.3.

Example 8.5. Find

Table 8.3. Weights and arguments in the Gaussian quadrature

n	Weight, wi	Argument, ti
2	w1 = 1 w2 = 1
3	w1 = 0.555556 w2 = 0.888889 w3 = 0.555556	t2 = 0
4	w1 = 0.347855 w2 = 0.652145 w3 = 0.652145 w4 = 0.347855	t1 = −0.861136 t2 = −0.339981 t3 = 0.339981 t4 = 0.861136
5	w1 = 0.236927 w2 = 0.478629 w3 = 0.568889 w4 = 0.478629 w5 = 0.236927	t1 = −0.90610 t2 = −0.538469 t3 = 0 t4 = 0.538469 t5 = 0.90610

Solution. We have

Equation 8.32. 

We get

Equation 8.33. 

Therefore,

Equation 8.34. 

The solution to a differentiation problem is handled by Differentiation(). The function evaluates the first and second derivatives of the given function at (x_i, y_i), for i = 1, 2, ..., m − 1, using the central-difference rules as given by Equations (8.5a) and (8.5b). The function is given by

void CCode8::Differentiation()
{
      int i, psi[6];
      double psv[6];
      CString str;
      fStatus=1;
      pt[0].x=atof(input[3].item);
      h=atof(input[2].item);
      m=(int)(atof(input[4].item)-atof(input[3].item))/h;
      m=((m<M)?m:M);
      pt[m].x=pt[0].x+(double)m*h;
      psi[1]=23; psv[1]=pt[0].x;
      pt[0].y=parse(input[1].item, 1, psv, psi);
      for (i=0;i<=m;i++)
            if (i<m)
            {
                  pt[i+1].x=pt[i].x+h;
                  psv[1]=pt[i+1].x;
                  pt[i+1].y=parse(input[1].item, 1, psv, psi);
                  if (i>0)
                  {
                        pt[i].yd1=(pt[i+1].y-pt[i-1].y)/(2*h);
                        pt[i].yd2=(pt[i+1].y-2*pt[i].y
                                   +pt[i-1].y)/(h*h);
                  }
            }
}

In Differentiation(), the input string is read as input[1].item. The first derivative is represented by pt[i].yd1, whereas the second is pt[i].yd2. With the central-difference rules, no derivatives can be evaluated at (x ₀, y₀) and (x_m, y_m) as the solution requires one-point forward and one-point backward. Differentiation() computes the first and second derivatives of the input function f (x) that is read as input[1].item. The derivatives are computed at each point (x_i, y_i), which is represented by pt[i].x and pt[i].y in the coding.

A function called Integration() handles the solution to the integration problem using the trapezium, Simpson, and Gaussian quadrature methods. The Simpson and Simpson's 3/8 methods produce the results correctly when the number of input subintervals m is a multiple of two and three, respectively. The function is given by

void CCode8::Integration()
{
      int i, psi[2];
      double psv[2];
      aTrap=0; aSimp=0; aSimp38=0; aGL=0;
      fStatus=1;
      pt[0].x=atof(input[3].item);
      m=atoi(input[2].item); m=((m<M)?m:M);
      h=(atof(input[4].item)-atof(input[3].item))/(double)m;
      pt[m].x=pt[0].x+(double)m*h;
      psi[1]=23;
      for (i=0;i<=m;i++)
      {
            psv[1]=pt[i].x;
            pt[i].y=parse(input[1].item, 1, psv, psi);
            if (i<0 && i<m)
            {
                  aTrap += 2*pt[i].y;
                  if (m%2==0)
                  {
                        if (i%2==1)
                        aSimp += 4*pt[i].y;
                        if (i%2==0)
                        aSimp += 2*pt[i].y;
                  }
                  if (m%3==0)
                  {
                        if (i%3==0)
                        aSimp38 += 2*pt[i].y;
                        else
                        aSimp38 += 3*pt[i].y;
                  }
            }
            if (i<m)
                  pt[i+1].x=pt[i].x+h;
            }
            aTrap += pt[0].y+pt[m].y;
            aTrap *= h/2;
            if (m%2==0)
            {
                  aSimp += pt[0].y+pt[m].y;
                  aSimp *= h/3;
            }
            if (m%3==0)

{
                  aSimp38 += pt[0].y+pt[m].y;
                  aSimp38 *= 3*h/8;
            }
            double g1, g2, g3, t1, t2, t3, a, b;
            a=pt[0].x; b=pt[m].x;
            t1=−0.774597; psv[1]=((b-a)*t1+(b+a))/2;
            g1=(b-a)/2*parse(input[1].item, 1, psv, psi);
            t2=0; psv[1]=((b-a)*t2+(b+a))/2;
            g2=(b-a)/2*parse(input[1].item, 1, psv, psi);
            t3=0.774597; psv[1]=((b-a)*t3+(b+a))/2;
            g3=(b-a)/2*parse(input[1].item, 1, psv, psi);
            aGL=5*g1/9+8*g2/9+5*g3/9;
}

The number of subintervals m is denoted as m in the coding. The maximum number allowed is 200, which is stored as the macro M. A simple statement can be added to the code to control the user's input so that this maximum value is not breached, through

m=atoi(input[2].item); m=((m<M)?m:M);

The trapezium and Simpson methods are solved by performing iterations from i = 0 to i = m. Because of their constraints, the points in the Simpson and Simpson's 3/8 methods become relevant through the expressions m%2=0 and m%3=0, which indicate the multiplicity of two and three, respectively. The following code fragments show how the three methods are handled:

for (i=0;i<=m;i++)
{
      psv[1]=pt[i].x;
      pt[i].y=parse(input[1].item, 1, psv, psi);
      if (i<0 && i<m)
      {
            aTrap += 2*pt[i].y;
            if (m%2==0)
            {
                  if (i%2==1)
                  aSimp += 4*pt[i].y;
                  if (i%2==0)
                  aSimp += 2*pt[i].y;
            }
            if (m%3==0)
            {
                  if (i%3==0)
                  aSimp38 += 2*pt[i].y;
                  else

aSimp38 += 3*pt[i].y;
            }
      }
      if (i<m)
            pt[i+1].x=pt[i].x+h;
}
aTrap += pt[0].y+pt[m].y;
aTrap *= h/2;
if (m%2==0)
{
      aSimp += pt[0].y+pt[m].y;
      aSimp *= h/3;
}
if (m%3==0)
{
      aSimp38 += pt[0].y+pt[m].y;
      aSimp38 *= 3*h/8;
}

The Gauss quadrature three-point method involves a transformation of coordinates from x to t through the relationship given by Equation (8.12). The method is handled through the following code fragments:

double g1, g2, g3, t1, t2, t3, a, b;
a=pt[0].x; b=pt[m].x;
t1=−0.774597; psv[1]=((b-a)*t1+(b+a))/2;
g1=(b-a)/2*parse(input[1].item, 1, psv, psi);
t2=0; psv[1]=((b-a)*t2+(b+a))/2;
g2=(b-a)/2*parse(input[1].item, 1, psv, psi);
t3=0.774597; psv[1]=((b-a)*t3+(b+a))/2;
g3=(b-a)/2*parse(input[1].item, 1, psv, psi);
aGL=5*g1/9+8*g2/9+5*g3/9;

Output in Code8 is expressed as the iterated values in a list view table and is plotted as graphs. The functions for these operations are ShowTable() and DrawCurve(), which are quite similar to the functions of the same names in the previous chapters. In DrawCurve(), two additional curves are plotted on top of the graph of y = f(x). They are the graphs of the first-derivative y' = f'(x) and the second-derivative y" = f"(x). The three graphs are plotted in the same window to illustrate their relationship at the points.