Parametric Representations

Learning Objectives

By the end of this section you will be able to:

1. Read any parametric pair $(x(t), y(t))$ as the position of a moving particle and trace its path by hand.
2. Switch between parametric form and Cartesian form $y = f(x)$ when (and only when) it is possible — and explain why some curves cannot be written as a single graph.
3. Compute the velocity vector $r'(t) = (x'(t), y'(t))$ and the scalar speed $|r'(t)|$ for any parametric curve.
4. Recognise classic curves on sight — line, circle, ellipse, Lissajous, astroid, cycloid, helix — and know what each one parametrises.
5. Derive the cycloid from the geometric story of a rolling wheel and explain why its cusps correspond to $r'(t) = \mathbf{0}$.
6. Implement parametric curves in NumPy and verify the analytic derivative numerically with PyTorch autograd.

Why Single-Equation Curves Aren't Enough

Every function you have met so far has the same shape: $y = f(x)$. For each $x$ there is exactly one $y$. The graph is a curve, but it is a very special kind of curve — the vertical-line test always passes.

The trouble: most real curves fail the vertical-line test. A circle has two $y$-values above almost every $x$. A loop has many. A spaceship's flight path can cross itself five times. None of these can be written as a single $y = f(x)$.

We need a different kind of description. Instead of asking "given $x$, what is $y$?" we will ask "at time $t$, where is the particle?"

This single change of perspective unlocks every curve you can imagine — circles, ellipses, spirals, knots, the cardioid your physics professor scribbled on the board, the path of a bouncing pendulum, the orbit of Mars. It is also exactly how computer graphics, robotics, and animation engines all represent curves internally.

Definition: Two Clocks, One Pen

A parametric representation of a curve in the plane is a pair of functions

We package the two outputs into one vector-valued function

and read it as: "at time $t$, the particle is at position $r(t)$." The variable $t$ is called the parameter. It does not have to be time — it can be an angle, an arc length, anything that monotonically labels positions along the curve — but the time intuition almost never fails you.

The smallest possible example: a line

Start at point $(1, 2)$ and walk at velocity $(3, -1)$. Where are you after time $t$?

At $t = 0$ you are at $(1, 2)$. At $t = 1$ you are at $(4, 1)$. At $t = 2$ you are at $(7, 0)$. The pen traces a straight line. That is a parametric line — and notice you got both an equation and a velocity for free, instead of just $y = -\tfrac{1}{3}x + \tfrac{7}{3}$.

Reading a Parametric Curve

To read any parametric pair, build a small table. Pick a handful of $t$ values, compute both coordinates, plot the points, connect them. That is it. The table is the curve.

Example: a circle

Take

Build the table:

Six points trace a hexagon-shaped circle. Six hundred points trace a circle indistinguishable from one drawn with a compass. That is what NumPy's linspace does for you.

Interactive 2D Explorer

Push the play button and watch the pen draw. Drag the $t$ slider yourself if you want to stop the pen mid-stroke and read the coordinates. Change the curve in the row of buttons, tweak $a, b, k, \phi$, and see how the shape responds.

A few things to try, in order:

1. Pick Circle. Confirm the speed reads $|r'(t)| = R$ (the radius itself). Slide $a$ and watch both the size and the speed change in lock-step.
2. Pick Ellipse. Now $a \neq b$ and the speed is no longer constant — slow at the long ends, fast at the short ends. The particle does not move uniformly even though $t$ does.
3. Pick Lissajous. Try $k = 1$, $\phi = 0$ — you get a line. Try $k = 1, \phi = \pi/2$ — you get a circle. Try $k = 3$ — you get a knot.
4. Pick Astroid. Look at the four sharp points. The velocity $r'(t)$ vanishes there — the pen stops for an instant before changing direction. This is the same phenomenon that creates the cusps in the cycloid below.

Eliminating the Parameter

Sometimes we can squeeze the parameter out and recover a familiar Cartesian equation relating $x$ and $y$ directly. Two clean tactics:

Tactic 1 — solve for $t$, then substitute

For the parametric line

solve the first equation: $t = (x - 1)/3$. Substitute into the second:

We recovered the Cartesian equation of the line. Notice we lost the velocity information — the Cartesian form tells us where the curve lives but not how it is being traced.

Tactic 2 — use a trig identity

For the parametric circle

the Pythagorean identity $\cos^2 t + \sin^2 t = 1$ hands us the answer directly:

Square the coordinates, divide by $R^2$, add. The parameter annihilates itself.

The Velocity Vector $r'(t)$

Here is where calculus walks in. The particle is at $r(t)$ at time $t$ and at $r(t + h)$ a moment later. The average velocity over $h$ seconds is

Take $h \to 0$ on both components independently. The result is the velocity vector:

That is the entire calculus of parametric curves in one line. Differentiate each coordinate separately. The vector you get has two properties:

• Direction: it is tangent to the curve at $r(t)$ — the instantaneous heading of the particle.
• Magnitude: $|r'(t)| = \sqrt{x'(t)^2 + y'(t)^2}$ is the speed — how fast the particle is sweeping along its trail.

Worked check: circle of radius R

Take $r(t) = (R\cos t, R\sin t)$. Differentiate each component:

The magnitude:

Constant. The particle sweeps the circle at uniform speed $R$. Slide the radius slider in the explorer above and watch the "speed" readout track it exactly.

A Gallery of Classic Curves

Every working scientist and engineer should recognise these on sight. They are the "periodic table" of 2D curves.

Worked Example: The Cycloid by Hand

The cycloid is the path traced by a point on the rim of a wheel rolling along the ground. Its parametric form is

Take $r = 1$ and trace one full arch by hand. Open the panel below, work through every row with pencil and paper, then unpause the rolling animation in the next subsection and watch the same numbers go by in real time.

The Cycloid as a Rolling Wheel

Watch the grey wheel roll. The amber dot is the point on the rim you just hand-computed. The cyan curve is the trail it leaves behind — the cycloid.

Two things to notice while it rolls:

• The cusps occur exactly when the amber dot touches the ground — i.e., when the spoke points straight down. That matches the calculation: $r'(t) = (0,0)$ at $t = 0, 2\pi, 4\pi, \ldots$.
• At the top of each arch the dot is whizzing across the screen — that is the $|r'(\pi)| = 2$ observation. A point at the top of a rolling wheel moves at twice the speed of the wheel's centre. This is why mudguards exist.

Into 3D: The Helix

Parametric thinking generalises to three dimensions for free. Just add a third clock:

The textbook example is the helix: a circle in two coordinates, plus steady linear rise in the third.

Drop the third coordinate (the "shadow" on the floor) and you see a circle. Drop the first two and you see a straight line. The helix is the union — a circle promoted into space by a constant lift.

Slide $c$ to zero and the helix collapses to a circle (the shadow). Crank $c$ up and the spiral stretches into a near-vertical staircase. The speed

is constant — the particle climbs the spiral at uniform speed. The reading on the right of the viewer confirms this in real time.

Python Implementation

Time to make this concrete. We will plot the parametric circle in plain Python with NumPy, then read the velocity vector off the analytic derivative. The whole script is twenty lines.

np.cos(np.array([0, 1.5]))  ->  array([1.0000, 0.0707])

np.linspace(0, 2*np.pi, 5) -> [0, 1.57, 3.14, 4.71, 6.28]

For R = 1.5 we expect 1.5000 every time.

1import numpy as np
2import matplotlib.pyplot as plt
3
4def parametric_circle(t, R=1.5):
5    """Return (x, y) on a circle of radius R for parameter t."""
6    x = R * np.cos(t)
7    y = R * np.sin(t)
8    return x, y
9
10# Sample the parameter t from 0 to 2 pi
11t = np.linspace(0.0, 2 * np.pi, 200)
12
13# Vectorised evaluation: shape (200,)
14x, y = parametric_circle(t, R=1.5)
15
16# Velocity vector at a chosen instant t0 = pi / 4
17t0 = np.pi / 4
18x0, y0 = parametric_circle(t0, R=1.5)
19vx, vy = -1.5 * np.sin(t0), 1.5 * np.cos(t0)
20speed = np.hypot(vx, vy)
21print(f"point  at t0  = ({x0:.4f}, {y0:.4f})")
22print(f"r'(t0)        = ({vx:.4f}, {vy:.4f})")
23print(f"|r'(t0)|      = {speed:.4f}")
24
25# Plot the trace and the velocity arrow at t0
26plt.figure(figsize=(5, 5))
27plt.plot(x, y, color="#22d3ee", lw=2, label="r(t)")
28plt.arrow(x0, y0, vx*0.3, vy*0.3, head_width=0.08, color="#a78bfa")
29plt.scatter([x0], [y0], color="#f59e0b", zorder=5)
30plt.gca().set_aspect("equal")
31plt.grid(True, alpha=0.3)
32plt.title("Parametric circle r(t) = (R cos t, R sin t)")
33plt.legend()
34plt.show()

Expected output when you run the script:

point  at t0  = (1.0607, 1.0607)
r'(t0)        = (-1.0607, 1.0607)
|r'(t0)|      = 1.5000

Match? Good. Now the speed is exactly the radius, as the calculus predicts. Twenty lines of code, and you have the curve, the velocity, the speed, and a picture.

PyTorch & Autograd: Letting the Computer Differentiate

In the NumPy code above, we differentiated $r(t)$ by hand and typed the result $(-R\sin t, R\cos t)$ into the script. That works for elementary curves. For a complicated $r(t)$ — say, the position of a robot end-effector after seven chained rotations — you do not want to differentiate by hand. You want PyTorch to do it for you.

t = torch.tensor(0.5, requires_grad=True)

If we forget retain_graph=True, line 14 raises 'graph has been freed'.

1import torch
2from math import pi
3
4# Parameter t with autograd tracking
5t = torch.tensor(pi / 4, requires_grad=True)
6R = 1.5
7
8# r(t) = (R cos t, R sin t)
9x = R * torch.cos(t)
10y = R * torch.sin(t)
11
12# r'(t) = (dx/dt, dy/dt) — autograd derives each component for us
13(dx_dt,) = torch.autograd.grad(x, t, retain_graph=True)
14(dy_dt,) = torch.autograd.grad(y, t)
15
16speed = torch.sqrt(dx_dt ** 2 + dy_dt ** 2)
17
18print(f"r(t0)    = ({x.item():.4f}, {y.item():.4f})")
19print(f"r'(t0)   = ({dx_dt.item():.4f}, {dy_dt.item():.4f})")
20print(f"|r'(t0)| = {speed.item():.4f}   # expect 1.5000")
21
22# Sanity check against analytic derivative
23expected = torch.tensor([-R * torch.sin(t).item(), R * torch.cos(t).item()])
24got      = torch.stack([dx_dt, dy_dt]).detach()
25assert torch.allclose(expected, got, atol=1e-6)
26print("autograd matches analytic derivative ✓")

Expected output:

r(t0)    = (1.0607, 1.0607)
r'(t0)   = (-1.0607, 1.0607)
|r'(t0)| = 1.5000   # expect 1.5000
autograd matches analytic derivative ✓

Real-World Applications

Common Pitfalls

Summary

A parametric representation describes a curve by giving the position of a moving point as a function of a parameter:

1. The parameter $t$ is a clock; the curve is the trail the moving point leaves behind.
2. The velocity vector $r'(t) = (x'(t), y'(t))$ is the derivative of each component. Its magnitude is the scalar speed $|r'(t)|$; its direction is tangent to the curve.
3. Eliminating $t$ sometimes recovers $y = f(x)$ — by solving for $t$ or by a trig identity — but loses orientation, speed, and parameter range.
4. Cusps occur where $r'(t) = \mathbf{0}$ (the pen pauses); self-intersections occur where two distinct $t$ give the same point.
5. NumPy evaluates parametric curves vectorially in one call. PyTorch autograd computes $r'(t)$ for any curve you can write down — the formula you would have differentiated by hand emerges from the chain rule the engine applies behind the scenes.
6. The classic curves — circle, ellipse, Lissajous, astroid, cycloid, helix — are the working vocabulary of physics, graphics, robotics, biology, and machine learning. You will meet every one of them again.

The takeaway. A curve is not a graph; it is the history of a moving point. Once you adopt that mindset, every curve in the universe becomes a small program — two or three clocks, ticked through their range, leaving a trail.