convolver 2.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08959da24c94d02889f0067f18f7233578b4b14ec4e58538b144efeef1cbe25f'
-  data.tar.gz: c39df2ebf01a04f93fa62e49bd8a4542e78244868d822d7f47a00cc78b9aaa7e
+  metadata.gz: 0461fd5af32c0104f8214df035709fea95c2b50f21f63d1b88c7999cadcafd29
+  data.tar.gz: 770518e0498a79c213c3be551f7749d6e20139a9fd327357f1d3608c0cbb72fd
 SHA512:
-  metadata.gz: 73d425b7851b21dd93cb135ca7ad88aa75f760b41a53ed8a2b72b2a9110e183062c1643af9563f81d59248d50d3f49a531e2bbac6d0c5cdcef6383717e31f73a
-  data.tar.gz: 89ddc9f26950329b9ce2ce3917e5f90057c3c625f2210eb39fcc527cbe7b3f418f14f387665a3be3c1ea44d50beac101907c038c6ef9998998e30c21d61966d2
+  metadata.gz: 40b871a7ad8883742b27ff4b05ae830f38cbdd7f09f3fc6ef85fd26166bbc9613fe3fc7b3d73bd47f6ce45642dfa3e4b884bc69f9b88bc69028a043d5da5e4de
+  data.tar.gz: 506e52bd6f023d6fb169589e1763fe2a3668baf5158a04e545dd8bbc4de151e4b03ece49a51dd9b6d1b0f71666a662d9a148a269ecd96cd73c9ce6d0a2c0fa2b

data/CHANGELOG.md

@@ -5,7 +5,88 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [4.0.0] - 2026-10-06
+
+### Added
+
+- Optional `dtype: Numo::SFloat` or `dtype: Numo::DFloat` on all calculation
+  and estimator methods, with matching result types and genuine native double
+  arithmetic. Omitted or nil dtype selects precision from both operands.
+
+### Changed
+
+- **Breaking, v4.0.0:** Automatically promote SFloat and 8/16-bit integer
+  inputs to SFloat, and DFloat and 32/64-bit integer inputs to DFloat; the
+  wider floating candidate wins independently of operand order.
+- **Breaking:** Reject Bit, RObject, complex arrays and custom NArray subclasses,
+  including with an explicit floating dtype. Integer results are not supported.
+- Reuse a single operation plan during automatic dispatch and account for
+  selected dtype and input conversion in cost estimates and buffer checks.
+- Bound FFT shape search in native code and skip FFT planning when a cheap
+  cost bound already favors direct execution.
+- Calibrate direct/FFT selection for ranks one through three on arm64 macOS
+  and x86_64/aarch64 Linux, including dtype, fixed setup, continuous kernel
+  costs, boundary indexing and periodic folding. Retain the existing heuristic
+  on other platforms and higher ranks.
+
+### Fixed
+
+- Cast both inputs and fill to the resolved dtype before boundary preparation,
+  periodic folding and arithmetic, consistently across direct and FFT paths.
+  `dtype: Numo::SFloat` selects single-precision inputs/results, but does not
+  guarantee bit-for-bit version 3 results. FFT work remains double precision.
+
+## [3.0.1] - 2026-10-04
+
+### Changed
+
+- Require `numo-pocketfft >= 0.7.0` and allow `numo-narray-alt < 0.12`,
+  enabling the NArray 0.11 series.
+
+### Fixed
+
+- Read the logical values of contiguous signal and kernel slices in direct
+  convolution and correlation, including unaligned SSE kernels and scalar views.
+- Retain a representable exact FFT shape when an optional fast candidate exceeds
+  the native element limit.
+- Reject unrepresentable FFT buffers and native integer arithmetic before
+  allocation, including preparation, inverse staging and work buffers. Automatic
+  selection retains a safe direct path when FFT exceeds its limits.
+
+## [3.0.0] - 2026-08-22
+
+### Added
+
+- Added the `correlate`, `correlate_basic`, and `correlate_fft` calculation
+  methods for cross-correlation, preserving the numerical operation exposed by
+  the version 2 `convolve*` methods.
+- Added `predict_correlate_basic_time` and `predict_correlate_fft_time` as the
+  corresponding estimator family.
+- Added distinct native correlation and convolution primitives whose hot loops
+  perform the required traversal directly without materializing a reversed
+  kernel.
+
+### Changed
+
+- **Breaking:** Changed `convolve`, `convolve_basic`, and `convolve_fft` to
+  calculate mathematical discrete convolution. Version 2 users who need
+  unchanged results must rename these calls to their `correlate*` counterparts.
+- **Breaking:** Changed the `predict_convolve_*_time` methods to estimate the
+  new mathematical convolution implementations.
+- Defined operation-specific `:same` alignment. Correlation uses
+  `signal[i + j - anchor]`; convolution uses
+  `signal[i + anchor - j]`. This places the extra boundary sample for an even
+  kernel on opposite sides.
+- Reworked linear PocketFFT calculations around real transforms and checked
+  exact/even or 2/3/5-smooth transform shapes. Circular calculations use real
+  transforms when an axis is even and retain complex transforms for all-odd
+  shapes.
+
+### Removed
+
+- **Breaking:** Removed the deprecated `convolve_fftw3` compatibility method.
+  Use `correlate_fft` to preserve version 2 results or `convolve_fft` for
+  mathematical convolution.
 
 ## [2.0.0] - 2026-08-20
 
@@ -81,7 +162,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Updated the native extension to use the maintained Numo C API and removed the
   legacy untyped-data compatibility code.
 
-[Unreleased]: https://github.com/neilslater/convolver/compare/v2.0.0...HEAD
+[Unreleased]: https://github.com/neilslater/convolver/compare/v3.0.1...HEAD
+[3.0.0]: https://github.com/neilslater/convolver/compare/v2.0.0...v3.0.0
 [2.0.0]: https://github.com/neilslater/convolver/compare/v1.0.1...v2.0.0
 [1.0.1]: https://github.com/neilslater/convolver/compare/v1.0.0...v1.0.1
 [1.0.0]: https://github.com/neilslater/convolver/compare/v0.3.2...v1.0.0

data/README.md

@@ -3,16 +3,14 @@
 [![CI](https://github.com/neilslater/convolver/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/neilslater/convolver/actions/workflows/ci.yml)
 [![Gem Version](https://badge.fury.io/rb/convolver.svg)](https://badge.fury.io/rb/convolver)
 
-Convolver calculates cross-correlations between multidimensional
-[`Numo::NArray`](https://github.com/yoshoku/numo-narray-alt) values, with
-configurable output extents and signal boundary extensions. It chooses between
-a direct native implementation for smaller inputs and a
-[`Numo::Pocketfft`](https://github.com/yoshoku/numo-pocketfft)-based
+Convolver calculates mathematical convolution and cross-correlation between
+multidimensional
+[`Numo::NArray`](https://github.com/yoshoku/numo-narray-alt) values. Both
+operations support configurable output extents and signal boundary extensions.
+Convolver chooses between a direct native implementation for smaller inputs
+and a [`Numo::Pocketfft`](https://github.com/yoshoku/numo-pocketfft)-based
 implementation for larger inputs.
 
-Version 1.0 replaces the unmaintained `narray` and `fftw3` gems with
-`numo-narray-alt` and `numo-pocketfft`.
-
 ## Installation
 
 Add Convolver to your application's Gemfile:
@@ -21,22 +19,16 @@ Add Convolver to your application's Gemfile:
 gem 'convolver'
 ```
 
-Then run:
-
-```sh
-bundle install
-```
-
-Alternatively, install it directly:
-
-```sh
-gem install convolver
-```
-
-No external FFT library is required; PocketFFT is bundled by its Ruby gem.
+Then run `bundle install`, or install the gem directly with
+`gem install convolver`. No external FFT library is required; PocketFFT is
+bundled by its Ruby gem.
 
 ## Usage
 
+`convolve` calculates mathematical discrete convolution. `correlate`
+calculates cross-correlation, following the public naming convention used by
+NumPy and SciPy:
+
 ```ruby
 require 'convolver'
 
@@ -45,32 +37,43 @@ kernel = Numo::SFloat[1.3, -0.5]
 
 Convolver.convolve(signal, kernel)
 # => Numo::SFloat#shape=[2]
+#    [0.37, 0.45]
+
+Convolver.correlate(signal, kernel)
+# => Numo::SFloat#shape=[2]
 #    [0.19, 0.27]
 ```
 
-With no keywords, Convolver preserves its original valid-correlation behavior:
-the signal and kernel must have the same rank, the kernel must be no larger
-than the signal in any dimension, and only positions with complete overlap are
-returned. The result size in each dimension is:
+For real one-dimensional inputs, the two valid operations are:
 
-```ruby
-signal_size - kernel_size + 1
+```text
+correlate(signal, kernel)[p] = sum_j signal[p + j] * conjugate(kernel[j])
+convolve(signal, kernel)[n]  = sum_j signal[n - j] * kernel[j]
 ```
 
-Inputs are converted to single-precision floats internally, and results are
-returned as `Numo::SFloat`. Supplying `Numo::SFloat` inputs avoids conversion in
-the direct implementation.
+The formulas apply component-wise to multidimensional arrays. Correlation
+conventionally conjugates the second operand, although Convolver's current
+real input contract makes conjugation invisible.
 
-`Convolver.convolve` normally chooses the implementation automatically. The
-implementations can also be called directly for application-specific
-benchmarking:
+With no keywords, the signal and kernel must have the same rank, the kernel
+must be no larger than the signal in any dimension, and only positions with
+complete overlap are returned. Both inputs determine the floating result dtype,
+or you can select it explicitly with `dtype:`.
+
+The automatic, direct, and FFT implementations are available for both
+operations:
 
 ```ruby
+Convolver.convolve(signal, kernel)
 Convolver.convolve_basic(signal, kernel)
 Convolver.convolve_fft(signal, kernel)
+
+Convolver.correlate(signal, kernel)
+Convolver.correlate_basic(signal, kernel)
+Convolver.correlate_fft(signal, kernel)
 ```
 
-Both implementations and the automatic method accept the same options:
+Every calculation method accepts the same options:
 
 ```ruby
 Convolver.convolve(signal, kernel,
@@ -79,6 +82,41 @@ Convolver.convolve(signal, kernel,
                    origin: 0)
 ```
 
+### Input and result precision
+
+`dtype:` accepts `Numo::SFloat`, `Numo::DFloat`, or `nil` (automatic, the
+default). Automatic selection maps each input type using this table, then
+chooses DFloat if either input maps to DFloat, otherwise SFloat:
+
+| Input type | Automatic floating type |
+| --- | --- |
+| `SFloat`, `Int8`, `UInt8`, `Int16`, `UInt16` | `Numo::SFloat` |
+| `DFloat`, `Int32`, `UInt32`, `Int64`, `UInt64` | `Numo::DFloat` |
+
+The input type names above are classes in `Numo`. Both operands must be instances
+of these concrete classes. Bit, RObject, complex arrays, custom subclasses and
+ordinary Ruby arrays are rejected, even with an explicit `dtype:`. Integer
+results and complex arithmetic are not supported.
+
+```ruby
+signal = Numo::SFloat[1, 2, 3]
+kernel = Numo::DFloat[0.25, 0.75]
+Convolver.convolve(signal, kernel)                     # DFloat result
+Convolver.convolve(signal, kernel, dtype: Numo::SFloat) # SFloat result
+```
+
+Both inputs are cast to the selected dtype before extension, folding or
+arithmetic. Inputs are never mutated. `fill_value` is cast to this same dtype
+and never promotes the result. Ordinary floating conversion applies, including
+rounding, overflow to infinity and underflow; NaN and infinity are not rejected.
+Non-finite propagation and rounding can differ between algorithms.
+
+Direct products and accumulation use the selected precision. PocketFFT uses
+double-precision working buffers for either result dtype. The returned class
+is independent of algorithm selection. Integer inputs become approximate
+floating computations: DFloat represents every 32-bit integer, but not every
+64-bit integer, and neither dtype guarantees exact integer convolution.
+
 ### Output modes
 
 `mode:` controls the returned extent independently in each dimension:
@@ -113,45 +151,106 @@ passed with another boundary. `:reflect` repeats the edge sample; `:mirror`
 does not. All boundary modes work across every dimension, including
 length-one axes and extensions wider than the stored signal.
 
-### Kernel origin
+### Kernel origin and alignment
 
-`origin:` shifts the kernel anchor for `:same`. It accepts one integer applied
-to every dimension or an array with one integer per dimension. For a kernel
-dimension of length `K`:
+`origin:` shifts the stored-kernel anchor for `:same`. It accepts one integer
+applied to every dimension or an array with one integer per dimension. For a
+kernel dimension of length `K`:
 
-```ruby
-anchor = (K / 2) + origin
+```text
+anchor = floor(K / 2) + origin
+
+correlation[i] = sum_j extended_signal[i + j - anchor] * kernel[j]
+convolution[i] = sum_j extended_signal[i + anchor - j] * kernel[j]
 ```
 
-The anchor must remain within the kernel. Positive origins sample farther
-toward lower signal indices. With the default origin, an even kernel gives the
-extra boundary sample to the lower-index, or left, side: a length-four kernel
-uses two samples before and one after the aligned signal position. Nonzero
-origins are supported only for `:same`; `:valid` and `:full` require zero.
+The anchor must remain within the kernel. Correlation pads `anchor` samples
+before the signal and `K - 1 - anchor` after it; convolution swaps those
+widths. Odd centered kernels therefore align alike. For an even centered
+kernel, correlation puts the extra sample before the signal and convolution
+puts it after the signal. Positive origins move correlation toward lower signal
+indices and convolution toward higher signal indices.
+
+Nonzero origins are supported only for `:same`; `:valid` and `:full` require
+zero.
+
+### Estimators
 
-The estimator methods accept and validate the same options:
+The estimator methods accept and validate the same options as their calculation
+families:
 
 ```ruby
 Convolver.predict_convolve_basic_time(signal, kernel, mode: :same, boundary: :nearest)
 Convolver.predict_convolve_fft_time(signal, kernel, mode: :same, boundary: :wrap)
+
+Convolver.predict_correlate_basic_time(signal, kernel, mode: :same, boundary: :nearest)
+Convolver.predict_correlate_fft_time(signal, kernel, mode: :same, boundary: :wrap)
 ```
 
-`Convolver.convolve_fftw3` remains as a deprecated alias for `convolve_fft` to
-ease migration from Convolver 0.x and forwards all options.
+Estimates are machine-dependent heuristics, including input conversion, boundary
+preparation and periodic kernel folding. Automatic selection avoids FFT planning
+when a cheap lower bound already favors direct calculation. Ranks one through
+three use calibrated profiles on arm64 macOS and x86_64/aarch64 Linux; other
+platforms and higher ranks retain the general heuristic. Algorithm choices
+can change as estimates improve; benchmark the explicit methods for workloads
+where the choice matters.
+
+Calculations and estimators reject unrepresentable buffer sizes with `RangeError`
+before allocation. FFT planning also checks conservative PocketFFT integer and
+work-buffer limits, including full complex staging for real inverse transforms.
+Automatic selection uses direct calculation when FFT exceeds its limits and the
+direct path remains valid. These checks do not reserve memory; ordinary allocator
+exhaustion still raises `NoMemoryError`.
+
+### Migrating from version 3
+
+Version 4 changes default result types and values: DFloat and 32/64-bit integer
+inputs now select DFloat. Pass `dtype: Numo::SFloat` to request single-precision
+inputs and results. This retains the version 3 result type, but does not promise
+identical numerical results: version 4 consistently casts both inputs before
+processing, whereas version 3's direct and FFT paths could round differently.
+The input-class restrictions listed above also apply with a dtype override.
+
+### Migrating from version 2
+
+Version 2's `convolve*` methods calculated cross-correlation. Version 3 corrects
+the terminology and changes every `convolve*` method to mathematical
+convolution. Asymmetric kernels make the result change visible.
+
+To preserve version 2 results, rename the complete method family:
+
+| Version 2 | Version 3 equivalent |
+| --- | --- |
+| `convolve` | `correlate` |
+| `convolve_basic` | `correlate_basic` |
+| `convolve_fft` | `correlate_fft` |
+| `predict_convolve_basic_time` | `predict_correlate_basic_time` |
+| `predict_convolve_fft_time` | `predict_correlate_fft_time` |
+| `convolve_fftw3` | `correlate_fft` |
+
+`convolve_fftw3` has been removed. No `cross_correlate` aliases are provided;
+the standard `correlate` name denotes cross-correlation explicitly documented
+above.
 
 ## Contributing
 
-Install the development dependencies, then run the main suite:
+Install the development dependencies, then run the complete local gate:
 
 ```sh
 bundle install
 bundle exec rake
 bundle exec rubocop
+bundle exec ncs-rubocop-conf-audit
 bundle exec rake c:lint
+bundle exec bundle-audit check --update
+bundle exec rake docs:check
 ```
 
-The Ruby specs exercise both the Ruby API and native extension. Additional
-native-code checks are available:
+The Ruby specs exercise both the Ruby API and native extension and enforce 95%
+line and branch coverage for the Ruby library. Dependency auditing refreshes
+the advisory database and requires network access. The documentation check
+rejects YARD warnings and undocumented public API objects; private implementation
+classes are marked `@private`. Additional native-code checks are available:
 
 ```sh
 bundle exec rake c:coverage  # Requires GCC and gcovr

data/ext/convolver/convolve_raw.c

@@ -1,169 +1,57 @@
-// ext/convolver/convolve_raw.c
-
 #include "convolve_raw.h"
+#include "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;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//
-//  Convolve
-//
-//    Benchmark: 640x480 image, 8x8 kernel, 1000 iterations. 12.3 seconds.
-//
-
-void convolve_raw(
-    int in_rank, const size_t *in_shape, const float *in_ptr,
-    int kernel_rank, const size_t *kernel_shape, const float *kernel_ptr,
-    int out_rank, const size_t *out_shape, float *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 % 4;
-  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 );
-
-  // Main convolve loop
-  for ( i = 0; i < out_size; i++ ) {
-#if CONVOLVER_USE_SSE
-    __m128 simd_x, simd_y, simd_t;
-    float v[4];
-    simd_t = _mm_setzero_ps();
-#endif
-    float t = 0.0;
-
-#if CONVOLVER_USE_SSE
-    // Use SIMD for all the aligned values in groups of 4
-    for ( j = 0; j < kernel_aligned; j +=4 ) {
-      simd_x = _mm_load_ps( kernel_ptr + j );
-      // Yes the backwards alignment is correct
-      simd_y = _mm_set_ps( in_ptr[ offset + kernel_co_incr_cache[j+3] ], in_ptr[ offset + kernel_co_incr_cache[j+2] ],
-                           in_ptr[ offset + kernel_co_incr_cache[j+1] ], in_ptr[ offset + kernel_co_incr_cache[j] ] );
-      simd_x = _mm_mul_ps( simd_x, simd_y );
-      simd_t = _mm_add_ps( simd_x, simd_t );
-    }
-    _mm_store_ps( v, simd_t );
+#define RAW_INDEX(j) (kernel_size - 1 - (j))
+#if defined(__SSE__)
+#define RAW_SIMD 1
 #else
-    // SSE is unavailable on architectures such as Apple Silicon.
-    // Use the same calculation without x86-specific intrinsics.
-    for ( j = 0; j < kernel_aligned; j++ ) {
-      t += in_ptr[ offset + kernel_co_incr_cache[j] ] * kernel_ptr[j];
-    }
+#define RAW_SIMD 0
 #endif
-
-    // Complete any remaining 1,2 or 3 items one at a time
-    for ( j = kernel_aligned; j < kernel_size; j++ ) {
-      t += in_ptr[ offset + kernel_co_incr_cache[j] ] * kernel_ptr[ j ];
-    }
-
-#if CONVOLVER_USE_SSE
-    out_ptr[i] = v[0] + v[1] + v[2] + v[3] + t;
+#define RAW_NAME convolve_raw
+#define RAW_TYPE float
+#define RAW_LANES 4
+#define RAW_VECTOR __m128
+#define RAW_ZERO _mm_setzero_ps
+#define RAW_LOAD _mm_loadu_ps
+#define RAW_STORE _mm_storeu_ps
+#define RAW_ADD _mm_add_ps
+#define RAW_MUL _mm_mul_ps
+#include "raw_loop.h"
+#undef RAW_NAME
+#undef RAW_TYPE
+#undef RAW_LANES
+#undef RAW_VECTOR
+#undef RAW_ZERO
+#undef RAW_LOAD
+#undef RAW_STORE
+#undef RAW_ADD
+#undef RAW_MUL
+#undef RAW_SIMD
+
+#if defined(__SSE2__)
+#define RAW_SIMD 1
 #else
-    out_ptr[i] = t;
+#define RAW_SIMD 0
 #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 );
-}
+#define RAW_NAME convolve_raw_double
+#define RAW_TYPE double
+#define RAW_LANES 2
+#define RAW_VECTOR __m128d
+#define RAW_ZERO _mm_setzero_pd
+#define RAW_LOAD _mm_loadu_pd
+#define RAW_STORE _mm_storeu_pd
+#define RAW_ADD _mm_add_pd
+#define RAW_MUL _mm_mul_pd
+#include "raw_loop.h"
+#undef RAW_NAME
+#undef RAW_TYPE
+#undef RAW_LANES
+#undef RAW_VECTOR
+#undef RAW_ZERO
+#undef RAW_LOAD
+#undef RAW_STORE
+#undef RAW_ADD
+#undef RAW_MUL
+#undef RAW_SIMD
+
+#undef RAW_INDEX

data/ext/convolver/convolve_raw.h

@@ -1,25 +1,14 @@
-// ext/convolver/convolve_raw.h
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-//
-// Declarations of narray helper functions
-//
-
 #ifndef CONVOLVE_RAW_H
 #define CONVOLVE_RAW_H
-
-#include <ruby.h>
-#if defined(__SSE__)
-#include <xmmintrin.h>
-#define CONVOLVER_USE_SSE 1
-#else
-#define CONVOLVER_USE_SSE 0
-#endif
-#define LARGEST_RANK 16
+#include "raw_config.h"
 
 void convolve_raw(
     int in_rank, const size_t *in_shape, const float *in_ptr,
     int kernel_rank, const size_t *kernel_shape, const float *kernel_ptr,
     int out_rank, const size_t *out_shape, float *out_ptr );
 
+void convolve_raw_double(
+    int in_rank, const size_t *in_shape, const double *in_ptr,
+    int kernel_rank, const size_t *kernel_shape, const double *kernel_ptr,
+    int out_rank, const size_t *out_shape, double *out_ptr );
 #endif