Add more binop-assign methods and reduction methods

Author: tsnl

src/vector.rs

@@ -1,7 +1,7 @@
 use super::*;
 use num_traits::identities::ConstZero;
 use std::fmt::Debug;
-use std::ops::{Add, Div, Index, Mul, Neg, Sub};
+use std::ops::{Add, AddAssign, Div, DivAssign, Index, Mul, MulAssign, Neg, Sub, SubAssign};
 
 pub trait SimdVector: Sized {
     type LaneType: Sized + ConstZero + Copy + Debug + PartialEq + PartialOrd;
@@ -86,6 +86,27 @@ macro_rules! impl_simd_vec_universal_methods {
             pub fn dot(self, other: $name) -> $lane_ty {
                 (self.0 * other.0).reduce_sum()
             }
+            #[inline]
+            pub fn reduce_sum(self) -> $lane_ty {
+                self.0.reduce_sum()
+            }
+            #[inline]
+            pub fn reduce_product(self) -> $lane_ty {
+                self.0.reduce_product()
+            }
+        }
+        impl Mul<$lane_ty> for $name {
+            type Output = $name;
+            #[inline]
+            fn mul(self, rhs: $lane_ty) -> Self::Output {
+                $name(self.0 * <$simd_ty>::splat(rhs))
+            }
+        }
+        impl MulAssign<$lane_ty> for $name {
+            #[inline]
+            fn mul_assign(&mut self, rhs: $lane_ty) {
+                self.0 *= <$simd_ty>::splat(rhs);
+            }
         }
         impl Mul<$name> for $name {
             type Output = $name;
@@ -95,11 +116,10 @@ macro_rules! impl_simd_vec_universal_methods {
                 $name(self.0 * rhs.0)
             }
         }
-        impl Mul<$lane_ty> for $name {
-            type Output = $name;
+        impl MulAssign<$name> for $name {
             #[inline]
-            fn mul(self, rhs: $lane_ty) -> Self::Output {
-                $name(self.0 * <$simd_ty>::splat(rhs))
+            fn mul_assign(&mut self, rhs: $name) {
+                self.0 *= rhs.0;
             }
         }
         impl Div<$lane_ty> for $name {
@@ -109,6 +129,12 @@ macro_rules! impl_simd_vec_universal_methods {
                 $name(self.0 / <$simd_ty>::splat(rhs))
             }
         }
+        impl DivAssign<$lane_ty> for $name {
+            #[inline]
+            fn div_assign(&mut self, rhs: $lane_ty) {
+                self.0 /= <$simd_ty>::splat(rhs);
+            }
+        }
         impl Div<$name> for $name {
             type Output = $name;
             /// Element-wise division
@@ -117,20 +143,38 @@ macro_rules! impl_simd_vec_universal_methods {
                 $name(self.0 / rhs.0)
             }
         }
+        impl DivAssign<$name> for $name {
+            #[inline]
+            fn div_assign(&mut self, rhs: $name) {
+                self.0 /= rhs.0;
+            }
+        }
         impl Add<$name> for $name {
             type Output = $name;
             #[inline]
             fn add(self, rhs: $name) -> Self::Output {
                 $name(self.0 + rhs.0)
             }
         }
+        impl AddAssign<$name> for $name {
+            #[inline]
+            fn add_assign(&mut self, rhs: $name) {
+                self.0 += rhs.0;
+            }
+        }
         impl Sub<$name> for $name {
             type Output = $name;
             #[inline]
             fn sub(self, rhs: $name) -> Self::Output {
                 $name(self.0 - rhs.0)
             }
         }
+        impl SubAssign<$name> for $name {
+            #[inline]
+            fn sub_assign(&mut self, rhs: $name) {
+                self.0 -= rhs.0;
+            }
+        }
         impl $name {
             pub fn elementwise_min(self, other: $name) -> $name {
                 $name(self.0.simd_min(other.0))