1pub mod prelude;
2pub use prelude::IterExtra;
3
4#[cfg(test)]
5mod tests {
6 use crate::prelude::*;
7
8 #[test]
9 fn min_by_partial_key_basic() {
10 let numbers = vec![3.2, 1.5, 2.8, 0.9];
11 let min = numbers.iter().min_by_partial_key(|&x| x);
12 assert_eq!(min, Some(&0.9));
13 }
14
15 #[test]
16 fn min_by_partial_key_empty() {
17 let empty: Vec<f64> = vec![];
18 let min = empty.iter().min_by_partial_key(|&x| x);
19 assert_eq!(min, None);
20 }
21
22 #[test]
23 fn min_by_partial_key_single_element() {
24 let single = vec![42.0];
25 let min = single.iter().min_by_partial_key(|&x| x);
26 assert_eq!(min, Some(&42.0));
27 }
28
29 #[test]
30 fn min_by_partial_key_with_nan() {
31 let with_nan = vec![1.0, f64::NAN, 2.0, 0.5];
32 let min = with_nan.iter().min_by_partial_key(|&x| x);
33 assert_eq!(min, Some(&0.5));
34 }
35
36 #[test]
37 fn min_by_partial_key_all_nan() {
38 let all_nan = vec![f64::NAN, f64::NAN, f64::NAN];
39 let min = all_nan.iter().min_by_partial_key(|&x| x);
40 assert!(min.is_some());
41 assert!(min.unwrap().is_nan());
42 }
43
44 #[test]
45 fn min_by_partial_key_with_key_function() {
46 let people = vec![("Alice", 25), ("Bob", 30), ("Charlie", 20), ("Diana", 35)];
47 let youngest = people.iter().min_by_partial_key(|(_, age)| *age);
48 assert_eq!(youngest, Some(&("Charlie", 20)));
49 }
50
51 #[test]
52 fn min_by_partial_key_negative_numbers() {
53 let numbers = vec![-1.5, -3.2, -0.8, -2.1];
54 let min = numbers.iter().min_by_partial_key(|&x| x);
55 assert_eq!(min, Some(&-3.2));
56 }
57
58 #[test]
59 fn max_by_partial_key_basic() {
60 let numbers = vec![3.2, 1.5, 2.8, 0.9];
61 let max = numbers.iter().max_by_partial_key(|&x| x);
62 assert_eq!(max, Some(&3.2));
63 }
64
65 #[test]
66 fn max_by_partial_key_empty() {
67 let empty: Vec<f64> = vec![];
68 let max = empty.iter().max_by_partial_key(|&x| x);
69 assert_eq!(max, None);
70 }
71
72 #[test]
73 fn max_by_partial_key_single_element() {
74 let single = vec![42.0];
75 let max = single.iter().max_by_partial_key(|&x| x);
76 assert_eq!(max, Some(&42.0));
77 }
78
79 #[test]
80 fn max_by_partial_key_with_nan() {
81 let with_nan = vec![1.0, f64::NAN, 2.0, 0.5];
82 let max = with_nan.iter().max_by_partial_key(|&x| x);
83 assert_eq!(max, Some(&2.0));
84 }
85
86 #[test]
87 fn max_by_partial_key_all_nan() {
88 let all_nan = vec![f64::NAN, f64::NAN, f64::NAN];
89 let max = all_nan.iter().max_by_partial_key(|&x| x);
90 assert!(max.is_some());
91 assert!(max.unwrap().is_nan());
92 }
93
94 #[test]
95 fn max_by_partial_key_with_key_function() {
96 let people = vec![("Alice", 25), ("Bob", 30), ("Charlie", 20), ("Diana", 35)];
97 let oldest = people.iter().max_by_partial_key(|(_, age)| *age);
98 assert_eq!(oldest, Some(&("Diana", 35)));
99 }
100
101 #[test]
102 fn max_by_partial_key_negative_numbers() {
103 let numbers = vec![-1.5, -3.2, -0.8, -2.1];
104 let max = numbers.iter().max_by_partial_key(|&x| x);
105 assert_eq!(max, Some(&-0.8));
106 }
107
108 #[test]
109 fn min_max_with_equal_elements() {
110 let equal = vec![5.0, 5.0, 5.0];
111 let min = equal.iter().min_by_partial_key(|&x| x);
112 let max = equal.iter().max_by_partial_key(|&x| x);
113 assert_eq!(min, Some(&5.0));
114 assert_eq!(max, Some(&5.0));
115 }
116
117 #[test]
118 fn min_max_with_infinity() {
119 let with_inf = vec![1.0, f64::INFINITY, -f64::INFINITY, 2.0];
120 let min = with_inf.iter().min_by_partial_key(|&x| x);
121 let max = with_inf.iter().max_by_partial_key(|&x| x);
122 assert_eq!(min, Some(&f64::NEG_INFINITY));
123 assert_eq!(max, Some(&f64::INFINITY));
124 }
125
126 #[test]
127 fn min_max_with_option_flatten() {
128 let arr = vec![Some(1.1f64), None, Some(1.2f64), Some(0.5f64)];
129 assert_eq!(
130 arr.iter().flatten().min_by_partial_key(|&x| x),
131 Some(&0.5f64)
132 );
133
134 let arr = vec![Some(1.1f64), None, Some(1.2f64), Some(0.5f64)];
135 assert_eq!(
136 arr.iter().flatten().max_by_partial_key(|&x| x),
137 Some(&1.2f64)
138 );
139 }
140
141 #[test]
142 fn min_max_with_complex_key_function() {
143 let points = vec![(1.0, 2.0), (3.0, 1.0), (2.0, 3.0), (0.5, 0.5)];
144
145 let closest_to_origin = points.iter().min_by_partial_key(|(x, y)| x * x + y * y);
146 assert_eq!(closest_to_origin, Some(&(0.5, 0.5)));
147
148 let farthest_from_origin = points.iter().max_by_partial_key(|(x, y)| x * x + y * y);
149 assert_eq!(farthest_from_origin, Some(&(2.0, 3.0)));
150 }
151
152 #[test]
153 fn min_max_with_string_length() {
154 let words = vec!["hello", "world", "rust", "programming"];
155
156 let shortest = words.iter().min_by_partial_key(|s| s.len());
157 assert_eq!(shortest, Some(&"rust"));
158
159 let longest = words.iter().max_by_partial_key(|s| s.len());
160 assert_eq!(longest, Some(&"programming"));
161 }
162
163 #[test]
164 fn deltas() {
165 let arr = vec![1, 1, 2, 2, 3, 3, 2, 3, 4];
166 let deltas = arr.iter().deltas();
167 assert_eq!(
168 deltas.collect::<Vec<usize>>(),
169 vec![0, 0, 2, 0, 4, 0, 2, 1, 8]
170 );
171 }
172
173 #[test]
174 fn deltas_empty() {
175 let arr: Vec<i32> = vec![];
176 let deltas = arr.iter().deltas();
177 assert_eq!(deltas.collect::<Vec<usize>>(), vec![]);
178 }
179
180 #[test]
181 fn deltas_single() {
182 let arr = vec![1];
183 let deltas = arr.iter().deltas();
184 assert_eq!(deltas.collect::<Vec<usize>>(), vec![0]);
185 }
186
187 #[test]
188 fn deltas_all_unique() {
189 let arr = vec![1, 2, 3, 4, 5];
190 let deltas = arr.iter().deltas();
191 assert_eq!(deltas.collect::<Vec<usize>>(), vec![0, 1, 2, 3, 4]);
192 }
193
194 #[test]
195 fn deltas_all_same() {
196 let arr = vec![1, 1, 1, 1];
197 let deltas = arr.iter().deltas();
198 assert_eq!(deltas.collect::<Vec<usize>>(), vec![0, 0, 0, 0]);
199 }
200
201 #[test]
202 fn deltas_twice_over_same_collection() {
203 let arr = vec![1, 1, 1, 1];
204 let deltas = arr.iter().deltas().collect::<Vec<usize>>();
205 assert_eq!(deltas, vec![0, 0, 0, 0]);
206 }
207
208 #[test]
209 fn deltas_by_basic() {
210 let arr = vec![1, 3, 2, 4, 1, 5];
211 let deltas = arr.iter().deltas_by(|a, b| a.cmp(b));
212 assert_eq!(deltas.collect::<Vec<usize>>(), vec![0, 1, 2, 3, 3, 5]);
213 }
214
215 #[test]
216 fn deltas_by_custom_ordering() {
217 let arr = vec![1i32, -1, 2, -2, 3, -3];
218 let deltas = arr.iter().deltas_by(|a, b| a.abs().cmp(&b.abs()));
220 assert_eq!(deltas.collect::<Vec<usize>>(), vec![0, 0, 2, 0, 4, 0]);
221 }
222
223 #[test]
224 fn deltas_by_empty() {
225 let arr: Vec<i32> = vec![];
226 let deltas = arr.iter().deltas_by(|a, b| a.cmp(b));
227 assert_eq!(deltas.collect::<Vec<usize>>(), vec![]);
228 }
229
230 #[test]
231 fn deltas_by_single() {
232 let arr = vec![42];
233 let deltas = arr.iter().deltas_by(|a, b| a.cmp(b));
234 assert_eq!(deltas.collect::<Vec<usize>>(), vec![0]);
235 }
236
237 #[test]
238 fn deltas_by_key_basic() {
239 let arr = vec![1, 11, 2, 22, 1, 33];
240 let deltas = arr.iter().deltas_by_key(|x| *x % 10);
242 assert_eq!(deltas.collect::<Vec<usize>>(), vec![0, 0, 2, 0, 2, 5]);
243 }
244
245 #[test]
246 fn deltas_by_key_strings() {
247 let arr = vec!["apple", "apricot", "banana", "avocado", "blueberry"];
248 let deltas = arr.iter().deltas_by_key(|s| s.chars().next().unwrap());
250 assert_eq!(deltas.collect::<Vec<usize>>(), vec![0, 0, 2, 1, 1]);
251 }
252
253 #[test]
254 fn deltas_by_key_tuples() {
255 let arr = vec![(1, 'a'), (2, 'b'), (1, 'c'), (3, 'd'), (2, 'e')];
256 let deltas = arr.iter().deltas_by_key(|(x, _)| *x);
258 assert_eq!(deltas.collect::<Vec<usize>>(), vec![0, 1, 1, 3, 2]);
259 }
260
261 #[test]
262 fn deltas_by_key_empty() {
263 let arr: Vec<i32> = vec![];
264 let deltas = arr.iter().deltas_by_key(|x| *x);
265 assert_eq!(deltas.collect::<Vec<usize>>(), vec![]);
266 }
267
268 #[test]
269 fn deltas_by_key_single() {
270 let arr = vec![42];
271 let deltas = arr.iter().deltas_by_key(|x| *x);
272 assert_eq!(deltas.collect::<Vec<usize>>(), vec![0]);
273 }
274}