convolver 3.0.1 → 4.0.1

data/ext/convolver/convolve_raw.c

@@ -1,171 +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
-//
-
-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 convolution 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
-    // Contiguous kernel views need not start on a 16-byte boundary.
-    for ( j = 0; j < kernel_aligned; j +=4 ) {
-      simd_x = _mm_loadu_ps( kernel_ptr + j );
-      // Yes the backwards alignment is correct
-      simd_y = _mm_set_ps(
-        in_ptr[ offset + kernel_co_incr_cache[kernel_size - 1 - (j+3)] ],
-        in_ptr[ offset + kernel_co_incr_cache[kernel_size - 1 - (j+2)] ],
-        in_ptr[ offset + kernel_co_incr_cache[kernel_size - 1 - (j+1)] ],
-        in_ptr[ offset + kernel_co_incr_cache[kernel_size - 1 - 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[kernel_size - 1 - 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[kernel_size - 1 - 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,28 +1,14 @@
-// ext/convolver/convolve_raw.h
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-//
-// Declarations of narray helper functions
-//
-
 #ifndef CONVOLVE_RAW_H
 #define CONVOLVE_RAW_H
-
-#ifndef CONVOLVER_RAW_CONFIG
-#define CONVOLVER_RAW_CONFIG
-#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
-#endif
+#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

data/ext/convolver/convolver.c

@@ -4,18 +4,18 @@
 
 #include "correlate_raw.h"
 #include "convolve_raw.h"
+#include "fft_shape.h"
 
 static VALUE mConvolver;
 
 /* Contiguous views share their backing storage but start at a byte offset. */
-static const float *logical_pointer_for_read(VALUE value) {
-  return (const float *)(na_get_pointer_for_read(value) + na_get_offset(value));
+static const void *logical_pointer_for_read(VALUE value) {
+  return (const void *)(na_get_pointer_for_read(value) + na_get_offset(value));
 }
 
-static VALUE contiguous_sfloat(VALUE value) {
+static VALUE contiguous_float(VALUE value) {
   narray_t *narray;
 
-  value = rb_funcall(numo_cSFloat, rb_intern("cast"), 1, value);
   GetNArray(value, narray);
   /* A scalar has no strides; Numo's contiguous check requires an axis. */
   if (narray->ndim > 0 && !RTEST(na_check_contiguous(value))) {
@@ -54,8 +54,13 @@ static VALUE convolver_basic_valid(VALUE signal, VALUE kernel, enum convolver_op
     rb_raise(rb_eArgError, "signal and kernel must be Numo::NArray values");
   }
 
-  signal_value = contiguous_sfloat(signal);
-  kernel_value = contiguous_sfloat(kernel);
+  VALUE dtype = CLASS_OF(signal);
+  if ((dtype != numo_cSFloat && dtype != numo_cDFloat) || CLASS_OF(kernel) != dtype) {
+    rb_raise(rb_eArgError, "native inputs must have matching SFloat or DFloat dtypes");
+  }
+
+  signal_value = contiguous_float(signal);
+  kernel_value = contiguous_float(kernel);
   GetNArray(signal_value, signal_narray);
   GetNArray(kernel_value, kernel_narray);
 
@@ -82,19 +87,35 @@ static VALUE convolver_basic_valid(VALUE signal, VALUE kernel, enum convolver_op
     numo_result_shape[rank - i - 1] = (size_t)result_shape[i];
   }
 
-  result_value = nary_new(numo_cSFloat, rank, numo_result_shape);
-  if (operation == CONVOLVER_CORRELATION) {
-    correlate_raw(
-      rank, signal_shape, logical_pointer_for_read(signal_value),
-      rank, kernel_shape, logical_pointer_for_read(kernel_value),
-      rank, result_shape, (float *)na_get_pointer_for_write(result_value)
-    );
+  result_value = nary_new(dtype, rank, numo_result_shape);
+  if (dtype == numo_cSFloat) {
+    if (operation == CONVOLVER_CORRELATION) {
+      correlate_raw(
+        rank, signal_shape, logical_pointer_for_read(signal_value),
+        rank, kernel_shape, logical_pointer_for_read(kernel_value),
+        rank, result_shape, (float *)na_get_pointer_for_write(result_value)
+      );
+    } else {
+      convolve_raw(
+        rank, signal_shape, logical_pointer_for_read(signal_value),
+        rank, kernel_shape, logical_pointer_for_read(kernel_value),
+        rank, result_shape, (float *)na_get_pointer_for_write(result_value)
+      );
+    }
   } else {
-    convolve_raw(
-      rank, signal_shape, logical_pointer_for_read(signal_value),
-      rank, kernel_shape, logical_pointer_for_read(kernel_value),
-      rank, result_shape, (float *)na_get_pointer_for_write(result_value)
-    );
+    if (operation == CONVOLVER_CORRELATION) {
+      correlate_raw_double(
+        rank, signal_shape, logical_pointer_for_read(signal_value),
+        rank, kernel_shape, logical_pointer_for_read(kernel_value),
+        rank, result_shape, (double *)na_get_pointer_for_write(result_value)
+      );
+    } else {
+      convolve_raw_double(
+        rank, signal_shape, logical_pointer_for_read(signal_value),
+        rank, kernel_shape, logical_pointer_for_read(kernel_value),
+        rank, result_shape, (double *)na_get_pointer_for_write(result_value)
+      );
+    }
   }
 
   return result_value;
@@ -107,7 +128,7 @@ static VALUE convolver_basic_valid(VALUE signal, VALUE kernel, enum convolver_op
  * @overload correlate_basic_valid(signal, kernel)
  *   @param signal [Numo::NArray] input values
  *   @param kernel [Numo::NArray] correlation kernel
- *   @return [Numo::SFloat] valid cross-correlation result
+ *   @return [Numo::SFloat, Numo::DFloat] valid cross-correlation result
  */
 static VALUE convolver_correlate_basic_valid(VALUE self, VALUE signal, VALUE kernel) {
   (void)self;
@@ -121,7 +142,7 @@ static VALUE convolver_correlate_basic_valid(VALUE self, VALUE signal, VALUE ker
  * @overload convolve_basic_valid(signal, kernel)
  *   @param signal [Numo::NArray] input values
  *   @param kernel [Numo::NArray] convolution kernel
- *   @return [Numo::SFloat] valid mathematical convolution result
+ *   @return [Numo::SFloat, Numo::DFloat] valid mathematical convolution result
  */
 static VALUE convolver_convolve_basic_valid(VALUE self, VALUE signal, VALUE kernel) {
   (void)self;
@@ -130,6 +151,7 @@ static VALUE convolver_convolve_basic_valid(VALUE self, VALUE signal, VALUE kern
 
 void Init_convolver(void) {
   mConvolver = rb_define_module("Convolver");
+  convolver_init_fft_shape(mConvolver);
   rb_define_singleton_method(mConvolver, "correlate_basic_valid", convolver_correlate_basic_valid, 2);
   rb_define_singleton_method(mConvolver, "convolve_basic_valid", convolver_convolve_basic_valid, 2);
 }

data/ext/convolver/correlate_raw.c

@@ -1,167 +1,57 @@
-// ext/convolver/correlate_raw.c
-
 #include "correlate_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;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//
-//  Correlate
-//
-
-void correlate_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 correlation 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
-    // Contiguous kernel views need not start on a 16-byte boundary.
-    for ( j = 0; j < kernel_aligned; j +=4 ) {
-      simd_x = _mm_loadu_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) (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 correlate_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 correlate_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/correlate_raw.h

@@ -1,28 +1,14 @@
-// ext/convolver/correlate_raw.h
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-//
-// Declarations of narray helper functions
-//
-
 #ifndef CORRELATE_RAW_H
 #define CORRELATE_RAW_H
-
-#ifndef CONVOLVER_RAW_CONFIG
-#define CONVOLVER_RAW_CONFIG
-#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
-#endif
+#include "raw_config.h"
 
 void correlate_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 correlate_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

data/ext/convolver/extconf.rb

@@ -11,6 +11,7 @@ $LOAD_PATH.each do |load_path|
 end
 
 abort 'numo/narray.h not found' unless have_header('numo/narray.h')
+abort 'log2 not found' unless have_func('log2', 'math.h') || have_library('m', 'log2', 'math.h')
 
 if RUBY_PLATFORM.match?(/mswin|cygwin|mingw/)
   $LOAD_PATH.each do |load_path|