carray 3.0.0 → 3.0.2

data/ext/mkkernel.rb

@@ -144,6 +144,55 @@ module MkKernel
     SNIPPET
   end
 
+  # Complex libm comes in two widths: `csqrt` takes a `double _Complex`,
+  # `csqrtf` a `float _Complex`.  A body written with only the double-
+  # taking name still compiles for a cmplx64 cell, because the cell
+  # widens on the way in and rounds on the way out -- so the kernel
+  # computes at cmplx128 whatever the array said it was, and the `+ - *`
+  # kernels beside it stay narrow.  This builds the two expr entries that
+  # hold each complex data_type at its own width.
+  #
+  # In `body`, `<f>` marks each spot the `f` suffix belongs and `<t>` a
+  # real scalar of the matching width:
+  #
+  #   cmplx_widths("(#2) = csqrt<f>(#1);")
+  #   cmplx_widths("{ <t> _r = creal<f>(#1); ... }")
+  #
+  # Returns array-keyed entries, so merge it into an expr Hash that
+  # carries the other families:
+  #
+  #   expr: { float: "...", object: "..." }.merge(cmplx_widths("..."))
+  def self.cmplx_widths(body)
+    {
+      [:cmplx64]  => at_width(body, "f", "float"),
+      [:cmplx128] => at_width(body, "", "double"),
+    }
+  end
+
+  # The same split for the real families, and for the same reason: `sin`
+  # takes a double, so an f32 cell widens on the way in and rounds on the
+  # way out.  Use it in place of a `float:` entry whenever the body calls
+  # a libm function that has an `f` variant.
+  #
+  #   expr: { object: "..." }.merge(float_widths("(#2) = sin<f>(#1);"))
+  #
+  # Not every double-taking call wants this.  `fabs`, `fmin` / `fmax`,
+  # `ceil` / `floor` / `trunc` and the `isnan` family are exact on a
+  # float either way, and `round` (`floor(x + 0.5)`) is exact only in
+  # double -- narrowing it would round `x + 0.5f` first and step the
+  # answer at the boundary.
+  def self.float_widths(body)
+    {
+      [:f32] => at_width(body, "f", "float"),
+      [:f64] => at_width(body, "", "double"),
+    }
+  end
+
+  # Substitute the width markers in a kernel body.
+  def self.at_width(body, suffix, real_type)
+    body.gsub("<f>", suffix).gsub("<t>", real_type)
+  end
+
   # CA_NTYPE order from ext/carray.h.  Drives the per-data_type table layout
   # for eager-style monop/binop tables `ca_<form>_<name>[CA_NTYPE]`.
   # `:reserved` slots emit `ca_<form>_not_implement` (= retired holes
@@ -311,6 +360,7 @@ module MkKernel
                   face_gate: nil,
                   object_escape: nil,
                   identity_on_empty: false,
+                  all_nan_result: nil,
                   outputs: 1,
                   # Two-pass centred algorithm (variance / stddev family).
                   # When algorithm: :two_pass_centred is set, `state / init /
@@ -416,6 +466,30 @@ module MkKernel
         end
       end
     end
+    # all_nan_result: what an extreme-value reduction answers when every
+    # contributing cell was NaN.  The `(v < acc) ? v : acc` reduce body is
+    # false for NaN, so acc is never updated and the init (+/-INFINITY)
+    # leaks out as the answer -- a value that is neither the minimum of
+    # anything nor a missing marker, and indistinguishable from data that
+    # genuinely held only +INFINITY.
+    #
+    #   :nan   -- answer NaN (C99 fmin folded: a lone non-NaN wins, two
+    #             NaNs give NaN).  For kernels whose output can hold it.
+    #   :undef -- answer UNDEF, by folding into the mask_policy trigger.
+    #             For kernels whose output is a position (argmin family):
+    #             an integer output cannot hold NaN, and index 0 would be
+    #             a lie about where the minimum is.
+    #
+    # Only the float srcs act on it; integers and boolean have no NaN and
+    # their init is a legitimate value.
+    unless all_nan_result.nil? || %i[nan undef].include?(all_nan_result)
+      raise "#{name}: all_nan_result #{all_nan_result.inspect} invalid " \
+            "(expected :nan, :undef, or nil)"
+    end
+    if all_nan_result == :undef && mask_policy.nil?
+      raise "#{name}: all_nan_result: :undef needs a mask_policy " \
+            "(UNDEF is written through the mask_policy trigger)"
+    end
     if value_arg
       raise "#{name}: value_arg must be a Hash" unless value_arg.is_a?(Hash)
       raise "#{name}: value_arg: target must be :T_IN" unless value_arg[:target] == :T_IN
@@ -429,16 +503,29 @@ module MkKernel
     # selects direction (:min / :max) and output kind:
     #   :min / :max       -> extremum blob, output data_type = CA_FIXLEN
     #   :argmin / :argmax -> position of the extremum, output i64
+    #   :count_equal      -> how many cells memcmp-equal value_arg, output i64
     # Author must also list :fixlen in source: (parallel to how :object
     # opts in via source: + an :object body).
+    #
+    # :count_equal is the one mode that takes a value_arg, and takes it as a
+    # byte blob rather than a scalar: the dispatcher packs the query with
+    # rb_ca_obj2ptr into a ca->bytes buffer, the same way the search family
+    # already does for a fixlen query (which is what makes a short query
+    # NUL-pad to the cell width instead of never matching).
     if fixlen
-      unless %i[min max argmin argmax].include?(fixlen)
-        raise "#{name}: fixlen: must be :min / :max / :argmin / :argmax (got #{fixlen.inspect})"
+      unless %i[min max argmin argmax count_equal].include?(fixlen)
+        raise "#{name}: fixlen: must be :min / :max / :argmin / :argmax / :count_equal (got #{fixlen.inspect})"
       end
       raise "#{name}: fixlen: requires :fixlen in source:" unless source.include?(:fixlen)
       raise "#{name}: fixlen: requires mask_policy: :min_count" unless mask_policy == :min_count
       raise "#{name}: fixlen: requires outputs: 1" unless outputs == 1
-      raise "#{name}: fixlen: does not support value_arg / array_arg" if value_arg || array_arg
+      raise "#{name}: fixlen: does not support array_arg" if array_arg
+      if value_arg && fixlen != :count_equal
+        raise "#{name}: fixlen: only :count_equal takes a value_arg"
+      end
+      if fixlen == :count_equal && !value_arg
+        raise "#{name}: fixlen: :count_equal requires value_arg"
+      end
     elsif source.include?(:fixlen)
       raise "#{name}: source includes :fixlen but no fixlen: spec given"
     end
@@ -563,6 +650,7 @@ module MkKernel
       face_gate:       face_gate,
       object_escape:   object_escape,
       identity_on_empty: identity_on_empty,
+      all_nan_result:  all_nan_result,
       outputs:         outputs,
       algorithm:       algorithm,
       divisor:         divisor,
@@ -757,7 +845,7 @@ module MkKernel
   #                 output cell is UNDEF).
   #   :sentinel  -> masked cells are treated as an incomparable sentinel,
   #                 the same role NaN plays for :end nan_policy but runtime-
-  #                 selectable and dtype-agnostic.  Per fiber, unmasked
+  #                 selectable and type-agnostic.  Per fiber, unmasked
   #                 cells are compacted into a contiguous sub-range and only
   #                 that sub-range is sorted/quickselected; masked cells are
   #                 compacted into the complementary sub-range at the head
@@ -1005,7 +1093,9 @@ module MkKernel
     # demotes to real f64).  Hash form requires the kernel author to
     # write expr that produces output data_type values for each source family
     # (e.g. cabs() for complex returning double).
-    raise "#{name}: unknown output #{output}" unless output == :preserve || DTYPES.key?(output) || output.is_a?(Hash)
+    raise "#{name}: unknown output #{output}" \
+      unless output == :preserve || output == :real_of_source ||
+             DTYPES.key?(output) || output.is_a?(Hash)
     KERNELS << {
       kind:     :monop,
       name:     name,
@@ -1188,6 +1278,13 @@ module MkKernel
   #     fallback when no family matches.  Uses the same family aliases
   #     as monop_expr_family_match? (:numeric / :int / :float / :complex
   #     / :bool / :object).
+  #
+  # A Hash value (or a bare output form) may also be :real_of_source,
+  # meaning "the real component width of the source complex data_type"
+  # (cmplx64 -> f32, cmplx128 -> f64).  This is what an op like abs
+  # wants for its complex family: the magnitude of a cmplx64 is a
+  # float32, the same width `.real` and `.imag` already return.  Naming
+  # :f64 there would hand cmplx64 the real width of cmplx128.
   # SL.1.1: Resolve the reduce macro suffix for a given kernel entry,
   # driven by reduction_kind.  Returns "" for :none (= legacy
   # CA_SLAB_REDUCE_T_EX), or "_PLUS" / "_MIN" / "_MAX" / "_STAR" to
@@ -1208,7 +1305,7 @@ module MkKernel
   #
   # Ineligible:
   #   - suffix == ""  (:object src / no_simd_src override — reduce body
-  #     is Ruby callback or dtype-specific, single-accumulator required)
+  #     is Ruby callback or type-specific, single-accumulator required)
   #   - array_arg (weighted reductions use the ARRAY_T_EX macro family,
   #     which has its own emit path)
   def self.reduce_8way_eligible?(k, src, suffix)
@@ -1293,6 +1390,62 @@ module MkKernel
     io.puts "#undef #{expr_macro}"
   end
 
+  # State vars that start at the type's limit (T_LIMIT_HI / T_LIMIT_LO)
+  # and so can leak their init as an answer.  A position state (argmin's
+  # best_i, init "0") is deliberately not one of them: index 0 is a value
+  # a real minimum can legitimately produce.
+  def self.limit_init_state_vars(k, si, oi, src)
+    return [] unless k[:state]
+    k[:state].keys.filter_map do |var|
+      token = pick_family_string(k[:init][var], src, "init")
+      next unless %w[T_LIMIT_HI T_LIMIT_LO].include?(token)
+      [var, resolve_init_expr(k[:init][var], oi, si, src)]
+    end
+  end
+
+  # Emit the all-NaN fix-up for an extreme-value reduction (see the
+  # all_nan_result: validation in MkKernel.reduce for why it exists).
+  #
+  # The per-cell reduce body is left alone: it stays the SIMD-licensed
+  # ternary, so the 8-way horizontal split (reduce_8way_eligible?) and
+  # the `reduction(min:acc)` clause are untouched, and ordinary data pays
+  # one comparison per slab.  Carrying a "saw a number" flag as a second
+  # DSL state var was the alternative and costs more than it looks: it
+  # takes the kernel over reduce_8way_eligible?'s single-state gate and
+  # drops min / max back onto the legacy single-accumulator macro.
+  #
+  # acc still sitting at its init means either nothing updated it or the
+  # data genuinely held only +/-INFINITY.  Those are told apart by
+  # walking the slab once more for a non-NaN cell -- O(n), and only for
+  # a slab whose answer came out equal to the init.
+  #
+  # Returns true when it emitted anything.
+  def self.emit_all_nan_fixup(io, k, src, si, pairs, valid_guard,
+                              indent: "      ", flag_var: nil)
+    mode = k[:all_nan_result]
+    return false unless mode
+    return false unless FLOAT_DTYPES.include?(src)
+    cond = pairs.map { |var, init| "#{var} == (#{init})" }.join(" && ")
+    cond = "(#{cond}) && #{valid_guard}" if valid_guard
+    io.puts "#{indent}/* all-NaN fix-up (all_nan_result: #{mode.inspect}). */"
+    io.puts "#{indent}if ( #{cond} ) {"
+    io.puts "#{indent}  int64_t   __anf_seen = 0;"
+    io.puts "#{indent}  ca_size_t __anf_mc   = 0;"
+    io.puts "#{indent}  CA_SLAB_REDUCE_T_EX(#{si[:c]}, st, p, m, __anf_seen, 0, " \
+            "__anf_seen |= (v == v), __anf_mc);"
+    io.puts "#{indent}  (void) __anf_mc;"
+    io.puts "#{indent}  if ( ! __anf_seen ) {"
+    if mode == :nan
+      pairs.each { |var, _| io.puts "#{indent}    #{var} = (#{si[:c]}) NAN;" }
+    else
+      raise "#{k[:name]}: all_nan_result: :undef needs flag_var" unless flag_var
+      io.puts "#{indent}    #{flag_var} = 1;"
+    end
+    io.puts "#{indent}  }"
+    io.puts "#{indent}}"
+    true
+  end
+
   def self.reduce_macro_suffix(k, src = nil)
     # CA_OBJECT cannot ride the SIMD-licensed macros (= _PLUS / _MIN / _MAX
     # / _STAR), which assume C operators (= acc is a VALUE, so
@@ -1325,6 +1478,24 @@ module MkKernel
     end
   end
 
+  # Real component width of a complex data_type: cmplx64 -> f32,
+  # cmplx128 -> f64.  Raises for anything else, since :real_of_source
+  # only has a meaning for a complex source.
+  REAL_OF_CMPLX = { cmplx64: :f32, cmplx128: :f64 }.freeze
+
+  def self.resolve_output_dtype(kernel, src, dt)
+    case dt
+    when :preserve then DTYPES[src]
+    when :real_of_source
+      real = REAL_OF_CMPLX[src]
+      raise "#{kernel[:name]}: output :real_of_source needs a complex src (got #{src})" \
+        unless real
+      DTYPES[real]
+    else
+      DTYPES[dt]
+    end
+  end
+
   def self.output_info(kernel, src)
     out = kernel[:output]
     case out
@@ -1334,16 +1505,15 @@ module MkKernel
         next if family == :default
         if monop_expr_family_match?(family, src)
           # Hash value may itself be :preserve (= "same as source for this
-          # family") or a data_type symbol like :f64.
-          return (dt == :preserve) ? DTYPES[src] : DTYPES[dt]
+          # family"), :real_of_source, or a data_type symbol like :f64.
+          return resolve_output_dtype(kernel, src, dt)
         end
       end
       raise "#{kernel[:name]}: output Hash has no match for src #{src} and no :default" \
         unless out.key?(:default)
-      dt = out[:default]
-      (dt == :preserve) ? DTYPES[src] : DTYPES[dt]
+      resolve_output_dtype(kernel, src, out[:default])
     else
-      DTYPES[out]
+      resolve_output_dtype(kernel, src, out)
     end
   end
 
@@ -1699,7 +1869,7 @@ module MkKernel
 
     if streamable
       emit_reduce_streaming(io, k, si, oi, ruby_wrap, acc_var, acc_init,
-                            decls, reduce_stmt, finish_expr, extra_args)
+                            decls, reduce_stmt, finish_expr, extra_args, src)
     end
 
     # L.1 / L.3 / L.4 (PROPOSAL_REDUCTION_LOOP_INTERCHANGE):
@@ -1859,6 +2029,17 @@ module MkKernel
         emit_reduce_slab_call(io, k, src, si, oi, suffix, acc_var, acc_init,
                               reduce_stmt, "masked_cnt", indent: "      ")
       end
+      all_nan_flag = nil
+      if k[:all_nan_result]
+        pairs = limit_init_state_vars(k, si, oi, src)
+        if k[:all_nan_result] == :undef && FLOAT_DTYPES.include?(src)
+          all_nan_flag = "__anf_all_nan"
+          io.puts "      int #{all_nan_flag} = 0;"
+        end
+        emit_all_nan_fixup(io, k, src, si, pairs,
+                           "masked_cnt < st.slab_elements",
+                           indent: "      ", flag_var: all_nan_flag)
+      end
       trigger = case k[:mask_policy]
                 when :strict     then "masked_cnt > 0"
                 when :all_masked then "masked_cnt == st.slab_elements"
@@ -1880,6 +2061,7 @@ module MkKernel
                       ": st.slab_elements - masked_cnt < min_count)"
                   end
                 end
+      trigger = "(#{trigger}) || #{all_nan_flag}" if all_nan_flag
       finish_emit = view_flat \
         ? "(transform_active ? (outer_off + ((ca_size_t)(#{finish_expr})) * axis_vstride) : ((ca_size_t)(#{finish_expr})))" \
         : "(#{finish_expr})"
@@ -1962,13 +2144,15 @@ module MkKernel
   # the numeric argmin's best_i.  mask_policy is always :min_count here.
   def self.emit_reduce_native_fixlen(io, k, src)
     name      = k[:name]
+    counting  = k[:fixlen] == :count_equal
     want_max  = %i[max argmax].include?(k[:fixlen])
-    index_out = %i[argmin argmax].include?(k[:fixlen])
+    index_out = %i[argmin argmax].include?(k[:fixlen]) || counting
     cmp       = want_max ? ">" : "<"
+    varg      = counting ? ", const char *value_arg" : ""
 
     io.puts
     io.puts "static VALUE"
-    io.puts "#{name}_ki_native_fixlen (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)"
+    io.puts "#{name}_ki_native_fixlen (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis#{varg}, ca_size_t min_count)"
     io.puts "{"
     io.puts "  ca_size_t K = ca->bytes;   /* uniform fixlen byte width */"
     if index_out
@@ -1989,9 +2173,13 @@ module MkKernel
     io.puts "  ca_size_t   out_i   = 0;"
     io.puts "  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */"
     io.puts "  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {"
-    io.puts "    const char *best   = NULL;"
-    io.puts "    ca_size_t   best_i = 0;"
-    io.puts "    (void) best_i;" unless index_out   # value output ignores the index
+    if counting
+      io.puts "    int64_t     cnt    = 0;"
+    else
+      io.puts "    const char *best   = NULL;"
+      io.puts "    ca_size_t   best_i = 0;"
+      io.puts "    (void) best_i;" unless index_out   # value output ignores the index
+    end
     io.puts "    ca_size_t   masked_cnt = 0;"
     io.puts "    int8_t      sndim   = st.slab_ndim;"
     io.puts "    ca_size_t   sidx[CA_RANK_MAX] = { 0 };"
@@ -2007,12 +2195,18 @@ module MkKernel
     io.puts "      }"
     io.puts "      else {"
     io.puts "        const char *q = (const char *) p + doff;"
-    io.puts "        if ( best == NULL ) {"
-    io.puts "          best = q; best_i = idx;"
-    io.puts "        }"
-    io.puts "        else if ( memcmp(q, best, (size_t) K) #{cmp} 0 ) {"
-    io.puts "          best = q; best_i = idx;"
-    io.puts "        }"
+    if counting
+      io.puts "        if ( memcmp(q, value_arg, (size_t) K) == 0 ) {"
+      io.puts "          cnt++;"
+      io.puts "        }"
+    else
+      io.puts "        if ( best == NULL ) {"
+      io.puts "          best = q; best_i = idx;"
+      io.puts "        }"
+      io.puts "        else if ( memcmp(q, best, (size_t) K) #{cmp} 0 ) {"
+      io.puts "          best = q; best_i = idx;"
+      io.puts "        }"
+    end
     io.puts "      }"
     io.puts "      /* row-major odometer (innermost slab axis fastest) so idx"
     io.puts "         matches CA_SLAB_REDUCE_T's flat slab index. */"
@@ -2021,8 +2215,16 @@ module MkKernel
     io.puts "        sidx[sk] = 0;"
     io.puts "      }"
     io.puts "    }"
-    io.puts "    if ( min_count < 0 ? masked_cnt == st.slab_elements"
-    io.puts "                       : st.slab_elements - masked_cnt < min_count ) {"
+    # ERI.0: a count over nothing is 0, not UNDEF -- so the default
+    # (min_count < 0) never fires the mask for :count_equal.  An explicit
+    # min_count: still does.
+    if counting
+      io.puts "    if ( min_count < 0 ? 0"
+      io.puts "                       : st.slab_elements - masked_cnt < min_count ) {"
+    else
+      io.puts "    if ( min_count < 0 ? masked_cnt == st.slab_elements"
+      io.puts "                       : st.slab_elements - masked_cnt < min_count ) {"
+    end
     io.puts "      if ( ! op_mask ) {"
     io.puts "        ca_create_mask(co);"
     io.puts "        op_mask = (boolean8_t *) co->mask->ptr;"
@@ -2036,7 +2238,9 @@ module MkKernel
     io.puts "      out_i++;"
     io.puts "    }"
     io.puts "    else {"
-    if index_out
+    if counting
+      io.puts "      ((int64_t *) op)[out_i] = cnt;"
+    elsif index_out
       io.puts "      ((int64_t *) op)[out_i] = (int64_t) best_i;"
     else
       io.puts "      memcpy(op + out_i * K, best, (size_t) K);"
@@ -2364,6 +2568,49 @@ module MkKernel
     buf_decls = plus_info.map do |pi|
       "          #{pi[:c_type]}  #{pi[:buf]}[512];\n"
     end.join
+
+    # all-NaN fix-up for the tiled core (see emit_all_nan_fixup for the
+    # reduction counterpart).  Each output cell of a tile has its own
+    # accumulator, so the check is per column: a column whose accumulator
+    # is still at the init either saw only NaN or only +/-INFINITY.
+    #
+    # The `_Pragma("omp simd")` j-loop is left alone -- carrying a
+    # "saw a number" flag beside the accumulator would double its loads
+    # and stores on every cell of every column.  Instead the tile is
+    # tested once after the M loop (tile_len comparisons against M *
+    # tile_len already done), and only a tile that holds a suspicious
+    # column re-reads its rows.
+    li_nan_fixup =
+      if k[:all_nan_result] == :nan && FLOAT_DTYPES.include?(src) &&
+         plus_info.size == 1
+        pi = plus_info.first
+        seen_buf = "__li_buf_seen"
+        lambda do |m_step|
+          <<~C.rstrip
+                    {
+                      int __li_susp = 0;
+                      for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
+                        if ( #{pi[:buf]}[__j] == (#{pi[:c_type]}) (#{pi[:init]}) ) { __li_susp = 1; break; }
+                      }
+                      if ( __li_susp ) {
+                        int8_t #{seen_buf}[512];
+                        for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) #{seen_buf}[__j] = 0;
+                        for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
+                          const #{si[:c]} *__li_row = __li_plane + __li_i * #{m_step} + __li_tile;
+                          for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
+                            #{seen_buf}[__j] |= (__li_row[__j] == __li_row[__j]);
+                          }
+                        }
+                        for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
+                          if ( ! #{seen_buf}[__j] ) #{pi[:buf]}[__j] = (#{pi[:c_type]}) NAN;
+                        }
+                      }
+                    }
+          C
+        end
+      else
+        lambda { |_m_step| "" }
+      end
     init_loops = plus_info.map do |pi|
       "              for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {\n" \
       "                #{pi[:buf]}[__j] = (#{pi[:c_type]}) (#{pi[:init]});\n" \
@@ -2393,6 +2640,7 @@ module MkKernel
                         (void) v;
                       }
                     }
+        #{li_nan_fixup.call("__li_INNER")}
                     for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
                       #{opv}[__li_o * __li_INNER + __li_tile + __j] = (#{oi[:c]}) (#{finish_li});
                     }
@@ -2613,6 +2861,7 @@ module MkKernel
                       (void) v;
                     }
                   }
+        #{li_nan_fixup.call("__li_INNER")}
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
                     __li_op_k[__li_tile + __j] = (#{oi[:c]}) (#{finish_li});
                   }
@@ -2643,8 +2892,8 @@ module MkKernel
            write stride 1 (= contig output tail) both preserved -> SIMD
            tile reduce + write maintained.
 
-           Performance characteristic (deliver-via-view, per the CLAUDE.md
-           "deliver the materials" principle): bench (b2 pattern, M=200, K=5, eff_INNER
+           Performance characteristic (deliver-via-view -- the surface
+           prioritises delivering the cells over avoiding a copy): bench (b2 pattern, M=200, K=5, eff_INNER
            =360, INNER_pre_K=16) yields 3674 us vs eager-entity 1545 us
            = 2.38x slow.  Root cause is the multi-parent data layout
            (= 5 separate 9 MB regions instead of one contig 46 MB),
@@ -2771,6 +3020,7 @@ module MkKernel
                       (void) v;
                     }
                   }
+        #{li_nan_fixup.call("__li_M_stride")}
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
                     __li_op_k[__li_tile + __j] = (#{oi[:c]}) (#{finish_li});
                   }
@@ -2800,8 +3050,8 @@ module MkKernel
   #     reductions consume the same slab)
   #   - no streaming / view_flat / array_arg / value_arg
   #   - reduction_kind: :none only
-  # The if-form discipline (CLAUDE.md "write multi-reduction fused kernels
-  # in if-form") is enforced by author, not by the generator.
+  # The if-form discipline for multi-reduction fused kernels (see
+  # emit_min_max below) is enforced by author, not by the generator.
   def self.emit_reduce_native_multi(io, k, src)
     si        = DTYPES[src]
     oi        = output_info(k, src)
@@ -2862,6 +3112,10 @@ module MkKernel
     if min_count
       io.puts "      ca_size_t masked_cnt = 0;"
       io.puts "      CA_SLAB_REDUCE_T_EX(#{si[:c]}, st, p, m, #{acc_var}, #{acc_init}, #{reduce_stmt}, masked_cnt);"
+      if k[:all_nan_result]
+        emit_all_nan_fixup(io, k, src, si, limit_init_state_vars(k, si, oi, src),
+                           "masked_cnt < st.slab_elements", indent: "      ")
+      end
       # Same trigger as single-output :min_count: legacy default (all_masked)
       # when min_count < 0, otherwise need at least min_count valid cells.
       trigger = "(min_count < 0 ? masked_cnt == st.slab_elements " \
@@ -2937,7 +3191,7 @@ module MkKernel
   #   - mask present: ca_has_mask(ca)
   def self.emit_reduce_streaming(io, k, si, oi, ruby_wrap, acc_var,
                                   acc_init, decls, reduce_stmt,
-                                  finish_expr, extra_args)
+                                  finish_expr, extra_args, src)
     name      = k[:name]
     min_count = (k[:mask_policy] == :min_count)
     has_mp    = !k[:mask_policy].nil?
@@ -2968,6 +3222,14 @@ module MkKernel
     # acc_var requires explicit init (= the macro normally does this).
     # Other state vars in decls already include `= init` per line.
     io.puts "      #{acc_var} = (#{acc_init});"
+    # all-NaN fix-up, streaming variant.  The other two paths confirm a
+    # suspicious answer by re-reading the data; here re-reading means
+    # evaluating the lazy chain a second time, so the flag rides along in
+    # the chunk loop instead.  The loop already pays for producing each
+    # cell, which is what makes one more compare affordable here and not
+    # in the tiled core.
+    all_nan_stream = k[:all_nan_result] == :nan && FLOAT_DTYPES.include?(src)
+    io.puts "      int64_t __anf_seen = 0;" if all_nan_stream
     if has_mp
       # Mask-policy reductions need masked_cnt to satisfy the macro/
       # finish_expr signature.  On streaming we have no mask, so it's
@@ -2976,7 +3238,15 @@ module MkKernel
       io.puts "      (void) masked_cnt;"
     end
     io.puts "      ca_lazy_arena_enter();"
-    io.puts "      #{si[:c]} *__chunk = (#{si[:c]} *) ca_lazy_arena_acquire(__chunk_elems * sizeof(#{si[:c]}));"
+    if si[:c] == "VALUE"
+      # Object lane: the chunk holds VALUEs pulled from the source, and
+      # the fold below calls rb_funcall per cell.  A collection there
+      # would free cells a lazy source produced into the chunk, so the
+      # slot has to stay marked for as long as it is held.
+      io.puts "      VALUE *__chunk = (VALUE *) ca_lazy_arena_acquire_object(__chunk_elems);"
+    else
+      io.puts "      #{si[:c]} *__chunk = (#{si[:c]} *) ca_lazy_arena_acquire(__chunk_elems * sizeof(#{si[:c]}));"
+    end
     io.puts "      while ( __outer_off < __outer ) {"
     io.puts "        ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;"
     io.puts "        ca_size_t __n = __r * __inner;"
@@ -2987,11 +3257,15 @@ module MkKernel
     io.puts "        for ( __i = 0; __i < __n; __i++ ) {"
     io.puts "          #{si[:c]} v = __chunk[__i];"
     io.puts "          #{reduce_stmt};"
+    io.puts "          __anf_seen |= (v == v);" if all_nan_stream
     io.puts "        }"
     io.puts "        __outer_off += __r;"
     io.puts "      }"
     io.puts "      ca_lazy_arena_release(__chunk);"
     io.puts "      ca_lazy_arena_exit();"
+    if all_nan_stream
+      io.puts "      if ( ! __anf_seen && ca->elements > 0 ) #{acc_var} = (#{si[:c]}) NAN;"
+    end
     if has_mp
       # Streaming path has no mask source, so masked_cnt is 0; min_count
       # / strict / all_masked triggers all evaluate to false except
@@ -3235,7 +3509,17 @@ module MkKernel
     k[:source].each do |s|
       si = DTYPES[s]
       # Per-src value_arg cast: NUM2LL / NUM2ULL / NUM2DBL -> (T_IN).
-      varg_decl = has_varg ? "      #{si[:c]} value_arg = (#{si[:c]}) #{si[:num2c]}(rval);\n" : ""
+      varg_decl = if !has_varg
+                    ""
+                  elsif s == :fixlen
+                    # A fixlen query is a runtime-width byte blob with no
+                    # scalar cast; pack it the way the search family does,
+                    # which NUL-pads a short String to the cell width.
+                    "      char *value_arg = ALLOCA_N(char, src->bytes);\n" \
+                    "      rb_ca_obj2ptr(self, rval, value_arg);\n"
+                  else
+                    "      #{si[:c]} value_arg = (#{si[:c]}) #{si[:num2c]}(rval);\n"
+                  end
       if use_result_var || has_varg
         io.puts "    case #{si[:ca]}: {"
         io.print varg_decl unless varg_decl.empty?
@@ -3794,7 +4078,7 @@ module MkKernel
   # `masked_last` parameter.  Sets `sort_lo` / `sort_n` to the unmasked
   # sub-range so the downstream sort/quickselect call only ever compares
   # unmasked pairs -- masked cells are an incomparable sentinel, the same
-  # role NaN plays for nan_policy: :end, but dtype-agnostic and runtime-
+  # role NaN plays for nan_policy: :end, but type-agnostic and runtime-
   # selectable.  `payload_expr(k)` computes the `.i` payload (fiber-local
   # index for :fiber_local semantics, view-flat address for :view_flat)
   # given the Ruby string `k` naming the C loop variable.
@@ -4829,7 +5113,7 @@ module MkKernel
       {
         /* rev4 A1 via single-element CArray: convert CScalar / [1] 1-D /
            all dim==1 etc. to a Ruby Float and route it through the Case A
-           scalar path. The dtype matches ca (= rb_ca_obj2ptr coerces it
+           scalar path. The data type matches ca (= rb_ca_obj2ptr coerces it
            downstream). */
         if ( rb_obj_is_carray(rval) ) {
           CArray *cv_pre_;
@@ -5250,7 +5534,7 @@ module MkKernel
     io.puts "    }"
     io.puts "    if ( self_face_comparable ) {"
     io.puts "      if ( rval_is_face ) {"
-    io.puts "        rval = rb_ca_strip_face_value(rval);"
+    io.puts %Q[        rval = ca_face_operand_descend(rval, "#{name}_ki");]
     io.puts "      }"
     io.puts "    } else if ( self_was_face ) {"
     io.puts "      if ( rb_respond_to(self_ref, rb_intern(\"to_comparable\")) ) {"
@@ -6055,6 +6339,90 @@ module MkKernel
   # The aggregator init.c, where Init_carray_kernels() calls each per-tag
   # Init_<suffix>() in file_tags order.  No tag depends on another: an alias
   # already sits after its target within its own file.
+  # ---------------------------------------------------------------------
+  # The kernel bodies, as text, for a caller that has to compute the same
+  # thing somewhere other than in these kernels -- a compiler handed an
+  # expression tree, which must produce what the eager kernel produces.
+  # Emitting the table here rather than reading this generator at runtime
+  # keeps a build-time tool out of the running process.
+  #
+  # The bodies keep their `#1` / `#2` / `#3` and `<type>` placeholders: the
+  # caller substitutes its own operands.  Object-lane bodies are left out,
+  # since they call back into the interpreter and cannot be compiled apart
+  # from it.
+  # ---------------------------------------------------------------------
+
+  BODY_TABLE_DTYPES = %i[i8 u8 i16 u16 i32 u32 i64 u64 f32 f64
+                         bool cmplx64 cmplx128].freeze
+
+  def self.body_table_rows
+    rows = []
+    KERNELS.each do |k|
+      next unless %i[monop binop triop].include?(k[:kind])
+      BODY_TABLE_DTYPES.each do |src|
+        body = monop_expr_for(k, src)
+        next unless body.is_a?(String)
+        next if body.include?("rb_funcall")
+        rows << [k[:kind].to_s, k[:name].to_s,
+                 DTYPES[src][:ca].sub(/\ACA_/, "").downcase, body]
+      end
+    end
+    rows
+  end
+
+  def self.c_string_literal(text)
+    '"' + text.gsub("\\", "\\\\").gsub('"', '\\"').gsub("\n", '\\n') + '"'
+  end
+
+  def self.emit_kernel_bodies(io)
+    rows = body_table_rows
+    io.puts
+    io.puts "/* The text of every kernel body, for a caller that compiles the same"
+    io.puts "   operation elsewhere.  Placeholders are left in place. */"
+    io.puts
+    io.puts "typedef struct {"
+    io.puts "  const char *kind;"
+    io.puts "  const char *name;"
+    io.puts "  const char *data_type;"
+    io.puts "  const char *body;"
+    io.puts "} ca_kernel_body_t;"
+    io.puts
+    io.puts "static const ca_kernel_body_t ca_kernel_bodies[] = {"
+    rows.each do |kind, name, dtype, body|
+      io.puts "  { #{c_string_literal(kind)}, #{c_string_literal(name)}, " \
+              "#{c_string_literal(dtype)},"
+      io.puts "    #{c_string_literal(body)} },"
+    end
+    io.puts "};"
+    io.puts
+    io.puts "static const int ca_kernel_bodies_count = #{rows.size};"
+    io.puts
+    io.puts <<~C
+      /* CArray.__kernel_body__(kind, name, data_type) -> String, or nil where
+         this operation has no body at that data type. */
+      static VALUE
+      rb_ca_s_kernel_body (VALUE klass, VALUE rkind, VALUE rname, VALUE rtype)
+      {
+        VALUE kind = rb_obj_as_string(rkind);
+        VALUE name = rb_obj_as_string(rname);
+        VALUE type = rb_obj_as_string(rtype);
+        const char *k = StringValueCStr(kind);
+        const char *n = StringValueCStr(name);
+        const char *t = StringValueCStr(type);
+        int i;
+        for ( i = 0; i < ca_kernel_bodies_count; i++ ) {
+          const ca_kernel_body_t *e = &ca_kernel_bodies[i];
+          if ( strcmp(e->kind, k) == 0 &&
+               strcmp(e->name, n) == 0 &&
+               strcmp(e->data_type, t) == 0 ) {
+            return rb_str_new_cstr(e->body);
+          }
+        }
+        return Qnil;
+      }
+    C
+  end
+
   def self.emit_aggregator_init(io, tags)
     io.puts "/* GENERATED aggregator: dispatches to per-tag Init_carray_kernels_<tag>() */"
     io.puts "#include \"carray.h\""
@@ -6063,23 +6431,30 @@ module MkKernel
       io.puts "void Init_carray_kernels_#{file_suffix(kind, sub)} (void);"
     end
     io.puts
+    emit_kernel_bodies(io)
+    io.puts
     io.puts "void"
     io.puts "Init_carray_kernels (void)"
     io.puts "{"
     tags.each do |kind, sub|
       io.puts "  Init_carray_kernels_#{file_suffix(kind, sub)}();"
     end
+    io.puts "  rb_define_singleton_method(rb_cCArray, \"__kernel_body__\","
+    io.puts "                             rb_ca_s_kernel_body, 3);"
     io.puts "}"
   end
 
   # Single-stream Init_carray_kernels(): every kind emitted in order inside
   # one function.
   def self.emit_init(io)
+    emit_kernel_bodies(io)
     io.puts
     io.puts "void"
     io.puts "Init_carray_kernels (void)"
     io.puts "{"
     KERNELS.each { |k| emit_init_line(io, k) }
+    io.puts "  rb_define_singleton_method(rb_cCArray, \"__kernel_body__\","
+    io.puts "                             rb_ca_s_kernel_body, 3);"
     io.puts "}"
   end
 
@@ -6155,7 +6530,7 @@ module MkKernel
       # bench A/B comparison during Phase E (E.1-E.5); after E.7 they
       # are retired.  Maps and scans keep their `_ki` names because
       # they have no user-facing equivalent yet (cumsum etc. pending
-      # rewire per CLAUDE.md "methods awaiting reimplementation").
+      # rewire).
       #
       # SO.2 rev6 (2026-06-04): sort kernels can opt out of the _ki
       # binding via bind_ruby: false (= internal-only kernels consumed
@@ -6269,6 +6644,7 @@ MkKernel.reduce :min,
                      bool:    "acc = ((uint64_t) v < acc) ? (uint64_t) v : acc",
                      object:  'if (acc == Qundef) acc = v; else if (RTEST(rb_funcall(v, rb_intern("<"), 1, acc))) acc = v;' },
   reduction_kind:  :min,     # SL.1.2
+  all_nan_result:  :nan,
   # CA_FIXLEN: memcmp lexicographic min (byte order == the fixlen sort
   # order); the numeric reduce/init above are unused for fixlen (bespoke
   # slab walk, see the fixlen: option in MkKernel.reduce).
@@ -6293,6 +6669,7 @@ MkKernel.reduce :max,
                      bool:    "acc = ((uint64_t) v > acc) ? (uint64_t) v : acc",
                      object:  'if (acc == Qundef) acc = v; else if (RTEST(rb_funcall(v, rb_intern(">"), 1, acc))) acc = v;' },
   reduction_kind:  :max,     # SL.1.2
+  all_nan_result:  :nan,
   # CA_FIXLEN: memcmp lexicographic max (byte order == the fixlen sort order).
   fixlen:          :max,
   source:          MkKernel::ALL_NUMERIC + [:bool, :object, :fixlen],
@@ -6500,11 +6877,11 @@ MkKernel.reduce :stddev,
 # -fopenmp-simd).  The 2x f64 speedup survives SL.1.2's reduction(min/max:)
 # vectorizer reject because fminnm + fmaxnm dual-issue on M2's two FP pipes.
 #
-# if-form discipline (CLAUDE.md "write multi-reduction fused kernels in if-form"):
+# if-form discipline for multi-reduction fused kernels:
 # the body uses `if (v < lo) lo = v;` etc, NOT ternary `lo = (v < lo) ? v : lo;`.
 # DO NOT change to ternary — pragma-less ILP path depends on if-form.
 #
-# FM.1.0 scope: mask not yet propagated (FM.1.5).  Numeric dtypes only.
+# FM.1.0 scope: mask not yet propagated (FM.1.5).  Numeric data types only.
 
 MkKernel.reduce :minmax,
   state:           { lo: :load_type, hi: :load_type },
@@ -6518,6 +6895,7 @@ MkKernel.reduce :minmax,
                      # together on init, get set together on first reduce).
                      object:  'if (lo == Qundef) { lo = v; hi = v; } else { if (RTEST(rb_funcall(v, rb_intern("<"), 1, lo))) lo = v; if (RTEST(rb_funcall(v, rb_intern(">"), 1, hi))) hi = v; }' },
   outputs:         2,
+  all_nan_result:  :nan,
   finish:          { min: "lo", max: "hi" },
   source:          MkKernel::ALL_NUMERIC + [:bool, :object],
   # bool: u64 (Integer 0/1) so minmax returns [0/1, 0/1], not
@@ -6541,9 +6919,9 @@ MkKernel.reduce :minmax,
 # actual name (`best_v` here) through to the macro -- the macro accepts
 # any identifier as its accumulator argument.
 #
-# Exposed as Ruby `min_index` / `max_index` (= naming convention
-# "methods returning a position use *_index", see CLAUDE.md "methods
-# awaiting reimplementation" table).  These
+# Exposed as Ruby `min_index` / `max_index` (= the naming rule that a
+# method returning a position uses the `_index` suffix; see the rules
+# table in guides/devel/00_glossary.md).  These
 # replace the legacy `min_addr` / `max_addr` retired in E.7 stat_proc
 # retire (commit f5c7ecd).  3.0 breaking: name change from `*_addr` to
 # `*_index` is intentional.
@@ -6566,6 +6944,7 @@ MkKernel.reduce :argmin,
   # An ORDERABLE Face descends to its numeric storage (position output needs
   # no re-lift; the axis-local index is identical for Face and storage).
   face_gate:       :strip,
+  all_nan_result:  :undef,
   public_method: :min_index
 
 MkKernel.reduce :argmax,
@@ -6584,6 +6963,7 @@ MkKernel.reduce :argmax,
   fallback:        :raise,
   mask_policy:     :min_count,
   face_gate:       :strip,
+  all_nan_result:  :undef,
   public_method: :max_index
 
 # ---- argmin_addr / argmax_addr (view-flat address variants) ---------
@@ -6595,10 +6975,10 @@ MkKernel.reduce :argmax,
 # axis-local-to-flat-addr round-trip).
 #
 # Paired with the sort family's sort_addr(axis:) (= already public)
-# and partition family's partition_addr_ki (= internal).  Per
-# CLAUDE.md "«`_addr` is OK to expose: a per-axis primitive that returns a real flat address»"
-# (= "dual API: _index for axis-local position, _addr for view-flat
-# address").
+# and partition family's partition_addr_ki (= internal).  `_addr`
+# is OK to expose for a per-axis primitive that returns a real flat
+# address: the dual API is `_index` for an axis-local position, `_addr`
+# for a view-flat one.
 #
 # Runtime constraints:
 #   - naxes == 1 (single-axis reduce): view-flat transform applied
@@ -6627,6 +7007,7 @@ MkKernel.reduce :argmin_addr,
   mask_policy:     :min_count,
   semantics:       :view_flat,
   face_gate:       :strip,
+  all_nan_result:  :undef,
   public_method: :min_addr
 
 MkKernel.reduce :argmax_addr,
@@ -6644,6 +7025,7 @@ MkKernel.reduce :argmax_addr,
   mask_policy:     :min_count,
   semantics:       :view_flat,
   face_gate:       :strip,
+  all_nan_result:  :undef,
   public_method: :max_addr
 
 # ---- mask_policy demos ------------------------------------------------
@@ -6771,9 +7153,13 @@ MkKernel.reduce :count_false,
 
 MkKernel.reduce :count_equal,
   init:        "0",
-  reduce:      "if (v == value_arg) acc += 1",
+  # The object lane compares with rb_equal (= Ruby ==), not the C ==, which
+  # on two VALUEs would ask whether they are the same object.
+  reduce:      { numeric: "if (v == value_arg) acc += 1",
+                 object:  "if (RTEST(rb_equal(v, value_arg))) acc += 1" },
   reduction_kind: :plus,         # SL.1.4 (conditional predication; clang predicates safely under reduction(+:acc))
-  source:      MkKernel::ALL_NUMERIC,
+  source:      MkKernel::ALL_NUMERIC + [:object, :fixlen],
+  fixlen:      :count_equal,   # bespoke memcmp walk (a blob has no scalar C type)
   output:      :i64,
   ruby_scalar: :LL2NUM,
   fallback:    :raise,
@@ -6806,7 +7192,8 @@ MkKernel.reduce :count_equal,
 #     paths removed (= ALL_NUMERIC + :raise fallback).  Re-add via demand-
 #     driven complex specialization or CA_OBJECT bridge phase.
 #   - **per-axis support gained**: `a.wsum(w, 0)`, `a.wsum(w, 0, 1)`, etc.
-#     (= original "open per-axis" goal, CLAUDE.md per-axis-for-all principle).
+#     (= the original "open per-axis" goal: every reduction gains an
+#     axis form).
 #
 # public_method: true rebinds `wsum` from legacy rb_ca_wsum to
 # rb_ca_wsum_ki at Init time.
@@ -6965,22 +7352,38 @@ MkKernel.scan :cumprod,
 # init Qnil is the "no running extremum yet" sentinel, also never leaked
 # (unseen cells are masked).  First unmasked cell adopts v as acc;
 # subsequent unmasked cells compare via rb_funcall(:>) / rb_funcall(:<).
+# The float lane starts at NaN and folds with C99 fmin / fmax, whose
+# rule is exactly the one wanted: a lone number beats NaN, two NaNs give
+# NaN.  So a prefix that has seen only NaN answers NaN instead of leaking
+# +/-INFINITY -- the running form of the rule min / max follow
+# (all_nan_result:).  fmin / fmax are exact on a float at either width,
+# so the f32 lane needs no narrowing.  Integer and boolean have no NaN
+# and keep the limit init and the plain compare.
 MkKernel.scan :cummax,
   source:       MkKernel::ALL_NUMERIC + [:bool, :object],
   output:       { bool: :u64, default: :preserve },
-  init:         { numeric: "T_LIMIT_LO", bool: "T_LIMIT_LO", object: "Qnil" },
-  step:         { numeric: "if (v > acc) acc = v; r = acc",
+  init:         { float: "NAN", numeric: "T_LIMIT_LO", bool: "T_LIMIT_LO", object: "Qnil" },
+  step:         { float: "acc = fmax(acc, v); r = acc",
+                  numeric: "if (v > acc) acc = v; r = acc",
                   bool:    "if ((uint64_t) v > acc) acc = v; r = acc",
                   object:  'if (acc == Qnil) acc = v; else if (RTEST(rb_funcall(v, rb_intern(">"), 1, acc))) acc = v; r = acc' },
   fallback:     :raise,
   axis_default: :flatten,
   empty:        :undef
 
+# The float lane starts at NaN and folds with C99 fmin / fmax, whose
+# rule is exactly the one wanted: a lone number beats NaN, two NaNs give
+# NaN.  So a prefix that has seen only NaN answers NaN instead of leaking
+# +/-INFINITY -- the running form of the rule min / max follow
+# (all_nan_result:).  fmin / fmax are exact on a float at either width,
+# so the f32 lane needs no narrowing.  Integer and boolean have no NaN
+# and keep the limit init and the plain compare.
 MkKernel.scan :cummin,
   source:       MkKernel::ALL_NUMERIC + [:bool, :object],
   output:       { bool: :u64, default: :preserve },
-  init:         { numeric: "T_LIMIT_HI", bool: "T_LIMIT_HI", object: "Qnil" },
-  step:         { numeric: "if (v < acc) acc = v; r = acc",
+  init:         { float: "NAN", numeric: "T_LIMIT_HI", bool: "T_LIMIT_HI", object: "Qnil" },
+  step:         { float: "acc = fmin(acc, v); r = acc",
+                  numeric: "if (v < acc) acc = v; r = acc",
                   bool:    "if ((uint64_t) v < acc) acc = v; r = acc",
                   object:  'if (acc == Qnil) acc = v; else if (RTEST(rb_funcall(v, rb_intern("<"), 1, acc))) acc = v; r = acc' },
   fallback:     :raise,
@@ -7015,7 +7418,7 @@ MkKernel.scan :cumcount,
 # acc_type: :load_type -> acc carries T_LOAD (= last seen input value).
 # STEP additionally sees `first` (int) marking the first live cell of
 # the fiber.  Output data_type = :bool.  No production consumer remains:
-# every dtype's mask_duplicates now uses the O(distinct) seen-set hash
+# every data type's mask_duplicates now uses the O(distinct) seen-set hash
 # lane (__mask_duplicates__, with boolean riding its uint8 lane), which
 # has no sort buffers.  The numeric widths are kept as a standalone scan
 # kernel (a sort-path reference oracle in the mask_duplicates tests).
@@ -7368,12 +7771,32 @@ MkKernel.search :search_nearest,
     object: <<~C,
       /* CA_OBJECT nearest: minimum of query_val.distance(cell), compared
          with `<` (matches the legacy flat proc_nearest_addr_VALUE). */
+      /* Nearest needs a metric.  #distance is the protocol the 2.0 flat
+         kernel used, back when Numeric#distance was a monkey patch; it
+         is an opt-in refinement now, and a refinement does not reach an
+         rb_funcall from C -- so a number reaching here answers no more
+         than a String does.  Measure a number the way #distance itself
+         does, keep #distance for anything that defines a real one, and
+         refuse the rest by name rather than let a bare NoMethodError out
+         of the loop below. */
+      ID nearest_id = rb_intern("distance");
+      int nearest_by_distance = rb_respond_to(query_val, nearest_id);
+      if ( ! nearest_by_distance && ! rb_obj_is_kind_of(query_val, rb_cNumeric) ) {
+        rb_raise(rb_eCADataTypeError,
+                 "search_nearest: nearest needs a distance, and %s is neither a "
+                 "number nor answers #distance (define one on the stored "
+                 "objects, or use search / bsearch for an exact match)",
+                 rb_obj_classname(query_val));
+      }
       result = (ca_size_t) -1;
       VALUE best = Qnil;
       for ( ca_size_t i = 0; i < slab_n; i++ ) {
         if ( mask_in && mask_in[i * slab_mask_stride] ) continue;
         T_LOAD v = *(T_LOAD *)(slab_ptr + i * slab_stride);
-        VALUE dist = rb_funcall(query_val, rb_intern("distance"), 1, v);
+        VALUE dist = nearest_by_distance
+                   ? rb_funcall(query_val, nearest_id, 1, v)
+                   : rb_funcall(rb_funcall(query_val, '-', 1, v),
+                                rb_intern("abs"), 0);
         if ( NIL_P(best) || RTEST(rb_funcall(dist, rb_intern("<"), 1, best)) ) {
           best = dist; result = i;
         }
@@ -7392,8 +7815,8 @@ MkKernel.search :search_nearest,
 # (= axis-local position) is transformed to a view-flat (row-major) address
 # into self by the dispatcher.  Paired with the *_index family
 # (= bsearch / search / search_nearest already returning axis-local
-# positions per the dual `_index` / `_addr` API in CLAUDE.md "`_addr` is
-# OK to expose: a per-axis primitive that returns a real flat address").
+# positions per the dual `_index` / `_addr` API: `_index` for an
+# axis-local position, `_addr` for a view-flat one).
 #
 # Scope: scalar val path only (= case A).  CArray val + broadcast
 # path (case B/C) raises NotImpError until extended (= the per-element
@@ -7549,12 +7972,32 @@ MkKernel.search :search_nearest_addr,
     object: <<~C,
       /* CA_OBJECT nearest (view_flat addr): minimum of
          query_val.distance(cell), compared with `<`. */
+      /* Nearest needs a metric.  #distance is the protocol the 2.0 flat
+         kernel used, back when Numeric#distance was a monkey patch; it
+         is an opt-in refinement now, and a refinement does not reach an
+         rb_funcall from C -- so a number reaching here answers no more
+         than a String does.  Measure a number the way #distance itself
+         does, keep #distance for anything that defines a real one, and
+         refuse the rest by name rather than let a bare NoMethodError out
+         of the loop below. */
+      ID nearest_id = rb_intern("distance");
+      int nearest_by_distance = rb_respond_to(query_val, nearest_id);
+      if ( ! nearest_by_distance && ! rb_obj_is_kind_of(query_val, rb_cNumeric) ) {
+        rb_raise(rb_eCADataTypeError,
+                 "search_nearest_addr: nearest needs a distance, and %s is neither a "
+                 "number nor answers #distance (define one on the stored "
+                 "objects, or use search / bsearch for an exact match)",
+                 rb_obj_classname(query_val));
+      }
       result = (ca_size_t) -1;
       VALUE best = Qnil;
       for ( ca_size_t i = 0; i < slab_n; i++ ) {
         if ( mask_in && mask_in[i * slab_mask_stride] ) continue;
         T_LOAD v = *(T_LOAD *)(slab_ptr + i * slab_stride);
-        VALUE dist = rb_funcall(query_val, rb_intern("distance"), 1, v);
+        VALUE dist = nearest_by_distance
+                   ? rb_funcall(query_val, nearest_id, 1, v)
+                   : rb_funcall(rb_funcall(query_val, '-', 1, v),
+                                rb_intern("abs"), 0);
         if ( NIL_P(best) || RTEST(rb_funcall(dist, rb_intern("<"), 1, best)) ) {
           best = dist; result = i;
         }
@@ -7805,13 +8248,16 @@ MkKernel.monop :abs_i,
     MkKernel::SINT64_DTYPES     => "(#2) = llabs(#1);",
     MkKernel::UINT_DTYPES       => "(#2) = (#1);",
     MkKernel::FLOAT_DTYPES      => "(#2) = fabs((float64_t)#1);",
-    MkKernel::CMPLX_DTYPES      => "(#2) = cabs((cmplx128_t)#1);",
+    [:cmplx64]                  => "(#2) = cabsf(#1);",
+    [:cmplx128]                 => "(#2) = cabs(#1);",
     [:object]                   => '(#2) = rb_funcall((#1), rb_intern("abs"), 0);',
   }
 
 # abs: data_type-changing monop (the framework-piece test customer for monop
 # Hash output form).  numeric input -> preserve data_type (= int/float abs),
-# complex input -> f64 output (= magnitude is real).  Replaces the hand-
+# complex input -> the real component width of that complex data_type
+# (= magnitude is real, and a cmplx64 magnitude is a float32 just as
+# `.real` and `.imag` are).  Replaces the hand-
 # written rb_ca_abs / rb_ca_abs_bang in ext/carray_math.c.  Object data_type
 # kept on abs_i (= bind: false on object would need a different output
 # rule; deferred).  The abs_i monop above remains the primary kernel for
@@ -7820,13 +8266,15 @@ MkKernel.monop :abs_i,
 # returns the real-valued magnitude entity.
 MkKernel.monop :abs,
   source: MkKernel::ALL_NUMERIC + MkKernel::CMPLX_DTYPES,
-  output: { numeric: :preserve, complex: :f64 },
+  output: { numeric: :preserve, complex: :real_of_source },
   expr:   {
     MkKernel::SINT_SMALL_DTYPES => "(#2) = abs(#1);",
     MkKernel::SINT64_DTYPES     => "(#2) = llabs(#1);",
     MkKernel::UINT_DTYPES       => "(#2) = (#1);",
     MkKernel::FLOAT_DTYPES      => "(#2) = fabs(#1);",
-    MkKernel::CMPLX_DTYPES      => "(#2) = cabs(#1);",   # complex -> double (real magnitude)
+    # complex -> the real magnitude, at that complex type's own width
+    [:cmplx64]                  => "(#2) = cabsf(#1);",
+    [:cmplx128]                 => "(#2) = cabs(#1);",
   }
 
 # abs2: squared magnitude.  For real x this is x*x (identical to :square
@@ -7837,22 +8285,22 @@ MkKernel.monop :abs,
 # optics, signal processing) do not pay for a sqrt they immediately
 # square away.
 #
-# Output data_type follows :abs: numeric preserved, complex -> f64.
+# Output data_type follows :abs: numeric preserved, complex demoted to
+# its own real component width.
 MkKernel.monop :abs2,
   source: MkKernel::ALL_NUMERIC + MkKernel::CMPLX_DTYPES,
-  output: { numeric: :preserve, complex: :f64 },
+  output: { numeric: :preserve, complex: :real_of_source },
   expr:   {
     numeric: "(#2) = (#1) * (#1);",
-    complex: "{ double _r = creal(#1); double _i = cimag(#1); (#2) = _r * _r + _i * _i; }",
-  }
+  }.merge(MkKernel.cmplx_widths(
+    "{ <t> _r = creal<f>(#1); <t> _i = cimag<f>(#1); (#2) = _r * _r + _i * _i; }"))
 
 MkKernel.monop :conj,
   source: MkKernel::MATH_NUMERIC + [:object],
   expr:   {
     numeric: "(#2) = (#1);",
-    complex: "(#2) = conj(#1);",
     object:  '(#2) = rb_funcall((#1), rb_intern("conj"), 0);',
-  }
+  }.merge(MkKernel.cmplx_widths("(#2) = conj<f>(#1);"))
 
 # arg: data_type-changing monop — phase angle of the complex plane.
 # Mathematically `arg(z)` for z = re + im*i is `atan2(im, re)` in
@@ -7863,11 +8311,11 @@ MkKernel.monop :conj,
 # Replaces the hand-written rb_ca_arg in ext/carray_numeric.c (which
 # was f64-only, float-or-complex parent, also computed `carg`).
 #
-# Output data_type is always CA_FLOAT64.
-# We do NOT use the abs Hash pattern `{numeric: :preserve}` because
-# pi does not fit any integer slot — preserving int data_type would
-# silently truncate `arg(-1) = pi` to 3.  Float32 input also returns
-# f64 since carg itself returns double.
+# Output data_type keeps the width the input carries its real values in:
+# a float stays that float, a complex demotes to its own real component
+# width (cmplx64 -> f32, cmplx128 -> f64).  Integers are the exception
+# and go to f64, because pi does not fit any integer slot — preserving
+# the int data_type would silently truncate `arg(-1) = pi` to 3.
 #
 # 3.0 breaking (vs hand-written rb_ca_arg):
 #   - integer input is now accepted (was a raise).  Returns f64
@@ -7897,16 +8345,15 @@ MkKernel.monop :sign,
     MkKernel::UINT_DTYPES       => "(#2) = ((#1) > 0) ? 1 : 0;",
     MkKernel::SINT_DTYPES       => "(#2) = ((#1) > 0) - ((#1) < 0);",
     MkKernel::FLOAT_DTYPES      => "(#2) = isnan(#1) ? (#1) : (((#1) > 0) - ((#1) < 0));",
-    MkKernel::CMPLX_DTYPES      => "{ double _m = cabs(#1); (#2) = (_m == 0.0) ? 0 : ((#1) / _m); }",
-  }
+  }.merge(MkKernel.cmplx_widths(
+    "{ <t> _m = cabs<f>(#1); (#2) = (_m == 0) ? 0 : ((#1) / _m); }"))
 
 MkKernel.monop :arg,
   source: MkKernel::ALL_NUMERIC + MkKernel::CMPLX_DTYPES,
-  output: { numeric: :f64, complex: :f64 },
+  output: { int: :f64, float: :preserve, complex: :real_of_source },
   expr:   {
     numeric: "(#2) = carg((cmplx128_t)(#1));",
-    complex: "(#2) = carg(#1);",
-  }
+  }.merge(MkKernel.cmplx_widths("(#2) = carg<f>(#1);"))
 
 # imag_i: data_type-preserving kernel that places the imag part in the
 # slot (= cimag for complex stores into the real component since cmplx
@@ -7920,9 +8367,8 @@ MkKernel.monop :imag_i,
   source: MkKernel::MATH_NUMERIC + [:object],
   expr:   {
     numeric: "(#2) = 0;",
-    complex: "(#2) = cimag(#1);",
     object:  '(#2) = rb_funcall((#1), rb_intern("imaginary"), 0);',
-  }
+  }.merge(MkKernel.cmplx_widths("(#2) = cimag<f>(#1);"))
 
 # arg_i: data_type-preserving kernel that writes the complex argument
 # (phase angle) into the slot.  For complex input, cassignment from a
@@ -7937,9 +8383,9 @@ MkKernel.monop :imag_i,
 MkKernel.monop :arg_i,
   source: MkKernel::FLOAT_DTYPES + MkKernel::CMPLX_DTYPES,
   expr:   {
-    [:f32]      => "(#2) = (float)carg((cmplx128_t)(#1));",
+    [:f32]      => "(#2) = cargf((cmplx64_t)(#1));",
     [:f64]      => "(#2) = carg((cmplx128_t)(#1));",
-    [:cmplx64]  => "(#2) = (float)carg((cmplx128_t)(#1));",
+    [:cmplx64]  => "(#2) = cargf(#1);",
     [:cmplx128] => "(#2) = carg(#1);",
   }
 
@@ -7995,7 +8441,8 @@ MkKernel.monfunc :rcp,
   expr:   {
     int:     "if ((#1)==0) {ca_zerodiv();}; (#2) = 1/(#1);",
     float:   "(#2) = 1/(#1);",
-    complex: "(#2) = 1/(#1);",
+    [:cmplx64]  => "(#2) = op_crcp_cmplx64(#1);",
+    [:cmplx128] => "(#2) = 1/(#1);",
     object:  '(#2) = rb_funcall(INT2NUM(1), rb_intern("/"), 1, (#1));',
   }
 
@@ -8004,7 +8451,6 @@ MkKernel.monfunc :rcp,
 {
   sqrt:  "sqrt",
   exp:   "exp",
-  log:   "log",
   sin:   "sin",
   cos:   "cos",
   tan:   "tan",
@@ -8015,21 +8461,37 @@ MkKernel.monfunc :rcp,
   MkKernel.monfunc op,
     source: MkKernel::FLOAT_DTYPES + MkKernel::CMPLX_DTYPES + [:object],
     expr:   {
-      float:   "(#2) = #{c_fn}(#1);",
-      complex: "(#2) = c#{c_fn}(#1);",
       object:  MkKernel.obj_float_math("#{c_fn}(<v>)", c_fn),
-    }
+    }.merge(MkKernel.float_widths("(#2) = #{c_fn}<f>(#1);"))
+     .merge(MkKernel.cmplx_widths("(#2) = c#{c_fn}<f>(#1);"))
 end
 
+# log is the one member of the family whose complex form cancels, so it
+# does not follow the others onto `clogf`.  The real part of `clog(z)` is
+# `log|z|`, which vanishes on the unit circle; computing |z| at the
+# operand's width rounds away everything the logarithm then needs, and
+# the answer comes back with a relative error near 400 instead of 1e-7.
+# The complex branch therefore stays on the double-taking `clog`, the way
+# `*` and `/` do -- see ca_op_cmplx64.h.  Real `log` has no such step:
+# its operand is the argument itself, and `logf` measures at one float
+# epsilon right through x = 1.
+MkKernel.monfunc :log,
+  source: MkKernel::FLOAT_DTYPES + MkKernel::CMPLX_DTYPES + [:object],
+  expr:   {
+    complex: "(#2) = clog(#1);",
+    object:  MkKernel.obj_float_math("log(<v>)", "log"),
+  }.merge(MkKernel.float_widths("(#2) = log<f>(#1);"))
+
 # exp2 special case: complex variant uses cpow(2, x), not cexp2 (which
 # isn't standardized in C99/POSIX).
 MkKernel.monfunc :exp2,
   source: MkKernel::FLOAT_DTYPES + MkKernel::CMPLX_DTYPES + [:object],
   expr:   {
-    float:   "(#2) = exp2(#1);",
+    # cpow(a, z) is cexp(z * clog(a)), so it inherits clog's cancellation
+    # and stays on the double-taking form for both complex data_types.
     complex: "(#2) = cpow(2, (#1));",
     object:  MkKernel.obj_float_math("exp2(<v>)", "exp2"),
-  }
+  }.merge(MkKernel.float_widths("(#2) = exp2<f>(#1);"))
 
 # log10, log2, logb: no complex variant in the original mkmath emit
 {
@@ -8040,9 +8502,8 @@ MkKernel.monfunc :exp2,
   MkKernel.monfunc op,
     source: MkKernel::FLOAT_DTYPES + [:object],
     expr:   {
-      float:  "(#2) = #{c_fn}(#1);",
       object: MkKernel.obj_float_math("#{c_fn}(<v>)", c_fn),
-    }
+    }.merge(MkKernel.float_widths("(#2) = #{c_fn}<f>(#1);"))
 end
 
 # exp10: special object expr (= bypass OBJ_FLOAT_MATH for the
@@ -8050,8 +8511,6 @@ end
 MkKernel.monfunc :exp10,
   source: MkKernel::FLOAT_DTYPES + MkKernel::CMPLX_DTYPES + [:object],
   expr:   {
-    float:   "(#2) = pow(10, (#1));",
-    complex: "(#2) = cpow(10, (#1));",
     object:  <<~SNIPPET,
       {
         VALUE _obj_arg = (#1);
@@ -8062,10 +8521,13 @@ MkKernel.monfunc :exp10,
         }
       }
     SNIPPET
-  }
+    complex: "(#2) = cpow(10, (#1));",   # see exp2 on why cpow stays wide
+  }.merge(MkKernel.float_widths("(#2) = pow<f>(10, (#1));"))
 
-# Hyperbolic family: complex variant uses the real-typed C function
-# (matches original mkmath emit, which doesn't prefix `c`).
+# Hyperbolic family: float uses the real-typed C function, complex uses
+# the C99 `c`-prefixed one.  Passing a `double _Complex` to `sinh(double)`
+# discards the imaginary part, so the complex branch must not share the
+# real-typed name.
 {
   sinh:  "sinh",
   cosh:  "cosh",
@@ -8077,10 +8539,9 @@ MkKernel.monfunc :exp10,
   MkKernel.monfunc op,
     source: MkKernel::FLOAT_DTYPES + MkKernel::CMPLX_DTYPES + [:object],
     expr:   {
-      float:   "(#2) = #{c_fn}(#1);",
-      complex: "(#2) = #{c_fn}(#1);",
       object:  MkKernel.obj_float_math("#{c_fn}(<v>)", c_fn),
-    }
+    }.merge(MkKernel.float_widths("(#2) = #{c_fn}<f>(#1);"))
+     .merge(MkKernel.cmplx_widths("(#2) = c#{c_fn}<f>(#1);"))
 end
 
 # ---- M.1 (PyTorch alignment): additional monfunc / monop ------------------
@@ -8094,19 +8555,17 @@ end
   MkKernel.monfunc op,
     source: MkKernel::FLOAT_DTYPES + [:object],
     expr:   {
-      float:  "(#2) = #{c_fn}(#1);",
       object: MkKernel.obj_float_math("#{c_fn}(<v>)", c_fn),
-    }
+    }.merge(MkKernel.float_widths("(#2) = #{c_fn}<f>(#1);"))
 end
 
 # rsqrt: 1 / sqrt(x).  float + complex + object (complex via 1.0 / csqrt).
 MkKernel.monfunc :rsqrt,
   source: MkKernel::FLOAT_DTYPES + MkKernel::CMPLX_DTYPES + [:object],
   expr:   {
-    float:   "(#2) = 1.0 / sqrt(#1);",
-    complex: "(#2) = 1.0 / csqrt(#1);",
     object:  MkKernel.obj_float_math("1.0 / sqrt(<v>)", "rsqrt"),
-  }
+  }.merge(MkKernel.float_widths("(#2) = ((<t>)1.0) / sqrt<f>(#1);"))
+   .merge(MkKernel.cmplx_widths("(#2) = ((<t>)1.0) / csqrt<f>(#1);"))
 
 # trunc: toward-zero rounding.  Preserve-data_type form like ceil / floor /
 # round — int branch is identity, float branch uses C99 trunc, object
@@ -8136,7 +8595,7 @@ MkKernel.monop :square,
 # with f64-forced input/output via ca_call_cfunc_1_1; the mkkernel form
 # preserves the same numeric behaviour but rides the lazy substrate +
 # kernel_iterator engine.  Widening monfunc: integer input auto-casts
-# to f64, float input preserves dtype.
+# to f64, float input preserves data type.
 
 # deg_360: fold into [0, 360).  Use double-typed local for the fold
 # computation regardless of input precision (matches legacy hand-written
@@ -8315,12 +8774,12 @@ MkKernel.binop :minimum,
     object: '(#3) = rb_funcall(rb_assoc_new((#1),(#2)), rb_intern("min"), 0);',
   }
 
-# +, -, * use the same generic expression across all numeric data_types.
+# + and - work on the parts independently, so one generic expression
+# covers every numeric data_type at any width.
 {
-  add: ["+", "+", '"+"'],
-  sub: ["-", "-", '"-"'],
-  mul: ["*", "*", '"*"'],
-}.each do |name, (op, c_op, _ruby_op)|
+  add: ["+", "+"],
+  sub: ["-", "-"],
+}.each do |name, (op, c_op)|
   MkKernel.binop name,
     op:     op,
     source: MkKernel::MATH_NUMERIC + [:object],
@@ -8331,13 +8790,48 @@ MkKernel.binop :minimum,
     }
 end
 
+# * does not: a complex product subtracts two products of the parts, and
+# that subtraction cancels.  A cmplx64 gets it in double, where there are
+# bits left underneath -- see ca_op_cmplx64.h.  Unlike the divide this
+# costs speed rather than saving it, and is paid for the accuracy alone.
+MkKernel.binop :mul,
+  op:     "*",
+  source: MkKernel::MATH_NUMERIC + [:object],
+  expr:   {
+    numeric:     "(#3) = (#1) * (#2);",
+    [:cmplx64]  => "(#3) = op_cmul_cmplx64((#1), (#2));",
+    [:cmplx128] => "(#3) = (#1) * (#2);",
+    object:      '(#3) = rb_funcall((#1), rb_intern("*"), 1, (#2));',
+  }
+
+# div: `/`.  Integer division floors toward -inf (= Ruby `Integer#/` and
+# NumPy `floor_divide`), so that `(a / b) * b + a % b == a` holds for
+# every sign combination.  C's `/` truncates toward zero, so the signed
+# lanes correct the quotient by one when the division is inexact and the
+# operands have opposite signs.  Unsigned operands can never disagree in
+# sign, so they keep the bare C form.  Float `/` is true division and is
+# unchanged (matching Ruby `Float#/`); the identity above therefore holds
+# for integers only, exactly as in Ruby.
 MkKernel.binop :div,
   op:     "/",
   source: MkKernel::MATH_NUMERIC + [:object],
   expr:   {
-    int:     "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) / (#2);",
+    MkKernel::UINT_DTYPES => "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) / (#2);",
+    int:     %{
+      if ((#2)==0) {ca_zerodiv();};
+      {
+        <type> _q = (#1) / (#2);
+        if ( (#1) % (#2) != 0 && (((#1) < 0) != ((#2) < 0)) ) { _q -= 1; }
+        (#3) = _q;
+      }
+    },
     float:   "(#3) = (#1) / (#2);",
-    complex: "(#3) = (#1) / (#2);",
+    # A cmplx64 divide is computed in double and rounded once: see
+    # ca_op_cmplx64.h for why that is both faster and correctly rounded,
+    # and how Annex G survives it.  cmplx128 has no wider type to
+    # borrow, so it stays on the compiler's helper.
+    [:cmplx64]  => "(#3) = op_cdiv_cmplx64((#1), (#2));",
+    [:cmplx128] => "(#3) = (#1) / (#2);",
     object:  '(#3) = rb_funcall((#1), rb_intern("/"), 1, (#2));',
   }
 
@@ -8357,27 +8851,57 @@ MkKernel.binop :rcp_mul,
   expr:   {
     int:     "if ((#1)==0) {ca_zerodiv();}; (#3) = (#2) / (#1);",
     float:   "(#3) = (#2) / (#1);",
-    complex: "(#3) = (#2) / (#1);",
+    [:cmplx64]  => "(#3) = op_cdiv_cmplx64((#2), (#1));",
+    [:cmplx128] => "(#3) = (#2) / (#1);",
     object:  '(#3) = rb_funcall((#2), rb_intern("/"), 1, (#1));',
   }
 
+# mod: `%`.  Floored modulo -- the result carries the sign of the divisor
+# (= Ruby `%` and NumPy `np.mod`), and pairs with the floored `/` above.
+# C's `%` and `fmod` carry the sign of the dividend instead, so the signed
+# lanes add the divisor back when the remainder is non-zero and disagrees
+# in sign with it.  A zero remainder is given the divisor's sign so the
+# rule holds without exception (float only; integers have no signed zero).
+# Unsigned operands already satisfy the rule.  The truncating form stays
+# available as `fmod`.
 MkKernel.binop :mod,
   op:     "%",
   source: MkKernel::ALL_NUMERIC + [:object],
   expr:   {
-    int:    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);",
-    float:  "(#3) = fmod(#1, #2);",
+    MkKernel::UINT_DTYPES => "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);",
+    int:    %{
+      if ((#2)==0) {ca_zerodiv();};
+      {
+        <type> _r = (#1) % (#2);
+        if ( _r != 0 && ((_r < 0) != ((#2) < 0)) ) { _r += (#2); }
+        (#3) = _r;
+      }
+    },
+    float:  %{
+      {
+        <type> _r = fmod((#1), (#2));
+        if ( _r != 0 ) {
+          if ( (_r < 0) != ((#2) < 0) ) { _r += (#2); }
+        }
+        else { _r = copysign((<type>) 0, (#2)); }
+        (#3) = _r;
+      }
+    },
     object: '(#3) = rb_funcall((#1), rb_intern("%"), 1, (#2));',
   }
 
-MkKernel.binop :reminder,
-  op:     "reminder",
+# fmod: the truncating counterpart of `%` -- the remainder carries the
+# sign of the dividend, as C's `fmod` and `%` do.  Defined over integers
+# too (`%` no longer reaches that form since it floors), where it is C's
+# `%` with the same zero-divisor guard.  Ruby's `Numeric#remainder` is
+# this same operation, so the object lane delegates to it and keeps the
+# element's class (an Integer stays an Integer).
+MkKernel.binop :fmod,
   source: MkKernel::ALL_NUMERIC + [:object],
   expr:   {
     int:    "if ((#2)==0) {ca_zerodiv();}; (#3) = (#1) % (#2);",
-    float:  "(#3) = remainder(#1, #2);",
-    object: '(#3) = rb_funcall((#1), rb_intern("%"), 1, (#2));',
-  }
+    object: '(#3) = rb_funcall((#1), rb_intern("remainder"), 1, (#2));',
+  }.merge(MkKernel.float_widths("(#3) = fmod<f>((#1), (#2));"))
 
 MkKernel.binop :bit_and_i,
   op:     "&",
@@ -8482,6 +9006,7 @@ MkKernel.alias_binop :bit_rshift,  :">>"
 # pow / cpow.  Object uses Ruby's `**`.
 MkKernel.header_block <<~C
   #include "ca_op_powi.h"
+  #include "ca_op_cmplx64.h"
 C
 
 # ---- triop family ---------------------------------------------------------
@@ -8554,10 +9079,9 @@ MkKernel.binop :power,
   source: MkKernel::MATH_NUMERIC + [:object],
   expr:   {
     int:     "(#3) = op_powi_<type>((#1), (#2));",
-    float:   "(#3) = pow((#1), (#2));",
-    complex: "(#3) = cpow((#1), (#2));",
+    complex: "(#3) = cpow((#1), (#2));",   # see exp2 on why cpow stays wide
     object:  '(#3) = rb_funcall((#1), rb_intern("**"), 1, (#2));',
-  }
+  }.merge(MkKernel.float_widths("(#3) = pow<f>((#1), (#2));"))
 
 # ---- M.2 + M.3 (PyTorch alignment): float-only binop family --------------
 #
@@ -8573,7 +9097,6 @@ MkKernel.binop :power,
   copysign:  ["copysign",  "copysign"],
   logaddexp: [nil,         nil],          # custom expr — see below
   nextafter: ["nextafter", "nextafter"],
-  fmod:      ["fmod",      "fmod"],
   atan2:     ["atan2",     "atan2"],
   hypot:     ["hypot",     "hypot"],
 }.each do |op_name, (c_fn, ruby_fb)|
@@ -8581,7 +9104,6 @@ MkKernel.binop :power,
   MkKernel.binop op_name,
     source: MkKernel::FLOAT_DTYPES + [:object],
     expr:   {
-      float:  "(#3) = #{c_fn}((#1), (#2));",
       object: <<~SNIPPET,
         {
           VALUE _l = (#1);
@@ -8594,7 +9116,7 @@ MkKernel.binop :power,
           }
         }
       SNIPPET
-    }
+    }.merge(MkKernel.float_widths("(#3) = #{c_fn}<f>((#1), (#2));"))
 end
 
 # logaddexp: log(exp(x) + exp(y)).  Numerically stable form:
@@ -8603,7 +9125,6 @@ end
 MkKernel.binop :logaddexp,
   source: MkKernel::FLOAT_DTYPES + [:object],
   expr:   {
-    float:  "(#3) = fmax((#1), (#2)) + log1p(exp(-fabs((#1) - (#2))));",
     object: <<~SNIPPET,
       {
         VALUE _l = (#1);
@@ -8619,7 +9140,8 @@ MkKernel.binop :logaddexp,
         }
       }
     SNIPPET
-  }
+  }.merge(MkKernel.float_widths(
+    "(#3) = fmax<f>((#1), (#2)) + log1p<f>(exp<f>(-fabs<f>((#1) - (#2))));"))
 
 # ---- P.5b.4: moncmp family (predicates returning bool) ----------------
 
@@ -8669,7 +9191,7 @@ MkKernel.moncmp :is_invalid,
 # -0.0).  Integer branch: sint = (#1) < 0, uint = always 0.  Float branch
 # uses C99 signbit (handles -0.0 / NaN sign correctly).  No complex
 # variant (signbit on a complex is ambiguous; rejected at this layer).
-# `:sint` / `:uint` aren't family aliases — use array-of-dtypes form.
+# `:sint` / `:uint` aren't family aliases — use the array-of-types form.
 MkKernel.moncmp :signbit,
   source: MkKernel::SINT_DTYPES + MkKernel::UINT_DTYPES +
           MkKernel::FLOAT_DTYPES + [:object],