Area Under a Curve: Accumulating Quantity With Rectangles and Estimation

Accumulation as “Total Built From Pieces”

Many real questions are not about how fast something changes at one instant, but about how much has built up over an interval. Examples include total distance traveled over a time window, total water that flowed through a pipe during an hour, total energy used during a day, or total revenue earned over a week when the earning rate varies. In each case there is a quantity that accumulates, and we often know (or can measure) a rate or density that varies with an input such as time or position.

The central idea in this chapter is: area under a curve can represent accumulated quantity when the vertical axis measures a “per unit” amount. If the graph shows a rate (like liters per minute) versus time (minutes), then multiplying rate × time gives liters, and adding those pieces over the interval gives total liters. The “adding pieces” is where rectangles and estimation enter.

When Area Represents a Total

Area is measured in “vertical units × horizontal units.” That is exactly what you want when the vertical axis is “something per horizontal unit.” Here are common interpretations:

• Rate vs time: If r(t) is in meters/second and t is in seconds, then area under r(t) from t=a to t=b is in meters (total distance).
• Flow rate vs time: If f(t) is in gallons/minute, area gives gallons.
• Density vs position: If ρ(x) is in kg/meter along a rod, area gives kg (total mass) over a segment.
• Price per item vs quantity: If p(q) is dollars/item and q is items, area gives dollars (total cost) when price varies with quantity.

In all of these, the curve itself is not the total; the total is the accumulated sum of many small “rate × small width” contributions.

Rectangles as an Estimation Tool

Suppose you want the area under a nonnegative function y=f(x) from x=a to x=b. If f were constant, the area would be a rectangle: height f and width (b−a). When f varies, we approximate the region under the curve by slicing the interval into smaller subintervals and using rectangles on each slice.

Continue in our app.

You can listen to the audiobook with the screen off, receive a free certificate for this course, and also have access to 5,000 other free online courses.

Or continue reading below...

Download the app

Partitioning the Interval

Choose a number n of subintervals and divide [a,b] into n pieces. If we use equal widths, the width is:

Δx = (b - a) / n

The partition points are:

x0 = a, x1 = a + Δx, x2 = a + 2Δx, ..., xn = b

On each subinterval [x_{i-1}, x_i], we choose a rectangle height based on the function value at some sample point in that subinterval. The rectangle area is then:

area_i = f(sample point) * Δx

Adding all rectangle areas gives an estimate of the total area.

Left, Right, and Midpoint Rectangles

Three standard choices for the sample point are:

• Left endpoint: use height f(x_{i-1}). This produces the left Riemann sum.
• Right endpoint: use height f(x_i). This produces the right Riemann sum.
• Midpoint: use height f((x_{i-1}+x_i)/2). This produces the midpoint sum.

These are not just different “styles”; they behave differently depending on whether the function is increasing or decreasing. For an increasing function, left rectangles tend to underestimate (they use smaller heights), while right rectangles tend to overestimate. For a decreasing function, the roles reverse.

A Step-by-Step Example With Numbers

Imagine a car’s speed varies over time. Let v(t) be speed in meters per second, and suppose we have a simple model:

v(t) = 2t + 4   for 0 ≤ t ≤ 6

This is a straight line: at t=0 the speed is 4 m/s, and at t=6 the speed is 16 m/s. The total distance traveled from 0 to 6 seconds is the area under the speed curve from t=0 to t=6.

Step 1: Choose the Number of Rectangles

Take n=3 rectangles. Then:

Δt = (6 - 0) / 3 = 2 seconds

The subintervals are [0,2], [2,4], [4,6].

Step 2: Compute Left-Endpoint Estimate

Left endpoints are t=0,2,4. Compute speeds:

• v(0)=2(0)+4=4
• v(2)=2(2)+4=8
• v(4)=2(4)+4=12

Left sum estimate:

L3 = (v(0) + v(2) + v(4)) * Δt = (4 + 8 + 12) * 2 = 48 meters

Step 3: Compute Right-Endpoint Estimate

Right endpoints are t=2,4,6. Compute speeds:

• v(2)=8
• v(4)=12
• v(6)=2(6)+4=16

Right sum estimate:

R3 = (8 + 12 + 16) * 2 = 72 meters

Step 4: Interpret the Over/Under Behavior

Because v(t) is increasing, the left sum underestimates and the right sum overestimates. The true distance should be between 48 m and 72 m.

Step 5: Midpoint Estimate

Midpoints are t=1,3,5. Compute speeds:

• v(1)=2(1)+4=6
• v(3)=2(3)+4=10
• v(5)=2(5)+4=14

Midpoint estimate:

M3 = (6 + 10 + 14) * 2 = 60 meters

Midpoint rectangles often give a better estimate than left or right with the same number of rectangles, especially when the function is smooth.

Upper and Lower Estimates: Bounding the True Area

Rectangles can do more than “guess”; they can create guaranteed bounds when you use maximum and minimum heights on each subinterval.

Lower Sum and Upper Sum

On each subinterval [x_{i-1}, x_i], define:

• m_i = minimum value of f(x) on the subinterval
• M_i = maximum value of f(x) on the subinterval

Then:

• Lower sum: add rectangles with heights m_i
• Upper sum: add rectangles with heights M_i

These satisfy:

Lower sum ≤ true area ≤ Upper sum

If f is increasing, the minimum on each subinterval occurs at the left endpoint and the maximum at the right endpoint, so the lower sum matches the left sum and the upper sum matches the right sum. For decreasing functions, it flips.

Why Refining the Partition Improves Accuracy

When you use more rectangles (larger n), each rectangle becomes narrower. If the function does not change too wildly over small intervals, then the maximum and minimum values on each subinterval get closer together. That squeezes the true area between upper and lower sums that are closer together, improving the estimate.

Practically, this means you can control accuracy by choosing n large enough to make the difference between an upper and lower estimate smaller than a desired tolerance.

Estimating Area From a Table of Values

Often you do not have a formula for f(x). You may have measurements at discrete points: a table of values from an experiment, a sensor, or recorded data. Rectangle methods still work because they only require function values at sample points.

Example: Flow Rate Data

Suppose a pump’s flow rate (liters per minute) is measured every 10 minutes for an hour. Let t be minutes and f(t) be L/min:

t:     0   10   20   30   40   50   60  (minutes)  f(t):  5    7    6    9    8    7    6  (L/min)

We want total liters pumped from 0 to 60 minutes. Here Δt=10 minutes.

Left Rectangle Estimate

Use values at t=0,10,20,30,40,50:

L6 = (5 + 7 + 6 + 9 + 8 + 7) * 10 = 420 liters

Right Rectangle Estimate

Use values at t=10,20,30,40,50,60:

R6 = (7 + 6 + 9 + 8 + 7 + 6) * 10 = 430 liters

The true total is likely between 420 and 430 liters if the rate changes smoothly between measurements. The 10-liter gap gives a sense of uncertainty due to sampling and variation between points.

Midpoint Estimate When Midpoints Are Not Measured

Midpoint rectangles require values at t=5,15,25,... which we do not have. In practice, you might estimate midpoint values by averaging neighboring measurements (a simple interpolation idea):

• Approximate f(5) ≈ (f(0)+f(10))/2 = (5+7)/2 = 6
• Approximate f(15) ≈ (7+6)/2 = 6.5
• and so on

This introduces an additional modeling assumption, but it can improve accuracy when the function is roughly linear between samples.

What Changes When the Function Dips Below the Axis?

So far, we have treated “area under the curve” as a positive accumulation. But some graphs represent signed quantities. For example, velocity can be negative if moving backward, and net flow can be negative if flow reverses direction.

Signed Area vs Total Accumulation

• Signed area (net change): Regions above the axis contribute positively; regions below contribute negatively. This corresponds to net change, such as net displacement.
• Total accumulation (total amount moved): If you want total distance traveled regardless of direction, you would add the magnitudes, effectively using the area under |v(t)|.

Rectangle estimates can handle both: you simply multiply each rectangle’s height by the width. If the height is negative, that rectangle subtracts from the sum. The interpretation depends on the context.

Error Awareness: How Far Off Could Your Estimate Be?

Estimation is most useful when you can judge its reliability. Without advanced formulas, you can still reason about error using simple comparisons and refinement.

Using Upper–Lower Gaps as an Error Indicator

If you can compute an upper sum U and a lower sum L for the same partition, then the true area A satisfies:

L ≤ A ≤ U

So the maximum possible error of using the average (U+L)/2 is at most (U−L)/2. Even if you do not take the average, the gap U−L tells you how uncertain the estimate could be.

Example: Increasing Function Bound

Return to v(t)=2t+4 on [0,6] with n=3. We found L3=48 and R3=72. So the true distance is between 48 and 72 meters, and the uncertainty is large because the rectangles are wide. If we increase to n=6, then Δt=1 second:

Left endpoints t=0,1,2,3,4,5 give speeds 4,6,8,10,12,14. Then:

L6 = (4+6+8+10+12+14) * 1 = 54 meters

Right endpoints t=1,2,3,4,5,6 give speeds 6,8,10,12,14,16. Then:

R6 = (6+8+10+12+14+16) * 1 = 66 meters

Now the true distance is between 54 and 66 meters, a much tighter bracket.

Connecting the Geometry to Computation: The General Rectangle Sum

All rectangle methods can be written in a single template. Choose a partition a=x0<x1<...<xn=b. On each subinterval, choose a sample point c_i in [x_{i-1}, x_i]. Then the rectangle estimate is:

Sum = f(c1)(x1-x0) + f(c2)(x2-x1) + ... + f(cn)(xn-x{n-1})

For equal widths, this becomes:

Sum = (f(c1) + f(c2) + ... + f(cn)) * Δx

This is the computational heart of “accumulation by rectangles”: multiply a representative height by a width, then add.

Practical Workflow: Estimating Area Under a Curve From a Graph

Sometimes you have only a plotted curve (for example, a printed chart) and need an estimate. A practical workflow is:

Step 1: Identify Axes and Units

Confirm what the vertical and horizontal units are. This determines what the area means. If y is “liters per minute” and x is “minutes,” then area is liters.

Step 2: Choose an Interval and a Rectangle Width

Pick [a,b] and decide how many rectangles you can reasonably draw or compute. More rectangles usually means better accuracy, but also more work.

Step 3: Decide Left/Right/Midpoint (or Upper/Lower)

If the curve is increasing, left gives a low estimate and right gives a high estimate. If the curve is decreasing, it’s the opposite. If the curve changes direction, consider upper/lower on each subinterval or use midpoints for a balanced estimate.

Step 4: Read Heights Carefully

For each rectangle, read the function value at the sample point. If reading from a graph, be consistent: use the same scale and avoid rounding too early.

Step 5: Multiply and Add

Compute each rectangle area (height × width) and sum them. Keep units attached during computation to avoid mistakes.

Step 6: Check Reasonableness

Compare your estimate to simple bounds: a minimum possible area (using a low typical height) and a maximum possible area (using a high typical height). If your estimate falls outside those, revisit your readings or widths.

Why Rectangles Are the Starting Point (Even When Better Methods Exist)

Rectangles are simple enough to apply to formulas, tables, and graphs, and they directly match the idea of accumulation as “sum of small contributions.” They also create a bridge between discrete addition (adding finitely many rectangle areas) and a more refined notion of area obtained by using more and more rectangles with smaller widths.

In practice, rectangle estimates are often the first pass: they provide quick approximations, they can bracket the true value, and they help you understand what information matters most (how rapidly the function changes and how fine your partition should be).