convolver 3.0.1 → 4.0.1

data/ext/convolver/fft_shape.c

@@ -0,0 +1,116 @@
+#include "fft_shape.h"
+#include "raw_config.h"
+#include <limits.h>
+#include <math.h>
+
+static size_t positive_size(VALUE value) {
+  if (!RB_INTEGER_TYPE_P(value) || RTEST(rb_funcall(value, rb_intern("<="), 1, INT2FIX(0)))) {
+    rb_raise(rb_eArgError, "FFT dimensions and size limit must be positive integers");
+  }
+  return NUM2SIZET(value);
+}
+
+static long read_shape(VALUE shape, size_t *dimensions) {
+  Check_Type(shape, T_ARRAY);
+  long rank = RARRAY_LEN(shape);
+  if (rank < 1 || rank > LARGEST_RANK) {
+    rb_raise(rb_eArgError, "FFT shape rank must be between 1 and %d", LARGEST_RANK);
+  }
+  for (long axis = 0; axis < rank; axis++) {
+    dimensions[axis] = positive_size(rb_ary_entry(shape, axis));
+  }
+  return rank;
+}
+
+static size_t doubled_candidate(size_t initial, size_t target, int even, size_t maximum) {
+  size_t candidate = initial;
+  while (candidate < target || (even && candidate % 2 != 0)) {
+    if (candidate > maximum / 2) return 0;
+    candidate *= 2;
+  }
+  return candidate;
+}
+
+/* Enumerate 3/5 powers only while they can improve the best 2/3/5 candidate. */
+static size_t next_fast_size(size_t target, int even, size_t maximum) {
+  size_t best = 0, five = 1;
+  for (;;) {
+    size_t three = five;
+    for (;;) {
+      size_t candidate = doubled_candidate(three, target, even, maximum);
+      if (candidate != 0 && (best == 0 || candidate < best)) best = candidate;
+      size_t bound = best != 0 ? best : maximum;
+      if (three > bound / 3) break;
+      three *= 3;
+    }
+    size_t bound = best != 0 ? best : maximum;
+    if (five > bound / 5) break;
+    five *= 5;
+  }
+  return best;
+}
+
+/*
+ * Generates optional smooth dimensions without allocating numeric buffers.
+ * @private
+ */
+static VALUE convolver_fft_fast_shape(VALUE self, VALUE shape, VALUE maximum_value) {
+  (void)self;
+  size_t dimensions[LARGEST_RANK];
+  long rank = read_shape(shape, dimensions);
+  size_t maximum = positive_size(maximum_value);
+  for (long axis = 0; axis < rank; axis++) {
+    if (dimensions[axis] > maximum) return Qnil;
+    dimensions[axis] = next_fast_size(dimensions[axis], axis == rank - 1, maximum);
+    if (dimensions[axis] == 0) return Qnil;
+  }
+  VALUE result = rb_ary_new_capa(rank);
+  for (long axis = 0; axis < rank; axis++) {
+    rb_ary_push(result, SIZET2NUM(dimensions[axis]));
+  }
+  return result;
+}
+
+static double large_factor_penalty(size_t value) {
+  double penalty = 0.0;
+  size_t divisor = 2;
+  while (divisor <= value / divisor) {
+    while (value % divisor == 0) {
+      if (divisor > 7) penalty += 1.5 * (log2((double)divisor) - 3.0);
+      value /= divisor;
+    }
+    divisor += divisor == 2 ? 1 : 2;
+  }
+  if (value > 7) penalty += 1.5 * (log2((double)value) - 3.0);
+  return penalty;
+}
+
+/*
+ * Scores an admissible candidate; Ruby owns the complete FFT buffer policy.
+ * @private
+ */
+static VALUE convolver_fft_shape_cost(VALUE self, VALUE shape) {
+  (void)self;
+  size_t dimensions[LARGEST_RANK], product = 1;
+  long rank = read_shape(shape, dimensions);
+  for (long axis = 0; axis < rank; axis++) {
+    /* Bound trial factorization even if this private primitive is called directly. */
+    if (dimensions[axis] > (size_t)INT_MAX / 16) {
+      rb_raise(rb_eRangeError, "FFT scoring axis exceeds native integer limit");
+    }
+    if (dimensions[axis] > SIZE_MAX / product) {
+      rb_raise(rb_eRangeError, "FFT scoring size exceeds native element limit");
+    }
+    product *= dimensions[axis];
+  }
+  double cost = 0.0;
+  for (long axis = 0; axis < rank; axis++) {
+    cost += log2((double)dimensions[axis]) + large_factor_penalty(dimensions[axis]);
+  }
+  return DBL2NUM((double)product * cost);
+}
+
+void convolver_init_fft_shape(VALUE convolver) {
+  rb_define_singleton_method(convolver, "fft_fast_shape", convolver_fft_fast_shape, 2);
+  rb_define_singleton_method(convolver, "fft_shape_cost", convolver_fft_shape_cost, 1);
+}

data/ext/convolver/fft_shape.h

@@ -0,0 +1,8 @@
+#ifndef CONVOLVER_FFT_SHAPE_H
+#define CONVOLVER_FFT_SHAPE_H
+
+#include <ruby.h>
+
+void convolver_init_fft_shape(VALUE convolver);
+
+#endif

data/ext/convolver/raw_config.h

@@ -0,0 +1,11 @@
+#ifndef CONVOLVER_RAW_CONFIG_H
+#define CONVOLVER_RAW_CONFIG_H
+#include <ruby.h>
+#if defined(__SSE__)
+#include <xmmintrin.h>
+#endif
+#if defined(__SSE2__)
+#include <emmintrin.h>
+#endif
+#define LARGEST_RANK 16
+#endif

data/ext/convolver/raw_helpers.h

@@ -0,0 +1,71 @@
+#ifndef CONVOLVER_RAW_HELPERS_H
+#define CONVOLVER_RAW_HELPERS_H
+
+static inline size_t checked_add( size_t left, size_t right, const char *description ) {
+  if ( right > SIZE_MAX - left ) {
+    rb_raise( rb_eRangeError, "%s exceeds native implementation limit", description );
+  }
+  return left + right;
+}
+
+static inline size_t checked_multiply( size_t left, size_t right, const char *description ) {
+  if ( left != 0 && right > SIZE_MAX / left ) {
+    rb_raise( rb_eRangeError, "%s exceeds native implementation limit", description );
+  }
+  return left * right;
+}
+
+static inline size_t size_from_shape( int rank, const size_t *shape, const char *description ) {
+  size_t size = 1;
+  int i;
+  for ( i = 0; i < rank; i++ ) {
+    size = checked_multiply( size, shape[i], description );
+  }
+  return size;
+}
+
+// Sets reverse indices
+static inline void corner_reset( int rank, const size_t *shape, size_t *rev_indices ) {
+  int i;
+  for ( i = 0; i < rank; i++ ) { rev_indices[i] = shape[i] - 1; }
+}
+
+// Counts indices down, returns number of ranks that reset
+static inline int corner_dec( int rank, const size_t *shape, size_t *rev_indices ) {
+  int i = 0;
+  (void) rank;
+  while ( ! rev_indices[i]-- ) {
+    rev_indices[i] = shape[i] - 1;
+    i++;
+  }
+  return i;
+}
+
+// Generates co-increment steps by rank boundaries crossed, for the outer position as inner position is incremented by 1
+static inline void calc_co_increment(
+    int rank, const size_t *outer_shape, const size_t *inner_shape, size_t *co_increment ) {
+  size_t factor = 1;
+  int i;
+  co_increment[0] = 1; // co-increment is always 1 in lowest rank
+  for ( i = 0; i < rank; i++ ) {
+    size_t skipped = checked_multiply( factor, outer_shape[i] - inner_shape[i], "array offset" );
+    co_increment[i+1] = checked_add( co_increment[i], skipped, "array offset" );
+    factor = checked_multiply( factor, outer_shape[i], "array size" );
+  }
+}
+
+static inline size_t maximum_offset(
+    int rank, const size_t *outer_shape, const size_t *inner_shape, const char *description ) {
+  size_t factor = 1;
+  size_t offset = 0;
+  int i;
+  for ( i = 0; i < rank; i++ ) {
+    size_t dimension_offset = checked_multiply( factor, inner_shape[i] - 1, description );
+    offset = checked_add( offset, dimension_offset, description );
+    factor = checked_multiply( factor, outer_shape[i], "array size" );
+  }
+  return offset;
+}
+
+
+#endif

data/ext/convolver/raw_loop.h

@@ -0,0 +1,93 @@
+/* Intentionally included once per dtype; operation/dtype dispatch is outside hot loops. */
+void RAW_NAME(
+    int in_rank, const size_t *in_shape, const RAW_TYPE *in_ptr,
+    int kernel_rank, const size_t *kernel_shape, const RAW_TYPE *kernel_ptr,
+    int out_rank, const size_t *out_shape, RAW_TYPE *out_ptr ) {
+  size_t i, j, input_size, kernel_size, kernel_aligned, out_size, offset;
+  size_t maximum_input_offset;
+  size_t out_co_incr[LARGEST_RANK + 1], kernel_co_incr[LARGEST_RANK + 1];
+  size_t ker_q[LARGEST_RANK], out_q[LARGEST_RANK];
+  size_t *kernel_co_incr_cache;
+  VALUE cache_storage = 0;
+
+  kernel_size = size_from_shape( kernel_rank, kernel_shape, "kernel size" );
+  kernel_aligned = kernel_size - kernel_size % RAW_LANES;
+  out_size = size_from_shape( out_rank, out_shape, "output size" );
+  input_size = size_from_shape( in_rank, in_shape, "input size" );
+
+  calc_co_increment( in_rank, in_shape, out_shape, out_co_incr );
+  calc_co_increment( in_rank, in_shape, kernel_shape, kernel_co_incr );
+  maximum_input_offset = checked_add(
+    maximum_offset( in_rank, in_shape, out_shape, "input offset" ),
+    maximum_offset( in_rank, in_shape, kernel_shape, "input offset" ),
+    "input offset"
+  );
+  if ( maximum_input_offset >= input_size ) {
+    rb_raise( rb_eRangeError, "input offset exceeds native implementation limit" );
+  }
+
+  kernel_co_incr_cache = RB_ALLOCV_N( size_t, cache_storage, kernel_size );
+  kernel_co_incr_cache[0] = 0;
+
+  corner_reset( kernel_rank, kernel_shape, ker_q );
+  for ( i = 1; i < kernel_size; i++ ) {
+    kernel_co_incr_cache[i] = checked_add(
+      kernel_co_incr_cache[i-1],
+      kernel_co_incr[ corner_dec( kernel_rank, kernel_shape, ker_q ) ],
+      "kernel offset"
+    );
+  }
+
+  offset = 0;
+  corner_reset( out_rank, out_shape, out_q );
+
+  for ( i = 0; i < out_size; i++ ) {
+    RAW_TYPE t = 0;
+#if RAW_SIMD
+    RAW_VECTOR simd_t = RAW_ZERO();
+    RAW_TYPE v[RAW_LANES];
+    for ( j = 0; j < kernel_aligned; j += RAW_LANES ) {
+      RAW_VECTOR simd_x = RAW_LOAD(kernel_ptr + j);
+#if RAW_LANES == 4
+      RAW_VECTOR simd_y = _mm_set_ps(
+        in_ptr[offset + kernel_co_incr_cache[RAW_INDEX(j+3)]],
+        in_ptr[offset + kernel_co_incr_cache[RAW_INDEX(j+2)]],
+        in_ptr[offset + kernel_co_incr_cache[RAW_INDEX(j+1)]],
+        in_ptr[offset + kernel_co_incr_cache[RAW_INDEX(j)]]);
+#else
+      RAW_VECTOR simd_y = _mm_set_pd(
+        in_ptr[offset + kernel_co_incr_cache[RAW_INDEX(j+1)]],
+        in_ptr[offset + kernel_co_incr_cache[RAW_INDEX(j)]]);
+#endif
+      simd_t = RAW_ADD(RAW_MUL(simd_x, simd_y), simd_t);
+    }
+    RAW_STORE(v, simd_t);
+#else
+    for ( j = 0; j < kernel_aligned; j++ ) {
+      t += in_ptr[offset + kernel_co_incr_cache[RAW_INDEX(j)]] * kernel_ptr[j];
+    }
+#endif
+    for ( j = kernel_aligned; j < kernel_size; j++ ) {
+      t += in_ptr[offset + kernel_co_incr_cache[RAW_INDEX(j)]] * kernel_ptr[j];
+    }
+#if RAW_SIMD
+#if RAW_LANES == 4
+    out_ptr[i] = v[0] + v[1] + v[2] + v[3] + t;
+#else
+    out_ptr[i] = v[0] + v[1] + t;
+#endif
+#else
+    out_ptr[i] = t;
+#endif
+
+    if ( i + 1 < out_size ) {
+      offset = checked_add(
+        offset,
+        out_co_incr[ corner_dec( out_rank, out_shape, out_q ) ],
+        "input offset"
+      );
+    }
+  }
+
+  RB_ALLOCV_END( cache_storage );
+}

data/lib/convolver/buffer_preparation.rb

@@ -35,15 +35,15 @@ module Convolver
     attr_reader :plan, :signal_size, :kernel_size, :limits
 
     def common!
-      limits.buffer!(plan.result_size, 4, 'result buffer')
-      limits.buffer!(signal_size, 4, 'signal conversion buffer')
-      limits.buffer!(kernel_size, 4, 'kernel conversion buffer')
+      limits.buffer!(plan.result_size, plan.dtype::ELEMENT_BYTE_SIZE, 'result buffer')
+      limits.buffer!(signal_size, plan.dtype::ELEMENT_BYTE_SIZE, 'signal conversion buffer')
+      limits.buffer!(kernel_size, plan.dtype::ELEMENT_BYTE_SIZE, 'kernel conversion buffer')
     end
 
     def extension!
       return if plan.valid?
 
-      limits.buffer!(plan.extended_size, 4, 'extended signal buffer')
+      limits.buffer!(plan.extended_size, plan.dtype::ELEMENT_BYTE_SIZE, 'extended signal buffer')
       return if plan.boundary == :constant
 
       plan.extended_shape.each do |length|

data/lib/convolver/circular_fft_operation.rb

@@ -5,6 +5,7 @@ module Convolver
   # @private
   class CircularFftOperation
     def initialize(operation, signal, kernel, plan)
+      @dtype = plan.dtype
       @real_axis = plan.fft_buffers.real_axis
       @operation = operation
       @signal = Numo::DFloat.cast(signal)
@@ -28,7 +29,7 @@ module Convolver
 
     private
 
-    attr_reader :operation, :signal, :kernel, :real_axis
+    attr_reader :operation, :signal, :kernel, :real_axis, :dtype
 
     def real_product(real_axis)
       final_axis = signal.ndim - 1
@@ -36,7 +37,7 @@ module Convolver
       prepared_kernel = prepare_real_operand(kernel, real_axis, final_axis)
       result = real_spectrum_product(prepared_signal, prepared_kernel)
       result = result.swapaxes(real_axis, final_axis) unless real_axis == final_axis
-      Numo::SFloat.cast(result)
+      dtype.cast(result)
     end
 
     def prepare_real_operand(value, real_axis, final_axis)
@@ -55,7 +56,7 @@ module Convolver
       kernel_spectrum = Numo::Pocketfft.fftn(kernel)
       kernel_spectrum.inplace.conj if operation == :correlation
       result = Numo::Pocketfft.ifftn(signal_spectrum.inplace * kernel_spectrum).real
-      Numo::SFloat.cast(result)
+      dtype.cast(result)
     end
 
     def fold_kernel(source, signal_shape, anchors)

data/lib/convolver/cost_profiles.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Convolver
+  # Immutable measured-environment coefficients in seconds; ranks one through three.
+  # @private
+  module CostProfiles
+    MAC = {
+      direct: [[6.55e-6, 3.24e-10, 7.08e-10].freeze, [6.55e-6, 3.24e-10, 7.08e-10].freeze].freeze,
+      fixed: [1.64e-5, 5.12e-5, 1.13e-4].freeze,
+      transform: [8.02e-10, 7.17e-10, 1.54e-9].freeze,
+      indices: { reflect: 1.33e-7, nearest: 1.46e-7, mirror: 1.57e-7, wrap: 3.23e-8 }.freeze,
+      folding: [3.78e-7, 3.99e-7, 5.09e-7].freeze
+    }.freeze
+    X86 = {
+      direct: [[1.59e-5, 3.08e-10, 2.52e-10].freeze, [1.63e-5, 3.22e-10, 3.96e-10].freeze].freeze,
+      fixed: [3.77e-5, 1.20e-4, 1.98e-4].freeze,
+      transform: [2.00e-9, 2.13e-9, 3.13e-9].freeze,
+      indices: { reflect: 2.32e-7, nearest: 2.88e-7, mirror: 2.62e-7, wrap: 1.11e-7 }.freeze,
+      folding: [8.20e-7, 7.51e-7, 9.79e-7].freeze
+    }.freeze
+    ARM = {
+      direct: [[1.88e-5, 5.12e-10, 5.96e-10].freeze, [1.88e-5, 5.12e-10, 5.96e-10].freeze].freeze,
+      fixed: [4.20e-5, 1.20e-4, 2.70e-4].freeze,
+      transform: [3.29e-9, 2.89e-9, 3.74e-9].freeze,
+      indices: { reflect: 2.62e-7, nearest: 3.67e-7, mirror: 2.87e-7, wrap: 1.50e-7 }.freeze,
+      folding: [9.97e-7, 8.80e-7, 1.24e-6].freeze
+    }.freeze
+    def self.for_platform(platform)
+      case platform
+      when /\Aarm64-darwin/ then MAC
+      when /\Ax86_64-linux/ then X86
+      when /\Aaarch64-linux/ then ARM
+      end
+    end
+
+    CURRENT = for_platform(RUBY_PLATFORM)
+
+    def self.for_rank(rank)
+      CURRENT if (1..3).cover?(rank)
+    end
+  end
+
+  private_constant :CostProfiles
+end

data/lib/convolver/fft_cost.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'convolver/preparation_cost'
+
+module Convolver
+  # Shared transform costs and a lower bound that never constructs an FFT plan.
+  # @private
+  class FftCost
+    REAL = { 1 => 1.0e-9, 2 => 1.0e-9, 3 => 1.5e-9 }.freeze
+    COMPLEX = { 1 => 2.4e-9, 2 => 2.4e-9, 3 => 2.8e-9 }.freeze
+    FIXED = { 0 => 5.0e-6, 1 => 1.5e-5, 2 => 3.0e-5, 3 => 1.0e-4 }.freeze
+    PREPARATION = 1.0e-9
+
+    def self.fixed(rank, profile: nil)
+      return profile.fetch(:fixed).fetch(rank - 1) if profile
+
+      FIXED.fetch(rank, FIXED.values.last)
+    end
+
+    def self.transform(size, rank, real: true, profile: nil)
+      coefficient(rank, real:, profile:) * size * Math.log([size, 2].max)
+    end
+
+    def self.lower_bound(plan, kernel_shape, threshold:)
+      rank = kernel_shape.length
+      profile = plan.cost_profile
+      setup = fixed(rank, profile:)
+      return setup if setup >= threshold || plan.wrap? || rank.zero?
+
+      size = minimum_size(plan.extended_shape, kernel_shape)
+      setup + transform(size, rank, profile:) + (2 * PREPARATION * size) + PreparationCost.new(plan).indices
+    end
+
+    def self.coefficient(rank, real:, profile:)
+      return profile.fetch(:transform).fetch(rank - 1) * (real ? 1 : 2.2) if profile
+
+      costs = real ? REAL : COMPLEX
+      costs.fetch(rank, costs.values.last)
+    end
+    private_class_method :coefficient
+
+    def self.minimum_size(signal_shape, kernel_shape)
+      # Ruby integers avoid overflow: this is only a cost bound, never an allocation.
+      shape = signal_shape.zip(kernel_shape).map { |signal, kernel| signal + kernel - 1 }
+      shape[-1] += 1 if shape[-1].odd?
+      shape.reduce(1, :*)
+    end
+    private_class_method :minimum_size
+  end
+
+  private_constant :FftCost
+end

data/lib/convolver/fft_estimator.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
+require 'convolver/fft_cost'
+
 module Convolver
   # Estimates the selected real or complex PocketFFT implementation cost.
   # @private
   class FftEstimator
-    REAL_FFT_COST = { 1 => 1.0e-9, 2 => 9.0e-10, 3 => 1.45e-9 }.freeze
-    COMPLEX_FFT_COST = { 1 => 2.4e-9, 2 => 2.4e-9, 3 => 2.8e-9 }.freeze
-    FIXED_COST = 1.5e-4
-    PREPARATION_COST = 1.0e-9
     AXIS_MOVE_COST = 1.6e-9
+    RESULT_COST = 5.0e-10
     CORRELATION_COST = 2.0e-10
 
     def initialize(operation, signal, kernel, plan)
@@ -16,54 +15,48 @@ module Convolver
       @signal = signal
       @kernel = kernel
       @plan = plan
+      @profile = plan.cost_profile
       @buffers = plan.fft_buffers
+      @preparation = PreparationCost.new(plan)
     end
 
     def call
-      transform_size, spectrum_size, coefficient, moved_size = dimensions
-      transform_cost = coefficient * transform_size * Math.log([transform_size, 2].max)
-      preparation_cost = PREPARATION_COST * preparation_size(transform_size)
-      axis_move_cost = AXIS_MOVE_COST * moved_size
-      correlation_cost = operation == :correlation ? CORRELATION_COST * spectrum_size : 0.0
-      FIXED_COST + transform_cost + preparation_cost + axis_move_cost + correlation_cost
+      return FftCost.fixed(0) + preparation.conversion + result_cost if signal.ndim.zero?
+
+      transform_cost + preparation_cost + extra_cost
     end
 
     private
 
-    attr_reader :operation, :signal, :kernel, :plan, :buffers
+    attr_reader :operation, :signal, :kernel, :plan, :buffers, :preparation
 
-    def dimensions
-      return linear_dimensions unless plan.wrap?
-
-      circular_dimensions
+    def transform_cost
+      transform = FftCost.transform(buffers.transform_size, signal.ndim,
+                                    real: !buffers.real_axis.nil?, profile: @profile)
+      FftCost.fixed(signal.ndim, profile: @profile) + transform + (AXIS_MOVE_COST * moved_size)
     end
 
-    def circular_dimensions
-      real_axis = buffers.real_axis
-      [buffers.transform_size, buffers.spectrum_size, transform_coefficient(real_axis), moved_size(real_axis)]
+    def extra_cost
+      correlation_cost = operation == :correlation ? CORRELATION_COST * buffers.spectrum_size : 0.0
+      correlation_cost + preparation.conversion + result_cost
     end
 
-    def linear_dimensions
-      [buffers.transform_size, buffers.spectrum_size,
-       cost_for(REAL_FFT_COST), 0]
+    def result_cost
+      RESULT_COST * plan.result_size * (plan.dtype::ELEMENT_BYTE_SIZE / 4)
     end
 
-    def preparation_size(transform_size)
-      extension_size = plan.valid? || plan.wrap? ? 0 : plan.extended_size
-      working_size = plan.wrap? ? signal.size + kernel.size : 2 * transform_size
-      extension_size + working_size
-    end
+    def preparation_cost
+      return circular_preparation_cost if plan.wrap?
 
-    def cost_for(costs)
-      costs.fetch(signal.ndim, costs.values.last)
+      (2 * FftCost::PREPARATION * buffers.transform_size) + preparation.extension
     end
 
-    def transform_coefficient(real_axis)
-      cost_for(real_axis ? REAL_FFT_COST : COMPLEX_FFT_COST)
+    def circular_preparation_cost
+      (FftCost::PREPARATION * (signal.size + kernel.size)) + preparation.folding(kernel.size)
     end
 
-    def moved_size(real_axis)
-      real_axis && real_axis != signal.ndim - 1 ? 3 * signal.size : 0
+    def moved_size
+      buffers.real_axis && buffers.real_axis != signal.ndim - 1 ? 3 * signal.size : 0
     end
   end
 

data/lib/convolver/fft_limits.rb

@@ -2,7 +2,7 @@
 
 require 'convolver/buffer_limits'
 
-# Internal allocation and arithmetic checks for the PocketFFT paths.
+# @!macro convolver_overview
 module Convolver
   # Only FFT representability failures permit automatic direct fallback.
   # @private

data/lib/convolver/linear_fft_operation.rb

@@ -5,6 +5,7 @@ module Convolver
   # @private
   class LinearFftOperation
     def initialize(operation, signal, kernel, plan)
+      @dtype = plan.dtype
       @operation = operation
       @signal = signal
       @kernel = kernel
@@ -15,12 +16,13 @@ module Convolver
       signal_padded = zero_padded(signal)
       kernel_padded = zero_padded(kernel)
       full_result = real_spectrum_product(signal_padded, kernel_padded)
-      Numo::SFloat.cast(full_result[*valid_ranges])
+      cropped = full_result[*valid_ranges]
+      dtype == Numo::DFloat ? cropped.dup : dtype.cast(cropped)
     end
 
     private
 
-    attr_reader :operation, :signal, :kernel, :transform_shape
+    attr_reader :operation, :signal, :kernel, :transform_shape, :dtype
 
     def zero_padded(value)
       Numo::DFloat.zeros(*transform_shape).tap do |padded|

data/lib/convolver/operation_dtype.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Convolver
+  # Resolves public precision without allocating operand copies.
+  # @private
+  class OperationDtype
+    SINGLE_INPUTS = [Numo::SFloat, Numo::Int8, Numo::UInt8, Numo::Int16, Numo::UInt16].freeze
+    DOUBLE_INPUTS = [Numo::DFloat, Numo::Int32, Numo::UInt32, Numo::Int64, Numo::UInt64].freeze
+    INPUTS = (SINGLE_INPUTS + DOUBLE_INPUTS).freeze
+    OUTPUTS = [Numo::SFloat, Numo::DFloat].freeze
+
+    def self.resolve(signal, kernel, dtype)
+      validate_inputs!(signal, kernel)
+      validate_dtype!(dtype)
+      types = [signal.class, kernel.class]
+      dtype || (types.any? { |type| DOUBLE_INPUTS.include?(type) } ? Numo::DFloat : Numo::SFloat)
+    end
+
+    def self.validate_inputs!(signal, kernel)
+      unless signal.is_a?(Numo::NArray) && kernel.is_a?(Numo::NArray)
+        raise ArgumentError, 'signal and kernel must be Numo::NArray values'
+      end
+
+      return if [signal.class, kernel.class].all? { |type| INPUTS.include?(type) }
+
+      raise ArgumentError, 'unsupported signal or kernel dtype'
+    end
+
+    def self.validate_dtype!(dtype)
+      return if dtype.nil? || OUTPUTS.include?(dtype)
+
+      raise ArgumentError, 'dtype must be Numo::SFloat, Numo::DFloat, or nil'
+    end
+
+    def self.cast_fill(value, dtype)
+      # A scalar IEEE float conversion, without allocating a Numo buffer before preflight.
+      dtype == Numo::SFloat ? [value].pack('f').unpack1('f') : value
+    end
+  end
+
+  private_constant :OperationDtype
+end