arr_rs/core/operations/iter.rs
1use crate::{
2 core::prelude::*,
3 errors::prelude::*,
4};
5
6impl <N: ArrayElement> IntoIterator for Array<N> {
7 type Item = N;
8 type IntoIter = std::vec::IntoIter<N>;
9
10 fn into_iter(self) -> Self::IntoIter {
11 self.elements.into_iter()
12 }
13}
14
15impl<'a, N: ArrayElement> IntoIterator for &'a Array<N> {
16 type Item = &'a N;
17 type IntoIter = std::slice::Iter<'a, N>;
18
19 fn into_iter(self) -> Self::IntoIter {
20 self.elements.iter()
21 }
22}
23
24impl <N: ArrayElement> FromIterator<N> for Array<N> {
25
26 fn from_iter<T: IntoIterator<Item=N>>(iter: T) -> Self {
27 Self::flat(iter.into_iter().collect()).unwrap()
28 }
29}
30
31/// `ArrayTrait` - Array Iterable functions
32pub trait ArrayIter<T: ArrayElement> where Self: Sized + Clone {
33
34 /// Loop over array elements
35 ///
36 /// # Arguments
37 ///
38 /// * `f` - function to be called on each array element
39 ///
40 /// # Examples
41 ///
42 /// ```
43 /// use arr_rs::prelude::*;
44 ///
45 /// let arr = Array::new(vec![1, 2, 3, 4, 5, 6, 7, 8], vec![2, 4]).unwrap();
46 /// arr.for_each(|item| println!("{item}")).unwrap();
47 /// ```
48 ///
49 /// # Errors
50 ///
51 /// may returns `ArrayError`
52 fn for_each<F: FnMut(&T)>(&self, f: F) -> Result<(), ArrayError>;
53
54 /// Loop over enumerated array elements
55 ///
56 /// # Arguments
57 ///
58 /// * `f` - function to be called on each array element
59 ///
60 /// # Examples
61 ///
62 /// ```
63 /// use arr_rs::prelude::*;
64 ///
65 /// let arr = Array::new(vec![1, 2, 3, 4, 5, 6, 7, 8], vec![2, 4]).unwrap();
66 /// arr.for_each_e(|idx, item| println!("{idx}:{item}")).unwrap();
67 /// ```
68 ///
69 /// # Errors
70 ///
71 /// may returns `ArrayError`
72 fn for_each_e<F: FnMut(usize, &T)>(&self, f: F) -> Result<(), ArrayError>;
73
74 /// Filter over array elements
75 /// Returns a flat filtered array
76 ///
77 /// # Arguments
78 ///
79 /// * `f` - function to be called on each array element
80 ///
81 /// # Examples
82 ///
83 /// ```
84 /// use arr_rs::prelude::*;
85 ///
86 /// let arr: Array<i32> = Array::new(vec![1, 2, 3, 4, 5, 6, 7, 8], vec![2, 4]).unwrap();
87 /// arr.filter(|item| item % 2 == 0).unwrap();
88 /// ```
89 ///
90 /// # Errors
91 ///
92 /// may returns `ArrayError`
93 fn filter<F: FnMut(&T) -> bool>(&self, f: F)-> Result<Array<T>, ArrayError>;
94
95 /// Filter over enumerated array elements
96 /// Returns a flat filtered array
97 ///
98 /// # Arguments
99 ///
100 /// * `f` - function to be called on each array element
101 ///
102 /// # Examples
103 ///
104 /// ```
105 /// use arr_rs::prelude::*;
106 ///
107 /// let arr: Array<i32> = Array::new(vec![1, 2, 3, 4, 5, 6, 7, 8], vec![2, 4]).unwrap();
108 /// arr.filter_e(|idx, item| item % (idx + 1) as i32 == 0).unwrap();
109 /// ```
110 ///
111 /// # Errors
112 ///
113 /// may returns `ArrayError`
114 fn filter_e<F: FnMut(usize, &T) -> bool>(&self, f: F)-> Result<Array<T>, ArrayError>;
115}
116
117impl <T: ArrayElement> ArrayIter<T> for Array<T> {
118
119 fn for_each<F: FnMut(&T)>(&self, f: F) -> Result<(), ArrayError> {
120 self.elements.iter().for_each(f);
121 Ok(())
122 }
123
124 fn for_each_e<F: FnMut(usize, &T)>(&self, mut f: F) -> Result<(), ArrayError> {
125 self.elements.iter().enumerate().for_each(|(idx, item)| f(idx, item));
126 Ok(())
127 }
128
129 fn filter<F: FnMut(&T) -> bool>(&self, mut f: F) -> Result<Self, ArrayError> {
130 self.elements.clone().into_iter()
131 .filter(|item| f(item))
132 .collect::<Self>()
133 .ravel()
134 }
135
136 fn filter_e<F: FnMut(usize, &T) -> bool>(&self, mut f: F) -> Result<Self, ArrayError> {
137 self.elements.clone().into_iter().enumerate()
138 .filter(|(idx, item)| f(*idx, item))
139 .map(|i| i.1)
140 .collect::<Self>()
141 .ravel()
142 }
143}
144
145/// `ArrayTrait` - Array Iterable functions
146pub trait ArrayIterMut<S: ArrayElement, T: ArrayElement> where Self: Sized + Clone {
147
148 /// Map over array elements
149 ///
150 /// # Arguments
151 ///
152 /// * `f` - function to be called on each array element
153 ///
154 /// # Examples
155 ///
156 /// ```
157 /// use arr_rs::prelude::*;
158 ///
159 /// let arr: Array<i32> = Array::new(vec![1, 2, 3, 4, 5, 6, 7, 8], vec![2, 4]).unwrap();
160 /// arr.map(|item| item * 2).unwrap();
161 /// ```
162 ///
163 /// # Errors
164 ///
165 /// may returns `ArrayError`
166 fn map<F: FnMut(&T) -> S>(&self, f: F)-> Result<Array<S>, ArrayError>;
167
168 /// Map over enumerated array elements
169 ///
170 /// # Arguments
171 ///
172 /// * `f` - function to be called on each array element
173 ///
174 /// # Examples
175 ///
176 /// ```
177 /// use arr_rs::prelude::*;
178 ///
179 /// let arr: Array<i32> = Array::new(vec![1, 2, 3, 4, 5, 6, 7, 8], vec![2, 4]).unwrap();
180 /// arr.map_e(|idx, item| item * idx as i32).unwrap();
181 /// ```
182 ///
183 /// # Errors
184 ///
185 /// may returns `ArrayError`
186 fn map_e<F: FnMut(usize, &T) -> S>(&self, f: F)-> Result<Array<S>, ArrayError>;
187
188 /// Filter and map over array elements
189 /// Returns a flat filtered array
190 ///
191 /// # Arguments
192 ///
193 /// * `f` - function to be called on each array element
194 ///
195 /// # Examples
196 ///
197 /// ```
198 /// use arr_rs::prelude::*;
199 ///
200 /// let arr: Array<i32> = Array::new(vec![1, 2, 3, 4, 5, 6, 7, 8], vec![2, 4]).unwrap();
201 /// arr.filter_map(|item| if item % 2 == 0 { Some(*item) } else { None }).unwrap();
202 /// ```
203 ///
204 /// # Errors
205 ///
206 /// may returns `ArrayError`
207 fn filter_map<F: FnMut(&T) -> Option<S>>(&self, f: F)-> Result<Array<S>, ArrayError>;
208
209 /// Filter and map over enumerated array elements
210 /// Returns a flat filtered array
211 ///
212 /// # Arguments
213 ///
214 /// * `f` - function to be called on each array element
215 ///
216 /// # Examples
217 ///
218 /// ```
219 /// use arr_rs::prelude::*;
220 ///
221 /// let arr: Array<i32> = Array::new(vec![1, 2, 3, 4, 5, 6, 7, 8], vec![2, 4]).unwrap();
222 /// arr.filter_map_e(|idx, item| if item % (idx + 1) as i32 == 0 { Some(*item) } else { None }).unwrap();
223 /// ```
224 ///
225 /// # Errors
226 ///
227 /// may returns `ArrayError`
228 fn filter_map_e<F: FnMut(usize, &T) -> Option<S>>(&self, f: F)-> Result<Array<S>, ArrayError>;
229
230 /// Fold elements of array elements
231 ///
232 /// # Arguments
233 ///
234 /// * `f` - function to be called on each array element
235 ///
236 /// # Examples
237 ///
238 /// ```
239 /// use arr_rs::prelude::*;
240 ///
241 /// let arr: Array<i32> = Array::new(vec![1, 2, 3, 4, 5, 6, 7, 8], vec![2, 4]).unwrap();
242 /// arr.fold(0, |a, b| a + b).unwrap();
243 /// arr.fold(1, |a, b| a * b).unwrap();
244 /// ```
245 ///
246 /// # Errors
247 ///
248 /// may returns `ArrayError`
249 fn fold<F: FnMut(&S, &T) -> S>(&self, init: S, f: F) -> Result<S, ArrayError>;
250
251 /// 'Zips up' two iterators into a single iterator of pairs
252 ///
253 /// # Arguments
254 ///
255 /// * `other` - array to zip with
256 ///
257 /// # Examples
258 ///
259 /// ```
260 /// use arr_rs::prelude::*;
261 ///
262 /// let arr_1: Array<i32> = Array::flat(vec![1, 2]).unwrap();
263 /// let arr_2: Array<i32> = Array::flat(vec![5, 6]).unwrap();
264 /// assert_eq!(Array::flat(vec![Tuple2(1, 5), Tuple2(2, 6)]), arr_1.zip(&arr_2));
265 /// ```
266 ///
267 /// # Errors
268 ///
269 /// may returns `ArrayError`
270 fn zip(&self, other: &Array<S>) -> Result<Array<Tuple2<T, S>>, ArrayError>;
271}
272
273impl <S: ArrayElement, T: ArrayElement> ArrayIterMut<S, T> for Array<T> {
274
275 fn map<F: FnMut(&T) -> S>(&self, f: F) -> Result<Array<S>, ArrayError> {
276 self.elements.iter()
277 .map(f)
278 .collect::<Array<S>>()
279 .reshape(&self.get_shape()?)
280 }
281
282 fn map_e<F: FnMut(usize, &T) -> S>(&self, mut f: F) -> Result<Array<S>, ArrayError> {
283 self.elements.iter().enumerate()
284 .map(|(idx, item)| f(idx, item))
285 .collect::<Array<S>>()
286 .reshape(&self.get_shape()?)
287 }
288
289 fn filter_map<F: FnMut(&T) -> Option<S>>(&self, f: F) -> Result<Array<S>, ArrayError> {
290 self.elements.clone().iter()
291 .filter_map(f)
292 .collect::<Array<S>>()
293 .ravel()
294 }
295
296 fn filter_map_e<F: FnMut(usize, &T) -> Option<S>>(&self, mut f: F) -> Result<Array<S>, ArrayError> {
297 self.elements.clone().iter().enumerate()
298 .filter_map(|(idx, item)| f(idx, item))
299 .collect::<Array<S>>()
300 .ravel()
301 }
302
303 fn fold<F: FnMut(&S, &T) -> S>(&self, init: S, mut f: F) -> Result<S, ArrayError> {
304 let result = self.elements.iter().fold(init, |a, b| f(&a, b));
305 Ok(result)
306 }
307
308 fn zip(&self, other: &Array<S>) -> Result<Array<Tuple2<T, S>>, ArrayError> {
309 let other = other.broadcast_to(self.get_shape()?)?;
310 self.get_elements()?.into_iter()
311 .zip(other.get_elements()?)
312 .map(|item| Tuple2(item.0, item.1))
313 .collect::<Array<Tuple2<T, S>>>()
314 .reshape(&self.get_shape()?)
315 }
316}