Broadcasting in Julia

Broadcasting is Julia's mechanism for applying a function element-wise across arrays (or combinations of arrays and scalars) by appending a dot to the function call, as in sin.(x) or x .+ y. When shapes differ, broadcasting follows dimension-expansion rules similar to NumPy: a dimension of size 1 (or a missing trailing dimension) is virtually expanded to match the other operand's size, so adding a (3,1) column vector to a (1,4) row vector via .+ produces a full (3,4) matrix without either operand actually being copied into that shape beforehand — the expansion happens conceptually during the elementwise pass.

When multiple broadcasted operations are chained, such as y .= sin.(x) .+ cos.(x), Julia's compiler fuses them into a single loop that computes one output element at a time without allocating any intermediate arrays for sin.(x) or cos.(x) separately — this is called loop fusion and is a key reason dotted expressions in Julia can match hand-written C loops in performance. The @. macro is a convenience that automatically inserts a dot before every function call, operator, and assignment in an expression, so @. y = sin(x) + cos(x) is exactly equivalent to writing y .= sin.(x) .+ cos.(x) by hand.

By default, a user-defined struct is treated as a single indivisible unit during broadcasting rather than being iterated element-by-element — for a wrapper type like a physical Measurement struct, this is usually the desired behavior, since you want add.(measurements, 5) to add 5 to every measurement in an array, treating each Measurement scalar-like rather than trying to broadcast into its internal fields. If you actually want a custom type to behave as a collection that broadcasting iterates over, you implement the Broadcast.broadcastable interface (or ensure it subtypes AbstractArray with the required methods) so Julia knows to treat it as array-like during a broadcast expression.

Forgetting a dot in a mixed scalar/array expression, such as writing x + y when x is an array and y is a scalar, produces a MethodError because + has no method for combining an array and a number directly, whereas x .+ y correctly broadcasts. Shape mismatches — attempting to broadcast a (3,4) array against a (5,) vector where neither dimension is 1 or compatible — raise a DimensionMismatch error rather than silently truncating or padding, and writing y = f.(x) inside a hot loop repeatedly allocates a brand-new array every iteration, which the in-place form y .= f.(x) avoids entirely.