simd 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 459e978d4372f815dc06ad340ce39283369909e7
-  data.tar.gz: 7621df63dd917b69b6222f4f5b9fc72a430c8a21
+SHA256:
+  metadata.gz: 3d53f8f1be0f91871b2d9c24f8391a670d95773055e63f85f9c8f68773afcfd1
+  data.tar.gz: 336eb325b0a915398143b74eff672c44caaac641142893f54e50fbdd4ea63713
 SHA512:
-  metadata.gz: ea9d3e2b0366a7b377cea2c7412420b44170613b9704069883e7226982b643c9fb9aaefa16e39f842fce4b446725d85719cea1f16a19a951141d23ac5a2754e4
-  data.tar.gz: 99554543164a275329ec030fd482f175e96feb7d74985aee3b4b78c0991d1f55a903ef88c3295522f017016c8cf2edca8a21597ff1c8b6566fab339915b031fc
+  metadata.gz: ff39834f43fda25c6666fb10283515d04c80560c818eb75e32d01de8858558cca27205d177abf0e7488c1f195b03149b0dec1a24536b233214eb176053a7f6b2
+  data.tar.gz: 8caebb2c57d4c2274f485a66af676590ad589837bbea4de8bb3a2fb0613c9c8c3a40069d1a2871368961a4cd1116236ba5f91be88d38539b7d5bdd190b89809b

data/ext/simd/simd_common.c

@@ -131,6 +131,34 @@ VALUE internal_apply_operation(VALUE self, VALUE obj, size_t size, VALUE klass,
 }
 #pragma GCC diagnostic pop
 
+/* Internal: Perform an unary operation across one vector.
+ *
+ * As above, disable warnings regarding this for the current function. */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpointer-arith"
+VALUE internal_apply_unary_operation(VALUE self, size_t size, VALUE klass, u_operation func)
+{
+	unsigned long long int length, i;
+	vector_t *v1, *rv;
+	VALUE result_obj = allocate(klass);
+
+	Data_Get_Struct(self, vector_t, v1);
+	Data_Get_Struct(result_obj, vector_t, rv);
+	rv->data = internal_allocate_vector_array(v1->len);
+
+	length = ((v1->len + (XMM_BYTES / size - 1)) / (XMM_BYTES / size));
+	rv->len = v1->len;
+
+	for(i = 0; i < length; i++)
+	{
+		func((v1->data + XMM_BYTES * i), (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.

data/ext/simd/simd_common.h

@@ -11,4 +11,5 @@ VALUE method_length(VALUE self);
 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);
+VALUE internal_apply_unary_operation(VALUE self, size_t size, VALUE klass, u_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,9 +13,20 @@ 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, "sqrt", method_sqrt, 0);
 	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, "gte", method_gte, 1);
+	rb_define_method(SIMD_FloatArray, "lte", method_lte, 1);
+	rb_define_method(SIMD_FloatArray, ">", method_gt, 1);
+	rb_define_method(SIMD_FloatArray, "<", method_lt, 1);
+	rb_define_method(SIMD_FloatArray, ">=", method_gte, 1);
+	rb_define_method(SIMD_FloatArray, "<=", method_lte, 1);
+	rb_define_method(SIMD_FloatArray, "eq", method_eq, 1);
+	rb_define_method(SIMD_FloatArray, "neq", method_neq, 1);
 	rb_define_method(SIMD_FloatArray, "length", method_length, 0);
 	rb_define_method(SIMD_FloatArray, "to_a", method_to_a, 0);
 }
@@ -78,6 +90,13 @@ static VALUE method_subtract(VALUE self, VALUE obj)
 	return(internal_apply_operation(self, obj, sizeof(double), SIMD_FloatArray, func_subtract));
 }
 
+/* Public: Compute the square root of values contained in a FloatArray object,
+ * returning a new FloatArray. */
+static VALUE method_sqrt(VALUE self)
+{
+	return(internal_apply_unary_operation(self, sizeof(double), SIMD_FloatArray, func_sqrt));
+}
+
 /* 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)
@@ -99,6 +118,54 @@ 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: 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 or equal, and 0 otherwise. */
+static VALUE method_gte(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(double), SIMD_LongArray, func_gte));
+}
+
+/* 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 or equal, and 0 otherwise. */
+static VALUE method_lte(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(double), SIMD_LongArray, func_lte));
+}
+
+/* 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 equal, and 0 otherwise. */
+static VALUE method_eq(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(double), SIMD_LongArray, func_eq));
+}
+
+/* Public: Compare values contained in the data array with those contained in
+ * another FloatArray object, return a new LongArray with each element being
+ * 0 if the data array's value is equal, and -1 otherwise. */
+static VALUE method_neq(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(double), SIMD_LongArray, func_neq));
+}
+
 /* Public: Return a Ruby Array containing the doubles within the data array. */
 static VALUE method_to_a(VALUE self)
 {
@@ -141,6 +208,13 @@ static void func_subtract(void *v1, void *v2, void *r)
 	*(d2v *)r = *(d2v *)v1 - *(d2v *)v2;
 }
 
+/* Function: Compute square root for a vector. */
+static void func_sqrt(void *v1, void *r)
+{
+	(*(d2v *)r)[0] = sqrt((*(d2v *)v1)[0]);
+	(*(d2v *)r)[1] = sqrt((*(d2v *)v1)[1]);
+}
+
 /* Function: Perform a binary AND on two vectors. */
 static void func_and(void *v1, void *v2, void *r)
 {
@@ -158,3 +232,40 @@ 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);
+}
+
+/* Function: Compare vectors, return -1 if v1 is greater than v2, 0 otherwise */
+static void func_gte(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = (*(d2v *)v1 >= *(d2v *)v2);
+}
+
+/* Function: Compare vectors, return -1 if v1 is less than v2, 0 otherwise */
+static void func_lte(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = (*(d2v *)v1 <= *(d2v *)v2);
+}
+
+/* Function: Compare vectors, return -1 if v1 is equal to v2, 0 otherwise */
+static void func_eq(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = (*(d2v *)v1 == *(d2v *)v2);
+}
+
+
+/* Function: Compare vectors, return 0 if v1 is equal to v2, -1 otherwise */
+static void func_neq(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = (*(d2v *)v1 != *(d2v *)v2);
+}

data/ext/simd/simd_floatarray.h

@@ -1,20 +1,36 @@
 #include "ruby.h"
 #include "simd_common.h"
 
+extern VALUE SIMD_FloatArray;
+
 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_sqrt(VALUE self);
 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_gte(VALUE self, VALUE obj);
+static VALUE method_lte(VALUE self, VALUE obj);
+static VALUE method_eq(VALUE self, VALUE obj);
+static VALUE method_neq(VALUE self, VALUE obj);
 static VALUE method_to_a(VALUE self);
 
 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_sqrt(void *v1, 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);
+static void func_gte(void *v1, void *v2, void *r);
+static void func_lte(void *v1, void *v2, void *r);
+static void func_eq(void *v1, void *v2, void *r);
+static void func_neq(void *v1, void *v2, void *r);

data/ext/simd/simd_intarray.c

@@ -1,4 +1,5 @@
 #include "simd_intarray.h"
+#include "simd_smallfloatarray.h"
 
 VALUE SIMD_IntArray = Qnil;
 
@@ -12,9 +13,20 @@ void Init_SIMD_IntArray(VALUE parent)
 	rb_define_method(SIMD_IntArray, "/", method_divide, 1);
 	rb_define_method(SIMD_IntArray, "+", method_add, 1);
 	rb_define_method(SIMD_IntArray, "-", method_subtract, 1);
+	rb_define_method(SIMD_IntArray, "sqrt", method_sqrt, 0);
 	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, "gte", method_gte, 1);
+	rb_define_method(SIMD_IntArray, "lte", method_lte, 1);
+	rb_define_method(SIMD_IntArray, "eq", method_eq, 1);
+	rb_define_method(SIMD_IntArray, "neq", method_neq, 1);
+	rb_define_method(SIMD_IntArray, ">", method_gt, 1);
+	rb_define_method(SIMD_IntArray, "<", method_lt, 1);
+	rb_define_method(SIMD_IntArray, ">=", method_gte, 1);
+	rb_define_method(SIMD_IntArray, "<=", method_lte, 1);
 	rb_define_method(SIMD_IntArray, "length", method_length, 0);
 	rb_define_method(SIMD_IntArray, "to_a", method_to_a, 0);
 }
@@ -64,6 +76,20 @@ static VALUE method_divide(VALUE self, VALUE obj)
 	return(internal_apply_operation(self, obj, sizeof(int), SIMD_IntArray, func_divide));
 }
 
+/* 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, sizeof(int), SIMD_IntArray, func_subtract));
+}
+
+/* Public: Compute the square root of values contained in a IntArray object,
+ * returning a new SmallFloatArray. */
+static VALUE method_sqrt(VALUE self)
+{
+	return(internal_apply_unary_operation(self, sizeof(int), SIMD_SmallFloatArray, func_sqrt));
+}
+
 /* 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)
@@ -92,11 +118,52 @@ static VALUE method_xor(VALUE self, VALUE obj)
 	return(internal_apply_operation(self, obj, sizeof(int), SIMD_IntArray, func_xor));
 }
 
-/* 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)
+/* 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_subtract));
+	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: 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 or equal, and 0 otherwise. */
+static VALUE method_gte(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(int), SIMD_IntArray, func_gte));
+}
+
+/* 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 or equal, and 0 otherwise. */
+static VALUE method_lte(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(int), SIMD_IntArray, func_lte));
+}
+
+/* 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 equal, and 0 otherwise. */
+static VALUE method_eq(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(int), SIMD_IntArray, func_eq));
+}
+
+/* Public: Compare values contained in the data array with those contained in
+ * another IntArray object, return a new IntArray with each element being 0 if
+ * the data array's value is equal, and -1 otherwise. */
+static VALUE method_neq(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(int), SIMD_IntArray, func_neq));
 }
 
 /* Public: Return a Ruby Array containing the doubles within the data array. */
@@ -141,6 +208,15 @@ static void func_subtract(void *v1, void *v2, void *r)
 	*(i4v *)r = *(i4v *)v1 - *(i4v *)v2;
 }
 
+/* Function: Compute square root for a vector. */
+static void func_sqrt(void *v1, void *r)
+{
+	(*(f4v *)r)[0] = sqrt((*(i4v *)v1)[0]);
+	(*(f4v *)r)[1] = sqrt((*(i4v *)v1)[1]);
+	(*(f4v *)r)[2] = sqrt((*(i4v *)v1)[2]);
+	(*(f4v *)r)[3] = sqrt((*(i4v *)v1)[3]);
+}
+
 /* Function: Perform a binary AND on two vectors. */
 static void func_and(void *v1, void *v2, void *r)
 {
@@ -158,3 +234,39 @@ 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);
+}
+
+/* Function: Compare vectors, return -1 if v1 is greater than v2, 0 otherwise */
+static void func_gte(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_lte(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = (*(i4v *)v1 <= *(i4v *)v2);
+}
+
+/* Function: Compare vectors, return -1 if v1 is equal to v2, 0 otherwise */
+static void func_eq(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = (*(i4v *)v1 == *(i4v *)v2);
+}
+
+/* Function: Compare vectors, return 0 if v1 is equal to v2, -1 otherwise */
+static void func_neq(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = (*(i4v *)v1 != *(i4v *)v2);
+}

data/ext/simd/simd_intarray.h

@@ -1,20 +1,36 @@
 #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_sqrt(VALUE self);
 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_gte(VALUE self, VALUE obj);
+static VALUE method_lte(VALUE self, VALUE obj);
+static VALUE method_eq(VALUE self, VALUE obj);
+static VALUE method_neq(VALUE self, VALUE obj);
 static VALUE method_to_a(VALUE self);
 
 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_sqrt(void *v1, 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);
+static void func_gte(void *v1, void *v2, void *r);
+static void func_lte(void *v1, void *v2, void *r);
+static void func_eq(void *v1, void *v2, void *r);
+static void func_neq(void *v1, void *v2, void *r);

data/ext/simd/simd_longarray.c

@@ -1,4 +1,5 @@
 #include "simd_longarray.h"
+#include "simd_floatarray.h"
 
 VALUE SIMD_LongArray = Qnil;
 
@@ -12,9 +13,20 @@ void Init_SIMD_LongArray(VALUE parent)
 	rb_define_method(SIMD_LongArray, "/", method_divide, 1);
 	rb_define_method(SIMD_LongArray, "+", method_add, 1);
 	rb_define_method(SIMD_LongArray, "-", method_subtract, 1);
+	rb_define_method(SIMD_LongArray, "sqrt", method_sqrt, 0);
 	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, "gte", method_gte, 1);
+	rb_define_method(SIMD_LongArray, "lte", method_lte, 1);
+	rb_define_method(SIMD_LongArray, ">", method_gt, 1);
+	rb_define_method(SIMD_LongArray, "<", method_lt, 1);
+	rb_define_method(SIMD_LongArray, ">=", method_gte, 1);
+	rb_define_method(SIMD_LongArray, "<=", method_lte, 1);
+	rb_define_method(SIMD_LongArray, "eq", method_eq, 1);
+	rb_define_method(SIMD_LongArray, "neq", method_neq, 1);
 	rb_define_method(SIMD_LongArray, "length", method_length, 0);
 	rb_define_method(SIMD_LongArray, "to_a", method_to_a, 0);
 }
@@ -71,6 +83,20 @@ static VALUE method_add(VALUE self, VALUE obj)
 	return(internal_apply_operation(self, obj, sizeof(long long int), SIMD_LongArray, 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, sizeof(long long int), SIMD_LongArray, func_subtract));
+}
+
+/* Public: Compute the square root of values contained in a LongArray object,
+ * returning a new FloatArray. */
+static VALUE method_sqrt(VALUE self)
+{
+	return(internal_apply_unary_operation(self, sizeof(long long int), SIMD_FloatArray, func_sqrt));
+}
+
 /* 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)
@@ -92,11 +118,52 @@ static VALUE method_xor(VALUE self, VALUE obj)
 	return(internal_apply_operation(self, obj, sizeof(long long int), SIMD_LongArray, func_xor));
 }
 
-/* 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)
+/* 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 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_subtract));
+	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: 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 greater or equal, and 0 otherwise. */
+static VALUE method_gte(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(long long int), SIMD_LongArray, func_gte));
+}
+
+/* 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 or equal, and 0 otherwise. */
+static VALUE method_lte(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(long long int), SIMD_LongArray, func_lte));
+}
+
+/* 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 equal, and 0 otherwise. */
+static VALUE method_eq(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(long long int), SIMD_LongArray, func_eq));
+}
+
+/* Public: Compare values contained in the data array with those contained in
+ * another LongArray object, return a new LongArray with each element being 0 if
+ * the data array's value is equal, and -1 otherwise. */
+static VALUE method_neq(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(long long int), SIMD_LongArray, func_neq));
 }
 
 /* Public: Return a Ruby Array containing the doubles within the data array. */
@@ -141,6 +208,13 @@ static void func_subtract(void *v1, void *v2, void *r)
 	*(l2v *)r = *(l2v *)v1 - *(l2v *)v2;
 }
 
+/* Function: Compute square root for a vector. */
+static void func_sqrt(void *v1, void *r)
+{
+	(*(d2v *)r)[0] = sqrt((*(l2v *)v1)[0]);
+	(*(d2v *)r)[1] = sqrt((*(l2v *)v1)[1]);
+}
+
 /* Function: Perform a binary AND on two vectors. */
 static void func_and(void *v1, void *v2, void *r)
 {
@@ -158,3 +232,39 @@ 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);
+}
+
+/* Function: Compare vectors, return -1 if v1 is greater than v2, 0 otherwise */
+static void func_gte(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_lte(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = (*(l2v *)v1 <= *(l2v *)v2);
+}
+
+/* Function: Compare vectors, return -1 if v1 is equal to v2, 0 otherwise */
+static void func_eq(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = (*(l2v *)v1 == *(l2v *)v2);
+}
+
+/* Function: Compare vectors, return 0 if v1 is equal to v2, -1 otherwise */
+static void func_neq(void *v1, void *v2, void *r)
+{
+	*(l2v *)r = (*(l2v *)v1 != *(l2v *)v2);
+}

data/ext/simd/simd_longarray.h

@@ -1,20 +1,36 @@
 #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_sqrt(VALUE self);
 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_gte(VALUE self, VALUE obj);
+static VALUE method_lte(VALUE self, VALUE obj);
+static VALUE method_eq(VALUE self, VALUE obj);
+static VALUE method_neq(VALUE self, VALUE obj);
 static VALUE method_to_a(VALUE self);
 
 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_sqrt(void *v1, 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);
+static void func_gte(void *v1, void *v2, void *r);
+static void func_lte(void *v1, void *v2, void *r);
+static void func_eq(void *v1, void *v2, void *r);
+static void func_neq(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,9 +13,20 @@ 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, "sqrt", method_sqrt, 0);
 	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, "gte", method_gte, 1);
+	rb_define_method(SIMD_SmallFloatArray, "lte", method_lte, 1);
+	rb_define_method(SIMD_SmallFloatArray, "eq", method_eq, 1);
+	rb_define_method(SIMD_SmallFloatArray, "neq", method_neq, 1);
+	rb_define_method(SIMD_SmallFloatArray, ">", method_gt, 1);
+	rb_define_method(SIMD_SmallFloatArray, "<", method_lt, 1);
+	rb_define_method(SIMD_SmallFloatArray, ">=", method_gte, 1);
+	rb_define_method(SIMD_SmallFloatArray, "<=", method_lte, 1);
 	rb_define_method(SIMD_SmallFloatArray, "length", method_length, 0);
 	rb_define_method(SIMD_SmallFloatArray, "to_a", method_to_a, 0);
 }
@@ -78,6 +90,13 @@ static VALUE method_subtract(VALUE self, VALUE obj)
 	return(internal_apply_operation(self, obj, sizeof(float), SIMD_SmallFloatArray, func_subtract));
 }
 
+/* Public: Compute the square root of values contained in a SmallFloatArray
+ * object, returning a new SmallFloatArray. */
+static VALUE method_sqrt(VALUE self)
+{
+	return(internal_apply_unary_operation(self, sizeof(float), SIMD_SmallFloatArray, func_sqrt));
+}
+
 /* 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)
@@ -99,6 +118,54 @@ 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: 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 or equal, and 0 otherwise. */
+static VALUE method_gte(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(float), SIMD_IntArray, func_gte));
+}
+
+/* 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 or equal, and 0 otherwise. */
+static VALUE method_lte(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(float), SIMD_IntArray, func_lte));
+}
+
+/* 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 equal, and 0 otherwise. */
+static VALUE method_eq(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(float), SIMD_IntArray, func_eq));
+}
+
+/* Public: Compare values contained in the data array with those contained in
+ * another SmallFloatArray object, return a new IntArray with each element being
+ * 0 if the data array's value is equal, and -1 otherwise. */
+static VALUE method_neq(VALUE self, VALUE obj)
+{
+	return(internal_apply_operation(self, obj, sizeof(float), SIMD_IntArray, func_neq));
+}
+
 /* Public: Return a Ruby Array containing the doubles within the data array. */
 static VALUE method_to_a(VALUE self)
 {
@@ -141,6 +208,15 @@ static void func_subtract(void *v1, void *v2, void *r)
 	*(f4v *)r = *(f4v *)v1 - *(f4v *)v2;
 }
 
+/* Function: Compute square root for a vector. */
+static void func_sqrt(void *v1, void *r)
+{
+	(*(f4v *)r)[0] = sqrt((*(f4v *)v1)[0]);
+	(*(f4v *)r)[1] = sqrt((*(f4v *)v1)[1]);
+	(*(f4v *)r)[2] = sqrt((*(f4v *)v1)[2]);
+	(*(f4v *)r)[3] = sqrt((*(f4v *)v1)[3]);
+}
+
 /* Function: Perform a binary AND on two vectors. */
 static void func_and(void *v1, void *v2, void *r)
 {
@@ -158,3 +234,39 @@ 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);
+}
+
+/* Function: Compare vectors, return -1 if v1 is greater than v2, 0 otherwise */
+static void func_gte(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_lte(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = (*(f4v *)v1 <= *(f4v *)v2);
+}
+
+/* Function: Compare vectors, return -1 if v1 is equal to v2, 0 otherwise */
+static void func_eq(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = (*(f4v *)v1 == *(f4v *)v2);
+}
+
+/* Function: Compare vectors, return 0 if v1 is equal to v2, -1 otherwise */
+static void func_neq(void *v1, void *v2, void *r)
+{
+	*(i4v *)r = (*(f4v *)v1 != *(f4v *)v2);
+}

data/ext/simd/simd_smallfloatarray.h

@@ -1,20 +1,36 @@
 #include "ruby.h"
 #include "simd_common.h"
 
+extern VALUE SIMD_SmallFloatArray;
+
 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_sqrt(VALUE self);
 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_gte(VALUE self, VALUE obj);
+static VALUE method_lte(VALUE self, VALUE obj);
+static VALUE method_eq(VALUE self, VALUE obj);
+static VALUE method_neq(VALUE self, VALUE obj);
 static VALUE method_to_a(VALUE self);
 
 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_sqrt(void *v1, 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);
+static void func_gte(void *v1, void *v2, void *r);
+static void func_lte(void *v1, void *v2, void *r);
+static void func_eq(void *v1, void *v2, void *r);
+static void func_neq(void *v1, void *v2, void *r);

data/ext/simd/simd_types.h

@@ -54,3 +54,4 @@ typedef struct vector_t
 } vector_t;
 
 typedef void (b_operation)(void *v1, void *v2, void *r);
+typedef void (u_operation)(void *v1, void *r);

metadata

@@ -1,29 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simd
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Tina Wuest
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-11 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'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
 description: Access to SIMD (Single Instruction Multiple Data) instructions in Ruby
 email: tina@wuest.me
 executables: []
@@ -45,10 +30,14 @@ files:
 - ext/simd/simd_smallfloatarray.c
 - ext/simd/simd_smallfloatarray.h
 - ext/simd/simd_types.h
-homepage: https://gitlab.com/wuest/simd-ruby
-licenses: []
-metadata: {}
-post_install_message: 
+homepage: https://github.com/wuest/simd-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/wuest/simd-ruby
+  source_code_uri: https://github.com/wuest/simd-ruby
+  changelog_uri: https://github.com/wuest/simd-ruby/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -56,16 +45,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: SIMD instructions in ruby
 test_files: []