FEAT: Add mixed operations. Fast<f64> + f64 and so on

Author: bluss

src/lib.rs

@@ -75,43 +75,73 @@ pub fn regular_sum(xs: &[f64]) -> f64 {
 macro_rules! impl_op {
     ($($name:ident, $method:ident, $intrins:ident;)*) => {
         $(
-        impl $name for Fast<f64> {
+        // Fast<F> + F
+        impl $name<f64> for Fast<f64> {
             type Output = Self;
             #[inline(always)]
-            fn $method(self, rhs: Self) -> Self::Output {
+            fn $method(self, rhs: f64) -> Self::Output {
                 unsafe {
-                    Fast($intrins(self.0, rhs.0))
+                    Fast($intrins(self.0, rhs))
                 }
             }
         }
 
-        impl $name for Fast<f32> {
+        impl $name<f32> for Fast<f32> {
             type Output = Self;
             #[inline(always)]
-            fn $method(self, rhs: Self) -> Self::Output {
+            fn $method(self, rhs: f32) -> Self::Output {
                 unsafe {
-                    Fast($intrins(self.0, rhs.0))
+                    Fast($intrins(self.0, rhs))
                 }
             }
         }
-        )*
 
-    }
-}
+        // F + Fast<F>
+        impl $name<Fast<f64>> for f64 {
+            type Output = Fast<f64>;
+            #[inline(always)]
+            fn $method(self, rhs: Fast<f64>) -> Self::Output {
+                Fast(self).$method(rhs.0)
+            }
+        }
 
-macro_rules! impl_assignop {
-    ($($name:ident, $method:ident, $intrins:ident;)*) => {
-        $(
+        impl $name<Fast<f32>> for f32 {
+            type Output = Fast<f32>;
+            #[inline(always)]
+            fn $method(self, rhs: Fast<f32>) -> Self::Output {
+                Fast(self).$method(rhs.0)
+            }
+        }
+
+        // Fast<F> + Fast<F>
         impl $name for Fast<f64> {
+            type Output = Self;
             #[inline(always)]
-            fn $method(&mut self, rhs: Self) {
-                *self = *self + rhs
+            fn $method(self, rhs: Self) -> Self::Output {
+                self.$method(rhs.0)
             }
         }
 
         impl $name for Fast<f32> {
+            type Output = Self;
+            #[inline(always)]
+            fn $method(self, rhs: Self) -> Self::Output {
+                self.$method(rhs.0)
+            }
+        }
+        )*
+
+    }
+}
+
+macro_rules! impl_assignop {
+    ($($name:ident, $method:ident, $intrins:ident;)*) => {
+        $(
+        impl<F, Rhs> $name<Rhs> for Fast<F>
+            where Self: Add<Rhs, Output=Self> + Copy,
+        {
             #[inline(always)]
-            fn $method(&mut self, rhs: Self) {
+            fn $method(&mut self, rhs: Rhs) {
                 *self = *self + rhs
             }
         }