Skillversitas

Broadcasting

Broadcasting is the rule that lets operations combine arrays of different shapes: instead of requiring exact shape matches, NumPy aligns the shapes and stretches the smaller one across the larger. It is what makes matrix + offset_vector work, what powers the row/column tricks in data processing, and the source of the most common (and most confusing) shape errors in the language. The rule is three sentences; the examples are where it clicks.

The Rules

Two shapes are compatible for broadcasting if, comparing dimensions from the trailing (rightmost) axis backward:

  1. The dimensions are equal, or
  2. one of them is 1 (it gets stretched to the other's size), or
  3. one of the shapes has no such dimension (it is padded with 1s on the left).

The result shape is the maximum of the two along each axis. No data is copied for the "stretched" array - the engine reads the same element repeatedly, which is why broadcasting is fast, not a convenience loop.

The Examples That Matter

import numpy as np

m = np.arange(12).reshape(3, 4)      # (3, 4)

# scalar: (3,4) + () - trivial case
print(m + 10)

# row vector: (3,4) + (4,) - the (4,) pads to (1,4), stretches to 3 rows
offsets = np.array([1, 10, 100, 1000])
print(m + offsets)                   # each column shifted by its offset

# column vector: (3,4) + (3,1) - stretches across the 4 columns
row_shifts = np.array([[10], [20], [30]])
print(m + row_shifts)                # each row shifted

# outer form: (3,1) * (1,4) -> (3,4) - the classic "all pairs" pattern
left = np.array([[1], [2], [3]])
right = np.array([10, 20, 30, 40])
print(left * right)                  # every combination, one multiplication

Three patterns cover most real use. Row vector + matrix: per-column operations (subtract per-feature means, add per-column biases). Column vector + matrix: per-row operations (shift each row by its own value). Column x row (the outer form): compute every pairwise combination in one vectorized expression - distance matrices, similarity grids, and grid evaluations all reduce to it.

Making Shapes Broadcast

x = np.arange(4)                     # (4,) - a row
y = np.arange(3)                     # (3,) - another row

# (3,) and (4,) do NOT broadcast - both are trailing dimensions, neither is 1
# fix: reshape one to a column
print((y[:, None] + x).shape)        # (3, 4) - all pairwise sums

# a concrete use: distances between two point sets
A = np.random.default_rng(0).normal(size=(100, 2))   # 100 points in 2-D
B = np.random.default_rng(1).normal(size=(50, 2))    # 50 points

# squared distances: (100,1,2) - (50,1,2) -> (100,50,2) -> sum over last axis
diff = A[:, None, :] - B[None, :, :]
d2 = (diff ** 2).sum(axis=2)
print(d2.shape)                      # (100, 50)

When two shapes refuse to broadcast, the fix is almost always a None (or newaxis) insertion to add the axis that one array is missing. The squared-distance computation is the canonical example: three None insertions turn two point sets into a full pairwise distance matrix with no Python loops at all.

Debugging Broadcast Errors

try:
    np.ones((3, 4)) + np.ones((5,))
except ValueError as e:
    print(e)
    # operands could not be broadcast together with shapes (3,4) (5,)

The error prints both shapes - read them from the right. If the trailing dimensions differ and neither is 1, that is the conflict. The two standard resolutions: reshape one operand (usually to add a None axis), or check whether the operation should have been a dot product in the first place (a (3,4) + (4,) where you wanted rows-times-columns is a shape intent bug, not a broadcasting bug). When in doubt, print the shapes of every operand before the failing line.

Inspecting with broadcast_arrays

a = np.ones((3, 1))
b = np.ones((1, 4))
ba, bb = np.broadcast_arrays(a, b)
print(ba.shape, bb.shape)            # (3, 4) (3, 4) - the resolved shapes
print(ba.strides)                     # note: zero strides where it "stretches"

np.broadcast_arrays returns the operands as they would be seen in the operation - both at the result shape, with zero strides marking the stretched axes. It is the diagnostic tool: when you want to know what shapes an operation actually resolves to, ask it directly instead of guessing.

Summary

Broadcasting aligns shapes from the trailing axis and stretches any dimension of size 1 (or missing) to match: no copy, no loop, the engine re-reads the smaller array. The daily patterns are row-vector-per-column, column-vector-per-row, and the column-times-row outer form; when shapes conflict, insert None/newaxis to add the missing axis, and read the error's two shapes from the right to find the actual conflict. Use np.broadcast_arrays to see the resolved shapes when the intent is unclear.