irox-tools 0.10.3

Stuff that should have been in the Rust STL, but aren't
Documentation 
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

// SPDX-License-Identifier: MIT
// Copyright 2025 IROX Contributors
//

//!
//! Functions and tools for manipulating arrays of items.
//!

#[macro_export]
macro_rules! array {
    (@accum (0, $($_es:expr),*) -> ($($body:tt)*))
        => {array!(@as_expr [$($body)*])};
    (@accum (1, $($es:expr),*) -> ($($body:tt)*))
        => {array!(@accum (0, $($es),*) -> ($($body)* $($es,)*))};
    (@accum (2, $($es:expr),*) -> ($($body:tt)*))
        => {array!(@accum (0, $($es),*) -> ($($body)* $($es,)* $($es,)*))};
    (@accum (3, $($es:expr),*) -> ($($body:tt)*))
        => {array!(@accum (2, $($es),*) -> ($($body)* $($es,)*))};
    (@accum (4, $($es:expr),*) -> ($($body:tt)*))
        => {array!(@accum (2, $($es,)* $($es),*) -> ($($body)*))};
    (@accum (5, $($es:expr),*) -> ($($body:tt)*))
        => {array!(@accum (4, $($es),*) -> ($($body)* $($es,)*))};
    (@accum (6, $($es:expr),*) -> ($($body:tt)*))
        => {array!(@accum (4, $($es),*) -> ($($body)* $($es,)* $($es,)*))};
    (@accum (7, $($es:expr),*) -> ($($body:tt)*))
        => {array!(@accum (4, $($es),*) -> ($($body)* $($es,)* $($es,)* $($es,)*))};
    (@accum (8, $($es:expr),*) -> ($($body:tt)*))
        => {array!(@accum (4, $($es,)* $($es),*) -> ($($body)*))};
    (@accum (16, $($es:expr),*) -> ($($body:tt)*))
        => {array!(@accum (8, $($es,)* $($es),*) -> ($($body)*))};
    (@accum (32, $($es:expr),*) -> ($($body:tt)*))
        => {array!(@accum (16, $($es,)* $($es),*) -> ($($body)*))};
    (@accum (64, $($es:expr),*) -> ($($body:tt)*))
        => {array!(@accum (32, $($es,)* $($es),*) -> ($($body)*))};

    (@as_expr $e:expr) => {$e};

    [$e:expr; $n:tt] => { array!(@accum ($n, $e) -> ()) };
}

///
/// Scans through the array, looking for the maximum value contained within it, using the
/// [`PartialOrd`] operation.  Returns the first index of the maximum detected value.
///
/// # Example
/// ```
/// use irox_tools::arrays::max_index;
/// let arr = &[8,2,7,4,6,3,8,2,15,1,6];
/// let max_idx = max_index(arr);
///
/// assert_eq!(max_idx, Some(8));
/// ```
pub fn max_index<T: PartialOrd>(arr: &[T]) -> Option<usize> {
    let mut max_idx: Option<usize> = None;
    let mut max_val: Option<&T> = None;
    for (idx, val) in arr.iter().enumerate() {
        if max_idx.is_none() {
            max_idx = Some(idx);
            max_val = Some(val);
        } else if let Some(mv) = max_val {
            if val.gt(mv) {
                max_val = Some(val);
                max_idx = Some(idx);
            }
        }
    }
    max_idx
}

///
/// Copies from the provided source slice into a statically sized output array.  Uses [`&T::copy_from_slice`]
/// under-the-hood, and will panic if `N` is greater than the provided slice length.
pub fn copy_subset<T: Copy + Default, const N: usize>(arr: &[T]) -> [T; N] {
    let mut out = [T::default(); N];
    out.copy_from_slice(arr.split_at(N).0);
    out
}

///
/// Searches the provided array for the longest consecutive repeated sequence of 'val'.
///
/// # Example
/// ```
/// # use irox_tools::arrays::longest_consecutive_values;
/// let (position,length) = longest_consecutive_values(&[1,0,0,0,0,0,1,2,3,4,5,6], &0).unwrap();
///
/// assert_eq!(position, 1);
/// assert_eq!(length, 5);
/// ```
pub fn longest_consecutive_values<T: PartialOrd>(arr: &[T], val: &T) -> Option<(usize, usize)> {
    let len = arr.len();
    let mut best_count: usize = 0;
    let mut best_position: usize = 0;
    let mut start_pos = 0;
    while start_pos < len {
        let mut count: usize = 0;
        let arr = arr.get(start_pos..)?;
        for (idx, v) in arr.iter().enumerate() {
            if v.ne(val) {
                start_pos += idx;
                break;
            }
            count += 1;
        }
        if count > best_count {
            best_count = count;
            if start_pos != 0 {
                best_position = start_pos - count;
            }
        }
        start_pos += 1;
    }
    if best_count > 0 {
        return Some((best_position, best_count));
    }
    None
}

#[cfg(test)]
mod tests {
    use crate::arrays::longest_consecutive_values;

    #[test]
    pub fn test1() {
        let (position, length) =
            longest_consecutive_values(&[1, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6], &0).unwrap();

        assert_eq!(position, 1);
        assert_eq!(length, 5);
    }

    #[test]
    pub fn test2() {
        let (position, length) =
            longest_consecutive_values(&[1, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 4, 5, 6], &0).unwrap();

        assert_eq!(position, 6);
        assert_eq!(length, 5);
    }
}