Add reflect and symmetric padding modes to mx.pad

[katlun-lgtm]

Summary

Adds numpy.pad-compatible "reflect" and "symmetric" modes to mx.pad. These join the existing "constant" and "edge" modes.

Both modes match numpy.pad semantics for arbitrary pad sizes — when the pad width exceeds the axis length the reflection repeats, exactly as NumPy does. (Earlier attempts at these modes were limited to pad < dim; this implementation removes that restriction.)

• reflect — mirror padding that does not repeat the edge value (period 2(n-1)).
• symmetric — mirror padding that does repeat the edge value (period 2n).

Implementation

reflect_pad (in mlx/ops.cpp) builds a per-axis index map with a triangle-wave reflection function and gathers with take — one take per padded axis. A degenerate axis of length 1 maps every coordinate to 0. No new primitive or kernel is introduced; it composes existing ops, so it works on every backend and is differentiable for free.

Files changed

• mlx/ops.cpp — reflect_pad helper + reflect / symmetric dispatch branches in pad.
• python/src/ops.cpp — extend the mode Literal and docstring.
• python/tests/test_ops.py — test_pad_reflect_symmetric.
• tests/ops_tests.cpp — reflect/symmetric CHECK cases incl. multi-reflect.

Testing

All run locally on an M3 Max:

• Python test_pad_reflect_symmetric — 13 shape/pad-width cases × 2 modes compared element-for-element against numpy.pad (in-bounds, multi-reflect where pad ≫ axis, asymmetric per-axis, zero-width sides, and degenerate axes n==1, n==2). Exact match.
• C++ tests/ops_tests.cpp "test pad" — 9 assertions pass.
• Full C++ suite — 251 cases / 251 passed, 3442 assertions / 0 failed.

>>> import mlx.core as mx
>>> a = mx.array([1, 2, 3])
>>> mx.pad(a, 2, mode="reflect")
array([3, 2, 1, 2, 3, 2, 1], dtype=int32)
>>> mx.pad(a, 2, mode="symmetric")
array([2, 1, 1, 2, 3, 3, 2], dtype=int32)

[zcbenz]

Thanks for the PR, there was actually #2862 which is still waiting for a thorough review to merge. I think your PR is more elegant and I'm more in favor of this one, just in case do you think we are missing anything from #2862?

[katlun-lgtm]

Thanks @zcbenz! I went through #2862 carefully — functionally the two cover the same ground (reflect + symmetric, matching numpy.pad including the edge-excluded vs edge-included distinction), so nothing user-facing is missing.

Differences I found:

• Implementation: [Feature] Additional padding modes #2862 builds the padding with a slice/concatenate/tile/slice_update chain (a separate function per mode). This PR instead computes a single triangle-wave index map per padded axis and does one take (gather), with both modes sharing one helper via an include_edge flag — fewer lines and a lighter op graph.
• Multi-reflect (pad wider than the axis): handled in both; here it falls out of the modular index map rather than needing explicit tiling/reps logic.
• Tests: the suite here is a superset — it adds degenerate axes (n == 1, n == 2), multi-reflect on both sides simultaneously, asymmetric per-axis widths, and 3D cases, all checked elementwise against numpy.pad.
• The one thing [Feature] Additional padding modes #2862 had that this PR didn't — an ACKNOWLEDGMENTS.md entry — I've just added.

Happy to adjust naming or docs to whatever you prefer.