blackjack/series/
overloaders.rs

1//!
2//! Module holds overloading implementations for [`Series`].
3//!
4
5use std::marker::Send;
6use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
7
8use num::*;
9use rayon::iter::{IndexedParallelIterator, IntoParallelIterator};
10use rayon::prelude::*;
11
12use crate::prelude::*;
13
14/// Support `series * scalar`
15impl<T> Mul<T> for Series<T>
16where
17    T: Num + Copy + BlackJackData + Send + Sync,
18    Vec<T>: IntoParallelIterator<Item = T>,
19    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,
20{
21    type Output = Series<T>;
22
23    fn mul(self, scalar_val: T) -> Series<T> {
24        let vec: Vec<T> = self
25            .values
26            .into_par_iter()
27            .map(|v| v * scalar_val)
28            .collect();
29        Series::from_vec(vec)
30    }
31}
32
33impl<T> MulAssign<T> for Series<T>
34where
35    T: Num + Copy + BlackJackData + Send + Sync + MulAssign<T>,
36    Vec<T>: IntoParallelIterator<Item = T>,
37    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,
38{
39    fn mul_assign(&mut self, scalar_val: T) -> () {
40        self.values
41            .par_iter_mut()
42            .map(|v| *v *= scalar_val)
43            .collect::<Vec<()>>();
44    }
45}
46
47// Support `series + other_series` ect.
48impl_series_by_series_op!(Add, add, +);
49impl_series_by_series_op!(Sub, sub, -);
50impl_series_by_series_op!(Div, div, /);
51impl_series_by_series_op!(Mul, mul, *);
52
53// Support `series += other_series`
54impl_series_by_series_op_inplace!(MulAssign, mul_assign, *=);
55impl_series_by_series_op_inplace!(DivAssign, div_assign, /=);
56impl_series_by_series_op_inplace!(AddAssign, add_assign, +=);
57impl_series_by_series_op_inplace!(SubAssign, sub_assign, -=);
58
59/// Support `series + scalar`
60impl<T> Add<T> for Series<T>
61where
62    T: Num + Copy + BlackJackData + Send + Sync,
63    Vec<T>: IntoParallelIterator<Item = T>,
64    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,
65{
66    type Output = Series<T>;
67
68    fn add(self, scalar_val: T) -> Series<T> {
69        let vec: Vec<T> = self
70            .values
71            .into_par_iter()
72            .map(|v| v + scalar_val)
73            .collect();
74        Series::from_vec(vec)
75    }
76}
77
78/// Support `series += scalar`
79impl<T> AddAssign<T> for Series<T>
80where
81    T: Num + Copy + BlackJackData + Send + Sync + FromPrimitive + AddAssign<T>,
82    Vec<T>: IntoParallelIterator<Item = T>,
83    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,
84{
85    fn add_assign(&mut self, scalar_val: T) -> () {
86        self.values
87            .par_iter_mut()
88            .map(|v| *v += scalar_val)
89            .collect::<Vec<()>>();
90    }
91}
92
93/// Support `series - scalar`
94impl<T> Sub<T> for Series<T>
95where
96    T: Num + Copy + BlackJackData + Send + Sync + Sub,
97    Vec<T>: IntoParallelIterator<Item = T>,
98    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,
99{
100    type Output = Series<T>;
101
102    fn sub(self, scalar_val: T) -> Series<T> {
103        let vec: Vec<T> = self
104            .values
105            .into_par_iter()
106            .map(|v| v - scalar_val)
107            .collect();
108        Series::from_vec(vec)
109    }
110}
111
112/// Support `series -= scalar`
113impl<T> SubAssign<T> for Series<T>
114where
115    T: Num + Copy + BlackJackData + Send + Sync + SubAssign<T>,
116    Vec<T>: IntoParallelIterator<Item = T>,
117    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,
118{
119    fn sub_assign(&mut self, scalar_val: T) -> () {
120        self.values
121            .par_iter_mut()
122            .map(|v| *v -= scalar_val)
123            .collect::<Vec<()>>();
124    }
125}
126
127/// Support `series - scalar`
128impl<T> Div<T> for Series<T>
129where
130    T: Num + Copy + BlackJackData + Send + Sync,
131    Vec<T>: IntoParallelIterator<Item = T>,
132    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,
133{
134    type Output = Series<T>;
135
136    fn div(self, scalar_val: T) -> Series<T> {
137        let vec: Vec<T> = self
138            .values
139            .into_par_iter()
140            .map(|v| v / scalar_val)
141            .collect();
142        Series::from_vec(vec)
143    }
144}
145
146/// Support `series += scalar`
147impl<T> DivAssign<T> for Series<T>
148where
149    T: Num + Copy + BlackJackData + Send + Sync + DivAssign<T>,
150    Vec<T>: IntoParallelIterator<Item = T>,
151    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,
152{
153    fn div_assign(&mut self, scalar_val: T) -> () {
154        self.values
155            .par_iter_mut()
156            .map(|v| *v /= scalar_val)
157            .collect::<Vec<()>>();
158    }
159}
blackjack/series/overloaders.rs

blackjack/series/
overloaders.rs
