Physics

Physics is the study of matter, energy, space and time, and of the rules that connect them. A ball falling, a guitar string humming, a phone charging and a star shining all follow a handful of rules, and physics is the work of finding them, writing them as maths, and testing them against measurements. A rule that predicts what you then measure is kept; one that does not is fixed or thrown away.

Every rule is a model: a simplified picture that keeps what matters and drops the rest. A falling apple is treated as a single point with no air around it. That is not true, but it predicts where the apple lands to within a few centimetres, and knowing when a model is good enough is half of the skill.

Physical quantity

Something you can measure, given as a number and a unit: a mass of 2 kg, a time of 3.5 s.

Unit

The agreed amount you compare against: the metre, the second, the kilogram.

Measurement

Comparing a quantity with its unit, which always has some uncertainty.

Model

A simplified description that predicts what you will measure.

Physics predicts numbers, and a few lines of code can work them out, check them, and simulate motion that no formula solves. This course writes that code in C++, as the algebra course does. Here is all the C++ you need, in one program to remind you: press Run.

1#include <cmath>2#include <iostream>3#include <vector>4
5// A function: the type it returns, its name, its parameters6double speed(double distance, double time) {7  return distance / time;8}9
10int main() {11  double g = 9.8;  // a measured quantity: a double12  int laps = 7;    // a count: an int13  std::cout << laps / 2 << " " << laps / 2.0 << "\n";  // 3 3.514  std::cout << std::pow(3, 2) << " " << std::sqrt(2 * g * 20) << "\n";15
16  std::vector<double> times = {2.03, 1.98, 2.01};17  double total = 0;18  for (double t : times) total += t;19  if (total > 6) std::cout << "slow swings\n";20  std::cout << speed(100, 9.58) << " m/s\n";21  return 0;22}

1#include <functional>2
3// A struct groups values: here, a falling stone's state4struct State {5  double y;  // height, m6  double v;  // velocity, m/s7};8
9State step(State s, double dt) {10  s.v = s.v - 9.8 * dt;  // fields by name11  s.y = s.y + s.v * dt;12  return s;13}14
15// A function passed in is a std::function, called like any other16double slopeAt(std::function<double(double)> f, double x) {17  return (f(x + 1e-6) - f(x)) / 1e-6;18}19// slopeAt([](double x) { return x * x; }, 3) is about 6

• double for measured quantities, int for counts. An int divided by an int drops the fraction: 7 / 2 is 3 and 1 / 2 is 0, so write 7 / 2.0 or 0.5.
• C++ has no power operator: write x * x or std::pow(x, 2). And 2 ^ 3 compiles but is 1, not 8: ^ is a bitwise operation.
• <cmath> has std::sqrt, std::pow, std::exp, std::log (natural), std::log10 and std::abs; std::sin and the other trigonometric functions take radians. std::numbers::pi, from <numbers>, is $\pi$.
• A challenge here is functions with no main: its tests call them. Floats are compared with EXPECT_NEAR(actual, expected, within), since a computed double is rarely exact.

A number without a unit means nothing: "the table is 2 long" could be 2 metres or 2 kilometres. Scientists everywhere use the SI, the International System of Units. It has seven base units; every other unit is built from them.

Derived units are combinations of base units. Speed is a length over a time, so it is measured in metres per second, $\text{m/s}$. Force, which you meet in module 4, is measured in newtons: $1\text{N}=1{\text{kg·m/s}}^2$. A named unit like the newton is only shorthand for its base units.

Physics deals with numbers that are huge and tiny, so it writes them in scientific notation: a number between 1 and 10 times a power of ten. The Earth’s mass is $5.97\times {10}^{24}\text{kg}$; a hydrogen atom is about $1\times {10}^{-10}\text{m}$ across. A negative power means "divide by ten that many times": ${10}^{-3}=0.001$.

Multiplying powers of ten adds the exponents, and dividing subtracts them: ${10}^3\times {10}^{-9}={10}^{-6}$. In code, 1e3 is how you write $1\times {10}^3$, and 6.0e-7 is $6.0\times {10}^{-7}$.

1double kilometre = 1e;2double millimetre = 1e;3double micrometre = 1e;4double nanometre = 1e;

To change units, multiply by a conversion factor: a fraction whose top and bottom are the same amount, so it equals one. $\frac{1000\text{m}}{1\text{km}}$ is one, because 1000 m is 1 km. Write units as if they were numbers and cancel them like factors; if the units left over are the ones you want, the conversion is right.

1double kmhToMs(double kmh) {2  return 0;  // TODO3}4
5double msToKmh(double ms) {6  return 0;  // TODO7}

Every quantity has a dimension: what kind of thing it is, made of length $[L]$, mass $[M]$ and time $[T]$ (and a few others). Speed has dimension $[L]{[T]}^{-1}$, acceleration $[L]{[T]}^{-2}$. Two rules follow. You can only add or compare things with the same dimension (adding a mass to a time is meaningless), and both sides of a correct equation have the same dimension.

Writing $2.0\text{m}$ and $2.000\text{m}$ says different things: the first is known to about a tenth of a metre, the second to a millimetre. The digits you trust are the significant figures. Leading zeros are not significant ($0.0034$ has 2); zeros after the point at the end are ($3.40$ has 3). Scientific notation removes doubt: $3.40\times {10}^2$ has 3, where $340$ alone is unclear.

• Multiplying or dividing: keep as many significant figures as the least precise input. $12.0\times 3.1=37.2$, written $37$.
• Adding or subtracting: keep as many decimal places as the input with the fewest. $12.31+4.2=16.51$, written $16.5$.
• Round only at the end; carry extra digits through the working.

Time a pendulum’s swing five times with a stopwatch and you get five different numbers: $2.03$, $1.98$, $2.01$, $2.05$, $1.99\text{s}$. None is "the" answer. The best estimate is their mean, the sum over the count: $10.06/5=2.012\text{s}$. A simple measure of the spread is the half-range, half the gap between the largest and smallest: $(2.05-1.98)/2=0.035\text{s}$. So the period is $2.01\pm 0.04\text{s}$.

The absolute uncertainty is the $\pm$ amount in the quantity’s units; the relative uncertainty is that divided by the value, often as a percentage: $0.04/2.01\approx 2\%$. When you add or subtract quantities, add their absolute uncertainties. When you multiply or divide, add their relative ones.

1#include <vector>2
3double mean(const std::vector<double>& values) {4  return 0;  // TODO5}6
7double halfRange(const std::vector<double>& values) {8  return 0;  // TODO9}

The physicist Enrico Fermi was famous for answering questions like "how many piano tuners are there in Chicago?" with no data, just by breaking them into pieces you can guess. Each guess can be off, but errors partly cancel, and the answer usually lands within a factor of ten. That is often enough to know whether an idea is possible at all. How many times does your heart beat in a lifetime?

1#include <iomanip>2#include <iostream>3
4int main() {5  std::cout << std::setprecision(2);  // two significant figures6  double beatsPerMinute = 70;7  double minutesPerYear = 60 * 24 * 365;8  double years = 80;9
10  // double, not int: an int stops at about 2.1 billion11  double beats = beatsPerMinute * minutesPerYear * years;12  std::cout << beats << " heartbeats\n";13
14  // Try another: how many litres of water do you drink in a life?15  double litresPerDay = 2;16  std::cout << litresPerDay * 365 * years << " litres\n";17  return 0;18}

The order of magnitude of a number is its power of ten, roughly: $3\times {10}^9$ is "order ${10}^9$". Physics spans more than forty orders of magnitude in size alone, and the same rules of measurement work across all of them. A ruler and a telescope differ only in the scale of what they compare.

• A physical quantity is a number and a unit; the SI has seven base units, and every other unit is built from them.
• Scientific notation and prefixes (k, M, G; m, µ, n) handle huge and tiny numbers.
• Convert units by multiplying by fractions equal to one, and cancel units like factors.
• Both sides of a correct equation have the same dimension: a quick check on any formula.
• Significant figures show precision: multiply or divide to the fewest significant figures.
• Repeat a measurement: quote the mean, plus or minus an uncertainty.
• A Fermi estimate breaks a big question into guesses and lands within a factor of ten.

To describe motion along a straight line, pick a point to call zero, the origin, and a direction to call positive. An object’s position $x$ is then a number: $x=3\text{m}$ is 3 metres on the positive side, $x=-2\text{m}$ is 2 metres on the other. The choice is yours; physics does not care where zero is, as long as you keep it.

The displacement is the change of position, final minus initial: $\mathrm{\Delta }x=x_{\text{f}}-x_{\text{i}}$ ($\mathrm{\Delta }$, the Greek capital delta, means "change in"). The distance is how much ground was covered. Walk 5 m forward and 3 m back: the distance is 8 m, the displacement only $+2\text{m}$.

Average speed is distance over time. Average velocity is displacement over time, so it has a sign, a direction:

A scalar is a quantity with only a size (distance, speed, time, mass). A vector has a size and a direction (displacement, velocity). In one dimension the direction is just the sign; module 3 deals with directions in a plane.

Plot position against time and the motion becomes a picture. Moving at constant velocity $v$ from a starting position $x_0$ gives a straight line, $x=x_0+vt$. Its slope, rise over run, is $\mathrm{\Delta }x/\mathrm{\Delta }t$: the velocity. Steeper means faster; sloping down means moving in the negative direction; flat means standing still.

When the velocity changes, the position–time graph curves, and the average over a long interval hides what happens at each moment. Shrink the interval and the average velocity settles on a single number: the instantaneous velocity, the slope of the line that just touches the curve, the tangent. A speedometer shows its size.

Acceleration is the change in velocity per unit time, $a=\frac{\mathrm{\Delta }v}{\mathrm{\Delta }t}$. Its unit is metres per second per second, ${\text{m/s}}^2$: a car with $a=3{\text{m/s}}^2$ gains 3 m/s of velocity every second. Acceleration is a vector, so it has a sign too, and the sign is the part that trips people up.

The rule: when velocity and acceleration have the same sign, the object speeds up; when they have opposite signs, it slows down. A negative acceleration does not always mean "slowing down".

Plot velocity against time. The slope is now the acceleration. And the area between the line and the time axis is the displacement: for constant velocity, the area is a rectangle, $v\times t$, which is distance at that speed. Area below the axis counts as negative displacement.

When the acceleration is constant, the areas and slopes above turn into four equations linking five quantities: the time $t$, the displacement $\mathrm{\Delta }x$, the initial and final velocities $v_0$ and $v$, and the acceleration $a$. Each equation leaves one of them out, so pick the one without the quantity you neither know nor want. (In Britain they are the "suvat" equations, after the letters $s,u,v,a,t$.)

A worked example. A car starts from rest and reaches 27 m/s in 9.0 s. What is its acceleration, and how far does it go?

1double v0 = 0;2double a = 3.0;3double t = 9.0;4double v = v0 + ;5double dx = v0 * t + 0.5 * a * ;6std::cout << v << " " << dx << "\n";  // 27 121.5

A driver sees a hazard. For the reaction time $t_r$, about a second, the car keeps going at its speed $v$: that covers $v{t}_r$. Then the brakes give a deceleration of size $a$, and the car stops after $v^2/(2a)$, from $v^2=v_0^2+2a\mathrm{\Delta }x$ with the final velocity zero. The total is the stopping distance.

1double stoppingDistance(double speed, double reactionTime,2                        double braking) {3  return speed * reactionTime;  // TODO: add the braking distance4}

Near the Earth’s surface, anything moving only under gravity, with air resistance small enough to ignore, has the same downward acceleration, $g\approx 9.8{\text{m/s}}^2$, whatever its mass. This is free fall, and it covers a ball thrown up as much as one dropped: on the way up it slows by 9.8 m/s each second, at the top it stops for an instant, and on the way down it speeds up. Take up as positive, and $a=-g$ throughout.

The equations above only work for constant acceleration. Real motion (with air drag, springs, rockets) often has none that simple, so computers step it: chop time into small steps $\mathrm{\Delta }t$, and on each one, nudge the velocity by $a\mathrm{\Delta }t$ and then the position by $v\mathrm{\Delta }t$. This is the Euler method; updating the velocity first, as here, is semi-implicit Euler, which game physics engines use because it stays stable.

1#include <iostream>2
3int main() {4  double y = 20;  // height, m5  double v = 0;   // velocity, m/s (up is positive)6  double t = 0;7  const double g = 9.8;8  const double dt = 0.01;  // the time step, s9
10  while (y > 0) {11    double a = -g;  // the acceleration right now12    v += a * dt;13    y += v * dt;14    t += dt;15  }16  std::cout << t << " s, " << v << " m/s\n";17  return 0;18}

1struct State {2  double y;  // height, m3  double v;  // velocity, m/s4};5
6State simulateFall(double v0, double dt, int steps) {7  double y = 0;8  double v = v0;9  // TODO: take the steps10  return {y, v};11}

• Position is measured from an origin; displacement is final minus initial position, and has a sign.
• Velocity is displacement over time (a vector); speed is distance over time (a scalar).
• On a position–time graph the slope is the velocity; on a velocity–time graph the slope is the acceleration and the area the displacement.
• Speeding up means velocity and acceleration have the same sign; slowing down, opposite signs.
• For constant acceleration: $v=v_0+at$, $\mathrm{\Delta }x=v_{0}t+\frac{1}{2}a{t}^2$, $v^2=v_0^2+2a\mathrm{\Delta }x$.
• Free fall: $a=g\approx 9.8{\text{m/s}}^2$ downward, all the way up and down.
• Euler stepping: update velocity by $a\mathrm{\Delta }t$, then position by $v\mathrm{\Delta }t$, many times.

In a line, a sign was enough to give a direction. On a flat field or in the air, you need more: "5 m/s" does not say whether a ball goes up, sideways or towards the goal. A vector is a quantity with a size, its magnitude, and a direction. It is drawn as an arrow whose length is the magnitude, and written with an arrow over it, $\overrightarrow{v}$; its magnitude is $|\overrightarrow{v}|$ or just $v$.

Scalar

Only a size: mass, time, temperature, distance, speed, energy.

Vector

A size and a direction: displacement, velocity, acceleration, force.

Magnitude

The size of a vector, never negative: the length of the arrow.

Component

How much of a vector points along one axis: its $x$ part or its $y$ part.

Any arrow in a plane is the sum of a horizontal arrow and a vertical one, its components. For a vector of magnitude $v$ at angle $\theta$ above the $x$ axis, trigonometry gives them, and Pythagoras and the inverse tangent go back:

To add two vectors, draw the second starting at the tip of the first; the sum, the resultant, goes from the start of the first to the tip of the second. With numbers, it is easier: add the $x$ components, add the $y$ components. Walk 3 m east and 4 m north and you are $\sqrt{3^2+4^2}=5\text{m}$ from the start, though you walked 7.

1#include <cmath>2#include <numbers>3
4struct Vec {5  double x;6  double y;7};8
9Vec components(double size, double angleDeg) {10  return {0, 0};  // TODO11}12
13double magnitude(double x, double y) {14  return 0;  // TODO15}

A velocity is always measured relative to something. Walk at 1.5 m/s towards the front of a train moving at 30 m/s, and someone on the platform sees you at 31.5 m/s. In general, your velocity relative to the ground is your velocity relative to the train plus the train’s relative to the ground, added as vectors: ${\overrightarrow{v}}_{\text{you,ground}}={\overrightarrow{v}}_{\text{you,train}}+{\overrightarrow{v}}_{\text{train,ground}}$.

A projectile is anything thrown or launched that then moves under gravity alone: a ball, a jet of water, a long jumper. The key fact, first worked out by Galileo, is that its horizontal and vertical motions are independent. Horizontally there is no force (ignoring air), so $v_x$ stays constant. Vertically it is free fall, exactly as in module 2: $a_y=-g$.

Eliminate $t$ from the two equations and $y$ becomes a quadratic in $x$: the path is a parabola. Drag the launch speed and angle and watch how the range and the height change.

A worked example: a ball kicked at 20 m/s, 30° above the ground.

The formulas only work without air and with launch and landing at the same height. A simulation has no such limits: step $v_x$, $v_y$, $x$ and $y$ through time exactly as module 2 stepped one dimension, and stop when $y$ drops below zero. First, find the mistake in this formula-based version.

1#include <cmath>2#include <numbers>3
4double simulateRange(double speed, double angleDeg, double dt) {5  double angle = angleDeg * std::numbers::pi / 180;6  double x = 0;7  double y = 0;8  // TODO: the velocities, and the steps9  return x;10}

A car going round a roundabout at a steady 10 m/s is still accelerating, because its velocity keeps changing direction. In uniform circular motion (a circle, at constant speed) the velocity is always along the tangent, and the acceleration always points to the centre: the centripetal acceleration.

• A vector has a magnitude and a direction; a scalar only a size.
• Components: $v_x=v\cos \theta$, $v_y=v\sin \theta$; magnitude $\sqrt{v_x^2+v_y^2}$.
• Add vectors by adding components; velocities relative to different observers add the same way.
• A projectile moves at constant $v_x$ while falling freely in $y$; its path is a parabola.
• On flat ground, $R=v_0^2\sin 2\theta /g$, largest at 45° without air.
• Uniform circular motion accelerates towards the centre: $a_c=v^2/r$.
• Code takes radians: convert degrees with $\times \pi /180$.

Modules 2 and 3 described motion without asking what causes it. A force is what changes motion: a push or a pull by one object on another. It is a vector, with a size and a direction, and its SI unit is the newton, N. One newton is about the weight of a small apple. Isaac Newton’s three laws, from 1687, say how forces and motion are related, and they still run bridges, cars and game engines today.

Contact force

Acts by touching: a push, friction, the floor holding you up, a rope pulling.

Non-contact force

Acts across space: gravity, electric and magnetic forces.

Newton (N)

The SI unit of force, $1\text{N}=1{\text{kg·m/s}}^2$.

Net force

All the forces on an object added together, as vectors.

Newton’s first law: an object stays at rest, or keeps moving at a constant velocity in a straight line, unless a net force acts on it. This tendency to keep doing what it was doing is inertia. It surprised people, because everyday things do stop on their own: a rolling ball slows down. But that is friction and air, forces you do not see. On ice, or in space, things keep going.

When several forces act on one object, what matters is their vector sum, the net force ${\overrightarrow{F}}_{\text{net}}=\sum \overrightarrow{F}$ ($\sum$, a capital sigma, means "add them all up"). Two people pushing a car the same way add; a tug of war subtracts; forces at an angle add by components, as in module 3.

Newton’s second law says how much a net force changes motion. The acceleration is in the direction of the net force, and its size is the force divided by the mass, the amount of inertia: the same push makes a shopping trolley fly and a car barely creep.

1#include <vector>2
3double netForce(const std::vector<double>& forces) {4  return 0;  // TODO5}6
7double acceleration(const std::vector<double>& forces, double mass) {8  return 0;  // TODO9}

Your mass, in kilograms, is how much matter you are made of and how hard you are to accelerate. It is the same everywhere. Your weight is the force of gravity on you, in newtons, and it depends on where you are: $W=mg$, with $g\approx 9.8\text{N/kg}$ on Earth (the same number as $9.8{\text{m/s}}^2$: drop anything and its weight is the net force giving it the acceleration $g$).

A free-body diagram draws one object, alone, as a dot or a box, with an arrow for every force acting on it, starting at the object. Forces it exerts on other things do not go on it. It is the most useful habit in mechanics: almost every wrong answer comes from a missing or extra force.