1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
use array_trait::Array;
use slice_ops::AsSlice;
#[const_trait]
pub trait ArrayArgReduce<T, const N: usize>: Array + AsSlice<Item = T>
{
/// Performs an argument reduction, finding the final righthand operand for which the comparison yields true.
///
/// # Example
///
/// ```rust
/// use array__ops::ops::*;
///
/// fn my_argmax<T, const N: usize>(slice: &[T; N]) -> Option<usize>
/// where
/// T: PartialOrd
/// {
/// slice.argreduce(PartialOrd::gt)
/// }
///
/// fn my_argmin<T, const N: usize>(slice: &[T; N]) -> Option<usize>
/// where
/// T: PartialOrd
/// {
/// slice.argreduce(PartialOrd::lt)
/// }
///
/// let x = [1, 5, 5, 6, 2, -1, 0, -4, -1, 6];
///
/// assert_eq!(my_argmax(&x), x.argmax());
/// assert_eq!(my_argmin(&x), x.argmin());
/// ```
fn argreduce<'a, F>(&'a self, reduction: F) -> Option<usize>
where
F: FnMut(&'a T, &'a T) -> bool /*+ ~const Destruct*/,
T: 'a;
/// Performs an argument reduction on the hashed values, finding the final righthand operand for which the comparison yields true.
///
/// # Example
///
/// ```rust
/// use array__ops::ops::*;
///
/// fn hasher(str: &&str) -> i32
/// {
/// i32::from_str_radix(str, 10).unwrap()
/// }
///
/// fn my_argmax<const N: usize>(slice: &[&str; N]) -> Option<usize>
/// {
/// slice.argreduce_key(PartialOrd::gt, hasher)
/// }
///
/// fn my_argmin<const N: usize>(slice: &[&str; N]) -> Option<usize>
/// {
/// slice.argreduce_key(PartialOrd::lt, hasher)
/// }
///
/// let x = ["1", "5", "5", "6", "2", "-1", "0", "-4", "-1", "6"];
///
/// assert_eq!(my_argmax(&x), x.argmax_by_key(hasher));
/// assert_eq!(my_argmin(&x), x.argmin_by_key(hasher));
/// ```
fn argreduce_key<'a, B, FR, FB>(&'a self, reduction: FR, hasher: FB) -> Option<usize>
where
FR: FnMut(&B, &B) -> bool /*+ ~const Destruct*/,
FB: FnMut(&'a T) -> B /*+ ~const Destruct*/,
T: 'a;
}
impl<T, const N: usize> ArrayArgReduce<T, N> for [T; N]
{
fn argreduce<'a, F>(&'a self, mut reduction: F) -> Option<usize>
where
F: FnMut(&'a T, &'a T) -> bool /*+ ~const Destruct*/,
T: 'a
{
if N == 0
{
return None;
}
let mut i = 1;
let mut j = 0;
while i < N
{
if reduction(&self[i], &self[j])
{
j = i;
}
i += 1;
}
Some(j)
}
fn argreduce_key<'a, B, FR, FB>(&'a self, mut reduction: FR, mut hasher: FB) -> Option<usize>
where
FR: FnMut(&B, &B) -> bool /*+ ~const Destruct*/,
FB: FnMut(&'a T) -> B /*+ ~const Destruct*/,
T: 'a
{
if N == 0
{
return None;
}
let mut j = 0;
let mut i = 1;
let mut key = hasher(&self[j]);
while i < N
{
let next_key = hasher(&self[i]);
if reduction(&next_key, &key)
{
j = i;
key = next_key;
}
i += 1;
}
Some(j)
}
}