Calculation of the polygonal approximation with 5 rectangles:

The function whose graph is shown above is  f(x)=.008*x^3-.3040*x^2+3.1360*x-.1200, and the interval is  [a,b]=[2,25].  We define the function and the interval.

>

restart:

>	f:=x->.008*x^3-.3040*x^2+3.1360*x-.1200;

>	a:=2;b:=25;

Look at the graph of f(x).  

>	plot(f(x),x=a..b,y=0..f(b),scaling=constrained);

Notice that Maple chooses to draw the vertical axis at x=2 instead of the y-axis in order to make the graph fill up as large as possible region of the picture.

>

Consider the five rectangles shown in the first frame of our animation.  These rectangles are of equal width.  To determine this width, divide the interval [a,b]=[2,25] of width 23 into five equal subintervals, each of width (b-a)/5=(25-2)/5=23/5.  Call this width  deltax, and define it next:

>	deltax:=(b-a)/5;

>

Now that we know the widths of the rectangles, we need to compute their heights. Each rectangle in our diagram has its top right vertex on the graph of  y=f(x).  These heights are, therefore, values of the function  f(x)  at the right-hand endpoints of the subintervals.  We'll call the endpoints of the subintervals  a = x(0),  x(1),  x(2),  x(3),  x(4), and  x(5) = b, and their values are:  

          x(0) = a = 2,

          x(1) = a +     deltax = 2+23/5,

          x(2) = a + 2*deltax = 2+2*(23/5),

          x(3) = a + 3*deltax = 2+3*(23/5),

          x(4) = a + 4*deltax = 2+4*(23/5), and

          x(5) = a + 5*deltax = 2+5*(23/5)

Here is a picture of the five rectangles, displaying the six partition points  x(0),  x(1), . . . , x(5):

>

We define these endpoints  x(0), x(1), . . . , x(5)  by defining a function  x(i), for i=0, 1, 2, . . . , 5:

>	x:=i->a+i*deltax;

Check to see that these  x(i)'s  are correct, by asking for the sequence of values, from  i=0  to  i=5:

>	seq(x(i),i=0..5);

So the right-hand endpoints of the five subintervals are  x(1), x(2), x(3), x(4), and  x(5).  The heights of the five rectangles are, therefore,  f(x(1)), f(x(2)), f(x(3)), f(x(4)), and  f(x(5)).  The ith rectangle has height  f(x(i))  and width deltax, so its area is  f(x(i))*deltax.  Compute the total area inside of these five rectangles by summing the areas of each of the rectangles as  i  goes from  1  to  5:

>	sum(f(x(i))*deltax,i=1..5);

>

This sum is an example of a right endpoint Riemann sum .  It approximates the area of the shaded region lying under the curve and above the x-axis between  x=2  and  x=25  using  5  rectangles, each of height determined by the value of the function at the  right  endpoint of its base.

>

Calculation of a polygonal approximation using left endpoints:

The height of each rectangle in the previous calculation was determined by the value of the function at the right endpoint of its base.  What approximation would we have obtained had we instead used the left endpoint of each subinterval?  The following diagram shows a left endpoint approximation:

>

 To compute this left endpoint approximation, use the same function on the same interval; these do not have to be redefined.

Since the subdivision (the partition) of  [a,b]  is the same, the value of deltax is unchanged. What does change?  The height of the first rectangle is determined by the value of  f at the left  endpoint of the first rectangle, which is  x(0); this height is  f(x(0)).  What is the height of the second? third? . . . fifth?  A slight change in the formula that we used earlier for our right endpoint approximation produces the left endpoint approximation.  

• Alter the following command, which we used earlier for the right endpoint approximation, so that the ith rectangle will have height determined by the left endpoint.  Enter it to determine the value of this left endpoint approximation.

>	sum(f(x(i))*deltax,i=0..4);

If your approximation is , your calculation is correct!

>

Inscribed and circumscribed rectangles:

Consider the function  f(x)=  on the interval [a,b]=[1,3].

>

restart:

>	f:=x->1+x+x^3;

>	plot(f(x),x=1..3);

You can see that this function is decreasing on the entire interval. The left and right endpoint Riemann sums are especially informative for such a function, which is said to be monotonically   increasing  on the interval.  To see why, use the following commands to generate pictures of these approximations.  The rectangles are called circumscribed rectangles.

>

• First define a, b, and n.  Since you want [a,b] to be [1,3], choose a=1 and b=3.  Subdivide this interval into n equal subintervals, where the value of n is 10 plus the number of letters in your last name.

>

a:=1;

>

b:= 3 ;

>

n:=10;

• Now compute the value of deltax, which represents the width of each of the n subintervals.  Express deltax in terms of a, b, and n, so that you can easily change these values later.

>	deltax:= (b-a)/n;

• Define the partition points  x(0),  x(1), . . . ,  x(n), by defining  x(i)  in terms of  a,  i, and deltax as we did earlier.

>	x:=i->a+i*deltax;

• In order to allow yourself the flexibility to experiment with left and right endpoint approximations, define xstar(i) to be your choice of either the right or the left endpoint of the ith subinterval.  For this example, the right endpoint approximation, choose xstar(i) to be equal to x(i).  You will change this later when you want to compute the left endpoint approximation.

>	xstar:=i->x(i);

We want now to construct and plot the Riemann rectangles used to approximate this region. We will define rectangles using the rectangle  command, which exists in the package plottools , so we must first load this package with the following command.

>	with(plottools):

Note:   You may have noticed that the previous command ended with a colon instead of the usual semicolon; the colon suppresses display of the output, so use the colon if you are not interested in seeing the output.  Go back now, replace the colon with a semicolon, and enter the command to see the list of commands available in the plottools  package.

Now we define the ith rectangle,  called riemannrectangle(i), by listing a pair of opposite vertices.  Since the bottom left vertex is at [x(i-1),0], we list this vertex, together with its opposite vertex, which has x-coordinate x(i) and y-coordinate f(xstar(i)).

>	riemannrectangle:=i->rectangle([x(i-1),0],[x(i),f(xstar(i))],color=red);

Form the sequence of all of these rectangles,

>	rectangles:=[seq(riemannrectangle(i),i=1..n)]:

and, since you want to simultaneously display the graph of the function and the Riemann rectangles, open up the package plots , which contains the display  command,

>	with(plots):

and display the graph of f along with the rectangles and a title to the display:

>	display(plot(f(x),x=a..b,title=`Right Endpoint Riemann Sum`,color=navy,thickness=2),rectangles);

>

Finally, the following command defines and evaluates the Riemann sum:

>	riemannsum:=sum(f(xstar(i))*deltax,i=1..n);

To find a decimal approximation of this Riemann sum, use the evalf command:

>	evalf(riemannsum);

>

Look  at your diagram.  Is your approximation too big or too small?  What do you expect from a right endpoint approximation for this example?

• Now redo the picture and the calculation with the same value of n, but using the left  endpoint of each subinterval, to find bounds on the area under this function from x=1 to x=3.  This time the rectangles are inscribed . Simply adjust the first of these commands to use the left instead of the right endpoint, then enter the commands:

First enter the appropriate formula for xstar(i) on the right of the arrow to  select the left endpoint of the ith subinterval to be xstar(i):

>	xstar:=i->x(i-1)  ;

Then define the ith rectangle.

>	riemannrectangle:=i->rectangle([x(i-1),0],[x(i),f(xstar(i))],color=green);

The plottools and plots packages are already open, so we do not have to open them again.  Define the rectangles  and display and calculate the Riemann sum.

>	rectangles:=[seq(riemannrectangle(i),i=1..n)]:

>	display(plot(f(x),x=a..b,title=`Left Endpoint Riemann Sum`,color=navy,thickness=2),rectangles);

>

>	riemannsum:=sum(f(xstar(i))*deltax,i=1..n);

>	evalf(riemannsum);

>

What do these two calculations enable you conclude about the area under the curve?

The Limit of the Riemann Sum

Project:  The Riemann Sum

Open a new file, type a heading at the top, then write an introductory paragraph to present your investigation.  

• Define f(x) to be a polynomial having degree at most 6. Let [a,b] = [2,4] Use Maple to find a simple formula for the left,right and midpoint  Riemann sums as functions of n . Then evaluate the limits of these sums as n  approaches infinity.
• Let m represent the number of letters in your first name.  Let f(x) =   .  You want to write the numerator as 1.0 m rather than as m because 1.0 is a floating point number.  Its presence is contagious throughout your calculations, freeing Maple to compute with decimal approximations rather than having to compute exact values.  Exact value calculations can be extremely slow, particularly when making large numbers of calculations, such as when adding up 100,000 rectangular areas.
• Plot the graph of  f(x)  and notice that this function is monotonically decreasing for .  
• Define left and right-hand Riemann sum approximations of the area between this curve and the x-axis, from x=1 to x=2, using  n  rectangles of equal width.
• Calculate the integral of f(x) from x=1 to x=2, to compare with your approximations below.
• Define the left and right error as functions of n.
• In the work below with spreadsheets we are going to want to increase the number of digits that Maple uses in its calculations. This is accomplished by entering the following command:

>	Digits:=20;

>

• Instead of printing lists of values as above, we are going to use a spreadsheet. Insert a spreadsheet like the one below. Label the first column "n", the second column "Left Sum(n)", the third column "RightSum(n)", the fourth column "Left Error(n)", and the fifth column "Right Error".  With the cursor inside the spreadsheet click on Spreadsheet-Properties in the Menu.  Under "precision" set the number of digits used during calculations equal to 20 and the number of displayed decimals to 8. Click Apply and then OK. To add rows or columns to your spreadsheed, click on the border of the spreadsheet and expand it either horizontally or vertically or both by dragging one of the little black squares in one of the sides or in one of the corners.

With the cursor in the second column second row, enter leftriemannsum(~A2). leftriemannsum is your function for the left Riemann sum with n subintervals. The expression ~A2 instructs Maple to evaluate the function leftriemannsum at the number in the cell A2 (first column second row). If you have defined everything correctly, you should get a number in the cell B2. Now highlight cell B2 by clicking the mouse with the cursor in B2. Then click the copy button on the tool bar. Choose the next cell B3 in the second column and then click on the paste button. This will evaluate the left Riemann sum at the value n = 100. Continue to paste in the remaining cells in the first column. Continue to fill in the spreadsheet one column at a time. The third column will contain the right Riemann sums, the fourth column will contain the error between the left Riemann sum and the integral, and the fifth column will contain the error between the right Riemann sum and the integral.

• Add some rows at the bottom of your spreadsheet with some larger values of n, such as 500, 1000. Try to estimate the number of subintervals required for the left and right errors to be smaller than .01. For large sums Maple sometimes displays the answer in complex-number format  where b  = 0.
• Bonus:   Generate a similar spreadsheet in which you use midpoints for generating your Riemann sums. Compare the errors with those for the left and right sums. Explain why the midpoint sums are more accurate in this case.
• Write a concluding paragraph for your report.