one-indexed-vec 0.2.0

A one-based (1-indexed) wrapper around Vec<T>: element at position N is accessed via vec[N].
Documentation
//! Search operations.

use crate::Vec1;

// ============================================================================
// Element lookup (T: PartialEq)
// ============================================================================

impl<T> Vec1<T>
where
    T: Copy + PartialEq,
{
    /// 1-based index of first occurrence.
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let v = vec1![10, 20, 30, 20, 40];
    /// assert_eq!(v.find_first(&20), Some(2));
    /// assert_eq!(v.find_first(&50), None);
    /// ```
    #[inline]
    pub fn find_first(&self, value: &T) -> Option<usize> {
        self.iter().position(|x| x == value).map(|p| p + 1)
    }

    /// 1-based index of last occurrence.
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let v = vec1![10, 20, 30, 20, 40];
    /// assert_eq!(v.find_last(&20), Some(4));
    /// assert_eq!(v.find_last(&50), None);
    /// ```
    #[inline]
    pub fn find_last(&self, value: &T) -> Option<usize> {
        self.iter().rposition(|x| x == value).map(|p| p + 1)
    }

    /// All 1-based indices of `value`.
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let v = vec1![1, 2, 1, 3, 1];
    /// assert_eq!(v.find_all(&1).as_slice(), &[1, 3, 5]);
    /// ```
    pub fn find_all(&self, value: &T) -> Vec1<usize> {
        let mut out = Vec1::new();
        for (i, x) in self.iter().enumerate() {
            if x == value {
                out.push(i + 1);
            }
        }
        out
    }
}

// ============================================================================
// Extremum indices (T: PartialOrd)
// ============================================================================

impl<T> Vec1<T>
where
    T: PartialOrd,
{
    /// 1-based index of the maximum element.
    ///
    /// Returns `None` for an empty vector.
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let v = vec1![3, 1, 4, 1, 5, 9, 2, 6];
    /// assert_eq!(v.argmax(), Some(6));
    /// ```
    pub fn argmax(&self) -> Option<usize> {
        let mut best_idx: Option<usize> = None;
        let mut best_val: Option<&T> = None;
        for (i, x) in self.iter().enumerate() {
            match best_val {
                None => {
                    best_val = Some(x);
                    best_idx = Some(i + 1);
                }
                Some(b) => {
                    if x > b {
                        best_val = Some(x);
                        best_idx = Some(i + 1);
                    }
                }
            }
        }
        best_idx
    }

    /// 1-based index of the minimum element.
    ///
    /// Returns `None` for an empty vector.
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let v = vec1![3, 1, 4, 1, 5, 9, 2, 6];
    /// assert_eq!(v.argmin(), Some(2));
    /// ```
    pub fn argmin(&self) -> Option<usize> {
        let mut best_idx: Option<usize> = None;
        let mut best_val: Option<&T> = None;
        for (i, x) in self.iter().enumerate() {
            match best_val {
                None => {
                    best_val = Some(x);
                    best_idx = Some(i + 1);
                }
                Some(b) => {
                    if x < b {
                        best_val = Some(x);
                        best_idx = Some(i + 1);
                    }
                }
            }
        }
        best_idx
    }
}

// ============================================================================
// Tests
// ============================================================================

#[cfg(test)]
mod tests {
    use super::*;
    use crate::vec1;

    // ----- find_first / find_last -----

    #[test]
    fn find_first_last() {
        let v = vec1![10, 20, 30, 20, 40];
        assert_eq!(v.find_first(&20), Some(2));
        assert_eq!(v.find_last(&20), Some(4));
        assert_eq!(v.find_first(&50), None);
        assert_eq!(v.find_last(&50), None);
    }

    #[test]
    fn find_first_last_empty() {
        let v: Vec1<i32> = Vec1::new();
        assert_eq!(v.find_first(&1), None);
        assert_eq!(v.find_last(&1), None);
    }

    // ----- find_all -----

    #[test]
    fn find_all_basic() {
        let v = vec1![1, 2, 1, 3, 1];
        assert_eq!(v.find_all(&1).as_slice(), &[1, 3, 5]);
    }

    #[test]
    fn find_all_no_match() {
        let v = vec1![1, 2, 3];
        assert!(v.find_all(&99).is_empty());
    }

    #[test]
    fn find_all_single() {
        let v = vec1![5];
        assert_eq!(v.find_all(&5).as_slice(), &[1]);
    }

    // ----- argmax / argmin -----

    #[test]
    fn argmax_argmin() {
        let v = vec1![3, 1, 4, 1, 5, 9, 2, 6];
        assert_eq!(v.argmax(), Some(6));
        assert_eq!(v.argmin(), Some(2));
    }

    #[test]
    fn argmax_argmin_empty() {
        let v: Vec1<i32> = Vec1::new();
        assert_eq!(v.argmax(), None);
        assert_eq!(v.argmin(), None);
    }

    #[test]
    fn argmax_argmin_single() {
        let v = vec1![7];
        assert_eq!(v.argmax(), Some(1));
        assert_eq!(v.argmin(), Some(1));
    }

    #[test]
    fn argmax_first_maximum() {
        // Ties: argmax returns the first occurrence
        let v = vec1![1, 5, 3, 5, 2];
        assert_eq!(v.argmax(), Some(2));
        assert_eq!(v.argmin(), Some(1));
    }
}