M1: remaining op inventory + soak + dtype smoke matrix

Extend Emily.Native with the ops needed to close M1:
- sort/topk: sort, argsort, partition, argpartition, topk
- axis-aligned gather/scatter: take_along_axis, put_along_axis,
  scatter_add_axis
- misc: clip, roll, softmax, logcumsumexp, array_equal
- conv_general: full-featured N-D convolution (padding bundled as a
  {lo, hi} tuple to keep arity credo-clean)
- random: random_key, random_split, random_uniform, random_normal,
  random_randint, random_bernoulli, random_gumbel, random_categorical;
  keys carried through as std::optional<Tensor> so nil uses MLX's
  default key sequence
- fft: fftn, ifftn, rfftn, irfftn
- memory: get_active_memory, get_peak_memory, reset_peak_memory,
  get_cache_memory, clear_cache — used by the soak harness to observe
  allocator state

Tests:
- test/support/tensor_helpers.ex: extract f32/s32/pred builders,
  flat-list readers, and assert_close into a shared module.
- test/emily/native_test.exs: refactor to import the shared helpers;
  add per-op unit tests for every new NIF.
- test/soak/memory_test.exs (@tag :soak): 5000-iteration allocate/eval/
  drop loop; asserts MLX active memory returns within 1 MB of baseline
  after clear_cache. Excluded from default mix test via test_helper.
- test/emily/dtype_matrix_test.exs: smoke matrix covering every
  supported dtype across creation, cast, unary (float + numeric),
  binary, reductions, and comparisons.

All M1 exit criteria now met: every MLX op we care about is callable
from Elixir with correct outputs, the dtype × op surface is verified,
and the memory soak shows no leaks under 5k iterations.

Author: ausimian

RELEASE.md

@@ -5,9 +5,9 @@
 - M0 scaffold: mix project, MLX 0.25.1 prebuilt fetch pipeline,
   Makefile wiring `fine` + MLX, `Emily.Native` NIF surface for tensor
   round-trip, application supervisor skeleton, smoke test suite.
-- M1 (partial) — `Emily.Native` op inventory. Shared headers in
-  `c_src/emily/` (dtype mapping, Tensor resource, helpers);
-  per-category op files under `c_src/ops/`:
+- M1 — `Emily.Native` op inventory. Shared headers in `c_src/emily/`
+  (dtype mapping, Tensor resource, helpers); per-category op files
+  under `c_src/ops/`:
   - Creation: `zeros`, `ones`, `full`, `arange`, `eye`.
   - Cast: `astype`.
   - Unary elementwise: `negative`, `abs`, `sign`, `floor`, `ceil`,
@@ -26,24 +26,46 @@
     `right_shift`.
   - Reductions (axes + keepdims): `sum`, `mean`, `prod`, `max`, `min`,
     `all`, `any`, `logsumexp`; plus `var`/`std` with `ddof`,
-    `argmax`/`argmin`, cumulative `cumsum`/`cumprod`/`cummax`/`cummin`.
+    `argmax`/`argmin`, cumulative `cumsum`/`cumprod`/`cummax`/`cummin`/
+    `logcumsumexp`.
   - Shape: `reshape`, `transpose`, `squeeze`, `expand_dims`,
     `broadcast_to`, `concatenate`, `stack`, `flatten`, `tile`,
     `swapaxes`, `pad`, `repeat`.
-  - Indexing: `slice`, `take`, `where`.
+  - Sort family: `sort`, `argsort`, `partition`, `argpartition`,
+    `topk`.
+  - Indexing: `slice`, `take`, `where`, `take_along_axis`,
+    `put_along_axis`, `scatter_add_axis`.
+  - Misc: `clip`, `roll`, `softmax`, `array_equal`.
   - Linalg: `matmul`, `tensordot`, `outer`, `inner`.
-- `Emily.Native.to_binary/1` now routes through `mx::contiguous` so
+  - Convolution: `conv_general` (N-D with asymmetric padding,
+    dilation, groups, flip).
+  - Random: `random_key`, `random_split`, `random_uniform`,
+    `random_normal`, `random_randint`, `random_bernoulli`,
+    `random_gumbel`, `random_categorical` — keys passed as optional
+    tensor args (nil uses MLX's default key sequence).
+  - FFT: `fftn`, `ifftn`, `rfftn`, `irfftn`.
+  - Memory: `get_active_memory`, `get_peak_memory`,
+    `reset_peak_memory`, `get_cache_memory`, `clear_cache` — exposed
+    so the soak harness can observe allocator state.
+- `Emily.Native.to_binary/1` routes through `mx::contiguous` so
   strided views (transpose/slice/swapaxes/broadcast) materialize
   correctly.
+- `test/support/tensor_helpers.ex` — shared build/inspect helpers.
+- `test/soak/memory_test.exs` (`@tag :soak`, excluded by default) —
+  5000-iteration allocate/eval/drop loop; asserts MLX active memory
+  returns within 1 MB of baseline after `clear_cache`.
+- `test/emily/dtype_matrix_test.exs` — smoke matrix covering every
+  supported dtype across creation, cast, unary (float + numeric),
+  binary, reductions, and comparisons.
 - Makefile compiles `c_src/**/*.cpp` recursively.
 
 ## Notes
 
 - Ops files use anonymous namespaces to prevent NIF function names
   (`sin`, `log1p`, `sqrt`, ...) from colliding with C math-library
   symbols pulled in by MLX headers.
-- Deferred to later iterations of M1: sort/argsort, clip,
-  `slice_update`, `take_along_axis`, `scatter*`, convolutions,
-  `hadamard_transform`, random ops, FFT, quantized ops,
-  memory-stats/soak tests. Tracked for M1 completion before moving to
-  M2 (Backend).
+- Deferred beyond M1: the full `scatter`/`scatter_add`/... family with
+  vector-of-indices (only the axis-aligned forms are bound),
+  `hadamard_transform`, quantized matmul, `linalg.*` decompositions
+  (LU, QR, Cholesky, SVD). These will be added opportunistically when
+  M2/M3 callers need them.

c_src/memory.cpp

@@ -0,0 +1,40 @@
+// MLX allocator introspection — exposed as NIFs so the soak harness
+// can observe allocator state and assert it returns to baseline.
+
+#include <fine.hpp>
+#include <mlx/mlx.h>
+
+#include <cstdint>
+
+namespace mx = mlx::core;
+
+namespace {
+
+int64_t get_active_memory(ErlNifEnv *) {
+  return static_cast<int64_t>(mx::get_active_memory());
+}
+FINE_NIF(get_active_memory, 0);
+
+int64_t get_peak_memory(ErlNifEnv *) {
+  return static_cast<int64_t>(mx::get_peak_memory());
+}
+FINE_NIF(get_peak_memory, 0);
+
+fine::Ok<> reset_peak_memory(ErlNifEnv *) {
+  mx::reset_peak_memory();
+  return fine::Ok<>{};
+}
+FINE_NIF(reset_peak_memory, 0);
+
+int64_t get_cache_memory(ErlNifEnv *) {
+  return static_cast<int64_t>(mx::get_cache_memory());
+}
+FINE_NIF(get_cache_memory, 0);
+
+fine::Ok<> clear_cache(ErlNifEnv *) {
+  mx::clear_cache();
+  return fine::Ok<>{};
+}
+FINE_NIF(clear_cache, 0);
+
+} // namespace

c_src/ops/conv.cpp

@@ -0,0 +1,47 @@
+// Convolutions.
+//
+// Only the most general form (`conv_general`) is bound; 1-D/2-D/3-D
+// specialisations can be layered in Elixir by picking strides/padding
+// vectors of the right arity. This mirrors how Nx.conv/2 translates.
+
+#include "../emily/tensor.hpp"
+
+#include <fine.hpp>
+#include <mlx/mlx.h>
+
+#include <cstdint>
+#include <vector>
+
+namespace mx = mlx::core;
+using emily::Tensor;
+using emily::to_int_vec;
+using emily::wrap;
+
+namespace {
+
+// `padding` bundles low/high padding into a single tuple so the NIF
+// arity stays manageable; both have length == spatial rank.
+fine::ResourcePtr<Tensor> conv_general(
+    ErlNifEnv *,
+    fine::ResourcePtr<Tensor> input,
+    fine::ResourcePtr<Tensor> weight,
+    std::vector<int64_t> stride,
+    std::tuple<std::vector<int64_t>, std::vector<int64_t>> padding,
+    std::vector<int64_t> kernel_dilation,
+    std::vector<int64_t> input_dilation,
+    int64_t groups,
+    bool flip) {
+  return wrap(mx::conv_general(
+      input->array,
+      weight->array,
+      to_int_vec(stride),
+      to_int_vec(std::get<0>(padding)),
+      to_int_vec(std::get<1>(padding)),
+      to_int_vec(kernel_dilation),
+      to_int_vec(input_dilation),
+      static_cast<int>(groups),
+      flip));
+}
+FINE_NIF(conv_general, 0);
+
+} // namespace

c_src/ops/fft.cpp

@@ -0,0 +1,59 @@
+// Fast Fourier Transforms.
+//
+// We bind the n-dimensional forms; 1-D/2-D specialisations can be
+// built on top by picking axis vectors of the right length.
+
+#include "../emily/tensor.hpp"
+
+#include <fine.hpp>
+#include <mlx/mlx.h>
+
+#include <cstdint>
+#include <vector>
+
+namespace mx = mlx::core;
+namespace fft = mlx::core::fft;
+using emily::Tensor;
+using emily::to_int_vec;
+using emily::to_mlx_shape;
+using emily::wrap;
+
+namespace {
+
+fine::ResourcePtr<Tensor> fftn(
+    ErlNifEnv *,
+    fine::ResourcePtr<Tensor> a,
+    std::vector<int64_t> n,
+    std::vector<int64_t> axes) {
+  return wrap(fft::fftn(a->array, to_mlx_shape(n), to_int_vec(axes)));
+}
+FINE_NIF(fftn, 0);
+
+fine::ResourcePtr<Tensor> ifftn(
+    ErlNifEnv *,
+    fine::ResourcePtr<Tensor> a,
+    std::vector<int64_t> n,
+    std::vector<int64_t> axes) {
+  return wrap(fft::ifftn(a->array, to_mlx_shape(n), to_int_vec(axes)));
+}
+FINE_NIF(ifftn, 0);
+
+fine::ResourcePtr<Tensor> rfftn(
+    ErlNifEnv *,
+    fine::ResourcePtr<Tensor> a,
+    std::vector<int64_t> n,
+    std::vector<int64_t> axes) {
+  return wrap(fft::rfftn(a->array, to_mlx_shape(n), to_int_vec(axes)));
+}
+FINE_NIF(rfftn, 0);
+
+fine::ResourcePtr<Tensor> irfftn(
+    ErlNifEnv *,
+    fine::ResourcePtr<Tensor> a,
+    std::vector<int64_t> n,
+    std::vector<int64_t> axes) {
+  return wrap(fft::irfftn(a->array, to_mlx_shape(n), to_int_vec(axes)));
+}
+FINE_NIF(irfftn, 0);
+
+} // namespace

c_src/ops/index.cpp

@@ -50,4 +50,42 @@ fine::ResourcePtr<Tensor> where(
 }
 FINE_NIF(where, 0);
 
+// take_along_axis/3 — gather along `axis` using integer indices whose
+// shape matches `a` except along `axis`.
+fine::ResourcePtr<Tensor> take_along_axis(
+    ErlNifEnv *,
+    fine::ResourcePtr<Tensor> a,
+    fine::ResourcePtr<Tensor> indices,
+    int64_t axis) {
+  return wrap(mx::take_along_axis(
+      a->array, indices->array, static_cast<int>(axis)));
+}
+FINE_NIF(take_along_axis, 0);
+
+// put_along_axis/4 — write `values` into `a` at the given indices
+// along `axis`.
+fine::ResourcePtr<Tensor> put_along_axis(
+    ErlNifEnv *,
+    fine::ResourcePtr<Tensor> a,
+    fine::ResourcePtr<Tensor> indices,
+    fine::ResourcePtr<Tensor> values,
+    int64_t axis) {
+  return wrap(mx::put_along_axis(
+      a->array, indices->array, values->array, static_cast<int>(axis)));
+}
+FINE_NIF(put_along_axis, 0);
+
+// scatter_add_axis/4 — add `values` into `a` at the given indices
+// along `axis`.
+fine::ResourcePtr<Tensor> scatter_add_axis(
+    ErlNifEnv *,
+    fine::ResourcePtr<Tensor> a,
+    fine::ResourcePtr<Tensor> indices,
+    fine::ResourcePtr<Tensor> values,
+    int64_t axis) {
+  return wrap(mx::scatter_add_axis(
+      a->array, indices->array, values->array, static_cast<int>(axis)));
+}
+FINE_NIF(scatter_add_axis, 0);
+
 } // namespace

c_src/ops/misc.cpp

@@ -0,0 +1,73 @@
+// Miscellaneous ops that didn't fit elsewhere: clip, roll, softmax,
+// logcumsumexp, array_equal.
+
+#include "../emily/tensor.hpp"
+
+#include <fine.hpp>
+#include <mlx/mlx.h>
+
+#include <cstdint>
+#include <vector>
+
+namespace mx = mlx::core;
+using emily::Tensor;
+using emily::to_int_vec;
+using emily::wrap;
+
+namespace {
+
+// clip/3 — clip each element to [min, max]. Both bounds are required
+// tensors; the caller can broadcast a scalar if only one side is
+// interesting.
+fine::ResourcePtr<Tensor> clip(
+    ErlNifEnv *,
+    fine::ResourcePtr<Tensor> a,
+    fine::ResourcePtr<Tensor> a_min,
+    fine::ResourcePtr<Tensor> a_max) {
+  return wrap(mx::clip(a->array, a_min->array, a_max->array));
+}
+FINE_NIF(clip, 0);
+
+// roll/3 — shift elements `shift` steps along `axis` with wrap-around.
+fine::ResourcePtr<Tensor> roll(
+    ErlNifEnv *,
+    fine::ResourcePtr<Tensor> a,
+    int64_t shift,
+    int64_t axis) {
+  return wrap(mx::roll(
+      a->array, static_cast<int>(shift), static_cast<int>(axis)));
+}
+FINE_NIF(roll, 0);
+
+// softmax along the given axes.
+fine::ResourcePtr<Tensor> softmax(
+    ErlNifEnv *,
+    fine::ResourcePtr<Tensor> a,
+    std::vector<int64_t> axes,
+    bool precise) {
+  return wrap(mx::softmax(a->array, to_int_vec(axes), precise));
+}
+FINE_NIF(softmax, 0);
+
+fine::ResourcePtr<Tensor> logcumsumexp(
+    ErlNifEnv *,
+    fine::ResourcePtr<Tensor> a,
+    int64_t axis,
+    bool reverse,
+    bool inclusive) {
+  return wrap(mx::logcumsumexp(
+      a->array, static_cast<int>(axis), reverse, inclusive));
+}
+FINE_NIF(logcumsumexp, 0);
+
+// array_equal/2 — returns a scalar bool tensor. Treats NaNs as unequal.
+fine::ResourcePtr<Tensor> array_equal(
+    ErlNifEnv *,
+    fine::ResourcePtr<Tensor> a,
+    fine::ResourcePtr<Tensor> b,
+    bool equal_nan) {
+  return wrap(mx::array_equal(a->array, b->array, equal_nan));
+}
+FINE_NIF(array_equal, 0);
+
+} // namespace