simplify by using Array::from_fn

Author: mcroomp

src/lib.rs

@@ -976,17 +976,8 @@ pub trait SimdType<T, const N: usize> {
   #[must_use]
   fn from_array(array: [T; N]) -> Self;
 
-  /// Performs a binary operation corresponding elements
-  /// on two SIMD types and returns the result.
-  ///
-  /// This is useful for implementing
-  /// operations that the compiler vectorizes but this library
-  /// don't provide explicit support  for.
-  fn binary_op<FN: Fn(T, T) -> T>(self, rhs: Self, op: FN) -> Self;
-
-  /// performs a unary operation on each element of the SIMD type
-  /// and returns the result.
-  fn unary_op<FN: Fn(T) -> T>(self, op: FN) -> Self;
+  /// provide same functionarlity as array from_fn
+  fn from_fn<F: Fn(usize) -> T>(cb: F) -> Self;
 }
 
 macro_rules! bulk_impl_const_rhs_op {

src/u32x4_.rs

@@ -546,15 +546,7 @@ impl SimdType<u32, 4> for u32x4 {
   }
 
   #[inline]
-  fn binary_op<FN: Fn(u32, u32) -> u32>(self, rhs: Self, op: FN) -> Self {
-    let a: [u32; 4] = cast(self);
-    let b: [u32; 4] = cast(rhs);
-    cast([op(a[0], b[0]), op(a[1], b[1]), op(a[2], b[2]), op(a[3], b[3])])
-  }
-
-  #[inline]
-  fn unary_op<FN: Fn(u32) -> u32>(self, op: FN) -> Self {
-    let a: [u32; 4] = cast(self);
-    cast([op(a[0]), op(a[1]), op(a[2]), op(a[3])])
+  fn from_fn<F: Fn(usize) -> u32>(cb: F) -> Self {
+    cast([cb(0), cb(1), cb(2), cb(3)])
   }
 }

src/u32x8_.rs

@@ -359,33 +359,7 @@ impl SimdType<u32, 8> for u32x8 {
   }
 
   #[inline]
-  fn binary_op<FN: Fn(u32, u32) -> u32>(self, rhs: Self, op: FN) -> Self {
-    let a: [u32; 8] = cast(self);
-    let b: [u32; 8] = cast(rhs);
-    cast([
-      op(a[0], b[0]),
-      op(a[1], b[1]),
-      op(a[2], b[2]),
-      op(a[3], b[3]),
-      op(a[4], b[4]),
-      op(a[5], b[5]),
-      op(a[6], b[6]),
-      op(a[7], b[7]),
-    ])
-  }
-
-  #[inline]
-  fn unary_op<FN: Fn(u32) -> u32>(self, op: FN) -> Self {
-    let a: [u32; 8] = cast(self);
-    cast([
-      op(a[0]),
-      op(a[1]),
-      op(a[2]),
-      op(a[3]),
-      op(a[4]),
-      op(a[5]),
-      op(a[6]),
-      op(a[7]),
-    ])
+  fn from_fn<F: Fn(usize) -> u32>(cb: F) -> Self {
+    cast([cb(0), cb(1), cb(2), cb(3), cb(4), cb(5), cb(6), cb(7)])
   }
 }

tests/all_tests/t_common.rs

@@ -15,29 +15,17 @@ pub fn test_binary_op<
   fn_scalar: FnScalar,
   fn_vector: FnVector,
 ) {
-  let mut expected = T::default();
-  for i in 0..N {
-    expected.as_mut_array()[i] = fn_scalar(a.as_array()[i], b.as_array()[i]);
-  }
+  let expected = T::from_fn(|i| fn_scalar(a.as_array()[i], b.as_array()[i]));
 
   let actual = fn_vector(a, b);
 
   // assert equality for manually calculated result
   assert_eq!(expected, actual, "scalar={:?} vector={:?}", expected, actual);
-
-  // assert equality using the binary_op method as well
-  assert_eq!(
-    expected,
-    a.binary_op(b, fn_scalar),
-    "scalar={:?} binary_op={:?}",
-    expected,
-    actual
-  );
 }
 
 pub fn test_unary_op<
-  T: SimdType<V, N> + Default + PartialEq + std::fmt::Debug + Copy,
-  V: Copy,
+  T: SimdType<V, N> + PartialEq + std::fmt::Debug + Copy,
+  V: Copy + PartialEq + std::fmt::Debug,
   FnVector: Fn(T) -> T,
   FnScalar: Fn(V) -> V,
   const N: usize,
@@ -46,22 +34,14 @@ pub fn test_unary_op<
   fn_scalar: FnScalar,
   fn_vector: FnVector,
 ) {
-  let mut expected = T::default();
+  let expected = T::from_fn(|i| fn_scalar(a.as_array()[i]));
+  // ensure that the elements got put in the right place
   for i in 0..N {
-    expected.as_mut_array()[i] = fn_scalar(a.as_array()[i]);
+    assert_eq!(expected.as_array()[i], fn_scalar(a.as_array()[i]));
   }
 
   let actual = fn_vector(a);
 
   // assert equality for manually calculated result
   assert_eq!(expected, actual, "scalar={:?} vector={:?}", expected, actual);
-
-  // assert equality using the unary_op method as well
-  assert_eq!(
-    expected,
-    a.unary_op(fn_scalar),
-    "scalar={:?} unary_op={:?}",
-    expected,
-    actual
-  );
 }

tests/all_tests/t_usefulness.rs

@@ -394,7 +394,8 @@ fn branch_free_divide(numerator: u32x8, magic: u32x8, shift: u32x8) -> u32x8 {
   // Returns 32 high bits of the 64 bit result of multiplication of two u32s
   let mul_hi = |a, b| ((u64::from(a) * u64::from(b)) >> 32) as u32;
 
-  let q = numerator.binary_op(magic, mul_hi);
+  let q =
+    u32x8::from_fn(|i| mul_hi(numerator.as_array()[i], magic.as_array()[i]));
   let t = ((numerator - q) >> 1) + q;
   t >> shift
 }