gpurs/linalg/
bool_ops.rs

1use crate::IsFloat;
2use crate::Result;
3use crate::Jeeperr;
4use crate::linalg::Matrix;
5
6/// Trait containing boolean operations for the Matrix struct.
7pub trait BooleanMatrixOperations<T: IsFloat + std::fmt::Debug + Copy + Clone> {
8    /// Return boolean vector with one element for each matrix element
9    /// with values based on element == number
10    fn equal(matrix: &Matrix<T>, number: T) -> Vec<bool>;
11
12    /// Return boolean vector with one element for each matrix element
13    /// with values based on element < number
14    fn less_than(matrix: &Matrix<T>, number: T) -> Vec<bool>;
15    /// Return boolean vector with one element for each matrix element
16    /// with values based on element <= number
17    fn less_equal(matrix: &Matrix<T>, number: T) -> Vec<bool>;
18
19    /// Return boolean vector with one element for each matrix element
20    /// with values based on element > number
21    fn greater_than(matrix: &Matrix<T>, number: T) -> Vec<bool>;
22    /// Return boolean vector with one element for each matrix element
23    /// with values based on element >= number
24    fn greater_equal(matrix: &Matrix<T>, number: T) -> Vec<bool>;
25
26    /// Return boolean vector with one element for each matrix element
27    /// with values based on left_element == right_element
28    /// 
29    /// Returns error if left and right matrices have different dimensions
30    fn equal_mat(left_matrix: &Matrix<T>, right_matrix: &Matrix<T>) -> Result<Vec<bool>>;
31
32    /// Return boolean vector with one element for each matrix element
33    /// with values based on left_element < right_element
34    /// 
35    /// Returns error if left and right matrices have different dimensions
36    fn less_than_mat(left_matrix: &Matrix<T>, right_matrix: &Matrix<T>) -> Result<Vec<bool>>;
37    /// Return boolean vector with one element for each matrix element
38    /// with values based on left_element <= right_element
39    /// 
40    /// Returns error if left and right matrices have different dimensions
41    fn less_equal_mat(left_matrix: &Matrix<T>, right_matrix: &Matrix<T>) -> Result<Vec<bool>>;
42
43    /// Return boolean vector with one element for each matrix element
44    /// with values based on left_element > right_element
45    /// 
46    /// Returns error if left and right matrices have different dimensions
47    fn greater_than_mat(left_matrix: &Matrix<T>, right_matrix: &Matrix<T>) -> Result<Vec<bool>>;
48    /// Return boolean vector with one element for each matrix element
49    /// with values based on left_element >= right_element
50    /// 
51    /// Returns error if left and right matrices have different dimensions
52    fn greater_equal_mat(left_matrix: &Matrix<T>, right_matrix: &Matrix<T>) -> Result<Vec<bool>>;
53}
54
55impl BooleanMatrixOperations<f32> for Matrix<f32> {
56    /// Return boolean vector with one element for each matrix element
57    /// with values based on element == number
58    fn equal(matrix: &Matrix<f32>, number: f32) -> Vec<bool> {
59        let output_bools: Vec<bool> = matrix.get_data().into_iter()
60            .map(|&item| item == number)
61            .collect::<Vec<bool>>();
62
63        return output_bools
64    }
65
66    /// Return boolean vector with one element for each matrix element
67    /// with values based on element < number
68    fn less_than(matrix: &Matrix<f32>, number: f32) -> Vec<bool> {
69        let output_bools: Vec<bool> = matrix.get_data().into_iter()
70            .map(|&item| item < number)
71            .collect::<Vec<bool>>();
72
73        return output_bools
74    }
75
76    /// Return boolean vector with one element for each matrix element
77    /// with values based on element <= number
78    fn less_equal(matrix: &Matrix<f32>, number: f32) -> Vec<bool> {
79        let output_bools: Vec<bool> = matrix.get_data().into_iter()
80            .map(|&item| item <= number)
81            .collect::<Vec<bool>>();
82
83        return output_bools
84    }
85
86    /// Return boolean vector with one element for each matrix element
87    /// with values based on element > number
88    fn greater_than(matrix: &Matrix<f32>, number: f32) -> Vec<bool> {
89        let output_bools: Vec<bool> = matrix.get_data().into_iter()
90            .map(|&item| item > number)
91            .collect::<Vec<bool>>();
92
93        return output_bools
94    }
95
96    /// Return boolean vector with one element for each matrix element
97    /// with values based on element >= number
98    fn greater_equal(matrix: &Matrix<f32>, number: f32) -> Vec<bool> {
99        let output_bools: Vec<bool> = matrix.get_data().into_iter()
100            .map(|&item| item >= number)
101            .collect::<Vec<bool>>();
102
103        return output_bools
104    }
105
106    /// Return boolean vector with one element for each matrix element
107    /// with values based on left_element == right_element
108    /// 
109    /// Returns error if left and right matrices have different dimensions
110    fn equal_mat(left_matrix: &Matrix<f32>, right_matrix: &Matrix<f32>) -> Result<Vec<bool>> {
111        if left_matrix.get_rows() != right_matrix.get_rows() || left_matrix.get_cols() != right_matrix.get_cols() {
112            return Err(Jeeperr::DimensionError)
113        }
114
115        let n_elements: usize = left_matrix.get_rows() * left_matrix.get_cols();
116
117        let output_bools: Vec<bool> = (0..n_elements).into_iter()
118            .map(|idx| left_matrix.lindex(idx) == right_matrix.lindex(idx))
119            .collect::<Vec<bool>>();
120
121        return Ok(output_bools)
122    }
123
124    /// Return boolean vector with one element for each matrix element
125    /// with values based on left_element < right_element
126    /// 
127    /// Returns error if left and right matrices have different dimensions
128    fn less_than_mat(left_matrix: &Matrix<f32>, right_matrix: &Matrix<f32>) -> Result<Vec<bool>> {
129        if left_matrix.get_rows() != right_matrix.get_rows() || left_matrix.get_cols() != right_matrix.get_cols() {
130            return Err(Jeeperr::DimensionError)
131        }
132
133        let n_elements: usize = left_matrix.get_rows() * left_matrix.get_cols();
134
135        let output_bools: Vec<bool> = (0..n_elements).into_iter()
136            .map(|idx| left_matrix.lindex(idx) < right_matrix.lindex(idx))
137            .collect::<Vec<bool>>();
138
139        return Ok(output_bools)
140    }
141
142    /// Return boolean vector with one element for each matrix element
143    /// with values based on left_element <= right_element
144    /// 
145    /// Returns error if left and right matrices have different dimensions
146    fn less_equal_mat(left_matrix: &Matrix<f32>, right_matrix: &Matrix<f32>) -> Result<Vec<bool>> {
147        if left_matrix.get_rows() != right_matrix.get_rows() || left_matrix.get_cols() != right_matrix.get_cols() {
148            return Err(Jeeperr::DimensionError)
149        }
150
151        let n_elements: usize = left_matrix.get_rows() * left_matrix.get_cols();
152
153        let output_bools: Vec<bool> = (0..n_elements).into_iter()
154            .map(|idx| left_matrix.lindex(idx) <= right_matrix.lindex(idx))
155            .collect::<Vec<bool>>();
156
157        return Ok(output_bools)
158    }
159
160    /// Return boolean vector with one element for each matrix element
161    /// with values based on left_element > right_element
162    /// 
163    /// Returns error if left and right matrices have different dimensions
164    fn greater_than_mat(left_matrix: &Matrix<f32>, right_matrix: &Matrix<f32>) -> Result<Vec<bool>> {
165        if left_matrix.get_rows() != right_matrix.get_rows() || left_matrix.get_cols() != right_matrix.get_cols() {
166            return Err(Jeeperr::DimensionError)
167        }
168
169        let n_elements: usize = left_matrix.get_rows() * left_matrix.get_cols();
170
171        let output_bools: Vec<bool> = (0..n_elements).into_iter()
172            .map(|idx| left_matrix.lindex(idx) > right_matrix.lindex(idx))
173            .collect::<Vec<bool>>();
174
175        return Ok(output_bools)
176    }
177
178    /// Return boolean vector with one element for each matrix element
179    /// with values based on left_element >= right_element
180    /// 
181    /// Returns error if left and right matrices have different dimensions
182    fn greater_equal_mat(left_matrix: &Matrix<f32>, right_matrix: &Matrix<f32>) -> Result<Vec<bool>> {
183        if left_matrix.get_rows() != right_matrix.get_rows() || left_matrix.get_cols() != right_matrix.get_cols() {
184            return Err(Jeeperr::DimensionError)
185        }
186
187        let n_elements: usize = left_matrix.get_rows() * left_matrix.get_cols();
188
189        let output_bools: Vec<bool> = (0..n_elements).into_iter()
190            .map(|idx| left_matrix.lindex(idx) >= right_matrix.lindex(idx))
191            .collect::<Vec<bool>>();
192
193        return Ok(output_bools)
194    }
195}
196
197impl BooleanMatrixOperations<f64> for Matrix<f64> {
198    /// Return boolean vector with one element for each matrix element
199    /// with values based on element == number
200    fn equal(matrix: &Matrix<f64>, number: f64) -> Vec<bool> {
201        let output_bools: Vec<bool> = matrix.get_data().into_iter()
202            .map(|&item| item == number)
203            .collect::<Vec<bool>>();
204
205        return output_bools
206    }
207
208    /// Return boolean vector with one element for each matrix element
209    /// with values based on element < number
210    fn less_than(matrix: &Matrix<f64>, number: f64) -> Vec<bool> {
211        let output_bools: Vec<bool> = matrix.get_data().into_iter()
212            .map(|&item| item < number)
213            .collect::<Vec<bool>>();
214
215        return output_bools
216    }
217
218    /// Return boolean vector with one element for each matrix element
219    /// with values based on element <= number
220    fn less_equal(matrix: &Matrix<f64>, number: f64) -> Vec<bool> {
221        let output_bools: Vec<bool> = matrix.get_data().into_iter()
222            .map(|&item| item <= number)
223            .collect::<Vec<bool>>();
224
225        return output_bools
226    }
227
228    /// Return boolean vector with one element for each matrix element
229    /// with values based on element > number
230    fn greater_than(matrix: &Matrix<f64>, number: f64) -> Vec<bool> {
231        let output_bools: Vec<bool> = matrix.get_data().into_iter()
232            .map(|&item| item > number)
233            .collect::<Vec<bool>>();
234
235        return output_bools
236    }
237
238    /// Return boolean vector with one element for each matrix element
239    /// with values based on element >= number
240    fn greater_equal(matrix: &Matrix<f64>, number: f64) -> Vec<bool> {
241        let output_bools: Vec<bool> = matrix.get_data().into_iter()
242            .map(|&item| item >= number)
243            .collect::<Vec<bool>>();
244
245        return output_bools
246    }
247
248    /// Return boolean vector with one element for each matrix element
249    /// with values based on left_element == right_element
250    /// 
251    /// Returns error if left and right matrices have different dimensions
252    fn equal_mat(left_matrix: &Matrix<f64>, right_matrix: &Matrix<f64>) -> Result<Vec<bool>> {
253        if left_matrix.get_rows() != right_matrix.get_rows() || left_matrix.get_cols() != right_matrix.get_cols() {
254            return Err(Jeeperr::DimensionError)
255        }
256
257        let n_elements: usize = left_matrix.get_rows() * left_matrix.get_cols();
258
259        let output_bools: Vec<bool> = (0..n_elements).into_iter()
260            .map(|idx| left_matrix.lindex(idx) == right_matrix.lindex(idx))
261            .collect::<Vec<bool>>();
262
263        return Ok(output_bools)
264    }
265
266    /// Return boolean vector with one element for each matrix element
267    /// with values based on left_element < right_element
268    /// 
269    /// Returns error if left and right matrices have different dimensions
270    fn less_than_mat(left_matrix: &Matrix<f64>, right_matrix: &Matrix<f64>) -> Result<Vec<bool>> {
271        if left_matrix.get_rows() != right_matrix.get_rows() || left_matrix.get_cols() != right_matrix.get_cols() {
272            return Err(Jeeperr::DimensionError)
273        }
274
275        let n_elements: usize = left_matrix.get_rows() * left_matrix.get_cols();
276
277        let output_bools: Vec<bool> = (0..n_elements).into_iter()
278            .map(|idx| left_matrix.lindex(idx) < right_matrix.lindex(idx))
279            .collect::<Vec<bool>>();
280
281        return Ok(output_bools)
282    }
283
284    /// Return boolean vector with one element for each matrix element
285    /// with values based on left_element <= right_element
286    /// 
287    /// Returns error if left and right matrices have different dimensions
288    fn less_equal_mat(left_matrix: &Matrix<f64>, right_matrix: &Matrix<f64>) -> Result<Vec<bool>> {
289        if left_matrix.get_rows() != right_matrix.get_rows() || left_matrix.get_cols() != right_matrix.get_cols() {
290            return Err(Jeeperr::DimensionError)
291        }
292
293        let n_elements: usize = left_matrix.get_rows() * left_matrix.get_cols();
294
295        let output_bools: Vec<bool> = (0..n_elements).into_iter()
296            .map(|idx| left_matrix.lindex(idx) <= right_matrix.lindex(idx))
297            .collect::<Vec<bool>>();
298
299        return Ok(output_bools)
300    }
301
302    /// Return boolean vector with one element for each matrix element
303    /// with values based on left_element > right_element
304    /// 
305    /// Returns error if left and right matrices have different dimensions
306    fn greater_than_mat(left_matrix: &Matrix<f64>, right_matrix: &Matrix<f64>) -> Result<Vec<bool>> {
307        if left_matrix.get_rows() != right_matrix.get_rows() || left_matrix.get_cols() != right_matrix.get_cols() {
308            return Err(Jeeperr::DimensionError)
309        }
310
311        let n_elements: usize = left_matrix.get_rows() * left_matrix.get_cols();
312
313        let output_bools: Vec<bool> = (0..n_elements).into_iter()
314            .map(|idx| left_matrix.lindex(idx) > right_matrix.lindex(idx))
315            .collect::<Vec<bool>>();
316
317        return Ok(output_bools)
318    }
319
320    /// Return boolean vector with one element for each matrix element
321    /// with values based on left_element >= right_element
322    /// 
323    /// Returns error if left and right matrices have different dimensions
324    fn greater_equal_mat(left_matrix: &Matrix<f64>, right_matrix: &Matrix<f64>) -> Result<Vec<bool>> {
325        if left_matrix.get_rows() != right_matrix.get_rows() || left_matrix.get_cols() != right_matrix.get_cols() {
326            return Err(Jeeperr::DimensionError)
327        }
328
329        let n_elements: usize = left_matrix.get_rows() * left_matrix.get_cols();
330
331        let output_bools: Vec<bool> = (0..n_elements).into_iter()
332            .map(|idx| left_matrix.lindex(idx) >= right_matrix.lindex(idx))
333            .collect::<Vec<bool>>();
334
335        return Ok(output_bools)
336    }
337}
gpurs/linalg/bool_ops.rs

gpurs/linalg/
bool_ops.rs
