The benefit of using a type of quadrature is that it allows you to solve rather difficult integrations.  This is done by finding a polynomial interpolation of the given function then integrating the resulting polynomial.  It makes difficult integrations possible, well at least they are usually a fairly good estimation.

Rectangle Method (for integration)

If you are unable to determine the polynomial interpolation of a function, there is an alternative.  You can use something called the Rectangle Method.  What it does is it divides the graph of the equation into many rectangles.  There are three different types of rectangles that you can use.  They are the right hand, left hand, and midpoint rectangles.  If we let (a,b) be the limits of integration and n as the number of rectangles over the interval, the rectangles have a width of:  Δ = (b − a) / n.  Let us assume x₁ and x₂ make up a sub-interval of (a,b), then the heights of the rectangles are based on what type of rectangle you are using:

Height of Rectangles

• Left Hand : Top left corner of rectangle, h=f(x₁)
• Right Hand : Top right corner of rectangle, h=f(x₂)
• Midpoint : h=f(x₂ + x₁ / 2)

For an easy example, suppose you have a rectangle whose width is from x=1 to x=1.1, then the heights of the rectangles would be:

• LH : h=f(1)
• RH : h=f(1.1)
• MP : h=f(1.1+1/2)=f(2.1/2)=f(1.05)

Here are some examples of what a function looks like broken up into rectangles (from Wikipedia):

Now that we have the height and width of the rectangle, we know the area of the rectangle is HxW.  We repeat each step to find the area of every other rectangle to find an approximation of the definite integral.  Our approximation becomes more and more accurate when we increase the total number of sub-intervals.

Here is a code from Wikipedia that utilizes the midpoint rectangles:

function [I] = riemann(f,a,b,n)
%f=name of function, a=start value, b=end value, n=number of
%iterations
%made by Carolina, Niklas, Benjamin and Damiano
h=(b-a)./n;
S=f(a);
i=1:1:n-1;
x=a+h.*i;
y=f(x);
S=S+sum(y);
S=S+f(b);
F=h.*S;
end

Trapezoidal Rule

Similar and much more accurate than the midpoint rule, the trapezoidal rule breaks the function into trapezoids (how obvious was that?).  Much like the rectangle rules, the trapezoidal rules divides the interval into smaller sub-intervals.  The area of each of these trapezoids are not that easy to predict, so we can utilize the formula from Wikipedia:

Here is a coding for the composite Trapezoidal Rule:

function [F] = trap(f,a,b,n)
%f=name of function, a=start value, b=end value, n=number of
%iterations
%made by Carolina, Niklas, Benjamin and Damiano
h=(b-a)./n;
S=f(a);
i=1:1:n-1;
x=a+h.*i;
y=f(x);
S=S+2.*sum(y);
S=S+f(b);
F=h.*S./2;
F;
end

Simpson’s Rule

Here is another example of how to approximate an integral.  It is conveniently equal to the average of the midpoint and trapezoidal rules.  If you do not feel like calculating both approximations, you can just use the equation:

Simpson’s Rule is by far the most accurate approximation besides calculating the definite integral itself.  Below is a code for the Simpson’s Rule:

function [P] = simpson(f,a,b,n)
%f=name of function, a=start value, b=end value, n=number of
%iterations
h=(b-a)/n;
S=f(a);
i=1:2:n-1;
x=a+h.*i;
y=f(x);
S=S+4*sum(y);
i=2:2:n-2;
x=a+h.*i;
y=f(x);
S=S+2*sum(y);
S=S+f(b);
P=h*S/3;
end

The objective of polynomial interpolation is to determine the coefficients of this polynomial.  There are several methods to finding such coefficients.

Vandermonde Matrix

The first method is to use a special type matrix called a Vandermonde Matrix.  We begin by determining the set of points as {(x₀, f(x₀)), (x₁, f(x₁)), (x₂, f(x₂)),…, (x_n+1, f(x_n+1))}.  From these points, we set up the system of equations:

We can now transform this system of equations into a matrix form:

From here, it is easy to type the matrix into Matlab and allow the program to find the inverse of the Vandermonde Matrix.  Unfortunately, with large values of n, the matrix becomes closer and closer to being singular which is something Matlab has trouble with.  So if n is large, we have to try other methods of polynomial interpolation.

Lagrange Interpolation

The best possible definition for Lagrange Interpolation comes straight from Wikipedia:

Given a set of k + 1 data points

where no two x_j are the same, the interpolation polynomial in the Lagrange form is a linear combination

of Lagrange basis polynomials

(1)

The function we are looking for has to be a polynomial function L(x) of degree less than or equal to k with

The Lagrange polynomial is a solution to the interpolation problem.  As can be seen

1. is a polynomial and has degree k.
2. 

Thus the function L(x) is a polynomial with degree at most k and

(2)

Let us use a very easy to understand example from Wikipedia just for a proof of concept.  The example calls for a polynomial interpolation of degree two (k=2) with the points:

x₀=1 : f(x₀)=1
x₁=2 : f(x₁)=4
x₂=3 : f(x₂)=9

Now let us use equation (1).  We do so by substituting in our values of x₀, x₁, x₂.

From these answers, we can now use equation (2).

For problems in which we need to find higher degree polynomials, we can rely on Matlab and the following code to figure out the coefficients of the polynomial (code courtesy of Kristie):

clear

N=20;

xp=linspace(0,1,N+1); %creates equidistant points

M=100;

x=linspace(0,1.2,M);

f=cos(20*xp); %function value

ff=cos(20*x);

for k=1:M  % each point x(k)

%Lagrange Interpolants

for j=1:N+1

L(j,k)=1;

for i=1:N+1

if i~=j

L(j,k)=L(j,k).*(x(k)-xp(i))/(xp(j)-xp(i));

end

end

end

end

P=L’*f’  % this does the summation which builds the interpolating polynomial

plot(x,P)

hold on

plot(x,ff,’r’)

plot(xp,f,’gp’)

Newtons Divided Differences

Another method for interpolating polynomials is by using a method called Newtons Divided Differences.  Much like Lagrange Interpolation, we begin with a set of points.  The definition from Wikipedia for Newton Divided Differences:

where

are called the divided differences and

called the Newton Basis Polynomial.

The key to knowing how divided differences work is to understand in what way they are recursive.  The first few divided differences can be mentioned as:

Here is an example code that shows how Newton Divided Differences interpolates the function f(x)=3x^2

clear all
N=50;
for j=1:N+1
xp(j)=-cos(pi*(j-1)/N); %Chebyshev Gauss Labatto Points
end
M=50;
x=linspace(-1.0,1.0,M);
f=3.0.*xp.*xp;
ff=3.0.*x.*x;

for j=1:N
D(1,j)=(f(j+1)-f(j))/(xp(j+1)-xp(j));
end
%Newton divided differences
for k=1:N-1
for j=1:N-k
D(k+1,j)=(D(k,j+1)-D(k,j))/(xp(j+k+1)-xp(j));
end
end
%build the basis polynomials
Pol(1,:)=(x(:)-xp(1));
for j=1:N-1
Pol(j+1,:)=Pol(j,:)’.*(x(:)-xp(j+1));
end

P=f(1)+0.0*x;
for j=1:N
P(:)=P(:)+D(j,1)*Pol(j,:)’;
end
P’
plot(x,P)
hold on
plot(x,ff,’bp’)
plot(xp,f,’gp’)

Conclusion

Polynomial interpolation is a tricky subject to cover because there are a couple methods that are straight forward in finding the coefficients for the polynomials, such as the Vandermonde Matrix and Lagrange Interpolation.  But unlike those two, Newton Divided differences is a little bit trickier to understand.  From the code I am using, it seems that Newton Divided Differences just gives you a bunch of points.  The Vandermonde Matrix is quite easy to use and understand, but unfortunately it becomes an obscure method with an increased number of points.  Overall, I feel like Lagrange Interpolation is the most effective method of polynomial interpolation.

Another formidable technique for determining the zero of a function is by using Newton’s Method.  It is very similar to the Fixed Point method in that it uses recursion to determine the zero.  Newton’s Method is defined as:

Where x_n is an initial guess and is the original function divided by the derivative of the function.  This method is repeated until the specified accuracy is achieved.

Let us recall our previous example of f(x)=x^2-2 .  From calculus, we know the derivative of f(x):  f’(x)=2x.

Since we already have a general idea of what the zero of this function is, we can make a fairly accurate guess.  Let us use x₀=1.5.  Now according to Newton’s Method, our first approximation should look like:

Now as you can see, 1.41666667 is still not close enough to the exact answer so we would repeat these steps to find f(x₀).  The first ten iterations of this method yield:

f(x₀)=1.416666666666667
f(x₁)=1.414215686274510
f(x₂)=1.414213562374690
f(x₃)=1.414215686274510
f(x₄)=1.414213562373095
f(x₅)=1.414213562373095
f(x₆)=1.414213562373095
f(x₇)=1.414213562373095
f(x₈)=1.414213562373095
f(x₉)=1.414213562373095
f(x₁₀)=1.414213562373095

As you can see, we approach our desired approximation very quickly, five iterations to be exact.  You can see how quickly this method converges to our desired answer by looking at the following chart.

Here is the code that finds the zero of f(x)=x^2-2 and produced the previous graph.

%Newton’s Method for f(x)=x^2-2

clear all
format long
p(1)=1.5;
pexact(1)=1.414;
error(1)=abs(p(1)-pexact(1));
rate(1)=error(1);
n=10;
for i=1:n
p(i+1)=p(i)-(p(i)*p(i)-2)/(2*p(i));
pexact(i+1)=1.414;
error(i+1)=abs(p(i+1)-pexact(i+1));
rate(i+1)=(1/4)*rate(i);
end
for i=1:n
p(i)
end
plot(p)
hold on
plot(pexact, ‘r’)
figure
plot(error, ‘r’)
hold on
plot(rate, ‘b’)

Bisection Method

The first method was the bisection method.  This method involved finding the midpoint of the interval [a,b].  I called this point m.  The next step was to determine if a<c<m or m<c<b.  In other words, I was trying to determine if the function’s zero value was between the interval of a and m or the interval of m and b.  This is simply done by multiplying f(a) with f(m).  If this product is negative, then that means c (or zero value) is between a and m.  Otherwise, if f(a) x f(m) is positive, then m<c<b.  Although, on the rare occasion, if f(m)=0, then we have found the zero of the function, c=m.

After determining the correct section in which c is located, you must reassign values for either a or b.  If a<c<m, then set b=m.  If m<c<b, then set a=m.  Now, that the method is understood, all that is left to do is to repeat these steps until you have a margin of error of 10^-15.  In other words, b-m should roughly equal 10^-15.

Doing these calculations by hand will become tedious very quickly.  To make it easier to understand, here is the coding to determine the zero of the function f(x)=x²-2 on the interval [1,2].  Basic algebra tells us that the zero of f(x) that is on the interval of [1,2] is the square root of 2.   *This is the coding for a MATLAB .m file.

a=1;       %left endpoint
b=2;      %right endpoint
fa=a^2-2;    %left function value of f(x)=x^2-2
fb=b^2-2;    %right function value of f(x)=x^2-2
Nstop=log(1.e15)/log(2);   %figure our how many iterations
for j=1:Nstop+1
m(j)=(a+b)/2;
f(j)=m(j)*m(j) -2 ;
if (f(j)==0)
mm=m(j);
break
end    %need to stop!
if (f(j)*fa<0) b=m(j) ;
else a=m(j);
end
fa=a^2-2;
fb=b^2-2;
end

Multi-partition Method

The next idea was to determine if it is more efficient to divide the interval into more than two partitions like the bisection method used.  This is called the multi-partition method.  It uses the same ideas as the bisection method except that you have the choice of how many partitions to separate the interval into.  It comes with its own advantages and disadvantages.  For example, it requires far less number of intervals to be divided because the error will get closer to the desired error of 10^-15.  Unfortunately, you may have to do “n number of partitions” per interval which significantly increases the total number of iterations that need to be done and the longer it takes to get to an answer.

The multi-partition works the same way as the bisection method in regards to finding partition in which c is located.  We start this procedure by first determining how many partitions we want to use.  We will designate each partition point as i_k with k=1…n number of partitions.  Just like the bisection method, after we find the partition where point c is located, we reassign point a to the point i_k and point b to the point i_k+1, where i_k<c<i_k+1. We repeat these steps until b-c is roughly10^-15.

Using the same function as earlier, f(x)=x²-2 on the interval [1,2], here is the coding for the multi-partition method.

a=1;    %initial left endpoint
b=2;      %initial right endpoint
fa=a^2-2;        %initial left function value
fb=b^2-2;       %initial right function value
partition=10;    %number of partitions
Nstop=log(1.e15)/log(partition);         %figure our how many iterations
i=0;
for j=1:Nstop+1     %iteration loop
interval=(b-a)/partition;    %interval between each partition
m=0;
while (m~=b)     %continues until the right partition is found
m=a+interval;
fm=m^2-2;
if (fm==0)
mm=m;
break
end    %need to stop!
if (fa*fm<0)
b=m;
fb=b^2-2;
end
if (fa*fm>0)
a=m;
fa=a^2-2;
end
end
end
m    %outputs the zero of f(x)

Fixed Point Method

Another unique way of finding the zero is by using the fixed point method.  We still want to find the point c such that f(c)=0.  But now also we have to define another function g(x) in which g(c)=c, thus defining a fixed point.  Another condition that is required is that |g’(x)|<1.

We would assume g(x)=x, but instead we are going to say g(x)=x+r•f(x) where r•f(x) is the error.  Eventually r•f(x) will converge to zero as x gets closer to c.  Using our previous example of  f(x)=x²-2, we can now say g(x)=x+r•(x²-2).

Now solving the triangle inequality:

• |g’(x)|<1 → -1<g’(x)<1
• where g’(x)=1+2rx → -1<1+2rx<1
• which implies -2<2rx<0 → -1<rx<0 → -1/x<r<0

From this we begin by taking an estimate of the zero value.  Our estimate has to be on the interval of [1,2].  To make it easy, let us use x₁=1.5. Using this value for x₁, we can now find decide on a value of r. Remember -1/x<r<0, so in our example, -1/1.5<r<0 → -0.6667<r<0.  Let us pick a value of r satisfying this inequality.  Let r=-0.25.

We can now find out what g(x₂) is equal to.

• g(x₂)=x₁ + r•(x₁²-2)
• g(x₂)=1.5 + (-0.25)(1.5²-2)
• g(x₂)=1.5 + (-0.25)(2.25-2)
• g(x₂)=1.5 + (-0.25)(0.25)
• g(x₂)=1.5 – 0.0625
• g(x₂)=1.4375

Using this procedure, we can find g(x_n) by following these steps n times.  For example, g(x₃) can be found by:

• g(x₃)=x₂ + r•(x₂²-2)
• g(x₃)=1.4375 + (-0.25)(1.4375²-2)
• g(x₃)=1.4375 + (-0.25)(2.0664-2)
• g(x₃)=1.4375 + (-0.25)(0.0664)
• g(x₃)=1.4375 – 0.0166
• g(x₃)=1.4209

As you can see, we are getting closer to our targeted value of 1.41421356.  It is much more efficient to let a computer calculate more precise answers.  This can be done by using the following code designed for our example.

p(1)=1.5;   %initial guess
pexact(1)=1.41421356237095;   %exact value of c
error(1)=abs(p(1)-pexact(1));
rate(1)=error(1);
r=-0.25;
n=25;  %number of iterations
for x=1:n
p(x+1)=p(x)+r*(p(x)*p(x)-2);
pexact(x+1)=1.41421356237095;
error(x+1)=abs(p(x+1)-pexact(x+1)); %measures how far away the estimate is off from the exact answer. converges to 0.
rate(x+1)=(1/2)*rate(x);
end
p(n)
plot(p)   %plots x_n
hold on
plot(pexact, ‘r’) %plots exact value c. Shows how x_n converges to c.
figure
plot(error, ‘r’)
hold on
plot(rate, ‘b’)

Figure 1: Shows how each estimate gets closer and eventually converges to the value of c.

Figure 2: Shows how far off each estimate is compared to the value of c. After a short period of time, the error converges to 0.

Conclusion

All three of these methods yielded the same result.  The only difference is their ease of usage.  The bisection method is by far the easiest to use, but the fixed point method yielded the quickest answer.  The fixed point method requires several calculations to be found, specifically g’(x) which might now be known to those with no calculus background.  The multi-partition has no real advantage over the bisection method since it is essentially the same thing, but with a longer calculation time.  If I had to recommend a method, it would be the bisection method because of its ease of use and effectiveness.