From 74fd3e1a041bdf6dfc255fcb6940e0d9377eb431 Mon Sep 17 00:00:00 2001
From: Jason Orendorff <jason.orendorff@gmail.com>
Date: Sun, 17 Apr 2016 02:25:08 -0500
Subject: [PATCH] Support `f64 * Vec3<f64>` and so on.

To be specific, support is added for `N op T<N>` where `N` is `f32` or `f64`,
`op` is one of `+` `-` `*`, and `T` is one of the `Vec`, `DVec`, `Mat`, or `DMat`
generic types. These are all cases where `T<N> op N` is already supported.

Rust does not support generic impls in this case, but `f32` and `f64` cover
many common cases.

 Fixes #182.
---
 src/structs/dmat_macros.rs | 90 ++++++++++++++++++++++++++++++++++++++
 src/structs/mat_macros.rs  | 56 +++++++++++++++++++++++-
 src/structs/vec_macros.rs  | 54 +++++++++++++++++++++++
 src/structs/vecn_macros.rs | 90 ++++++++++++++++++++++++++++++++++++++
 4 files changed, 289 insertions(+), 1 deletion(-)

diff --git a/src/structs/dmat_macros.rs b/src/structs/dmat_macros.rs
index 4891fb3a..8cd70f34 100644
--- a/src/structs/dmat_macros.rs
+++ b/src/structs/dmat_macros.rs
@@ -634,6 +634,36 @@ macro_rules! dmat_impl(
             }
         }
 
+        impl Mul<$dmat<f32>> for f32 {
+            type Output = $dmat<f32>;
+
+            #[inline]
+            fn mul(self, right: $dmat<f32>) -> $dmat<f32> {
+                let mut res = right;
+
+                for mij in res.mij.iter_mut() {
+                    *mij = self * *mij;
+                }
+
+                res
+            }
+        }
+
+        impl Mul<$dmat<f64>> for f64 {
+            type Output = $dmat<f64>;
+
+            #[inline]
+            fn mul(self, right: $dmat<f64>) -> $dmat<f64> {
+                let mut res = right;
+
+                for mij in res.mij.iter_mut() {
+                    *mij = self * *mij;
+                }
+
+                res
+            }
+        }
+
         impl<N: Copy + Div<N, Output = N>> Div<N> for $dmat<N> {
             type Output = $dmat<N>;
 
@@ -664,6 +694,36 @@ macro_rules! dmat_impl(
             }
         }
 
+        impl Add<$dmat<f32>> for f32 {
+            type Output = $dmat<f32>;
+
+            #[inline]
+            fn add(self, right: $dmat<f32>) -> $dmat<f32> {
+                let mut res = right;
+
+                for mij in res.mij.iter_mut() {
+                    *mij = self + *mij;
+                }
+
+                res
+            }
+        }
+
+        impl Add<$dmat<f64>> for f64 {
+            type Output = $dmat<f64>;
+
+            #[inline]
+            fn add(self, right: $dmat<f64>) -> $dmat<f64> {
+                let mut res = right;
+
+                for mij in res.mij.iter_mut() {
+                    *mij = self + *mij;
+                }
+
+                res
+            }
+        }
+
         impl<N: Copy + Add<N, Output = N>> Add<$dmat<N>> for $dmat<N> {
             type Output = $dmat<N>;
 
@@ -715,6 +775,36 @@ macro_rules! dmat_impl(
             }
         }
 
+        impl Sub<$dmat<f32>> for f32 {
+            type Output = $dmat<f32>;
+
+            #[inline]
+            fn sub(self, right: $dmat<f32>) -> $dmat<f32> {
+                let mut res = right;
+
+                for mij in res.mij.iter_mut() {
+                    *mij = self - *mij;
+                }
+
+                res
+            }
+        }
+
+        impl Sub<$dmat<f64>> for f64 {
+            type Output = $dmat<f64>;
+
+            #[inline]
+            fn sub(self, right: $dmat<f64>) -> $dmat<f64> {
+                let mut res = right;
+
+                for mij in res.mij.iter_mut() {
+                    *mij = self - *mij;
+                }
+
+                res
+            }
+        }
+
         impl<N: Copy + Sub<N, Output = N>> Sub<$dmat<N>> for $dmat<N> {
             type Output = $dmat<N>;
 
diff --git a/src/structs/mat_macros.rs b/src/structs/mat_macros.rs
index 8f028d0d..16a7d44b 100644
--- a/src/structs/mat_macros.rs
+++ b/src/structs/mat_macros.rs
@@ -118,6 +118,24 @@ macro_rules! mat_mul_scalar_impl(
                 $t::new($(self.$compN * *right),+)
             }
         }
+
+        impl Mul<$t<f32>> for f32 {
+            type Output = $t<f32>;
+
+            #[inline]
+            fn mul(self, right: $t<f32>) -> $t<f32> {
+                $t::new($(self * right.$compN),+)
+            }
+        }
+
+        impl Mul<$t<f64>> for f64 {
+            type Output = $t<f64>;
+
+            #[inline]
+            fn mul(self, right: $t<f64>) -> $t<f64> {
+                $t::new($(self * right.$compN),+)
+            }
+        }
     )
 );
 
@@ -144,6 +162,24 @@ macro_rules! mat_add_scalar_impl(
                 $t::new($(self.$compN + *right),+)
             }
         }
+
+        impl Add<$t<f32>> for f32 {
+            type Output = $t<f32>;
+
+            #[inline]
+            fn add(self, right: $t<f32>) -> $t<f32> {
+                $t::new($(self + right.$compN),+)
+            }
+        }
+
+        impl Add<$t<f64>> for f64 {
+            type Output = $t<f64>;
+
+            #[inline]
+            fn add(self, right: $t<f64>) -> $t<f64> {
+                $t::new($(self + right.$compN),+)
+            }
+        }
     )
 );
 
@@ -175,7 +211,7 @@ macro_rules! repeat_impl(
 
 macro_rules! mat_sub_scalar_impl(
     ($t: ident, $($compN: ident),+) => (
-        impl<N: Sub<N, Output = N> Sub<N> for $t<N> {
+        impl<N: Sub<N, Output = N>> Sub<N> for $t<N> {
             type Output = $t<N>;
 
             #[inline]
@@ -183,6 +219,24 @@ macro_rules! mat_sub_scalar_impl(
                 $t::new($(self.$compN - *right),+)
             }
         }
+
+        impl Sub<f32> for $t<f32> {
+            type Output = $t<f32>;
+
+            #[inline]
+            fn sub(self, right: $t<f32>) -> $t<f32> {
+                $t::new($(self - right.$compN),+)
+            }
+        }
+
+        impl Sub<f64> for $t<f64> {
+            type Output = $t<f64>;
+
+            #[inline]
+            fn sub(self, right: $t<f64>) -> $t<f64> {
+                $t::new($(self - right.$compN),+)
+            }
+        }
     )
 );
 
diff --git a/src/structs/vec_macros.rs b/src/structs/vec_macros.rs
index f07e27ba..0aa3cb46 100644
--- a/src/structs/vec_macros.rs
+++ b/src/structs/vec_macros.rs
@@ -386,6 +386,24 @@ macro_rules! scalar_add_impl(
                 $t::new($(self.$compN + right),+)
             }
         }
+
+        impl Add<$t<f32>> for f32 {
+            type Output = $t<f32>;
+
+            #[inline]
+            fn add(self, right: $t<f32>) -> $t<f32> {
+                $t::new($(self + right.$compN),+)
+            }
+        }
+
+        impl Add<$t<f64>> for f64 {
+            type Output = $t<f64>;
+
+            #[inline]
+            fn add(self, right: $t<f64>) -> $t<f64> {
+                $t::new($(self + right.$compN),+)
+            }
+        }
     )
 );
 
@@ -412,6 +430,24 @@ macro_rules! scalar_sub_impl(
                 $t::new($(self.$compN - right),+)
             }
         }
+
+        impl Sub<$t<f32>> for f32 {
+            type Output = $t<f32>;
+
+            #[inline]
+            fn sub(self, right: $t<f32>) -> $t<f32> {
+                $t::new($(self - right.$compN),+)
+            }
+        }
+
+        impl Sub<$t<f64>> for f64 {
+            type Output = $t<f64>;
+
+            #[inline]
+            fn sub(self, right: $t<f64>) -> $t<f64> {
+                $t::new($(self - right.$compN),+)
+            }
+        }
     )
 );
 
@@ -437,6 +473,24 @@ macro_rules! scalar_mul_impl(
                 $t::new($(self.$compN * right),+)
             }
         }
+
+        impl Mul<$t<f32>> for f32 {
+            type Output = $t<f32>;
+
+            #[inline]
+            fn mul(self, right: $t<f32>) -> $t<f32> {
+                $t::new($(self * right.$compN),+)
+            }
+        }
+
+        impl Mul<$t<f64>> for f64 {
+            type Output = $t<f64>;
+
+            #[inline]
+            fn mul(self, right: $t<f64>) -> $t<f64> {
+                $t::new($(self * right.$compN),+)
+            }
+        }
     )
 );
 
diff --git a/src/structs/vecn_macros.rs b/src/structs/vecn_macros.rs
index c4bd8945..dcdf7a7b 100644
--- a/src/structs/vecn_macros.rs
+++ b/src/structs/vecn_macros.rs
@@ -264,6 +264,36 @@ macro_rules! vecn_dvec_common_impl(
             }
         }
 
+        impl<$($param : ArrayLength<N>),*> Mul<$vecn<f32 $(, $param)*>> for f32 {
+            type Output = $vecn<f32 $(, $param)*>;
+
+            #[inline]
+            fn mul(self, right: $vecn<f32 $(, $param)*>) -> $vecn<f32 $(, $param)*> {
+                let mut res = right;
+
+                for e in res.as_mut().iter_mut() {
+                    *e = self * *e;
+                }
+
+                res
+            }
+        }
+
+        impl<$($param : ArrayLength<N>),*> Mul<$vecn<f64 $(, $param)*>> for f64 {
+            type Output = $vecn<f64 $(, $param)*>;
+
+            #[inline]
+            fn mul(self, right: $vecn<f64 $(, $param)*>) -> $vecn<f64 $(, $param)*> {
+                let mut res = right;
+
+                for e in res.as_mut().iter_mut() {
+                    *e = self * *e;
+                }
+
+                res
+            }
+        }
+
         impl<N: Copy + Div<N, Output = N> + Zero $(, $param : ArrayLength<N>)*> Div<N> for $vecn<N $(, $param)*> {
             type Output = $vecn<N $(, $param)*>;
 
@@ -294,6 +324,36 @@ macro_rules! vecn_dvec_common_impl(
             }
         }
 
+        impl<$($param : ArrayLength<f32>),*> Add<$vecn<f32 $(, $param)*>> for f32 {
+            type Output = $vecn<f32 $(, $param)*>;
+
+            #[inline]
+            fn add(self, right: $vecn<f32 $(, $param)*>) -> $vecn<f32 $(, $param)*> {
+                let mut res = right;
+
+                for e in res.as_mut().iter_mut() {
+                    *e = self + *e;
+                }
+
+                res
+            }
+        }
+
+        impl<$($param : ArrayLength<f64>),*> Add<$vecn<f64 $(, $param)*>> for f64 {
+            type Output = $vecn<f64 $(, $param)*>;
+
+            #[inline]
+            fn add(self, right: $vecn<f64 $(, $param)*>) -> $vecn<f64 $(, $param)*> {
+                let mut res = right;
+
+                for e in res.as_mut().iter_mut() {
+                    *e = self + *e;
+                }
+
+                res
+            }
+        }
+
         impl<N: Copy + Sub<N, Output = N> + Zero $(, $param : ArrayLength<N>)*> Sub<N> for $vecn<N $(, $param)*> {
             type Output = $vecn<N $(, $param)*>;
 
@@ -308,5 +368,35 @@ macro_rules! vecn_dvec_common_impl(
                 res
             }
         }
+
+        impl<$($param : ArrayLength<f32>),*> Sub<$vecn<f32 $(, $param)*>> for f32 {
+            type Output = $vecn<f32 $(, $param)*>;
+
+            #[inline]
+            fn sub(self, right: $vecn<f32 $(, $param)*>) -> $vecn<f32 $(, $param)*> {
+                let mut res = right;
+
+                for e in res.as_mut().iter_mut() {
+                    *e = self - *e;
+                }
+
+                res
+            }
+        }
+
+        impl<$($param : ArrayLength<f64>),*> Sub<$vecn<f64 $(, $param)*>> for f64 {
+            type Output = $vecn<f64 $(, $param)*>;
+
+            #[inline]
+            fn sub(self, right: $vecn<f64 $(, $param)*>) -> $vecn<f64 $(, $param)*> {
+                let mut res = right;
+
+                for e in res.as_mut().iter_mut() {
+                    *e = self - *e;
+                }
+
+                res
+            }
+        }
     )
 );