Exercises — 3D plots — surface, wireframe

The rule from the parent note: meshgrid(x, y) returns two arrays of shape $(\text{len}(y),\text{len}(x))$.

• WHAT: len(y) = 2 (that's 10, 20) and len(x) = 4 (that's 1,2,3,4).
• WHY this order: rows vary in $y$, columns vary in $x$ — like an image indexed (row, col).
• So $X.\text{shape}=(2,4)$ and $Y.\text{shape}=(2,4)$. Both are the same shape.

Concretely:

X = [[1,2,3,4],      Y = [[10,10,10,10],
     [1,2,3,4]]           [20,20,20,20]]

$x$ repeats down each row; $y$ repeats across each column.

• ax.plot_surface → filled colored patches (supports a cmap that maps height to color).
• ax.plot_wireframe → a see-through mesh of lines (usually one solid color=). Think DRAPE: a bedsheet (surface) vs a fishing net (wireframe).

The keyword is projection='3d'.

ax = fig.add_subplot(projection='3d')

WHY: the 3D drawing methods (plot_surface, plot_wireframe) only exist on a 3D axes object. Ask a plain 2D axes for plot_surface and you get an AttributeError.

• WHAT: first write the coordinate grids.

X = [[0,1,2],      Y = [[ 0, 0, 0],
     [0,1,2]]           [10,10,10]]

• WHY elementwise: Z = X + Y adds cell-by-cell (this is NumPy vectorization) — no loop needed.
• Add matching cells: $Z=\left[\begin{array}{ccc}0+0& 1+0& 2+0\\ 0+10& 1+10& 2+10\end{array}\right]=\left[\begin{array}{ccc}0& 1& 2\\ 10& 11& 12\end{array}\right]$ Z.shape is (2, 3) — same as X and Y.

• WHAT: the plot is literally the function drawn, so read the height by plugging the coordinates into $f$.
• $z=3^2+4^2=9+16=25$.
• WHY it looks like a bowl: $z$ is the squared distance from the origin, so it grows in every direction from the minimum $z=0$ at $(0,0)$.

• Let $r=\sqrt{x^2+y^2}$ be the distance from the origin. Here $r=\sqrt{0+(\pi /2{)}^2}=\pi /2$.
• WHY $\sqrt{x^2+y^2}$: it's the Pythagorean distance — this surface only cares how far you are from the center, not the direction, so it makes concentric ripples.
• $z=\sin (\pi /2)=1$. That's the top of the first ripple crest.

• WHAT rstride means: row stride = draw every $k$-th grid row line; cstride does the same for columns.
• (a) len(y) = 61, so there are 61 row lines before striding.
• (b) Drawing every 10th of 61: indices $0,10,20,30,40,50,60$ → $\lfloor 60/10\rfloor +1=7$ lines.
• WHY thin the mesh: a $61\times 61$ full mesh is a dense hairball; striding trades detail for a readable see-through cage.

• X.shape = Y.shape = (len(y), len(x)) = (40, 100).
• Z = np.cos(X) * Y is elementwise, so Z.shape = (40, 100) too.
• All three grids match → plot_surface(X, Y, Z) succeeds. The requirement is simply X.shape == Y.shape == Z.shape.

• x is 1D with shape (len(x),), so np.sin(x) is also 1D of shape (len(x),).
• But X and Y are 2D of shape (len(y), len(x)).
• WHY it fails: plot_surface needs a full 2D table of heights, one per floor cell. A 1D Z has no height for most cells → a shape mismatch error.
• Fix: always feed the grid arrays into $f$: Z = np.sin(X).

Follow GRID → HEIGHT → DRAPE:

import numpy as np
import matplotlib.pyplot as plt
 
x = np.linspace(-2, 2, 80)          # GRID: even, endpoint-inclusive sampling
y = np.linspace(-2, 2, 80)
X, Y = np.meshgrid(x, y)            # 2D coordinate grids, shape (80, 80)
Z = X**2 - Y**2                    # HEIGHT: vectorized, same shape as X
 
fig = plt.figure()
ax = fig.add_subplot(projection='3d')   # 3D axes — required
ax.plot_surface(X, Y, Z, cmap='viridis')  # DRAPE the colored sheet
ax.set_xlabel('x'); ax.set_ylabel('y'); ax.set_zlabel('z')
plt.show()

WHY linspace not arange: we want exactly 80 evenly spaced points including both ends — smoother surface. See Colormaps in Matplotlib for cmap choices. What it looks like: a Pringle chip — rising along the $x$-axis, falling along the $y$-axis.

Replace the surface call:

ax.plot_wireframe(X, Y, Z, rstride=8, cstride=8, color='green')

• WHY rstride=8, cstride=8: an $80\times 80$ mesh is far too dense; every 8th line gives $\lfloor 79/8\rfloor +1=10$ lines per direction — a clean cage.
• WHY no cmap: wireframes are lines, not patches — a colormap has no per-face patch to color, so we pass a single color=.

• WHAT meshgrid does: repeat x down the rows, repeat y across the columns.

import numpy as np
x = np.array([1,2,3]); y = np.array([10,20])
X = np.tile(x, (len(y), 1))          # x as a row, stacked len(y) times
Y = np.tile(y.reshape(-1,1), (1, len(x)))  # y as a column, stretched len(x) wide

Result:

X = [[1,2,3],      Y = [[10,10,10],
     [1,2,3]]           [20,20,20]]

• WHY it matches: this is exactly what meshgrid and broadcasting does internally — X from broadcasting a row, Y from broadcasting a column.

• Let $r=\sqrt{x^2+y^2}$. The surface is $z=\sin (r)$ — concentric ripples because it depends only on distance $r$.
• First trough where $\sin (r)=-1$: the smallest positive $r$ is $r=\frac{3\pi }{2}\approx 4.712$.
• At $r=2\pi$: $z=\sin (2\pi )=0$ — back to floor level, one full ripple completed.
• WHY concentric: since only $r$ enters, every point on a circle of radius $r$ has the same height → rings, like a pond after a stone drops.

• (a) The exponent $-(x^2+y^2)$ is largest (least negative) at the origin where it equals $0$, so $z=e^0=1$. Peak height $=1$ at $(0,0)$.
• (b) $z=e^{-(1+1)}=e^{-2}\approx 0.1353$.
• (c) As $r\to \infty$, $-(x^2+y^2)\to -\infty$, so $z=e^{-\infty }\to 0$. The bump flattens to the floor — a single smooth hill that never quite reaches $0$.
• WHY $e^{-r^2}$ and not $e^{-r}$: using $x^2+y^2$ keeps it smooth and rotationally symmetric with a rounded top; a bare $r$ would give a sharp cone tip at the origin.

• Use a contour plot (ax.contourf(X, Y, Z)), viewed on a plain 2D axes.
• What stays the same: the entire X, Y, Z grid — a contour is literally the surface's height map seen from the top, colored by height, exactly as colormaps color the surface.
• WHY it works: both a surface and a contour answer "what is $z$ at each floor point?"; one drapes a sheet, the other paints the floor.

• A grid of $n$ rows by $m$ columns of points creates $(n-1)$ gaps down and $(m-1)$ gaps across.
• Each pair of gaps bounds one quadrilateral facet → total facets $=(n-1)(m-1)$.
• For $m=61,n=41$: $(41-1)(61-1)=40\times 60=2400$ facets.
• WHY this matters: facet count explodes with grid size (this is why rstride/cstride exist) — a $200\times 200$ grid is $199\times 199=39601$ facets, too dense to see.

meshgrid(x,y) with len(x)=5, len(y)=3 gives X.shape = ? ::: (3, 5), i.e. (len(y), len(x)). Height of Z = X2 + Y2 at (3,4)? ::: 25. Height of Z = sin(sqrt(X²+Y²)) at (0, π/2)? ::: sin(π/2) = 1. First-trough radius of z = sin(r)? ::: r = 3π/2 ≈ 4.712. Peak of z = e^{-(x²+y²)} and where? ::: 1, at the origin. Facets drawn by plot_surface for m×n points? ::: (n−1)(m−1). Does bigger rstride give more or less detail? ::: Less — it skips more lines.