How do you keep direction and remove length?

Try $(3,4)$, then $(1,1)$, then zero. Predict which quantities remain defined at zero. The three length measures all become zero, while the unit-vector rows disappear into an explicit exception. Moving the tip away from zero restores a unit direction.

Intuition: size depends on what you measure

Euclidean length measures a straight move. Taxicab length counts the total travel along the two coordinate axes. The largest-component norm measures the worst coordinate displacement. These answer different questions about the same vector. None depends on which quadrant contains it, because signs describe direction rather than size.

Normalization removes Euclidean length without changing a nonzero vector’s direction. A short vector and a long vector along the same ray give the same normalized arrow. A vector on the opposite ray gives the negative unit vector. The unit circle acts as a catalogue of possible directions.

Definition

For $\mathbf v=(v_x,v_y)$,

An unqualified norm in this block means the Euclidean norm. A unit vector has Euclidean norm $1$. The normalized vector is defined only for $\mathbf v\ne\mathbf0$:

A norm is nonnegative, vanishes only at zero, scales by the absolute value of a scalar, and satisfies the triangle inequality $\norm{\mathbf u+\mathbf v}\le\norm{\mathbf u}+\norm{\mathbf v}$. For Euclidean distance, the straight route is no longer than the route through an intermediate point. Equality occurs for moves along the same ray, including a zero move.

Mechanics: the three unit balls

The unit ball of a norm consists of vectors whose norm is at most $1$. The stage draws its boundary. For $L_1$, $|x|+|y|=1$ gives the diamond. For $L_\infty$, $\max(|x|,|y|)=1$ gives the square. For $L_2$, $x^2+y^2=1$ gives the circle. These shapes follow directly from the norm definitions, rather than from the current vector’s length.

At $(1,1)$ the norms are $2$, $\sqrt2$, and $1$, respectively. The point lies on the square boundary, outside the Euclidean circle, and outside the diamond. If you divide by $L_1$ instead, the resulting vector lands on the diamond; it generally is not a Euclidean unit vector.

Derivation: why the normalized length is one

The length is positive when the vector is nonzero. Apply the scaling law from II.2 Scalar multiplication:

The scaling factor is positive, so the direction is preserved. At zero the factor would be $1/0$, and this derivation cannot begin. A zero result is not a substitute: its norm is $0$, not $1$.

The component inequalities also compare the three norms:

The first follows because the sum of squares contains the square of the larger component. For the second, $(|x|+|y|)^2=x^2+y^2+2|xy|\ge x^2+y^2$; taking nonnegative square roots preserves the inequality. Both become equalities on an axis. The ordering does not make one norm universally better; each defines a different size measure.

Worked examples

For $(3,4)$ the Euclidean length is $5$. Normalization gives $(3/5,4/5)$, whose squared length is $9/25+16/25=1$. The other norms are $7$ and $4$.

For $(1,1)$ the normalized vector is $(1/\sqrt2,1/\sqrt2)$. Those expressions are exact. Decimal components such as $0.707107$ are approximations; squaring rounded display values is not an exact proof of unit length. The inspector separates exact component expressions from their numerical approximations.

Executable reference code

The code distinguishes computing a norm from computing a unit direction. The latter rescales first. The NumPy version checks both shape and finiteness, rejects zero, and uses the same bounded rescaling idea.

from math import hypot, isfinite


def norms(v):
    if len(v) != 2 or not all(isfinite(x) for x in v):
        raise ValueError('Expected two finite components')
    x, y = v
    return hypot(x, y), abs(x) + abs(y), max(abs(x), abs(y))


def normalize(v):
    _, _, m = norms(v)
    if m == 0:
        raise ValueError('Zero has no unit direction')
    x, y = v[0] / m, v[1] / m
    h = hypot(x, y)
    return x / h, y / h


if __name__ == '__main__':
    assert norms((-3, 4)) == (5, 7, 4)
    assert normalize((3, 4)) == (0.6, 0.8)
    assert hypot(*normalize((1.7e308, 1.7e308))) > 0.999999999999999

import numpy as np


def normalize(v):
    v = np.asarray(v, dtype=float)
    if v.shape != (2,) or not np.isfinite(v).all():
        raise ValueError('Expected a finite two-component vector')
    m = np.max(np.abs(v))
    if m == 0:
        raise ValueError('Zero has no unit direction')
    scaled = v / m
    return scaled / np.hypot(*scaled)


v = np.array([-3.0, 4.0])
l2 = np.hypot(*v)  # avoids squaring overflow; a truly huge norm can still overflow
l1 = np.sum(np.abs(v))
linf = np.max(np.abs(v))
assert (l2, l1, linf) == (5, 7, 4)
assert np.allclose(normalize(v), [-0.6, 0.8])

Explore

Compare $(3,4)$ with $(1.5,2)$: predict the unchanged normalized vector. Reverse both signs and predict the new unit vector. On the horizontal axis, compare all three norms. Move along the diagonal and explain why the three readouts differ even though there is only one arrow. Try zero last, and identify which definition fails.

Common mistakes

Dividing by the squared norm is generally wrong: $(3,4)/25$ has length $1/5$. Dividing each component by its own magnitude gives a sign pattern, not a unit direction. Adding a tiny constant to the denominator can avoid a software exception but changes the formula and produces lengths below $1$; such regularization needs its own explicit purpose and definition.

Numerical considerations

Squaring first can overflow or underflow even when a meaningful unit direction exists. For finite $\mathbf v\ne0$, set $m=\max(|v_x|,|v_y|)$ and $\mathbf z=\mathbf v/m$. At least one scaled component has magnitude $1$, and neither exceeds $1$. Then normalize $\mathbf z$ by its bounded length. This works for enormous inputs and for a pair of smallest subnormal components. The real norm itself may exceed the largest finite binary64 value; direction can still be representable.

Engineering and ML connections

Unit directions separate where a motion goes from how far it travels. Different norms measure different costs: total coordinate movement, Euclidean displacement, or a worst coordinate limit. Feature normalization can reduce the influence of overall scale in a similarity calculation, but discarding magnitude also discards information. Choose it because the task needs direction, rather than because every vector should have unit length.

Exercises

Summary and checkpoints

A norm defines size, and Euclidean normalization retains the direction of a nonzero vector with unit length. Check that you can explain the three unit-ball shapes, derive the unit-length property, reject zero, and rescale before dangerous arithmetic. II.4 Dot product compares two directions with a dot product.