From 1d186e1f1086df41765506c73163d7cfb5031096 Mon Sep 17 00:00:00 2001
From: m5l14i11 <siarhei.melnik@proton.me>
Date: Fri, 21 Jul 2023 01:14:33 +0300
Subject: [PATCH] refactor

---
 ta_lib/core/src/ops.rs | 244 +++++++++++++++--------------------------
 1 file changed, 86 insertions(+), 158 deletions(-)

diff --git a/ta_lib/core/src/ops.rs b/ta_lib/core/src/ops.rs
index 4f20b09f..dcef6839 100644
--- a/ta_lib/core/src/ops.rs
+++ b/ta_lib/core/src/ops.rs
@@ -19,6 +19,10 @@ impl Series<f64> {
         self.fmap(|val| val.map(|v| op(v, scalar)))
     }
 
+    pub fn neg(&self) -> Series<f64> {
+        self.fmap(|val| val.map(|v| v.neg()))
+    }
+
     pub fn add_series(&self, rhs: &Series<f64>) -> Series<f64> {
         self.binary_op_series(rhs, |a, b| a + b)
     }
@@ -77,9 +81,13 @@ impl Series<f64> {
     pub fn sub_scalar(&self, scalar: f64) -> Series<f64> {
         self.unary_op_scalar(scalar, |v, s| v - s)
     }
+}
 
-    pub fn neg(&self) -> Series<f64> {
-        self.fmap(|val| val.map(|v| v.neg()))
+impl Neg for &Series<f64> {
+    type Output = Series<f64>;
+
+    fn neg(self) -> Series<f64> {
+        self.neg()
     }
 }
 
@@ -99,124 +107,73 @@ impl Series<bool> {
     }
 }
 
-impl Add<Series<f64>> for &Series<f64> {
-    type Output = Series<f64>;
-
-    fn add(self, rhs: Series<f64>) -> Series<f64> {
-        self.add_series(&rhs)
-    }
-}
-
-impl Add<&Series<f64>> for Series<f64> {
-    type Output = Series<f64>;
-
-    fn add(self, rhs: &Series<f64>) -> Series<f64> {
-        self.add_series(rhs)
-    }
-}
-
-impl Add<&Series<f64>> for &Series<f64> {
-    type Output = Series<f64>;
-
-    fn add(self, rhs: &Series<f64>) -> Series<f64> {
-        self.add_series(rhs)
-    }
-}
-
-impl Mul<Series<f64>> for &Series<f64> {
-    type Output = Series<f64>;
-
-    fn mul(self, rhs: Series<f64>) -> Series<f64> {
-        self.mul_series(&rhs)
-    }
-}
-
-impl Mul<&Series<f64>> for Series<f64> {
-    type Output = Series<f64>;
-
-    fn mul(self, rhs: &Series<f64>) -> Series<f64> {
-        self.mul_series(rhs)
-    }
-}
-
-impl Mul<&Series<f64>> for &Series<f64> {
-    type Output = Series<f64>;
-
-    fn mul(self, rhs: &Series<f64>) -> Series<f64> {
-        self.mul_series(rhs)
-    }
-}
-
-impl Div<&Series<f64>> for &Series<f64> {
-    type Output = Series<f64>;
-
-    fn div(self, rhs: &Series<f64>) -> Series<f64> {
-        self.div_series(rhs)
-    }
-}
-
-impl Div<&Series<f64>> for Series<f64> {
-    type Output = Series<f64>;
-
-    fn div(self, rhs: &Series<f64>) -> Series<f64> {
-        self.div_series(rhs)
-    }
-}
-
-impl Div<Series<f64>> for &Series<f64> {
-    type Output = Series<f64>;
-
-    fn div(self, rhs: Series<f64>) -> Series<f64> {
-        self.div_series(&rhs)
-    }
-}
-
-impl Sub<&Series<f64>> for Series<f64> {
-    type Output = Series<f64>;
-
-    fn sub(self, rhs: &Series<f64>) -> Series<f64> {
-        self.sub_series(rhs)
-    }
-}
-
-impl Sub<Series<f64>> for &Series<f64> {
-    type Output = Series<f64>;
-
-    fn sub(self, rhs: Series<f64>) -> Series<f64> {
-        self.sub_series(&rhs)
-    }
-}
-
-impl Sub<&Series<f64>> for &Series<f64> {
-    type Output = Series<f64>;
+macro_rules! impl_series_ops {
+    ($trait_name:ident, $trait_method:ident, $method:ident) => {
+        impl $trait_name<Series<f64>> for &Series<f64> {
+            type Output = Series<f64>;
+            fn $trait_method(self, rhs: Series<f64>) -> Series<f64> {
+                self.$method(&rhs)
+            }
+        }
 
-    fn sub(self, rhs: &Series<f64>) -> Series<f64> {
-        self.sub_series(rhs)
-    }
-}
+        impl $trait_name<&Series<f64>> for Series<f64> {
+            type Output = Series<f64>;
+            fn $trait_method(self, rhs: &Series<f64>) -> Series<f64> {
+                self.$method(rhs)
+            }
+        }
 
-impl Add<f64> for &Series<f64> {
-    type Output = Series<f64>;
+        impl $trait_name<&Series<f64>> for &Series<f64> {
+            type Output = Series<f64>;
+            fn $trait_method(self, rhs: &Series<f64>) -> Series<f64> {
+                self.$method(rhs)
+            }
+        }
 
-    fn add(self, scalar: f64) -> Series<f64> {
-        self.add_scalar(scalar)
-    }
+        impl $trait_name<Series<f64>> for Series<f64> {
+            type Output = Series<f64>;
+            fn $trait_method(self, rhs: Series<f64>) -> Series<f64> {
+                self.$method(&rhs)
+            }
+        }
+    };
 }
 
-impl Mul<f64> for &Series<f64> {
-    type Output = Series<f64>;
+impl_series_ops!(Add, add, add_series);
+impl_series_ops!(Mul, mul, mul_series);
+impl_series_ops!(Div, div, div_series);
+impl_series_ops!(Sub, sub, sub_series);
+
+macro_rules! impl_scalar_ops {
+    ($trait_name:ident, $trait_method:ident, $method:ident) => {
+        impl $trait_name<&Series<f64>> for f64 {
+            type Output = Series<f64>;
+            fn $trait_method(self, rhs: &Series<f64>) -> Series<f64> {
+                rhs.$method(self)
+            }
+        }
 
-    fn mul(self, scalar: f64) -> Series<f64> {
-        self.mul_scalar(scalar)
-    }
-}
+        impl $trait_name<Series<f64>> for f64 {
+            type Output = Series<f64>;
+            fn $trait_method(self, rhs: Series<f64>) -> Series<f64> {
+                rhs.$method(self)
+            }
+        }
 
-impl Mul<f64> for Series<f64> {
-    type Output = Series<f64>;
+        impl $trait_name<f64> for &Series<f64> {
+            type Output = Series<f64>;
+            fn $trait_method(self, scalar: f64) -> Series<f64> {
+                self.$method(scalar)
+            }
+        }
 
-    fn mul(self, scalar: f64) -> Series<f64> {
-        self.mul_scalar(scalar)
-    }
+        impl $trait_name<f64> for Series<f64> {
+            type Output = Series<f64>;
+            fn $trait_method(self, scalar: f64) -> Series<f64> {
+                self.$method(scalar)
+            }
+        }
+    };
 }
 
 impl Div<f64> for &Series<f64> {
@@ -235,61 +192,37 @@ impl Div<f64> for Series<f64> {
     }
 }
 
-impl Sub<f64> for &Series<f64> {
-    type Output = Series<f64>;
-
-    fn sub(self, scalar: f64) -> Series<f64> {
-        self.sub_scalar(scalar)
-    }
-}
-
-impl Add<&Series<f64>> for f64 {
-    type Output = Series<f64>;
-
-    fn add(self, rhs: &Series<f64>) -> Series<f64> {
-        rhs.add_scalar(self)
-    }
-}
-
-impl Add<Series<f64>> for f64 {
-    type Output = Series<f64>;
-
-    fn add(self, rhs: Series<f64>) -> Series<f64> {
-        rhs.add_scalar(self)
-    }
-}
-
-impl Mul<&Series<f64>> for f64 {
+impl Div<&Series<f64>> for f64 {
     type Output = Series<f64>;
 
-    fn mul(self, rhs: &Series<f64>) -> Series<f64> {
-        rhs.mul_scalar(self)
+    fn div(self, rhs: &Series<f64>) -> Series<f64> {
+        let scalars = vec![self; rhs.len()];
+        Series::from(&scalars).div_series(&rhs)
     }
 }
 
-impl Mul<Series<f64>> for f64 {
+impl Div<Series<f64>> for f64 {
     type Output = Series<f64>;
 
-    fn mul(self, rhs: Series<f64>) -> Series<f64> {
-        rhs.mul_scalar(self)
+    fn div(self, rhs: Series<f64>) -> Series<f64> {
+        let scalars = vec![self; rhs.len()];
+        Series::from(&scalars).div_series(&rhs)
     }
 }
 
-impl Div<&Series<f64>> for f64 {
+impl Sub<f64> for &Series<f64> {
     type Output = Series<f64>;
 
-    fn div(self, rhs: &Series<f64>) -> Series<f64> {
-        let scalars = vec![self; rhs.len()];
-        Series::from(&scalars).div_series(&rhs)
+    fn sub(self, scalar: f64) -> Series<f64> {
+        self.sub_scalar(scalar)
     }
 }
 
-impl Div<Series<f64>> for f64 {
+impl Sub<f64> for Series<f64> {
     type Output = Series<f64>;
 
-    fn div(self, rhs: Series<f64>) -> Series<f64> {
-        let scalars = vec![self; rhs.len()];
-        Series::from(&scalars).div_series(&rhs)
+    fn sub(self, scalar: f64) -> Series<f64> {
+        self.sub_scalar(scalar)
     }
 }
 
@@ -309,6 +242,9 @@ impl Sub<Series<f64>> for f64 {
     }
 }
 
+impl_scalar_ops!(Add, add, add_scalar);
+impl_scalar_ops!(Mul, mul, mul_scalar);
+
 impl Mul<&Series<f64>> for &Series<bool> {
     type Output = Series<f64>;
 
@@ -324,11 +260,3 @@ impl Mul<&Series<f64>> for Series<bool> {
         self.mul_series(rhs)
     }
 }
-
-impl Neg for &Series<f64> {
-    type Output = Series<f64>;
-
-    fn neg(self) -> Series<f64> {
-        self.neg()
-    }
-}