outer_op

→TensorImplPtr

int outer_op(const int & a, const int & b)

source edit

Python wrappers

pylucid.linalg.outerfunction

Compute the outer (tensor) product of two 1-D vectors, yielding a 2-D matrix.

The implementation evaluates the outer product as a degenerate GEMM between reshaped operands: a[:, None] @ b[None, :] — i.e. an $(M, 1) \times (1, N)$ matmul producing an $(M, N)$ result. On Accelerate this maps onto cblas_sger (rank-1 update) or cblas_*gemm; on the GPU stream it routes through MLX's matmul primitive. Autograd is wired through the package-private OuterBackward node, which saves both operands.

Math

Forward:

C_{ij} = a_i\, b_j

Backward (with $G = \partial L/\partial C$ ):

\frac{\partial L}{\partial a_i} = \sum_j G_{ij}\, b_j = (G\, b)_i, \qquad \frac{\partial L}{\partial b_j} = \sum_i G_{ij}\, a_i = (a^\top G)_j

Shape

a.shape == {M} and b.shape == {N}.
Output shape {M, N}.

References

NumPy numpy.outer (which Lucid mirrors for the 1-D case).

See Also

dot_op : 1-D × 1-D inner product (the "dual" of outer). inner_op : Last-axis contraction. matmul_op : Generalised matmul with batch broadcasting.

Parameters

aTensorImplPtr

Left operand. Must be 1-D with length

M

bTensorImplPtr

Right operand. Must be 1-D with length

N

Returns

TensorImplPtr

Output matrix of shape $(M, N)$ with $\mathrm{out}[i, j] = a_i\, b_j$ .

Raises

ShapeMismatch

If either input has rank other than 1.

Notes

Schema uses AmpPolicy::KeepInput — outer products on integer vectors are valid and must not be promoted.

Examples

    // a: [3],  b: [4]  →  out: [3, 4]
    // out[i, j] = a[i] * b[j]