Foundations — 3D plots — surface, wireframe

Before you can read a single line of the parent note, you need to earn every symbol it uses. This page defines each one from absolute zero: plain words → the picture → why the topic needs it. We build them in dependency order, so nothing appears before it is explained.

1. The pair $(x,y)$ — a point on the floor

Picture a tiled floor seen from above. Pick a corner as the origin (the spot $(0,0)$). Any tile is reached by walking $x$ tiles right and $y$ tiles up. That address is the pair $(x,y)$.

Why the topic needs it: a surface is a rule that assigns a height to every floor spot. To talk about "every floor spot" you first need a way to name a floor spot — that is exactly $(x,y)$.

2. The symbol $z=f(x,y)$ — the height rule

• The letters $x,y$ are the two inputs (floor position).
• The letter $z$ is the one output (how high above that floor spot).
• $f$ is just a name for the rule — like $f(x,y)=x^2+y^2$ or $f(x,y)=\sin (\sqrt{x^2+y^2})$.

Why the topic needs it: the entire plot is the graph of $f$. No function, no surface. Every example in the parent (X**2 + Y**2, sin(sqrt(...))) is just a choice of $f$.

3. The 1D array $x=[x_0,x_1,\dots ,x_{m-1}]$

• The little number $j$ (the subscript) is the position, not multiplication.
• $x_0$ is the first entry, $x_1$ the second, and $x_{m-1}$ the last (because counting starts at $0$).

Why the topic needs it: the floor is continuous — infinitely many spots. A computer can only handle finitely many. So we choose a ladder of sample x-values and a ladder of sample y-values. Those two ladders are our 1D arrays.

4. The 2D array and the subscript $A_{ij}$ — a table of numbers

Picture a spreadsheet: $i$ tells you which row (which floor-up level), $j$ tells you which column (which floor-across position).

Why the topic needs it: the floor is 2D, so the height table is 2D. Every one of X, Y, Z in the parent note is a 2D array of the same shape. Understanding "row $i$, column $j$" is the whole game.

5. Turning two ladders into a grid — what meshgrid builds

np.meshgrid(x, y) returns two 2D arrays, both of shape $(n,m)$:

• X — the x-coordinate at each grid cell. Constant across a row, changing along it.
• Y — the y-coordinate at each grid cell. Constant down a column, changing down it.

What just happened / why / what it looks like: we stamped the little x-ladder down every row of X, and stamped the y-ladder across every column of Y. Now cell $(i,j)$ holds the full floor address $(X_{ij},Y_{ij})$. The picture is a lattice of dots on the floor, each dot knowing both its coordinates.

Why the topic needs it: to compute the height at every combination of x and y without a Python loop, we need both coordinates as full 2D tables. Then a single elementwise formula does all $n\times m$ evaluations at once.

6. Elementwise arithmetic — $Z=f(X,Y)$

$Z_{ij}=f(X_{ij},Y_{ij})$

• X**2 squares every entry (** is power in Python, not a footnote).
• sqrt, sin also act cell by cell.

Why the topic needs it: this is the step "compute the pole heights". Because X and Y already carry the coordinates, one line Z = np.sin(np.sqrt(X**2 + Y**2)) fills the entire height table. (See NumPy vectorization for why this is fast, and meshgrid and broadcasting for how shapes line up.)

7. Draping the sheet — plot_surface / plot_wireframe

• ax.plot_surface(X, Y, Z) — stretches a filled colored sheet over the pole tops.
• ax.plot_wireframe(X, Y, Z) — connects the pole tops with lines only (a see-through net).

Order of arguments is always (X, Y, Z) = floor-across, floor-up, sky. See Matplotlib figure and axes objects for what fig and ax are.

8. Colormaps and strides (the finishing knobs)

Viewed from straight above, the same $Z$ grid becomes a contour plot — same data, different camera.

Prerequisite map

Equipment checklist

Test yourself — reveal only after answering:

Connections

• Parent: 3D plots — surface & wireframe
• meshgrid and broadcasting
• 2D plots — line, scatter
• Matplotlib figure and axes objects
• Contour plots
• NumPy vectorization
• Colormaps in Matplotlib