What does a vector actually store?

Try it before reading on. Pull the tip into each quadrant, then onto an axis, then onto the origin. Two numbers $x$ and $y$ are all the page stores; the length, the angle and the triangle are derived from them every time. By the end of the chapter you will know why the length is $\sqrt{x^2+y^2}$, why the direction needs a function called $\operatorname{atan2}$ and not just $\arctan$, and what a vector is not.

Intuition: a vector is a move

Walk three blocks east and two blocks north. That instruction is a displacement: it says how far to move, not where you are. It means the same thing from your front door and from the library; only the place you end up changes.

A vector in the plane is exactly such a move, written as two numbers, a column:

The first number is the movement along $x$ (right is positive) and the second is the movement along $y$ (up is positive). We draw it as an arrow, but the arrow is a picture of the move; the two numbers are the move.

Points and displacements

A point is a place: $P=(1,-1)$ names a location. A vector is a move. They are written with the same two numbers, which is the source of a lot of confusion, so it is worth separating them carefully.

The two are tied by two equations: applying a move to a point gives another point, and two points give the move between them.

Slide the arrow around and watch the inspector. The points $P$ and $Q$ change; $\mathbf v$, its length and its direction do not. Now move only the tip: the displacement changes, because it is defined as the difference of the two points. An arrow drawn starting at the origin is the special case $P=(0,0)$, called standard position; it is the one place where the point $Q$ and the vector $\mathbf v$ happen to have the same numbers.

Definition

A vector in the plane is an ordered pair of real numbers, written as a column,

where $x$ is the horizontal component and $y$ is the vertical component. Two vectors are equal exactly when both components are equal. The zero vector $\mathbf 0=\begin{bmatrix}0\\0\end{bmatrix}$ is the move that goes nowhere.

Throughout this book the plane has $+x$ to the right and $+y$ up, vectors are columns, and angles are in radians measured from the $+x$ axis, counter-clockwise turns positive and clockwise turns negative (so $(1,-1)$ has direction $-\pi/4$). A vector has two derived quantities: its magnitude $\lVert\mathbf v\rVert$ (how long the move is) and, when it is not the zero vector, its direction $\theta$ (which way).

Magnitude: Pythagoras on the components

The move $\mathbf v=(x,y)$ goes $x$ across and $y$ up. Those two legs meet at a right angle, so the straight-line length of the arrow is the hypotenuse:

Pythagoras’ theorem says the areas of the squares on the legs add up to the area of the square on the hypotenuse. Here that is literal: drag the vector and compare the three squares.

Notice what the inspector says for $(3,2)$: the square on the arrow has area $13$, exactly, so the side is $\sqrt{13}$ exactly, and $\sqrt{13}\approx 3.605551$ is only a rounding. For $(3,4)$ the area is $25$ and the length is exactly $5$. The book writes $=$ for the first kind of statement and $\approx$ for the second, and never mixes them.

Two properties follow at once from the formula. The length is never negative, and it is $0$ only for the zero vector, because a sum of squares is $0$ only when both squares are. And $\lVert -\mathbf v\rVert=\lVert\mathbf v\rVert$, since squaring erases signs: reversing a move does not change how long it is.

Direction: the angle from the x-axis

The direction of a nonzero vector is the signed angle $\theta$ from the positive $x$ axis to the arrow: counter-clockwise is positive, clockwise is negative. In the right triangle, $\tan\theta$ is rise over run, so for a vector pointing into the right half-plane

That is a perfectly good formula, for a vector pointing right. The trouble is everything else.

Why $\arctan(y/x)$ is not enough

Take $\mathbf v=(-3,2)$, which points up and to the left. Then $y/x=-2/3$ and $\arctan(-2/3)\approx-0.588$ radians, which is a direction pointing down and to the right: exactly backwards. The vector $-\mathbf v=(3,-2)$ has the identical ratio $-2/3$, so a formula that sees only the ratio cannot tell $\mathbf v$ from $-\mathbf v$. And $\arctan$ is only able to answer between $-\pi/2$ and $\pi/2$, the right half-plane, so for a vector in the left half-plane it is wrong by exactly half a turn.

The function that fixes this is $\operatorname{atan2}(y,x)$. It takes the two components separately, so it can see their signs, and returns the angle in $(-\pi,\pi]$. For $x>0$ it equals $\arctan(y/x)$. For $x<0$ it equals $\arctan(y/x)+\pi$ when $y\ge0$ and $\arctan(y/x)-\pi$ when $y<0$. When $x=0$ a vertical vector has a perfectly valid direction but no defined ratio $y/x$; $\operatorname{atan2}$ does not divide, so $\operatorname{atan2}(y,0)=\pi/2$ for $y>0$ and $-\pi/2$ for $y<0$.

This identity needs $x\neq0$, because $y/x$ must exist. The correction is exactly $0$, $\pi$ or $-\pi$, decided by the signs of $x$ and $y$ alone. Here is the whole picture in one table, every cell computed by the same model the stage above uses.

And there is one vector for which neither formula has a right answer: the zero vector. It has no direction, because it points nowhere. The stage shows this as an undefined state, not as the number $0$.

Worked examples

Four vectors, worked step by step: the length first, then the direction. The last one, $(0,-5)$, is the case where $y/x$ does not exist.

Executable reference code

Run the Python examples below to follow the calculations step by step. First the mechanics, written out so every step is visible.

import math

# A 2D vector is stored as two components. Here: v = (3, 2).
x = 3.0
y = 2.0

# Pythagoras: the hypotenuse of the right triangle with legs |x| and |y|.
magnitude = math.sqrt(x * x + y * y)  # ‖v‖ = √(x² + y²)

# atan2 knows the quadrant of (x, y); atan(y / x) does not.
angle = math.atan2(y, x)  # radians, in (−π, π]

print(magnitude, angle)  # 3.605551275463989 0.5880026035475675

import math

# v = (-3, 2): left of the y-axis, above the x-axis (quadrant II).
x, y = -3.0, 2.0

theta_naive = math.atan(y / x)  # -0.588...: arctan only returns angles between -pi/2 and pi/2
theta = math.atan2(y, x)  # 2.553...: atan2 looks at the signs of BOTH y and x

# -v = (3, -2) has exactly the same ratio y/x, so atan cannot tell v from -v apart.
theta_naive_of_minus_v = math.atan((-y) / (-x))  # the same -0.588... as for v
theta_of_minus_v = math.atan2(-y, -x)  # -0.588...: atan2 DOES see the difference (it is theta - pi)


def direction(x, y):
    """The angle from the +x axis in (-pi, pi], or None for the zero vector (it has no direction)."""
    if x == 0 and y == 0:
        return None
    return math.atan2(y, x)


zero_direction = direction(0.0, 0.0)  # None: the mathematics has no answer
silent_zero = math.atan2(0.0, 0.0)  # 0.0: the library quietly picks a value. Do not mistake it for a direction.

# A vertical vector has no ratio y/x at all, but it has a perfectly good direction.
try:
    math.atan(2.0 / 0.0)
except ZeroDivisionError:
    vertical_naive = "ZeroDivisionError"
vertical_atan2 = math.atan2(2.0, 0.0)  # pi/2

print(theta_naive, theta, theta_of_minus_v, zero_direction, vertical_naive, vertical_atan2)

import math

# A displacement vector says "go 3 right and 2 up". It is not a place.
v = (3.0, 2.0)

# Drawn from the origin, the arrow ends at the point (3, 2) ...
tip_from_origin = (0.0 + v[0], 0.0 + v[1])

# ... drawn from another tail P = (1, -1), the SAME displacement ends at a different point Q = P + v.
P = (1.0, -1.0)
tip_from_other_tail = (P[0] + v[0], P[1] + v[1])  # (4.0, 1.0)

# The displacement is recovered from the two points as Q - P: it does not depend on where the arrow starts.
v_from_other_tail = (tip_from_other_tail[0] - P[0], tip_from_other_tail[1] - P[1])  # (3.0, 2.0)

magnitude = math.hypot(*v_from_other_tail)  # the length is a property of v, not of P

print(tip_from_origin, tip_from_other_tail, v_from_other_tail, magnitude)

Then the practical form. NumPy stores many vectors at once, one per row, and works on all of them in a single call. (Rows are a storage layout for a batch; each vector is still a column in the mathematics.)

import numpy as np

# The practical form: once the mechanism is clear, the library does the bookkeeping.
v = np.array([3.0, 2.0])

magnitude = np.linalg.norm(v)  # ‖v‖₂
angle = np.arctan2(v[1], v[0])  # radians, in (−π, π]

print(magnitude, angle)  # 3.605551275463989 0.5880026035475675

import numpy as np

# In data science code a collection of vectors is usually stored one per ROW. (This book writes a single
# vector as a column; the numbers are the same, only the layout differs.)
V = np.array([[3.0, 2.0], [-3.0, 2.0], [-3.0, -2.0], [3.0, -2.0]])

lengths = np.linalg.norm(V, axis=1)  # one norm per row
angles = np.arctan2(V[:, 1], V[:, 0])  # one quadrant-aware angle per row: y first, then x

print(lengths)  # four equal lengths, each sqrt(13)
print(angles)  # one angle per quadrant: I, II, III, IV

Explore: change the parameters

Use the stages above as a laboratory. These questions have definite answers; check them against the inspector.

• On the Pythagoras stage, which integer vectors have a whole-number length? Try $(3,4)$, $(4,3)$, $(0,4)$. Which others can you find with components up to $4$?
• On the points stage, move $P$ to the origin. What do $Q$ and $\mathbf v$ now have in common?
• On the direction stage, press −x axis and then +y axis. Which has a ratio $y/x$ and which does not, and what does $\operatorname{atan2}$ return for each?
• Walk a vector around the origin counter-clockwise through all four quadrants. Where does $\arctan(y/x)$ jump, and where does $\operatorname{atan2}$ jump?

Common mistakes

Numerical considerations

Mathematically $\lVert\mathbf v\rVert=\sqrt{x^2+y^2}$. In floating point, squaring first can lose the answer completely: $(10^{-200})^2=10^{-400}$ is smaller than the smallest double, and $(10^{200})^2$ is larger than the largest. The library function hypot avoids both by rescaling before it squares.

Two more points. Negative zero exists: $-0.0$ equals $0.0$ in comparisons but atan2(0.0, -0.0) returns $\pi$ while atan2(0.0, 0.0) returns $0$. The stages here normalise $-0$ to $0$ so the displayed direction is stable. And the angle from atan2 jumps from $\pi$ to $-\pi$ across the negative $x$ axis; that is a feature of the range, not a change of direction.

Connections to engineering and machine learning

• Features as vectors. A data point with two measurements is a vector; its length is its distance from the origin, the Euclidean norm that appears everywhere from nearest-neighbour search to regularisation.
• Normalisation. Dividing a vector by its length gives a unit vector that keeps the direction and discards the scale; cosine similarity compares directions only. The zero vector has no direction, so normalising it needs a guard (the usual eps in code).
• Robotics and graphics. Headings, velocities and forces are vectors; atan2 is how a robot turns a displacement to a target into a heading, and why it is the standard function in every such library.
• Gradients. The gradient of a function is a vector; its length is the steepness and its direction is the way uphill.

Exercises

Answer each question and press Check. A wrong answer tells you which mistake it looks like. After one attempt you may open a worked solution.

Summary and checkpoints

• A vector in the plane is a column of two numbers, a displacement: how far, not where. Points are places; $Q=P+\mathbf v$ and $\mathbf v=Q-P$.
• Its magnitude is $\lVert\mathbf v\rVert=\sqrt{x^2+y^2}$, Pythagoras on the components. It is exact when the sum is a perfect square or a known radical, and otherwise a rounding.
• Its direction is $\theta=\operatorname{atan2}(y,x)$, not $\arctan(y/x)$, which is wrong by $\pm\pi$ in the left half-plane and does not exist on the $y$-axis.
• The zero vector has length $0$ and no direction.
• In code: hypot for length, atan2 for direction, an explicit guard for zero.

Checkpoints. You are ready to move on when you can, without looking:

1. Say why $(-3,2)$ and $(3,-2)$ have the same $y/x$ but different directions.
2. Compute $\lVert(5,12)\rVert$ and state whether the answer is exact.
3. Explain why sliding an arrow does not change the vector.
4. Say what $\operatorname{atan2}$ returns for $(0,4)$, $(-4,0)$ and $(0,0)$.

You can revisit the interactive vector by itself in the foundation explorer.