appease the rustfmt gods

Author: miguelraz

crates/core_simd/examples/dot_product.rs

@@ -8,37 +8,34 @@
 #![feature(portable_simd)]
 use core_simd::*;
 
-// This is your barebones dot product implementation: 
+// This is your barebones dot product implementation:
 // Take 2 vectors, multiply them element wise and *then*
 // go along the resulting array and add up the result.
 // In the next example we will see if there
 //  is any difference to adding and multiplying in tandem.
 pub fn dot_prod_0(a: &[f32], b: &[f32]) -> f32 {
     assert_eq!(a.len(), b.len());
 
-    a.iter()
-    .zip(b.iter())
-    .map(|(a, b)| a * b)
-    .sum()
+    a.iter().zip(b.iter()).map(|(a, b)| a * b).sum()
 }
 
 // When dealing with SIMD, it is very important to think about the amount
 // of data movement and when it happens. We're going over simple computation examples here, and yet
 // it is not trivial to understand what may or may not contribute to performance
-// changes. Eventually, you will need tools to inspect the generated assembly and confirm your 
+// changes. Eventually, you will need tools to inspect the generated assembly and confirm your
 // hypothesis and benchmarks - we will mention them later on.
 // With the use of `fold`, we're doing a multiplication,
 // and then adding it to the sum, one element from both vectors at a time.
 pub fn dot_prod_1(a: &[f32], b: &[f32]) -> f32 {
     assert_eq!(a.len(), b.len());
     a.iter()
-    .zip(b.iter())
-    .fold(0.0, |a, zipped| {a + zipped.0 * zipped.1})
+        .zip(b.iter())
+        .fold(0.0, |a, zipped| a + zipped.0 * zipped.1)
 }
 
 // We now move on to the SIMD implementations: notice the following constructs:
 // `array_chunks::<4>`: mapping this over the vector will let use construct SIMD vectors
-// `f32x4::from_array`: construct the SIMD vector from a slice 
+// `f32x4::from_array`: construct the SIMD vector from a slice
 // `(a * b).reduce_sum()`: Multiply both f32x4 vectors together, and then reduce them.
 // This approach essentially uses SIMD to produce a vector of length N/4 of all the products,
 // and then add those with `sum()`. This is suboptimal.
@@ -67,11 +64,11 @@ pub fn dot_prod_simd_1(a: &[f32], b: &[f32]) -> f32 {
     a.array_chunks::<4>()
         .map(|&a| f32x4::from_array(a))
         .zip(b.array_chunks::<4>().map(|&b| f32x4::from_array(b)))
-        .fold(f32x4::splat(0.0), |acc, zipped| {acc + zipped.0 * zipped.1})
+        .fold(f32x4::splat(0.0), |acc, zipped| acc + zipped.0 * zipped.1)
         .reduce_sum()
 }
 
-// A lot of knowledgeable use of SIMD comes from knowing specific instructions that are 
+// A lot of knowledgeable use of SIMD comes from knowing specific instructions that are
 // available - let's try to use the `mul_add` instruction, which is the fused-multiply-add we were looking for.
 use std_float::StdFloat;
 pub fn dot_prod_simd_2(a: &[f32], b: &[f32]) -> f32 {
@@ -81,8 +78,10 @@ pub fn dot_prod_simd_2(a: &[f32], b: &[f32]) -> f32 {
     a.array_chunks::<4>()
         .map(|&a| f32x4::from_array(a))
         .zip(b.array_chunks::<4>().map(|&b| f32x4::from_array(b)))
-        .for_each(|(a,b)| { res = a.mul_add(b, res); });
-        res.reduce_sum()
+        .for_each(|(a, b)| {
+            res = a.mul_add(b, res);
+        });
+    res.reduce_sum()
 }
 
 // Finally, we will write the same operation but handling the loop remainder.
@@ -103,10 +102,9 @@ pub fn dot_prod_simd_3(a: &[f32], b: &[f32]) -> f32 {
     }
 
     let mut sums = f32x4::from_array(sums);
-    std::iter::zip(a_chunks, b_chunks)
-        .for_each(|(x, y)| {
-            sums += f32x4::from_array(*x) * f32x4::from_array(*y);
-        });
+    std::iter::zip(a_chunks, b_chunks).for_each(|(x, y)| {
+        sums += f32x4::from_array(*x) * f32x4::from_array(*y);
+    });
 
     sums.reduce_sum()
 }
@@ -134,6 +132,5 @@ mod tests {
 
         // We can handle vectors that are non-multiples of 4
         assert_eq!(1003.0, dot_prod_simd_3(&x, &y));
-
     }
 }