simd 0.4.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c15d248c872e4369c45e4151faf81e9761ea1587
-  data.tar.gz: cdfc5170454be15be1bc75ccc5eba08aa96c884d
+SHA256:
+  metadata.gz: d43585672169c7a727e7502dea99cb56e8103c2e6a8effe4f32521ee4cae6e5d
+  data.tar.gz: c404674a578002bdf5933baee75e54680717c562b1e8c839a0661e04dfee27a6
 SHA512:
-  metadata.gz: 38df7b30a113b325bba7be834fcbe24c44738706495579af5a9e4b508e4db4375e2f36b16a97612eab4dd8da379c450d062c6e0bceb6e8ddf308a952ecf6419c
-  data.tar.gz: 342680d7f4f6690c8b3338de32ef192aaadb2952461e62e86a848650414b09d793d71e70c5b38909e0c882f062e346995f86f40d3dbf1de692cbe3eb0cfb0c73
+  metadata.gz: 86c6b9e43f219190f4bd2a34d0ad1c309eacb56068dbdb0d44f46894b1ceee19bc68c77d4f682d42b335039250730c9637a1d19c5075861c9731fd13a48d71d0
+  data.tar.gz: a71afed09b9ead560531c9ec2a9ffb0260843398255963b549abe44db0b45dc036fb604a945c9caff7f5d54dd51626f78ed4f2877803a9a5d2bc455e68c5c332

data/ext/simd/extconf.rb

@@ -1,6 +1,12 @@
 # Makes Makefiles for Ruby extensions.
 require 'mkmf'
 
+cpu = RbConfig::CONFIG['arch'].downcase
+if cpu.include?('arm')
+  ver = cpu.gsub(/[^\d]*(\d+).*/, '\\1').to_i
+  $CFLAGS << ' -mfpu=neon' if ver >= 6
+end
+
 extension_name = 'simd'
 dir_config(extension_name)
 create_makefile(extension_name)

data/ext/simd/simd_common.c

@@ -1,5 +1,7 @@
 #include "simd_common.h"
 
+#define XMM_BYTES 16 /* Width of the xmm1,2... registers */
+
 /* Internal: Allocate memory for the vector container. */
 VALUE allocate(VALUE klass)
 {
@@ -36,10 +38,9 @@ VALUE method_length(VALUE self)
 }
 
 /* Internal: Allocate memory for the data array. */
-void *internal_allocate_vector_array(unsigned long count, size_t size)
+void *internal_allocate_vector_array(unsigned long long int count)
 {
-	unsigned int modulo = 16 / size;
-	void *vector = malloc(((count + (count % modulo)) / modulo + 1) * size);
+	void *vector = malloc((count + 1) * XMM_BYTES);
 	if(vector == NULL)
 	{
 		rb_raise(rb_eNoMemError, "Unable to allocate memory");
@@ -50,7 +51,7 @@ void *internal_allocate_vector_array(unsigned long count, size_t size)
 
 /* Internal: Determine if two arrays can be acted upon, by being of equal
  * lengths or with the operand's length being a multiple of the data array's. */
-int internal_align_vectors(unsigned long v1, unsigned long v2, unsigned int modulo)
+int internal_align_vectors(unsigned long long int v1, unsigned long long int v2, unsigned int modulo)
 {
 	if((v1 % modulo) != (v2 % modulo))
 	{
@@ -74,3 +75,80 @@ int internal_align_vectors(unsigned long v1, unsigned long v2, unsigned int modu
 	/* Never reached */
 	return(-1);
 }
+
+/* Internal: Given another object, perform an action specified via a function
+ * pointer against both.
+ *
+ * Since arithmetic is purposefully performed against a void pointers, disable
+ * warnings regarding this for the current function. */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpointer-arith"
+VALUE internal_apply_operation(VALUE self, VALUE obj, size_t size, VALUE klass, b_operation func)
+{
+	unsigned long long int length, i, j;
+	int align;
+	vector_t *v1, *v2, *rv;
+	void *data;
+	VALUE result_obj = allocate(klass);
+
+	Data_Get_Struct(self, vector_t, v1);
+	Data_Get_Struct(obj, vector_t, v2);
+	Data_Get_Struct(result_obj, vector_t, rv);
+	rv->data = internal_allocate_vector_array(v1->len);
+
+	align = internal_align_vectors(v1->len, v2->len, (XMM_BYTES / size));
+
+	length = ((v1->len + (XMM_BYTES / size - 1)) / (XMM_BYTES / size));
+	rv->len = v1->len;
+
+	switch(align)
+	{
+		case 0: /* Same size arrays */
+			for(i = 0; i < length; i++)
+			{
+				func((v1->data + XMM_BYTES * i), (v2->data + XMM_BYTES * i), (rv->data + XMM_BYTES * i));
+			}
+			break;
+		case 1: /* Operand is exactly 4 long (size of 1 sse register) */
+			for(i = 0; i < length; i++)
+			{
+				func((v1->data + XMM_BYTES * i), v2->data, (rv->data + XMM_BYTES * i));
+			}
+			break;
+		default: /* Self is a multiple of operand's length long */
+			for(j = 0; j < v2->len; j++)
+			{
+				data = v2->data + XMM_BYTES * j;
+				for(i = j; i < length; i+=v2->len)
+				{
+					func((v1->data + XMM_BYTES * i), data, (rv->data + XMM_BYTES * i));
+				}
+			}
+	}
+	internal_sanitize_unaligned_final_vector(rv, size);
+
+	return(result_obj);
+}
+#pragma GCC diagnostic pop
+
+/* Internal: Make sure that no null bytes exist beyond the boundary of
+ * unaligned vectors.  This function should be called after any operation that
+ * results in the mutation or creation of a vector array.
+ *
+ * Since arithmetic is purposefully performed against a void pointers, disable
+ * warnings regarding this for the current function. */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpointer-arith"
+void internal_sanitize_unaligned_final_vector(vector_t *rv, size_t size)
+{
+	unsigned long long int i;
+
+	if((rv->len * size) % XMM_BYTES)
+	{
+		for(i = 1; i <= XMM_BYTES - ((rv->len * size) % XMM_BYTES); i+=size)
+		{
+			*(unsigned char *)(rv->data + (rv->len * size + i)) = 1;
+		}
+	}
+}
+#pragma GCC diagnostic pop

data/ext/simd/simd_common.h

@@ -8,5 +8,7 @@ void deallocate(vector_t *vector);
 
 VALUE method_length(VALUE self);
 
-void *internal_allocate_vector_array(unsigned long count, size_t size);
-int internal_align_vectors(unsigned long v1, unsigned long v2, unsigned int modulo);
+void *internal_allocate_vector_array(unsigned long long int count);
+int internal_align_vectors(unsigned long long int v1, unsigned long long int v2, unsigned int modulo);
+VALUE internal_apply_operation(VALUE self, VALUE obj, size_t size, VALUE klass, b_operation func);
+void internal_sanitize_unaligned_final_vector(vector_t *rv, size_t size);

data/ext/simd/simd_floatarray.c

@@ -1,4 +1,5 @@
 #include "simd_floatarray.h"
+#include "simd_longarray.h"
 
 VALUE SIMD_FloatArray = Qnil;
 
@@ -12,6 +13,13 @@ void Init_SIMD_FloatArray(VALUE parent)
 	rb_define_method(SIMD_FloatArray, "/", method_divide, 1);
 	rb_define_method(SIMD_FloatArray, "+", method_add, 1);
 	rb_define_method(SIMD_FloatArray, "-", method_subtract, 1);
+	rb_define_method(SIMD_FloatArray, "&", method_and, 1);
+	rb_define_method(SIMD_FloatArray, "|", method_or, 1);
+	rb_define_method(SIMD_FloatArray, "^", method_xor, 1);
+	rb_define_method(SIMD_FloatArray, "gt", method_gt, 1);
+	rb_define_method(SIMD_FloatArray, "lt", method_lt, 1);
+	rb_define_method(SIMD_FloatArray, ">", method_gt, 1);
+	rb_define_method(SIMD_FloatArray, "<", method_lt, 1);
 	rb_define_method(SIMD_FloatArray, "length", method_length, 0);
 	rb_define_method(SIMD_FloatArray, "to_a", method_to_a, 0);
 }
@@ -22,7 +30,7 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
 {
 	vector_t *vector;
 	d2v_t *data;
-	unsigned long n,m,i;
+	unsigned long long int n,i;
 
 	Check_Type(rb_array, T_ARRAY);
 	Data_Get_Struct(self, vector_t, vector);
@@ -34,7 +42,7 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
 		rb_raise(rb_eArgError, "Vectors must be at least 4 long");
 	}
 
-	vector->data = internal_allocate_vector_array(vector->len, sizeof(d2v_t));
+	vector->data = internal_allocate_vector_array(vector->len);
 
 	data = (d2v_t *)vector->data;
 	for(i = 0; i < vector->len; i++)
@@ -42,12 +50,7 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
 		data[i/2].f[i%2] = NUM2DBL(rb_ary_entry(rb_array, i));
 	}
 
-	/* If the array is an odd number of elements, set the final element to 1 */
-	m = n + (n % 2);
-	for(i = n % 4; i > 0; i--)
-	{
-		data[m/2].f[1] = 1.0;
-	}
+	internal_sanitize_unaligned_final_vector(vector, sizeof(double));
 
 	return(self);
 }
@@ -56,34 +59,71 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_multiply(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_multiply));
+	return(internal_apply_operation(self, obj, sizeof(double), SIMD_FloatArray, func_multiply));
 }
 
 /* Public: Divide values contained in the data array by those contained in
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_divide(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_divide));
+	return(internal_apply_operation(self, obj, sizeof(double), SIMD_FloatArray, func_divide));
 }
 
 /* Public: add values contained in the data array with those contained in
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_add(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_add));
+	return(internal_apply_operation(self, obj, sizeof(double), SIMD_FloatArray, func_add));
 }
 
 /* Public: Subtract values contained in another FloatArray object from those
  * contained in the current data array object, returning a new FloatArray. */
 static VALUE method_subtract(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_subtract));
+	return(internal_apply_operation(self, obj, sizeof(double), SIMD_FloatArray, func_subtract));
+}
+
+/* Public: and values contained in the data array with those contained in
+ * another FloatArray object, returning a new FloatArray. */
+static VALUE method_and(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(double), SIMD_FloatArray, func_and));
+}
+
+/* Public: or values contained in the data array with those contained in
+ * another FloatArray object, returning a new FloatArray. */
+static VALUE method_or(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(double), SIMD_FloatArray, func_or));
+}
+
+/* Public: xor values contained in the data array with those contained in
+ * another FloatArray object, returning a new FloatArray. */
+static VALUE method_xor(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(double), SIMD_FloatArray, func_xor));
+}
+
+/* Public: Compare values contained in the data array with those contained in
+ * another FloatArray object, return a new LongArray with each element being
+ * -1 if the data array's value is greater, and 0 otherwise. */
+static VALUE method_gt(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(double), SIMD_LongArray, func_gt));
+}
+
+/* Public: Compare values contained in the data array with those contained in
+ * another FloatArray object, return a new LongArray with each element being
+ * -1 if the data array's value is less, and 0 otherwise. */
+static VALUE method_lt(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(double), SIMD_LongArray, func_lt));
 }
 
 /* Public: Return a Ruby Array containing the doubles within the data array. */
 static VALUE method_to_a(VALUE self)
 {
-	unsigned long i;
+	unsigned long long int i;
 	vector_t *vector;
 	d2v_t *data;
 	VALUE rb_array = rb_ary_new();
@@ -98,61 +138,6 @@ static VALUE method_to_a(VALUE self)
 	return(rb_array);
 }
 
-/* Internal: Given another FloatArray object, perform an action specified via a
- * function pointer against both. */
-static VALUE internal_apply_operation(VALUE self, VALUE obj, b_operation func)
-{
-	unsigned long size, i;
-	int align;
-	vector_t *v1, *v2, *rv;
-	d2v_t *d1, *d2, *r;
-	VALUE result_obj = allocate(SIMD_FloatArray);
-
-	Data_Get_Struct(self, vector_t, v1);
-	Data_Get_Struct(obj, vector_t, v2);
-	Data_Get_Struct(result_obj, vector_t, rv);
-	rv->data = internal_allocate_vector_array(v1->len, sizeof(d2v_t));
-
-	align = internal_align_vectors(v1->len, v2->len, 2);
-
-	/* Ensure that size will be the result of ceil(len / 4.0) */
-	size = (v1->len + 1) / 2;
-
-	d1 = (d2v_t *)v1->data;
-	d2 = (d2v_t *)v2->data;
-	r  = (d2v_t *)rv->data;
-
-	rv->len = v1->len;
-
-	switch(align)
-	{
-		case 0: /* Same size arrays */
-			for(i = 0; i < size; i++)
-			{
-				func(&d1[i].v, &d2[i].v, &r[i].v);
-			}
-			break;
-		case 1: /* Operand is exactly 2 long (size of 1 sse register) */
-			for(i = 0; i < size; i++)
-			{
-				func(&d1[i].v, &d2[0].v, &r[i].v);
-			}
-			break;
-		default: /* Self is a multiple of operand's length long */
-			for(i = 0; i < size; i++)
-			{
-				func(&d1[i].v, &d2[i % v2->len].v, &r[i].v);
-			}
-	}
-
-	if(rv->len != rv->len + (rv->len % 2))
-	{
-		r[size].f[1] = 1;
-	}
-
-	return(result_obj);
-}
-
 /* Function: Multiply two vectors. */
 static void func_multiply(void *v1, void *v2, void *r)
 {
@@ -176,3 +161,33 @@ static void func_subtract(void *v1, void *v2, void *r)
 {
 	*(d2v *)r = *(d2v *)v1 - *(d2v *)v2;
 }
+
+/* Function: Perform a binary AND on two vectors. */
+static void func_and(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = *(l2v *)v1 & *(l2v *)v2;
+}
+
+/* Function: Perform a binary OR on two vectors. */
+static void func_or(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = *(l2v *)v1 | *(l2v *)v2;
+}
+
+/* Function: Perform a binary XOR on two vectors. */
+static void func_xor(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = *(l2v *)v1 ^ *(l2v *)v2;
+}
+
+/* Function: Compare vectors, return -1 if v1 is greater than v2, 0 otherwise */
+static void func_gt(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = (*(d2v *)v1 > *(d2v *)v2);
+}
+
+/* Function: Compare vectors, return -1 if v1 is greater than v2, 0 otherwise */
+static void func_lt(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = (*(d2v *)v1 < *(d2v *)v2);
+}

data/ext/simd/simd_floatarray.h

@@ -6,11 +6,19 @@ static VALUE method_multiply(VALUE self, VALUE obj);
 static VALUE method_divide(VALUE self, VALUE obj);
 static VALUE method_add(VALUE self, VALUE obj);
 static VALUE method_subtract(VALUE self, VALUE obj);
+static VALUE method_and(VALUE self, VALUE obj);
+static VALUE method_or(VALUE self, VALUE obj);
+static VALUE method_xor(VALUE self, VALUE obj);
+static VALUE method_gt(VALUE self, VALUE obj);
+static VALUE method_lt(VALUE self, VALUE obj);
 static VALUE method_to_a(VALUE self);
 
-static VALUE internal_apply_operation(VALUE self, VALUE obj, b_operation func);
-
 static void func_multiply(void *v1, void *v2, void *r);
 static void func_divide(void *v1, void *v2, void *r);
 static void func_add(void *v1, void *v2, void *r);
 static void func_subtract(void *v1, void *v2, void *r);
+static void func_and(void *v1, void *v2, void *r);
+static void func_or(void *v1, void *v2, void *r);
+static void func_xor(void *v1, void *v2, void *r);
+static void func_gt(void *v1, void *v2, void *r);
+static void func_lt(void *v1, void *v2, void *r);

data/ext/simd/simd_intarray.c

@@ -15,6 +15,10 @@ void Init_SIMD_IntArray(VALUE parent)
 	rb_define_method(SIMD_IntArray, "&", method_and, 1);
 	rb_define_method(SIMD_IntArray, "|", method_or, 1);
 	rb_define_method(SIMD_IntArray, "^", method_xor, 1);
+	rb_define_method(SIMD_IntArray, "gt", method_gt, 1);
+	rb_define_method(SIMD_IntArray, "lt", method_lt, 1);
+	rb_define_method(SIMD_IntArray, ">", method_gt, 1);
+	rb_define_method(SIMD_IntArray, "<", method_lt, 1);
 	rb_define_method(SIMD_IntArray, "length", method_length, 0);
 	rb_define_method(SIMD_IntArray, "to_a", method_to_a, 0);
 }
@@ -25,7 +29,7 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
 {
 	vector_t *vector;
 	i4v_t *data;
-	unsigned long n,m,i;
+	unsigned long long int n,i;
 
 	Check_Type(rb_array, T_ARRAY);
 	Data_Get_Struct(self, vector_t, vector);
@@ -37,7 +41,7 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
 		rb_raise(rb_eArgError, "Vectors must be at least 4 long");
 	}
 
-	vector->data = internal_allocate_vector_array(vector->len, sizeof(i4v_t));
+	vector->data = internal_allocate_vector_array(vector->len);
 
 	data = (i4v_t *)vector->data;
 	for(i = 0; i < vector->len; i++)
@@ -45,12 +49,7 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
 		data[i/4].f[i%4] = NUM2INT(rb_ary_entry(rb_array, i));
 	}
 
-	/* If the array is an odd number of elements, set the final element to 1 */
-	m = n + (n % 4);
-	for(i = n % 4; i > 0; i--)
-	{
-		data[m/4].f[i] = 1.0;
-	}
+	internal_sanitize_unaligned_final_vector(vector, sizeof(int));
 
 	return(self);
 }
@@ -59,55 +58,71 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_multiply(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_multiply));
+	return(internal_apply_operation(self, obj, sizeof(int), SIMD_IntArray, func_multiply));
 }
 
 /* Public: Divide values contained in the data array by those contained in
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_divide(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_divide));
+	return(internal_apply_operation(self, obj, sizeof(int), SIMD_IntArray, func_divide));
 }
 
 /* Public: add values contained in the data array with those contained in
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_add(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_add));
+	return(internal_apply_operation(self, obj, sizeof(int), SIMD_IntArray, func_add));
 }
 
 /* Public: and values contained in the data array with those contained in
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_and(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_and));
+	return(internal_apply_operation(self, obj, sizeof(int), SIMD_IntArray, func_and));
 }
 
 /* Public: or values contained in the data array with those contained in
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_or(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_or));
+	return(internal_apply_operation(self, obj, sizeof(int), SIMD_IntArray, func_or));
 }
 
 /* Public: xor values contained in the data array with those contained in
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_xor(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_xor));
+	return(internal_apply_operation(self, obj, sizeof(int), SIMD_IntArray, func_xor));
+}
+
+/* Public: Compare values contained in the data array with those contained in
+ * another IntArray object, return a new IntArray with each element being -1
+ * if the data array's value is greater, and 0 otherwise. */
+static VALUE method_gt(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(int), SIMD_IntArray, func_gt));
+}
+
+/* Public: Compare values contained in the data array with those contained in
+ * another IntArray object, return a new IntArray with each element being -1 if
+ * the data array's value is less, and 0 otherwise. */
+static VALUE method_lt(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(int), SIMD_IntArray, func_lt));
 }
 
 /* Public: Subtract values contained in another FloatArray object from those
  * contained in the current data array object, returning a new FloatArray. */
 static VALUE method_subtract(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_subtract));
+	return(internal_apply_operation(self, obj, sizeof(int), SIMD_IntArray, func_subtract));
 }
 
 /* Public: Return a Ruby Array containing the doubles within the data array. */
 static VALUE method_to_a(VALUE self)
 {
-	unsigned long i;
+	unsigned long long int i;
 	vector_t *vector;
 	i4v_t *data;
 	VALUE rb_array = rb_ary_new();
@@ -122,64 +137,6 @@ static VALUE method_to_a(VALUE self)
 	return(rb_array);
 }
 
-/* Internal: Given another FloatArray object, perform an action specified via a
- * function pointer against both. */
-static VALUE internal_apply_operation(VALUE self, VALUE obj, b_operation func)
-{
-	unsigned long size, i;
-	int align;
-	vector_t *v1, *v2, *rv;
-	i4v_t *d1, *d2, *r;
-	VALUE result_obj = allocate(SIMD_IntArray);
-
-	Data_Get_Struct(self, vector_t, v1);
-	Data_Get_Struct(obj, vector_t, v2);
-	Data_Get_Struct(result_obj, vector_t, rv);
-	rv->data = internal_allocate_vector_array(v1->len, sizeof(i4v_t));
-
-	align = internal_align_vectors(v1->len, v2->len, 4);
-
-	/* Ensure that size will be the result of ceil(len / 4.0) */
-	size = (v1->len + 3) / 4;
-
-	d1 = (i4v_t *)v1->data;
-	d2 = (i4v_t *)v2->data;
-	r  = (i4v_t *)rv->data;
-
-	rv->len = v1->len;
-
-	switch(align)
-	{
-		case 0: /* Same size arrays */
-			for(i = 0; i < size; i++)
-			{
-				func(&d1[i].v, &d2[i].v, &r[i].v);
-			}
-			break;
-		case 1: /* Operand is exactly 4 long (size of 1 sse register) */
-			for(i = 0; i < size; i++)
-			{
-				func(&d1[i].v, &d2[0].v, &r[i].v);
-			}
-			break;
-		default: /* Self is a multiple of operand's length long */
-			for(i = 0; i < size; i++)
-			{
-				func(&d1[i].v, &d2[i % v2->len].v, &r[i].v);
-			}
-	}
-
-	if(rv->len != rv->len + (rv->len % 4))
-	{
-		for(i = 3; i > rv->len + (rv->len % 4); i--)
-		{
-			r[size].f[i] = 1;
-		}
-	}
-
-	return(result_obj);
-}
-
 /* Function: Multiply two vectors. */
 static void func_multiply(void *v1, void *v2, void *r)
 {
@@ -221,3 +178,15 @@ static void func_xor(void *v1, void *v2, void *r)
 {
 	*(i4v *)r = *(i4v *)v1 ^ *(i4v *)v2;
 }
+
+/* Function: Compare vectors, return -1 if v1 is greater than v2, 0 otherwise */
+static void func_gt(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = (*(i4v *)v1 > *(i4v *)v2);
+}
+
+/* Function: Compare vectors, return -1 if v1 is less than v2, 0 otherwise */
+static void func_lt(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = (*(i4v *)v1 < *(i4v *)v2);
+}

data/ext/simd/simd_intarray.h

@@ -1,18 +1,20 @@
 #include "ruby.h"
 #include "simd_common.h"
 
+extern VALUE SIMD_IntArray;
+
 static VALUE method_initialize(VALUE self, VALUE rb_array);
 static VALUE method_multiply(VALUE self, VALUE obj);
 static VALUE method_divide(VALUE self, VALUE obj);
 static VALUE method_add(VALUE self, VALUE obj);
+static VALUE method_subtract(VALUE self, VALUE obj);
 static VALUE method_and(VALUE self, VALUE obj);
 static VALUE method_or(VALUE self, VALUE obj);
 static VALUE method_xor(VALUE self, VALUE obj);
-static VALUE method_subtract(VALUE self, VALUE obj);
+static VALUE method_gt(VALUE self, VALUE obj);
+static VALUE method_lt(VALUE self, VALUE obj);
 static VALUE method_to_a(VALUE self);
 
-static VALUE internal_apply_operation(VALUE self, VALUE obj, b_operation func);
-
 static void func_multiply(void *v1, void *v2, void *r);
 static void func_divide(void *v1, void *v2, void *r);
 static void func_add(void *v1, void *v2, void *r);
@@ -20,3 +22,5 @@ static void func_subtract(void *v1, void *v2, void *r);
 static void func_and(void *v1, void *v2, void *r);
 static void func_or(void *v1, void *v2, void *r);
 static void func_xor(void *v1, void *v2, void *r);
+static void func_gt(void *v1, void *v2, void *r);
+static void func_lt(void *v1, void *v2, void *r);

data/ext/simd/simd_longarray.c

@@ -15,6 +15,10 @@ void Init_SIMD_LongArray(VALUE parent)
 	rb_define_method(SIMD_LongArray, "&", method_and, 1);
 	rb_define_method(SIMD_LongArray, "|", method_or, 1);
 	rb_define_method(SIMD_LongArray, "^", method_xor, 1);
+	rb_define_method(SIMD_LongArray, "gt", method_gt, 1);
+	rb_define_method(SIMD_LongArray, "lt", method_lt, 1);
+	rb_define_method(SIMD_LongArray, ">", method_gt, 1);
+	rb_define_method(SIMD_LongArray, "<", method_lt, 1);
 	rb_define_method(SIMD_LongArray, "length", method_length, 0);
 	rb_define_method(SIMD_LongArray, "to_a", method_to_a, 0);
 }
@@ -25,7 +29,7 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
 {
 	vector_t *vector;
 	l2v_t *data;
-	unsigned long n,m,i;
+	unsigned long long int n,i;
 
 	Check_Type(rb_array, T_ARRAY);
 	Data_Get_Struct(self, vector_t, vector);
@@ -37,7 +41,7 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
 		rb_raise(rb_eArgError, "Vectors must be at least 2 long");
 	}
 
-	vector->data = internal_allocate_vector_array(vector->len, sizeof(l2v_t));
+	vector->data = internal_allocate_vector_array(vector->len);
 
 	data = (l2v_t *)vector->data;
 	for(i = 0; i < vector->len; i++)
@@ -45,12 +49,7 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
 		data[i/2].f[i%2] = NUM2LONG(rb_ary_entry(rb_array, i));
 	}
 
-	/* If the array is an odd number of elements, set the final element to 1 */
-	m = n + (n % 2);
-	for(i = n % 2; i > 0; i--)
-	{
-		data[m/2].f[i] = 1;
-	}
+	internal_sanitize_unaligned_final_vector(vector, sizeof(long long int));
 
 	return(self);
 }
@@ -59,55 +58,71 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_multiply(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_multiply));
+	return(internal_apply_operation(self, obj, sizeof(long long int), SIMD_LongArray, func_multiply));
 }
 
 /* Public: Divide values contained in the data array by those contained in
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_divide(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_divide));
+	return(internal_apply_operation(self, obj, sizeof(long long int), SIMD_LongArray, func_divide));
 }
 
 /* Public: add values contained in the data array with those contained in
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_add(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_add));
+	return(internal_apply_operation(self, obj, sizeof(long long int), SIMD_LongArray, func_add));
 }
 
 /* Public: and values contained in the data array with those contained in
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_and(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_and));
+	return(internal_apply_operation(self, obj, sizeof(long long int), SIMD_LongArray, func_and));
 }
 
 /* Public: or values contained in the data array with those contained in
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_or(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_or));
+	return(internal_apply_operation(self, obj, sizeof(long long int), SIMD_LongArray, func_or));
 }
 
 /* Public: xor values contained in the data array with those contained in
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_xor(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_xor));
+	return(internal_apply_operation(self, obj, sizeof(long long int), SIMD_LongArray, func_xor));
+}
+
+/* Public: Compare values contained in the data array with those contained in
+ * another Longrray object, return a new LongArray with each element being -1
+ * if the data array's value is greater, and 0 otherwise. */
+static VALUE method_gt(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(long long int), SIMD_LongArray, func_gt));
+}
+
+/* Public: Compare values contained in the data array with those contained in
+ * another LongArray object, return a new LongArray with each element being -1 if
+ * the data array's value is less, and 0 otherwise. */
+static VALUE method_lt(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(long long int), SIMD_LongArray, func_lt));
 }
 
 /* Public: Subtract values contained in another FloatArray object from those
  * contained in the current data array object, returning a new FloatArray. */
 static VALUE method_subtract(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_subtract));
+	return(internal_apply_operation(self, obj, sizeof(long long int), SIMD_LongArray, func_subtract));
 }
 
 /* Public: Return a Ruby Array containing the doubles within the data array. */
 static VALUE method_to_a(VALUE self)
 {
-	unsigned long i;
+	unsigned long long int i;
 	vector_t *vector;
 	l2v_t *data;
 	VALUE rb_array = rb_ary_new();
@@ -122,61 +137,6 @@ static VALUE method_to_a(VALUE self)
 	return(rb_array);
 }
 
-/* Internal: Given another FloatArray object, perform an action specified via a
- * function pointer against both. */
-static VALUE internal_apply_operation(VALUE self, VALUE obj, b_operation func)
-{
-	unsigned long size, i;
-	int align;
-	vector_t *v1, *v2, *rv;
-	l2v_t *d1, *d2, *r;
-	VALUE result_obj = allocate(SIMD_LongArray);
-
-	Data_Get_Struct(self, vector_t, v1);
-	Data_Get_Struct(obj, vector_t, v2);
-	Data_Get_Struct(result_obj, vector_t, rv);
-	rv->data = internal_allocate_vector_array(v1->len, sizeof(l2v_t));
-
-	align = internal_align_vectors(v1->len, v2->len, 2);
-
-	/* Ensure that size will be the result of ceil(len / 4.0) */
-	size = (v1->len + 1) / 2;
-
-	d1 = (l2v_t *)v1->data;
-	d2 = (l2v_t *)v2->data;
-	r  = (l2v_t *)rv->data;
-
-	rv->len = v1->len;
-
-	switch(align)
-	{
-		case 0: /* Same size arrays */
-			for(i = 0; i < size; i++)
-			{
-				func(&d1[i].v, &d2[i].v, &r[i].v);
-			}
-			break;
-		case 1: /* Operand is exactly 4 long (size of 1 sse register) */
-			for(i = 0; i < size; i++)
-			{
-				func(&d1[i].v, &d2[0].v, &r[i].v);
-			}
-			break;
-		default: /* Self is a multiple of operand's length long */
-			for(i = 0; i < size; i++)
-			{
-				func(&d1[i].v, &d2[i % v2->len].v, &r[i].v);
-			}
-	}
-
-	if(rv->len != rv->len + (rv->len % 2))
-	{
-		r[size].f[1] = 1;
-	}
-
-	return(result_obj);
-}
-
 /* Function: Multiply two vectors. */
 static void func_multiply(void *v1, void *v2, void *r)
 {
@@ -218,3 +178,15 @@ static void func_xor(void *v1, void *v2, void *r)
 {
 	*(l2v *)r = *(l2v *)v1 ^ *(l2v *)v2;
 }
+
+/* Function: Compare vectors, return -1 if v1 is greater than v2, 0 otherwise */
+static void func_gt(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = (*(l2v *)v1 > *(l2v *)v2);
+}
+
+/* Function: Compare vectors, return -1 if v1 is less than v2, 0 otherwise */
+static void func_lt(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = (*(l2v *)v1 < *(l2v *)v2);
+}

data/ext/simd/simd_longarray.h

@@ -1,18 +1,20 @@
 #include "ruby.h"
 #include "simd_common.h"
 
+extern VALUE SIMD_LongArray;
+
 static VALUE method_initialize(VALUE self, VALUE rb_array);
 static VALUE method_multiply(VALUE self, VALUE obj);
 static VALUE method_divide(VALUE self, VALUE obj);
 static VALUE method_add(VALUE self, VALUE obj);
+static VALUE method_subtract(VALUE self, VALUE obj);
 static VALUE method_and(VALUE self, VALUE obj);
 static VALUE method_or(VALUE self, VALUE obj);
 static VALUE method_xor(VALUE self, VALUE obj);
-static VALUE method_subtract(VALUE self, VALUE obj);
+static VALUE method_gt(VALUE self, VALUE obj);
+static VALUE method_lt(VALUE self, VALUE obj);
 static VALUE method_to_a(VALUE self);
 
-static VALUE internal_apply_operation(VALUE self, VALUE obj, b_operation func);
-
 static void func_multiply(void *v1, void *v2, void *r);
 static void func_divide(void *v1, void *v2, void *r);
 static void func_add(void *v1, void *v2, void *r);
@@ -20,3 +22,5 @@ static void func_subtract(void *v1, void *v2, void *r);
 static void func_and(void *v1, void *v2, void *r);
 static void func_or(void *v1, void *v2, void *r);
 static void func_xor(void *v1, void *v2, void *r);
+static void func_gt(void *v1, void *v2, void *r);
+static void func_lt(void *v1, void *v2, void *r);

data/ext/simd/simd_smallfloatarray.c

@@ -1,4 +1,5 @@
 #include "simd_smallfloatarray.h"
+#include "simd_intarray.h"
 
 VALUE SIMD_SmallFloatArray = Qnil;
 
@@ -12,6 +13,13 @@ void Init_SIMD_SmallFloatArray(VALUE parent)
 	rb_define_method(SIMD_SmallFloatArray, "/", method_divide, 1);
 	rb_define_method(SIMD_SmallFloatArray, "+", method_add, 1);
 	rb_define_method(SIMD_SmallFloatArray, "-", method_subtract, 1);
+	rb_define_method(SIMD_SmallFloatArray, "&", method_and, 1);
+	rb_define_method(SIMD_SmallFloatArray, "|", method_or, 1);
+	rb_define_method(SIMD_SmallFloatArray, "^", method_xor, 1);
+	rb_define_method(SIMD_SmallFloatArray, "gt", method_gt, 1);
+	rb_define_method(SIMD_SmallFloatArray, "lt", method_lt, 1);
+	rb_define_method(SIMD_SmallFloatArray, ">", method_gt, 1);
+	rb_define_method(SIMD_SmallFloatArray, "<", method_lt, 1);
 	rb_define_method(SIMD_SmallFloatArray, "length", method_length, 0);
 	rb_define_method(SIMD_SmallFloatArray, "to_a", method_to_a, 0);
 }
@@ -22,7 +30,7 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
 {
 	vector_t *vector;
 	f4v_t *data;
-	unsigned long n,m,i;
+	unsigned long long int n,i;
 
 	Check_Type(rb_array, T_ARRAY);
 	Data_Get_Struct(self, vector_t, vector);
@@ -34,7 +42,7 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
 		rb_raise(rb_eArgError, "Vectors must be at least 4 long");
 	}
 
-	vector->data = internal_allocate_vector_array(vector->len, sizeof(f4v_t));
+	vector->data = internal_allocate_vector_array(vector->len);
 
 	data = (f4v_t *)vector->data;
 	for(i = 0; i < vector->len; i++)
@@ -42,12 +50,7 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
 		data[i/4].f[i%4] = (float)NUM2DBL(rb_ary_entry(rb_array, i));
 	}
 
-	/* If the array is an odd number of elements, set the final element to 1 */
-	m = n + (n % 4);
-	for(i = n % 4; i > 0; i--)
-	{
-		data[m/4].f[i] = 1.0;
-	}
+	internal_sanitize_unaligned_final_vector(vector, sizeof(float));
 
 	return(self);
 }
@@ -56,34 +59,71 @@ static VALUE method_initialize(VALUE self, VALUE rb_array)
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_multiply(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_multiply));
+	return(internal_apply_operation(self, obj, sizeof(float), SIMD_SmallFloatArray, func_multiply));
 }
 
 /* Public: Divide values contained in the data array by those contained in
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_divide(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_divide));
+	return(internal_apply_operation(self, obj, sizeof(float), SIMD_SmallFloatArray, func_divide));
 }
 
 /* Public: add values contained in the data array with those contained in
  * another FloatArray object, returning a new FloatArray. */
 static VALUE method_add(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_add));
+	return(internal_apply_operation(self, obj, sizeof(float), SIMD_SmallFloatArray, func_add));
 }
 
 /* Public: Subtract values contained in another FloatArray object from those
  * contained in the current data array object, returning a new FloatArray. */
 static VALUE method_subtract(VALUE self, VALUE obj)
 {
-	return(internal_apply_operation(self, obj, func_subtract));
+	return(internal_apply_operation(self, obj, sizeof(float), SIMD_SmallFloatArray, func_subtract));
+}
+
+/* Public: and values contained in the data array with those contained in
+ * another FloatArray object, returning a new FloatArray. */
+static VALUE method_and(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(float), SIMD_SmallFloatArray, func_and));
+}
+
+/* Public: or values contained in the data array with those contained in
+ * another FloatArray object, returning a new FloatArray. */
+static VALUE method_or(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(float), SIMD_SmallFloatArray, func_or));
+}
+
+/* Public: xor values contained in the data array with those contained in
+ * another FloatArray object, returning a new FloatArray. */
+static VALUE method_xor(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(float), SIMD_SmallFloatArray, func_xor));
+}
+
+/* Public: Compare values contained in the data array with those contained in
+ * another SmallFloatArray object, return a new IntArray with each element being
+ * -1 if the data array's value is greater, and 0 otherwise. */
+static VALUE method_gt(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(float), SIMD_IntArray, func_gt));
+}
+
+/* Public: Compare values contained in the data array with those contained in
+ * another SmallFloatArray object, return a new IntArray with each element being
+ * -1 if the data array's value is less, and 0 otherwise. */
+static VALUE method_lt(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(float), SIMD_IntArray, func_lt));
 }
 
 /* Public: Return a Ruby Array containing the doubles within the data array. */
 static VALUE method_to_a(VALUE self)
 {
-	unsigned long i;
+	unsigned long long int i;
 	vector_t *vector;
 	f4v_t *data;
 	VALUE rb_array = rb_ary_new();
@@ -98,64 +138,6 @@ static VALUE method_to_a(VALUE self)
 	return(rb_array);
 }
 
-/* Internal: Given another FloatArray object, perform an action specified via a
- * function pointer against both. */
-static VALUE internal_apply_operation(VALUE self, VALUE obj, b_operation func)
-{
-	unsigned long size, i;
-	int align;
-	vector_t *v1, *v2, *rv;
-	f4v_t *d1, *d2, *r;
-	VALUE result_obj = allocate(SIMD_SmallFloatArray);
-
-	Data_Get_Struct(self, vector_t, v1);
-	Data_Get_Struct(obj, vector_t, v2);
-	Data_Get_Struct(result_obj, vector_t, rv);
-	rv->data = internal_allocate_vector_array(v1->len, sizeof(f4v_t));
-
-	align = internal_align_vectors(v1->len, v2->len, 4);
-
-	/* Ensure that size will be the result of ceil(len / 4.0) */
-	size = (v1->len + 3) / 4;
-
-	d1 = (f4v_t *)v1->data;
-	d2 = (f4v_t *)v2->data;
-	r  = (f4v_t *)rv->data;
-
-	rv->len = v1->len;
-
-	switch(align)
-	{
-		case 0: /* Same size arrays */
-			for(i = 0; i < size; i++)
-			{
-				func(&d1[i].v, &d2[i].v, &r[i].v);
-			}
-			break;
-		case 1: /* Operand is exactly 4 long (size of 1 sse register) */
-			for(i = 0; i < size; i++)
-			{
-				func(&d1[i].v, &d2[0].v, &r[i].v);
-			}
-			break;
-		default: /* Self is a multiple of operand's length long */
-			for(i = 0; i < size; i++)
-			{
-				func(&d1[i].v, &d2[i % v2->len].v, &r[i].v);
-			}
-	}
-
-	if(rv->len != rv->len + (rv->len % 4))
-	{
-		for(i = 3; i > rv->len + (rv->len % 4); i--)
-		{
-			r[size].f[i] = 1;
-		}
-	}
-
-	return(result_obj);
-}
-
 /* Function: Multiply two vectors. */
 static void func_multiply(void *v1, void *v2, void *r)
 {
@@ -179,3 +161,33 @@ static void func_subtract(void *v1, void *v2, void *r)
 {
 	*(f4v *)r = *(f4v *)v1 - *(f4v *)v2;
 }
+
+/* Function: Perform a binary AND on two vectors. */
+static void func_and(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = *(i4v *)v1 & *(i4v *)v2;
+}
+
+/* Function: Perform a binary OR on two vectors. */
+static void func_or(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = *(i4v *)v1 | *(i4v *)v2;
+}
+
+/* Function: Perform a binary XOR on two vectors. */
+static void func_xor(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = *(i4v *)v1 ^ *(i4v *)v2;
+}
+
+/* Function: Compare vectors, return -1 if v1 is greater than v2, 0 otherwise */
+static void func_gt(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = (*(f4v *)v1 > *(f4v *)v2);
+}
+
+/* Function: Compare vectors, return -1 if v1 is less than v2, 0 otherwise */
+static void func_lt(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = (*(f4v *)v1 < *(f4v *)v2);
+}

data/ext/simd/simd_smallfloatarray.h

@@ -6,11 +6,19 @@ static VALUE method_multiply(VALUE self, VALUE obj);
 static VALUE method_divide(VALUE self, VALUE obj);
 static VALUE method_add(VALUE self, VALUE obj);
 static VALUE method_subtract(VALUE self, VALUE obj);
+static VALUE method_and(VALUE self, VALUE obj);
+static VALUE method_or(VALUE self, VALUE obj);
+static VALUE method_xor(VALUE self, VALUE obj);
+static VALUE method_gt(VALUE self, VALUE obj);
+static VALUE method_lt(VALUE self, VALUE obj);
 static VALUE method_to_a(VALUE self);
 
-static VALUE internal_apply_operation(VALUE self, VALUE obj, b_operation func);
-
 static void func_multiply(void *v1, void *v2, void *r);
 static void func_divide(void *v1, void *v2, void *r);
 static void func_add(void *v1, void *v2, void *r);
 static void func_subtract(void *v1, void *v2, void *r);
+static void func_and(void *v1, void *v2, void *r);
+static void func_or(void *v1, void *v2, void *r);
+static void func_xor(void *v1, void *v2, void *r);
+static void func_gt(void *v1, void *v2, void *r);
+static void func_lt(void *v1, void *v2, void *r);

data/ext/simd/simd_types.h

@@ -40,17 +40,17 @@ typedef union i4v_t
 /*
  * Types for LongArray
  */
-typedef long int __attribute__ ((vector_size (16))) l2v;
+typedef long long int __attribute__ ((vector_size (16))) l2v;
 typedef union l2v_t
 {
 	l2v v;
-	long int f[2];
+	long long int f[2];
 } l2v_t;
 
 typedef struct vector_t
 {
 	void *data;
-	unsigned long len;
+	unsigned long long int len;
 } vector_t;
 
 typedef void (b_operation)(void *v1, void *v2, void *r);

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: simd
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Tina Wuest
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-12-12 00:00:00.000000000 Z
+date: 2022-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.2'
 description: Access to SIMD (Single Instruction Multiple Data) instructions in Ruby
 email: tina@wuest.me
 executables: []
@@ -48,7 +48,7 @@ files:
 homepage: https://gitlab.com/wuest/simd-ruby
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -63,9 +63,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.4
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: SIMD instructions in ruby
 test_files: []