Monocurl Essays
Series Download

Position, velocity and acceleration: reading motion graphs

Slope turns a position graph into velocity and velocity into acceleration; area goes back. The constant-acceleration equations come from one trapezoid.

23 min·High school·

AssumesWhat slope means, and why y = mx + b is a line

A car’s 20 seconds on a straight, flat road, played at double speed. The curve records its position, measured in meters from where it started, against time.
Monocurl source
let fr = Frame(0, 20, 0, 100, [0.2, 0.68, 0], 6.0, 2.1)
let ROAD_Y = -1.62
let rx = |m| -2.8 + 0.06 * m
mesh plot = Panel(fr, [4, 8, 12, 16, 20], [25, 50, 75, 100], [0, 4, 8, 12, 16, 20], [0, 50, 100], "time t (s)", "position x (m)", XC)
mesh road = Road(rx(0), rx(100), ROAD_Y)
let Drive = |t| [
    Trace(fr, pos, t, XC),
    Pt(at(fr, t, pos(t)), EMBER, 0.09),
    Car([rx(pos(t)), ROAD_Y, 0])
]
mesh drive = Drive(t: 0)

slide "drive"
    play Wait(0.7)
    drive.t = 20
    play Lerp(10, [&drive], linear)
    play Wait(1.2)

Uses the shared definitions for this lesson's figures.

The graph above records where a car was during twenty seconds on a straight road. From the graph alone, try to say when the car was moving fastest, when it was standing still, and when it was going backward.

The tempting answer to the first question is “at the top”, because that is where the graph is highest. But the height of this graph is the car’s position, and between 12 and 14 seconds, where the graph is highest, the car is parked 96 meters down the road. The road is flat the whole way; the hill exists only in the graph.

Pause and try

Watch the animation again and commit to answers. During which stretch of time is the car fastest? When is it stopped? When is it reversing? For each, say what feature of the graph told you.

Show answerHide answer

It is fastest from 4 s to 8 s, where the graph climbs most steeply. It is stopped from 12 s to 14 s, where the graph is flat. It reverses from 14 s to 20 s, where the graph falls. In every case the information is in how steep the graph is and which way it tilts, and none of it is in how high the graph is.

Position needs an origin and a direction

To graph a motion we first have to turn “where the car is” into a number. Pick one point on the road and call it the origin. Pick one of the two directions along the road and call it positive. Every number that follows depends on these two choices, so a careful solution states them at the start. Here the origin is the place where the car starts, and the positive direction is the way it first drives.

The symbol $\Delta$ is read “change in”. For our car, $x(0) = 0$ m, $x(12) = 96$ m and $x(20) = 72$ m. Its displacement over the whole trip is $72 - 0 = +72$ m, but the distance it traveled is $96 + 24 = 120$ m, because it drove 96 m forward and then 24 m back.

Velocity is the slope of the position graph

Start where the motion is simplest. From 4 s to 8 s the graph is a straight line from 24 m up to 72 m, so the car covers 48 m in 4 s:

$$ \frac{72 \text{ m} - 24 \text{ m}}{8 \text{ s} - 4 \text{ s}} = 12 \text{ m/s}. $$

On the graph this is rise over run, the slope of the line, and it comes with units: meters on the vertical axis divided by seconds on the horizontal axis.

Now try the same recipe on the first four seconds. The car goes from 0 m to 24 m, an average of 6 m/s. That number is correct and unsatisfying, because the graph is curved there: the car began at rest and was doing 12 m/s by the end. What we want is the velocity at one moment, say at $t = 3$ s. An average needs an interval, so we use intervals that start at 3 s and get shorter.

  1. From 4 s to 8 s the graph is straight: 48 m in 4 s, a slope of 12 m/s.
  2. From 3 s to 4 s, on the curved part, the car covers 10.5 m: an average of 10.5 m/s.
  3. Shrink the interval to a tenth of a second: from 3 s to 3.1 s the slope is 9.15 m/s.
  4. From 12 s to 14 s the graph is flat. The slope is 0: the car is parked.
  5. From 16 s to 18 s the graph falls 12 m in 2 s. The slope is negative: the car is backing up.
Slopes read off the car’s position graph. On a straight stretch one slope describes the whole stretch; on a curved stretch the slope over a shrinking interval settles toward the velocity at a single moment.
Monocurl source
let fs = Frame(0, 20, 0, 100, [-0.95, 0.25, 0], 4.5, 3.0)
let Readout = |a, b| {
    let rise = pos(b) - pos(a)
    return [
        center{[2.65, 1.45, 0]} Note("time elapsed", 0.74),
        center{[2.65, 1.0, 0]} Math(str_join([to_string(b - a, 1), "\text{ s}"]), 0.95),
        center{[2.65, 0.35, 0]} Note("change in position", 0.74),
        center{[2.65, -0.1, 0]} Math(str_join([to_string(rise, 3), "\text{ m}"]), 0.95),
        center{[2.65, -0.75, 0]} Note("slope", 0.74),
        center{[2.65, -1.25, 0]} Math(str_join([to_string(rise / (b - a), 2), "\text{ m/s}"]), 1.1, EMBER)
    ]
}
let Stretch = |a, b| {
    let m = (pos(b) - pos(a)) / (b - a)
    let lo = max(0, a - 1.3)
    let hi = min(20, b + 1.3)
    var out = []
    if (abs(pos(b) - pos(a)) > 0.3) {
        out .= Seg(at(fs, a, pos(a)), at(fs, b, pos(a)), SLATE, 2.5)
        out .= Seg(at(fs, b, pos(a)), at(fs, b, pos(b)), SLATE, 2.5)
    }
    out .= Seg(at(fs, lo, pos(a) + m * (lo - a)), at(fs, hi, pos(a) + m * (hi - a)), EMBER, 3.5)
    out .= Pt(at(fs, a, pos(a)), EMBER, 0.085)
    out .= Pt(at(fs, b, pos(b)), EMBER, 0.085)
    return out
}
mesh plot = Panel(fs, [4, 8, 12, 16, 20], [25, 50, 75, 100], [0, 4, 8, 12, 16, 20], [0, 50, 100], "time t (s)", "position x (m)", XC)
mesh curve = Trace(fs, pos, 20, XC)
mesh stretch = []
mesh readout = []

slide "From 4 s to 8 s the graph is straight: 48 m in 4 s, a slope of 12 m/s."
    stretch = Stretch(a: 4, b: 8)
    readout = Readout(4, 8)
    play Fade(0.8)

slide "From 3 s to 4 s, on the curved part, the car covers 10.5 m: an average of 10.5 m/s."
    readout = []
    play Fade(0.3, [&readout])
    stretch.a = 3
    stretch.b = 4
    play Lerp(1.2, [&stretch])
    readout = Readout(3, 4)
    play Fade(0.4, [&readout])

slide "Shrink the interval to a tenth of a second: from 3 s to 3.1 s the slope is 9.15 m/s."
    readout = []
    play Fade(0.3, [&readout])
    stretch.b = 3.1
    play Lerp(1.2, [&stretch])
    readout = Readout(3, 3.1)
    play Fade(0.4, [&readout])

slide "From 12 s to 14 s the graph is flat. The slope is 0: the car is parked."
    readout = []
    play Fade(0.3, [&readout])
    stretch.a = 12
    stretch.b = 14
    play Lerp(1.4, [&stretch])
    readout = Readout(12, 14)
    play Fade(0.4, [&readout])

slide "From 16 s to 18 s the graph falls 12 m in 2 s. The slope is negative: the car is backing up."
    readout = []
    play Fade(0.3, [&readout])
    stretch.a = 16
    stretch.b = 18
    play Lerp(1.2, [&stretch])
    readout = Readout(16, 18)
    play Fade(0.4, [&readout])

Uses the shared definitions for this lesson's figures.

Over the intervals from 3 s to 4 s, to 3.5 s and to 3.1 s the average velocities are 10.5, 9.75 and 9.15 m/s. They are heading for 9, and we can see why. During the first four seconds this car’s position is $x = 1.5t^2$ meters (we will derive that formula below), so from $t = 3$ to $t = 3 + h$ the average velocity is

$$ \frac{1.5(3+h)^2 - 1.5(3)^2}{h} = \frac{9h + 1.5h^2}{h} = 9 + 1.5h \text{ m/s}. $$

The leftover $1.5h$ can be made as small as we like by shortening the interval, and the only number the averages approach is 9. That number is what we mean by the velocity at $t = 3$ s.

Velocity carries a sign, and the sign means direction. A positive slope says the car moves in the positive direction, a negative slope says it moves the other way, and zero slope says it is at rest. That settles the opening questions: steepest climb from 4 s to 8 s ($v = 12$ m/s), flat from 12 s to 14 s ($v = 0$), falling from 14 s to 20 s ($v < 0$, with $v = -6$ m/s on the straight part).

If we read the slope at every moment and plot it, we get a second graph. Then we can do the same thing to that graph and get a third.

The same trip at double speed with three graphs drawn in step: position, the slope of the position graph (velocity), and the slope of the velocity graph (acceleration).
Monocurl source
let fa = Frame(0, 20, 0, 100, [-2.275, 0.52, 0], 1.85, 1.9)
let fb = Frame(0, 20, -8, 14, [0.175, 0.52, 0], 1.85, 1.9)
let fc = Frame(0, 20, -4, 4, [2.625, 0.52, 0], 1.85, 1.9)
let ROAD_Y = -1.7
let rx = |m| -3.0 + 0.064 * m
let GX = [4, 8, 12, 16, 20]
mesh panels = [
    Panel(fa, GX, [25, 50, 75, 100], [0, 8, 16], [0, 50, 100], "time (s)", "position (m)", XC),
    Panel(fb, GX, [-6, 6, 12], [0, 8, 16], [-6, 0, 6, 12], "time (s)", "velocity (m/s)", VC),
    Panel(fc, GX, [-3, 3], [0, 8, 16], [-3, 0, 3], "time (s)", "acceleration (m/s²)", AC)
]
mesh road = Road(rx(0), rx(100), ROAD_Y)
let Sync = |t| {
    let m = vel(t)
    let lo = max(0, t - 2.2)
    let hi = min(20, t + 2.2)
    return [
        Trace(fa, pos, t, XC),
        Seg(at(fa, lo, clamp(0, pos(t) + m * (lo - t), 100)), at(fa, hi, clamp(0, pos(t) + m * (hi - t), 100)), VC, 3),
        Pt(at(fa, t, pos(t)), VC, 0.075),
        Trace(fb, vel, t, VC),
        Pt(at(fb, t, vel(t)), VC, 0.075),
        AccTrace(fc, t, AC),
        Pt(at(fc, t, acc(t)), AC, 0.075),
        Car([rx(pos(t)), ROAD_Y, 0])
    ]
}
mesh sync = Sync(t: 0)

slide "sync"
    play Wait(0.7)
    sync.t = 20
    play Lerp(10, [&sync], linear)
    play Wait(1.4)

Uses the shared definitions for this lesson's figures.

Acceleration is the slope of the velocity graph

The velocity graph of this trip is made of straight pieces, which is what makes it a good first example. Look at the first one. In 4 s the velocity rises from 0 to 12 m/s, so the car gains 3 m/s of velocity every second. A rate of “meters per second, per second” is written m/s².

Reading the slope of each straight piece gives the whole trip in one table.

Time (s)Velocity (m/s)Acceleration (m/s²)What the car is doing
0 to 40 up to 12$+3$speeding up, forward
4 to 8120cruising forward
8 to 1212 down to 0$-3$slowing down, forward
12 to 1400parked
14 to 160 down to $-6$$-3$speeding up, backward
16 to 18$-6$0cruising backward
18 to 20$-6$ up to 0$+3$slowing down, backward
The car's velocity graph (top) with a slope triangle on each sloping piece, and its acceleration graph (bottom) on the same time axis. Each level of the lower graph is the slope of the piece above it.
The car’s velocity graph (top) with a slope triangle on each sloping piece, and its acceleration graph (bottom) on the same time axis. Each level of the lower graph is the slope of the piece above it.
Monocurl source
let fv = Frame(0, 20, -8, 14, [0.15, 1.02, 0], 6.2, 1.42)
let fa = Frame(0, 20, -4, 4, [0.15, -0.84, 0], 6.2, 1.1)
let GX = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
let Tri = |t0, t1| Path([at(fv, t0, vel(t0)), at(fv, t1, vel(t0)), at(fv, t1, vel(t1))], SLATE, 2.5)
mesh panels = [
    Panel(fv, GX, [-6, 6, 12], [], [-6, 0, 6, 12], "", "velocity v (m/s)", VC),
    Panel(fa, GX, [-3, 3], [0, 4, 8, 12, 16, 20], [-3, 0, 3], "time t (s)", "acceleration a (m/s²)", AC)
]
mesh tris = [Tri(1, 3), Tri(9, 11), Tri(14.5, 15.5), Tri(18.5, 19.5)]
mesh vgraph = Trace(fv, vel, 20, VC, 4.5)
mesh agraph = AccTrace(fa, 20, AC, 4.5)

Uses the shared definitions for this lesson's figures.

Two rows of the table deserve a second look. From 14 s to 16 s the acceleration is negative and the car is speeding up. From 18 s to 20 s the acceleration is positive and the car is slowing down. Acceleration says which way the velocity is changing, and whether that makes the car faster or slower depends on which way it is already going. The rule that covers all seven rows is this: an object speeds up when $v$ and $a$ have the same sign, and slows down when they have opposite signs.

Going back: area under the velocity graph

Slopes took us from position to velocity. Suppose now that only the velocity graph survived, and we want to recover how far the car went.

Where the velocity is constant this is easy. From 4 s to 8 s the car does 12 m/s for 4 s, so $\Delta x = v\,\Delta t = 12 \times 4 = 48$ m. On the velocity graph, 12 is the height of a rectangle and 4 is its width, so the displacement is the rectangle’s area. The units agree: (m/s) × s = m.

During the first four seconds the velocity is changing, and there is no single height to multiply by. So we cut the time into short strips and treat the velocity as constant within each one. We can do this honestly in two ways. If the car’s velocity stays between 3 m/s and 6 m/s during some second, it travels at least 3 m and at most 6 m in that second. Using the lowest velocity in every strip gives a total that is too small, and using the highest gives one that is too large.

Pause and try

Cut the first 4 s into four strips of 1 s. The velocity is $v = 3t$, so it is 0, 3, 6, 9 and 12 m/s at $t = 0, 1, 2, 3, 4$. Find the too-small total and the too-large total. Then guess the exact displacement.

Show answerHide answer

Too small: $(0 + 3 + 6 + 9) \times 1 = 18$ m. Too large: $(3 + 6 + 9 + 12) \times 1 = 30$ m. The truth is somewhere between, and the midpoint, 24 m, is the natural guess. The figure tests it.

  1. Four strips of 1 s: the displacement is between 18 m and 30 m.
  2. Eight strips: between 21 m and 27 m.
  3. Sixteen strips: between 22.5 m and 25.5 m.
  4. Sixty-four strips: between 23.625 m and 24.375 m. Both totals close in on 24 m, the area of the triangle under the line.
The first four seconds of the velocity graph cut into strips. The blue rectangles use the lowest velocity in each strip and the grey caps raise them to the highest, so the true displacement is trapped between the two totals.
Monocurl source
let fz = Frame(0, 4, 0, 12, [-0.95, 0.25, 0], 4.5, 3.0)
let Strips = |n| block {
    for (k in range(0, n)) {
        let t0 = 4 * k / n
        let t1 = 4 * (k + 1) / n
        if (k > 0) {
            . Shape([at(fz, t0, 0), at(fz, t1, 0), at(fz, t1, 3 * t0), at(fz, t0, 3 * t0)], AZURE, 0.25, 1.2)
        }
        . Shape([at(fz, t0, 3 * t0), at(fz, t1, 3 * t0), at(fz, t1, 3 * t1), at(fz, t0, 3 * t1)], SLATE, 0.3, 1.2)
    }
}
let Totals = |n| [
    center{[2.65, 1.5, 0]} Note("strips", 0.74),
    center{[2.65, 1.05, 0]} Math(to_string(n), 0.95),
    center{[2.65, 0.4, 0]} Cap("too small", 0.74, AZURE),
    center{[2.65, -0.05, 0]} Math(str_join([to_string(24 - 24 / n, 3), "\text{ m}"]), 0.95, AZURE),
    center{[2.65, -0.7, 0]} Cap("too large", 0.74, SLATE),
    center{[2.65, -1.15, 0]} Math(str_join([to_string(24 + 24 / n, 3), "\text{ m}"]), 0.95, SLATE)
]
mesh plot = Panel(fz, [1, 2, 3, 4], [3, 6, 9, 12], [0, 1, 2, 3, 4], [0, 3, 6, 9, 12], "time t (s)", "velocity v (m/s)", VC)
mesh strips = []
mesh line = Seg(at(fz, 0, 0), at(fz, 4, 12), VC, 4.5)
mesh totals = []

slide "Four strips of 1 s: the displacement is between 18 m and 30 m."
    strips = Strips(4)
    totals = Totals(4)
    play Fade(0.8)

slide "Eight strips: between 21 m and 27 m."
    strips = []
    totals = []
    play Fade(0.3, [&strips, &totals])
    strips = Strips(8)
    totals = Totals(8)
    play Fade(0.6, [&strips, &totals])

slide "Sixteen strips: between 22.5 m and 25.5 m."
    strips = []
    totals = []
    play Fade(0.3, [&strips, &totals])
    strips = Strips(16)
    totals = Totals(16)
    play Fade(0.6, [&strips, &totals])

slide "Sixty-four strips: between 23.625 m and 24.375 m. Both totals close in on 24 m, the area of the triangle under the line."
    strips = []
    totals = []
    play Fade(0.3, [&strips, &totals])
    strips = Strips(64)
    totals = Totals(64)
    play Fade(0.6, [&strips, &totals])

Uses the shared definitions for this lesson's figures.

With $n$ strips the two totals work out to $24 - 24/n$ and $24 + 24/n$ meters. The true displacement lies between them for every $n$, and so does the area of the triangle under the line, since the blue staircase fits inside the triangle and the capped one covers it. Two numbers that are both trapped in an interval of width $48/n$, for every $n$, cannot differ. So the displacement in the first four seconds equals the triangle’s area exactly: $\tfrac{1}{2} \times 4 \text{ s} \times 12 \text{ m/s} = 24$ m, which is where the graph put the car at $t = 4$ s.

To be clear about the status of that argument: for a velocity graph that is a straight line, we have proved that displacement equals area, given one physical fact: over any interval, the displacement is at least the lowest velocity times the duration and at most the highest velocity times the duration. For a curved velocity graph the same trapping works, but showing that the two totals always close in on a single number takes more care; that is the subject of integrals and the fundamental theorem of calculus.

One more point before we use it. From 14 s to 20 s the velocity is negative, and $v\,\Delta t$ is negative for every strip, so the region between the graph and the time axis counts as negative there. Displacement is a signed area: regions above the axis add and regions below it subtract.

  1. For the first 4 s the area under the velocity graph is a triangle: 24 m.
  2. From 4 s to 8 s a rectangle adds 12 times 4, or 48 m. The car is at 72 m.
  3. Braking from 8 s to 12 s adds another triangle of 24 m: 96 m in all.
  4. While the car is parked the velocity is zero and no area is added.
  5. From 14 s to 20 s the velocity is negative. That area is -24 m, and the car ends at 72 m.
Signed area under the car’s velocity graph, accumulated from the start of the trip, rebuilds the position graph. Area above the time axis is blue and counts as positive; area below is gold and counts as negative.
Monocurl source
let fv = Frame(0, 20, -8, 14, [-0.75, 1.02, 0], 4.9, 1.42)
let fp = Frame(0, 20, 0, 100, [-0.75, -0.84, 0], 4.9, 1.1)
let GX = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
let Piece = |t0, t1| {
    if (abs(vel(t0)) + abs(vel(t1)) < 0.05) { return [] }
    var pts = [at(fv, t0, 0)]
    if (abs(vel(t0)) > 0.02) { pts .= at(fv, t0, vel(t0)) }
    if (abs(vel(t1)) > 0.02) { pts .= at(fv, t1, vel(t1)) }
    pts .= at(fv, t1, 0)
    if (vel(t0) + vel(t1) > 0) { return Region(pts, tint(AZURE, 0.3)) }
    return Region(pts, tint(GOLD, 0.4))
}
let Sweep = |t| {
    var out = []
    for (ph in PHASES) {
        let hi = min(t, ph[1])
        if (hi - ph[0] > 0.03) {
            out .= Piece(ph[0], hi)
        }
    }
    out .= Trace(fv, vel, 20, VC, 4)
    out .= Seg(at(fv, t, -8), at(fv, t, 14), SLATE, 2)
    out .= Trace(fp, pos, t, XC, 4)
    out .= Pt(at(fp, t, pos(t)), XC, 0.085)
    out .= center{[2.85, 1.12, 0]} scale{1.3} color{SLATE} Number(t, 1)
    out .= center{[2.85, -0.75, 0]} scale{1.5} color{XC} Number(pos(t), 1)
    return out
}
mesh panels = [
    Panel(fv, GX, [-6, 6, 12], [], [-6, 0, 6, 12], "", "velocity v (m/s)", VC),
    Panel(fp, GX, [25, 50, 75, 100], [0, 4, 8, 12, 16, 20], [0, 50, 100], "time t (s)", "position x (m)", XC)
]
mesh label = [
    center{[2.85, 1.6, 0]} Note("time (s)", 0.74),
    center{[2.85, 0.2, 0]} Note("signed area", 0.74),
    center{[2.85, -0.15, 0]} Note("so far (m)", 0.74)
]
mesh sweep = Sweep(t: 0.04)

slide "For the first 4 s the area under the velocity graph is a triangle: 24 m."
    sweep.t = 4
    play Lerp(1.6, [&sweep], linear)

slide "From 4 s to 8 s a rectangle adds 12 times 4, or 48 m. The car is at 72 m."
    sweep.t = 8
    play Lerp(1.6, [&sweep], linear)

slide "Braking from 8 s to 12 s adds another triangle of 24 m: 96 m in all."
    sweep.t = 12
    play Lerp(1.6, [&sweep], linear)

slide "While the car is parked the velocity is zero and no area is added."
    sweep.t = 14
    play Lerp(1, [&sweep], linear)

slide "From 14 s to 20 s the velocity is negative. That area is -24 m, and the car ends at 72 m."
    sweep.t = 20
    play Lerp(2.2, [&sweep], linear)

Uses the shared definitions for this lesson's figures.

Notice what area cannot tell you: it gives the change in position, so to know where the car is you need its starting position as well. The same argument one level up shows that the signed area under an acceleration graph is the change in velocity.

Constant acceleration: four equations from one trapezoid

Many motions have a stretch of constant acceleration: a car braking steadily, a ball in the air. For those the velocity graph is one straight line, the area under it is a trapezoid, and everything can be written as a formula.

Pause and try

A car moving at 4 m/s accelerates at 2 m/s² for 5 s. Sketch its velocity graph and find its displacement from the area, by splitting the region under the line into a rectangle and a triangle.

Show answerHide answer

The velocity climbs from 4 m/s to $4 + 2 \times 5 = 14$ m/s. The rectangle is 4 m/s tall and 5 s wide: 20 m. The triangle on top is 5 s wide and $14 - 4 = 10$ m/s tall: $\tfrac12 \times 5 \times 10 = 25$ m. Displacement: 45 m.

The velocity graph for a car that starts at 4 m/s and accelerates at 2 m/s² for 5 s. The rectangle is the distance it would cover at its starting velocity; the triangle is the extra distance gained by speeding up.
The velocity graph for a car that starts at 4 m/s and accelerates at 2 m/s² for 5 s. The rectangle is the distance it would cover at its starting velocity; the triangle is the extra distance gained by speeding up.
Monocurl source
let ft = Frame(0, 6, 0, 16, [-0.95, 0.25, 0], 4.5, 3.0)
let V0 = 4
let A = 2
let T = 5
let V1 = V0 + A * T
mesh plot = Panel(ft, [1, 2, 3, 4, 5, 6], [4, 8, 12, 16], [0, 1, 2, 3, 4, 5, 6], [0, 4, 8, 12, 16], "time t (s)", "velocity v (m/s)", VC)
mesh areas = [
    Region([at(ft, 0, 0), at(ft, T, 0), at(ft, T, V0), at(ft, 0, V0)], tint(AZURE, 0.3)),
    Region([at(ft, 0, V0), at(ft, T, V0), at(ft, T, V1)], tint(GOLD, 0.4)),
    Seg(at(ft, T, 0), at(ft, T, V1), SLATE, 2.5),
    Seg(at(ft, 0, V0), at(ft, T, V0), SLATE, 2.5)
]
mesh line = [Seg(at(ft, 0, V0), at(ft, T, V1), VC, 4.5), Pt(at(ft, 0, V0), VC, 0.085), Pt(at(ft, T, V1), VC, 0.085)]
mesh inside = [
    center{at(ft, 2.5, 2)} Math(str_join(["v_0 t = ", to_string(V0 * T), "\text{ m}"]), 0.85, AZURE),
    center{at(ft, 3.75, 6.1)} Math(str_join(["\frac{1}{2} a t^2 = ", to_string(A * T * T // 2), "\text{ m}"]), 0.8, INK)
]
mesh side = [
    center{[2.65, 1.45, 0]} Math(str_join(["v_0 = ", to_string(V0), "\text{ m/s}"]), 0.85),
    center{[2.65, 0.9, 0]} Math(str_join(["a = ", to_string(A), "\text{ m/s}^2"]), 0.85),
    center{[2.65, 0.35, 0]} Math(str_join(["t = ", to_string(T), "\text{ s}"]), 0.85),
    center{[2.65, -0.45, 0]} Note("displacement", 0.74),
    center{[2.65, -0.95, 0]} Math(str_join([to_string(V0 * T + A * T * T // 2), "\text{ m}"]), 1.1, LEAF)
]

Uses the shared definitions for this lesson's figures.

Replace the numbers with letters and the same picture gives the general result.

Check the units of (2): $v_0 t$ is (m/s)(s) = m and $\tfrac12 at^2$ is (m/s²)(s²) = m, so every term is a length. In (4) every term is in m²/s². A formula whose terms have different units is wrong.

Each equation leaves out one of the quantities $x - x_0$, $v$, $a$, $t$, and that tells you which to reach for: (4) has no $t$ in it, so it answers “how far” questions when nobody has told you how long.

The first four seconds of our car are the case $x_0 = 0$, $v_0 = 0$, $a = 3$ m/s², where (2) gives $x = 1.5t^2$, the formula we borrowed earlier. Another case is worth recognizing. An object falling freely near the Earth’s surface, with air resistance neglected, has a constant downward acceleration of magnitude $g \approx 9.8$ m/s². Dropped from rest, it falls $\tfrac12 g t^2 = 4.9t^2$ meters in $t$ seconds, which rounds to the $5t^2$ used for the falling ball in the calculus lesson linked above.

Worked examples

The thrown ball in real time, with its height graph and velocity graph. The velocity falls along one straight line of slope $-9.8$ m/s² for the whole flight and passes through zero at the top.
Monocurl source
let Y0 = 2
let V0 = 15
let G = 9.8
let TEND = (V0 + sqrt(V0 * V0 + 2 * G * Y0)) / G
let hgt = |t| Y0 + V0 * t - 0.5 * G * t * t
let spd = |t| V0 - G * t
let fh = Frame(0, 3.5, 0, 15, [-0.9, 0.2, 0], 2.55, 3.0)
let fw = Frame(0, 3.5, -18, 18, [2.42, 0.2, 0], 2.55, 3.0)
let BX = -3.25
let Curve = |f, fn, t, col| {
    let n = to_int(max(2, ceil(t * 30)))
    return stroke{col, 4} Polyline(map(sample(0, max(t, 0.03), n), |u| at(f, u, fn(u))))
}
mesh ruler = [
    Seg([BX - 0.35, fy(fh, 0) - 0.14, 0], [BX + 0.35, fy(fh, 0) - 0.14, 0], SLATE, 3),
    center{[BX, fy(fh, 15) + 0.3, 0]} Cap("the ball", 0.74, EMBER)
]
mesh panels = [
    Panel(fh, [1, 2, 3], [5, 10, 15], [0, 1, 2, 3], [0, 5, 10, 15], "time t (s)", "height y (m)", XC),
    Panel(fw, [1, 2, 3], [-15, -10, -5, 5, 10, 15], [0, 1, 2, 3], [-15, 0, 15], "time t (s)", "velocity v (m/s)", VC)
]
let Flight = |t| [
    Seg(at(fh, 0, hgt(t)), at(fh, max(t, 0.02), hgt(t)), SLATE, 1.5),
    Curve(fh, hgt, t, XC),
    Pt(at(fh, t, hgt(t)), XC, 0.085),
    Curve(fw, spd, t, VC),
    Pt(at(fw, t, spd(t)), VC, 0.085),
    Pt([BX, fy(fh, hgt(t)), 0], EMBER, 0.13)
]
mesh flight = Flight(t: 0)

slide "flight"
    play Wait(0.7)
    flight.t = TEND
    play Lerp(TEND, [&flight], linear)
    play Wait(1.5)

Uses the shared definitions for this lesson's figures.

At the top of the flight the velocity is zero and the acceleration is still $-9.8$ m/s². If both were zero the ball would stay there.

Where the equations stop working

The four equations were proved for one stretch of constant acceleration, and they fail the moment that hypothesis does. Apply (2) blindly to the car’s whole trip with the first phase’s numbers, $x = \tfrac12 (3)(20)^2$, and you get 600 m; the car is actually at 72 m. For a motion with several phases, use the equations one phase at a time, feeding the final position and velocity of each phase into the next as its $x_0$ and $v_0$, or go back to slopes and areas, which do not need the acceleration to be constant.

Free fall is the other place to be careful. Air resistance grows with speed, so a real falling object’s acceleration shrinks as it speeds up. For a ball thrown across a room the effect is too small to notice. For a skydiver it dominates: the model $v = 9.8t$ predicts 98 m/s after ten seconds, while a real skydiver in a spread position levels off near 55 m/s.

Finally, our car’s acceleration jumps from $+3$ to 0 at $t = 4$ s. The velocity graph has a corner there, so its slope, and with it the acceleration, has no single value at that instant. Real cars change acceleration over a few tenths of a second, which rounds the corners and changes the distances very little.

Check yourself

A ball thrown straight up is at the highest point of its flight. Taking up as positive and neglecting air resistance, what are its velocity and acceleration at that instant?

The next lesson, on Newton’s second law, asks what sets the acceleration in the first place, and the answer is force.

Problems

Use $g = 9.8$ m/s² and neglect air resistance unless told otherwise. State your origin and positive direction in every solution.

Problem 1

Using the car of this lesson, find its average velocity from $t = 2$ s to $t = 10$ s. (You will need $x(2)$ and $x(10)$; get them from the constant-acceleration equations.)

Show solutionHide solution

During the first phase $x = 1.5t^2$, so $x(2) = 6$ m. The third phase starts at $t = 8$ s with $x_0 = 72$ m, $v_0 = 12$ m/s and $a = -3$ m/s²; two seconds into it, $x = 72 + 12(2) + \tfrac12(-3)(2)^2 = 90$ m. So $v_{\text{avg}} = \dfrac{90 - 6}{10 - 2} = 10.5$ m/s. As a check, the area under the velocity graph from 2 s to 10 s is two trapezoids of $\tfrac12(6 + 12)(2) = 18$ m each and a rectangle of 48 m: 84 m in total.

Problem 2

A cyclist riding at 4 m/s accelerates uniformly to 10 m/s over 3 s and then holds that velocity for 5 s. Find her acceleration during the first 3 s and her total displacement over the 8 s.

Show solutionHide solution

Take her direction of travel as positive. Acceleration: $a = (10 - 4)/3 = 2$ m/s². The area under the velocity graph is a trapezoid followed by a rectangle. Trapezoid: $\tfrac12(4 + 10)(3) = 21$ m. Rectangle: $10 \times 5 = 50$ m. Total displacement: 71 m.

Problem 3

At what times is the lesson’s car exactly 84 m from its starting point?

Show solutionHide solution

The position rises to 96 m and comes back to 72 m, so it passes 84 m twice. On the way out: at $t = 8$ s the car is at 72 m, so 84 m is reached during the braking phase, where $x = 72 + 12u - 1.5u^2$ with $u = t - 8$. Setting this equal to 84 gives $1.5u^2 - 12u + 12 = 0$, that is, $u^2 - 8u + 8 = 0$, so $u = 4 \pm 2\sqrt2$. Only $u = 4 - 2\sqrt2 \approx 1.17$ lies within the phase ($0 \le u \le 4$), so $t \approx 9.17$ s. On the way back: at $t = 16$ s the car is at $96 - 6 = 90$ m and then moves at $-6$ m/s, so it reaches 84 m one second later, at $t = 17$ s.

Problem 4

A driver traveling at 30 m/s sees an obstacle 80 m ahead. Her reaction time is 0.8 s, during which the car keeps its velocity, and then she brakes at a constant 7.5 m/s². (a) What total distance would the car need to stop? (b) How fast is it moving when it reaches the obstacle?

Show solutionHide solution

Positive in the direction of travel, origin where she first sees the obstacle. (a) During the reaction time the car covers $30 \times 0.8 = 24$ m. Braking from 30 m/s to rest: $0 = 30^2 + 2(-7.5)\Delta x$, so $\Delta x = 900/15 = 60$ m. Total: 84 m, which is 4 m more than she has. (b) Braking begins at $x = 24$ m, leaving $80 - 24 = 56$ m. Then $v^2 = 30^2 + 2(-7.5)(56) = 900 - 840 = 60$, so $v \approx 7.7$ m/s. The last 4 m of the stopping distance would have removed the final 7.7 m/s.

Problem 5

For each statement, say whether it is true or false, and give an example from this lesson that supports your answer. (a) If an object’s velocity is zero at some instant, its acceleration is zero at that instant. (b) If an object’s acceleration is zero over an interval, it is at rest. (c) If an object’s acceleration is positive, its speed is increasing.

Show solutionHide solution

(a) False. The thrown ball at the top of its flight has $v = 0$ and $a = -9.8$ m/s². (b) False. From 4 s to 8 s the car has $a = 0$ and moves steadily at 12 m/s; zero acceleration means constant velocity, and rest is only the special case $v = 0$. (c) False. From 18 s to 20 s the car has $a = +3$ m/s² and $v < 0$, and its speed drops from 6 m/s to 0. Speed increases only when $a$ and $v$ have the same sign.

Problem 6

A speeding car passes a parked police car at a constant 24 m/s. At that instant the police car starts from rest with constant acceleration 3 m/s². (a) When and where does the police car draw level? (b) How fast is it going then? (c) Explain the answer to (b) using the two velocity graphs, without equations.

Show solutionHide solution

Origin at the parked police car, positive along the road, $t = 0$ when the speeder passes. (a) Speeder: $x = 24t$. Police: $x = \tfrac12(3)t^2 = 1.5t^2$. They are level when $1.5t^2 = 24t$, so $t = 0$ (the start) or $t = 16$ s, at $x = 24 \times 16 = 384$ m. (b) $v = 3 \times 16 = 48$ m/s, exactly twice the speeder’s velocity. (c) Both cars have the same displacement at the moment they are level, so the areas under their velocity graphs from 0 to that time are equal. The speeder’s is a rectangle of height 24; the police car’s is a triangle on the same base. A triangle has half the area of a rectangle with the same base and height, so to match the rectangle the triangle must be twice as tall: 48 m/s.

Problem 7

Galileo found that a ball starting from rest with constant acceleration covers distances in successive equal time intervals in the ratio $1 : 3 : 5 : 7 : \dots$ Prove it. Then explain it from the velocity graph.

Show solutionHide solution

Let the intervals have length $\tau$ and the acceleration be $a$, with $x_0 = 0$ and $v_0 = 0$. At the end of the $n$th interval $t = n\tau$ and $x = \tfrac12 a n^2\tau^2$. The distance covered during the $n$th interval is therefore

$$ \tfrac12 a\tau^2\bigl(n^2 - (n-1)^2\bigr) = \tfrac12 a\tau^2\,(2n - 1). $$

For $n = 1, 2, 3, 4$ the factor $2n - 1$ is $1, 3, 5, 7$. On the velocity graph, a line through the origin, cut the region under the line at $t = \tau, 2\tau, 3\tau, \dots$ The first piece is a triangle of area $\tfrac12 a\tau^2$. Each later piece is a trapezoid that can be tiled by copies of that triangle: the $n$th strip is a rectangle of height $(n-1)a\tau$, which is $2(n-1)$ triangles, with one more triangle on top, making $2n - 1$.

Problem 8

(a) Prove that for motion with constant acceleration, the average velocity over any time interval equals the instantaneous velocity at the middle instant of that interval. (b) Show with the lesson’s car that this can fail when the acceleration is not constant over the interval.

Show solutionHide solution

(a) Let the interval run from $t_1$ to $t_2$ with velocities $v_1$ and $v_2$ at its ends. Equation (3), applied with the clock started at $t_1$, gives $\Delta x = \tfrac12(v_1 + v_2)(t_2 - t_1)$, so $v_{\text{avg}} = \tfrac12(v_1 + v_2)$. The velocity at the middle instant $t_m = \tfrac12(t_1 + t_2)$ is, by equation (1), $v_1 + a\,(t_m - t_1) = v_1 + \tfrac12 a(t_2 - t_1) = v_1 + \tfrac12(v_2 - v_1) = \tfrac12(v_1 + v_2)$. (b) Take the interval from 0 s to 8 s. The average velocity is $72/8 = 9$ m/s. The middle instant is $t = 4$ s, when the velocity is 12 m/s. They differ because the acceleration changed from 3 m/s² to 0 at $t = 4$ s, so the velocity graph over this interval is not a single straight line.

Shared definitions used by this lesson's figures
# house kit: prepended to every essay figure after the std imports

# palette. AZURE and EMBER are the two actors, LEAF marks an answer, ROSE a problem
let PAPER = [1, 1, 1, 1]
let INK = [0.08, 0.09, 0.11, 1]
let SLATE = [0.40, 0.44, 0.50, 1]
let MIST = [0.85, 0.86, 0.88, 1]
let AZURE = [0.13, 0.42, 0.68, 1]
let EMBER = [0.89, 0.42, 0.12, 1]
let LEAF = [0.13, 0.55, 0.36, 1]
let ROSE = [0.78, 0.22, 0.24, 1]
let PLUM = [0.47, 0.30, 0.66, 1]
let GOLD = [0.85, 0.62, 0.08, 1]

background = PAPER

# an opaque pastel of col; use for fills so overlaps do not darken
let tint = |col, amount = 0.18| [
    1 - (1 - col[0]) * amount,
    1 - (1 - col[1]) * amount,
    1 - (1 - col[2]) * amount,
    1
]

# text: Cap for labels, Note for quiet labels, Math for typeset maths
let Cap = |txt, size = 0.75, col = INK| color{col} Text(txt, size, "Charter")
let Note = |txt, size = 0.65| color{SLATE} Text(txt, size, "Charter")
let Math = |tex, size = 0.9, col = INK| color{col} Tex(tex, size)

# a paper rectangle to sit behind text that crosses lines
let Plate = |pos, size| center{pos} fill{PAPER} stroke{alpha{0} PAPER, 0} Rect(size)

# shapes with fill and stroke both set, so no stray black appears
let Pt = |pos, col = INK, r = 0.075| center{pos} fill{col} stroke{col, 1} Circle(r, 48)
let Ring = |pos, col = INK, r = 0.1, w = 3| center{pos} fill{PAPER} stroke{col, w} Circle(r, 48)
let Seg = |a, b, col = INK, w = 3| stroke{col, w} Line(a, b)
let Path = |pts, col = INK, w = 3| stroke{col, w} Polyline(pts)
let Region = |pts, col| fill{col} stroke{alpha{0} col, 0} Polygon(pts)
let Outline = |pts, col = INK, w = 3| fill{alpha{0} PAPER} stroke{col, w} Polygon(pts)
let Shape = |pts, col, amount = 0.18, w = 3| fill{tint(col, amount)} stroke{col, w} Polygon(pts)
let Disc = |pos, r, col, amount = 0.18, w = 3| center{pos} fill{tint(col, amount)} stroke{col, w} Circle(r, 96)
let Box = |pos, size, col, amount = 0.18, w = 3| center{pos} fill{tint(col, amount)} stroke{col, w} Rect(size)
# a line from a to b ending in a small solid arrowhead
let Tip = |a, b, col = INK, w = 3, head = 0.17| {
    let d = normalize([b[0] - a[0], b[1] - a[1], 0])
    let n = [-d[1], d[0], 0]
    let base = [b[0] - d[0] * head, b[1] - d[1] * head, 0]
    return [
        stroke{col, w} Line(a, base),
        fill{col} stroke{col, 1} Polygon([
            b,
            [base[0] + n[0] * head * 0.42, base[1] + n[1] * head * 0.42, 0],
            [base[0] - n[0] * head * 0.42, base[1] - n[1] * head * 0.42, 0]
        ])
    ]
}

# plots. a frame is [x0, x1, y0, y1, centre, width, height]: a data window and the scene box it fills
let Frame = |x0, x1, y0, y1, c = [0, 0, 0], w = 6.4, h = 3.6| [x0, x1, y0, y1, c, w, h]
let fx = |fr, x| fr[4][0] + (x - (fr[0] + fr[1]) / 2) * fr[5] / (fr[1] - fr[0])
let fy = |fr, y| fr[4][1] + (y - (fr[2] + fr[3]) / 2) * fr[6] / (fr[3] - fr[2])
let at = |fr, x, y| [fx(fr, x), fy(fr, y), 0]

# axes through the data origin (or the nearest edge of the window), with optional names
let Axes = |fr, x_name = "", y_name = "", col = SLATE| {
    let ox = clamp(fr[0], 0, fr[1])
    let oy = clamp(fr[2], 0, fr[3])
    var parts = [
        Tip(at(fr, fr[0], oy), [fx(fr, fr[1]) + 0.25, fy(fr, oy), 0], col, 2.5, 0.15),
        Tip(at(fr, ox, fr[2]), [fx(fr, ox), fy(fr, fr[3]) + 0.25, 0], col, 2.5, 0.15)
    ]
    if (x_name != "") {
        parts .= center{[fx(fr, fr[1]) + 0.5, fy(fr, oy), 0]} Math(x_name, 0.8, col)
    }
    if (y_name != "") {
        parts .= center{[fx(fr, ox), fy(fr, fr[3]) + 0.5, 0]} Math(y_name, 0.8, col)
    }
    return parts
}

# tick marks with numbers at the listed data values
let XTicks = |fr, xs, col = SLATE, places = 0| block {
    let oy = fy(fr, clamp(fr[2], 0, fr[3]))
    for (x in xs) {
        . Seg([fx(fr, x), oy - 0.07, 0], [fx(fr, x), oy + 0.07, 0], col, 2)
        . center{[fx(fr, x), oy - 0.33, 0]} Math(to_string(x, places), 0.72, col)
    }
}
let YTicks = |fr, ys, col = SLATE, places = 0| block {
    let ox = fx(fr, clamp(fr[0], 0, fr[1]))
    for (y in ys) {
        . Seg([ox - 0.07, fy(fr, y), 0], [ox + 0.07, fy(fr, y), 0], col, 2)
        . center{[ox - 0.36, fy(fr, y), 0]} Math(to_string(y, places), 0.72, col)
    }
}

# faint grid lines at the listed data values
let GridLines = |fr, xs, ys, col = MIST| block {
    for (x in xs) {
        . Seg(at(fr, x, fr[2]), at(fr, x, fr[3]), col, 1.5)
    }
    for (y in ys) {
        . Seg(at(fr, fr[0], y), at(fr, fr[1], y), col, 1.5)
    }
}

# the graph of f over [a, b], drawn in the frame. values are clamped to the window
let Graph = |fr, f, a, b, col = AZURE, w = 4, n = 160|
    stroke{col, w} Polyline(map(sample(a, b, n), |x| at(fr, x, clamp(fr[2], f(x), fr[3]))))

# the region between the graph of f and the x axis over [a, b]
let AreaUnder = |fr, f, a, b, col = AZURE, amount = 0.2, n = 80| {
    var pts = [at(fr, a, 0)]
    for (x in sample(a, b, n)) {
        pts .= at(fr, x, clamp(fr[2], f(x), fr[3]))
    }
    pts .= at(fr, b, 0)
    return fill{tint(col, amount)} stroke{alpha{0} col, 0} Polygon(pts)
}

# a car on a straight road: seven phases of constant acceleration, [start s, end s, m/s^2]
let PHASES = [[0, 4, 3], [4, 8, 0], [8, 12, -3], [12, 14, 0], [14, 16, -3], [16, 18, 0], [18, 20, 3]]
let acc = |t| {
    for (ph in PHASES) {
        if (t < ph[1]) { return ph[2] }
    }
    return 3
}
let vel = |t| {
    if (t < 4) { return 3 * t }
    if (t < 8) { return 12 }
    if (t < 12) { return 12 - 3 * (t - 8) }
    if (t < 14) { return 0 }
    if (t < 16) { return -3 * (t - 14) }
    if (t < 18) { return -6 }
    return -6 + 3 * (t - 18)
}
let pos = |t| {
    if (t < 4) { return 1.5 * t * t }
    if (t < 8) { return 24 + 12 * (t - 4) }
    if (t < 12) { return 72 + 12 * (t - 8) - 1.5 * (t - 8) * (t - 8) }
    if (t < 14) { return 96 }
    if (t < 16) { return 96 - 1.5 * (t - 14) * (t - 14) }
    if (t < 18) { return 90 - 6 * (t - 16) }
    return 78 - 6 * (t - 18) + 1.5 * (t - 18) * (t - 18)
}
let XC = AZURE
let VC = EMBER
let AC = PLUM

# plot furniture: grid, left and bottom edges, a zero line, numbers along the edges, names
let Panel = |f, gx, gy, lx, ly, xname, title, col = SLATE| block {
    . GridLines(f, gx, gy)
    if (f[2] < 0) {
        . Seg(at(f, f[0], 0), at(f, f[1], 0), SLATE, 2)
    }
    . Path([at(f, f[0], f[3]), at(f, f[0], f[2]), at(f, f[1], f[2])], SLATE, 2.5)
    for (x in lx) {
        . center{[fx(f, x), fy(f, f[2]) - 0.3, 0]} Math(to_string(x), 0.72, SLATE)
    }
    for (y in ly) {
        . center{[fx(f, f[0]) - 0.36, fy(f, y), 0]} Math(to_string(y), 0.72, SLATE)
    }
    if (xname != "") {
        . center{[(fx(f, f[0]) + fx(f, f[1])) / 2, fy(f, f[2]) - 0.64, 0]} Note(xname, 0.72)
    }
    . center{[(fx(f, f[0]) + fx(f, f[1])) / 2, fy(f, f[3]) + 0.3, 0]} Cap(title, 0.74, col)
}
# times from 0 to t in steps of dt, ending exactly at t
let times = |t, dt = 0.25| {
    var out = []
    let n = to_int(floor(t / dt + 0.0001))
    for (k in range(0, n + 1)) {
        out .= k * dt
    }
    if (t - n * dt > 0.004) {
        out .= t
    }
    return out
}
let Trace = |f, fn, t, col, w = 4| {
    let ts = times(t)
    if (len(ts) < 2) { return [] }
    return stroke{col, w} Polyline(map(ts, |u| at(f, u, fn(u))))
}
let AccTrace = |f, t, col, w = 4| block {
    for (ph in PHASES) {
        let hi = min(t, ph[1])
        if (hi - ph[0] > 0.02) {
            . Seg(at(f, ph[0], ph[2]), at(f, hi, ph[2]), col, w)
        }
    }
}
# a small car whose wheels rest on the point p
let Car = |p, col = AZURE| [
    fill{col} stroke{col, 1} center{[p[0], p[1] + 0.17, 0]} Rect([0.58, 0.16]),
    fill{col} stroke{col, 1} Polygon([
        [p[0] - 0.2, p[1] + 0.24, 0], [p[0] - 0.12, p[1] + 0.38, 0],
        [p[0] + 0.1, p[1] + 0.38, 0], [p[0] + 0.2, p[1] + 0.24, 0]
    ]),
    Pt([p[0] - 0.17, p[1] + 0.07, 0], INK, 0.07),
    Pt([p[0] + 0.17, p[1] + 0.07, 0], INK, 0.07)
]
# a straight road from 0 m to 100 m drawn between scene x = x0 and x = x1
let Road = |x0, x1, y| block {
    . Seg([x0 - 0.3, y, 0], [x1 + 0.3, y, 0], SLATE, 3)
    for (m in [0, 20, 40, 60, 80, 100]) {
        let x = x0 + (x1 - x0) * m / 100
        . Seg([x, y - 0.09, 0], [x, y, 0], SLATE, 2.5)
        . center{[x, y - 0.32, 0]} Math(str_join([to_string(m), "\text{ m}"]), 0.72, SLATE)
    }
}