vectra 0.2.4

A multi-dimensional array library for Rust, similar to NumPy
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

use crate::{NumExt, core::Array};

impl<const D: usize, T: NumExt> Array<D, T> {
    pub fn min(&self) -> T {
        self.multi_iter()
            .min_by(|(_, a), (_, b)| a.cmp_ext(b))
            .map(|(_, x)| x.clone())
            .unwrap()
    }

    pub fn argmin(&self) -> [usize; D] {
        self.multi_iter()
            .min_by(|(_, a), (_, b)| a.cmp_ext(b))
            .map(|(i, _)| i)
            .unwrap()
    }

    pub fn min_axis(&self, axis: isize) -> Self {
        self.map_axis(axis, |v| {
            v.into_iter().min_by(|a, b| a.cmp_ext(b)).cloned().unwrap()
        })
    }

    pub fn argmin_axis(&self, axis: isize) -> Array<D, usize> {
        self.map_axis(axis, |v| {
            v.into_iter()
                .enumerate()
                .min_by(|(_, a), (_, b)| a.cmp_ext(b))
                .map(|(i, _)| i)
                .unwrap()
        })
    }

    pub fn max(&self) -> T {
        self.multi_iter()
            .max_by(|(_, a), (_, b)| a.cmp_ext(b))
            .map(|(_, x)| x.clone())
            .unwrap()
    }

    pub fn argmax(&self) -> [usize; D] {
        self.multi_iter()
            .max_by(|(_, a), (_, b)| a.cmp_ext(b))
            .map(|(i, _)| i)
            .unwrap()
    }

    pub fn max_axis(&self, axis: isize) -> Self {
        self.map_axis(axis, |v| {
            v.into_iter().max_by(|a, b| a.cmp_ext(b)).cloned().unwrap()
        })
    }

    pub fn argmax_axis(&self, axis: isize) -> Array<D, usize> {
        self.map_axis(axis, |v| {
            v.into_iter()
                .enumerate()
                .max_by(|(_, a), (_, b)| a.cmp_ext(b))
                .map(|(i, _)| i)
                .unwrap()
        })
    }
}

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

    #[test]
    fn test_float() {
        let arr = Array::from_vec(vec![1.0, 2.0, 3.0, 4.0], [2, 2]);
        assert_eq!(arr.max(), 4.0);
        assert_eq!(arr.min(), 1.0);

        let arr_min_a = arr.min_axis(-1);
        let arr_max_a = arr.max_axis(0);
        assert_eq!(arr_min_a, Array::from_vec(vec![1.0, 3.0], [2, 1]));
        assert_eq!(arr_max_a, Array::from_vec(vec![3.0, 4.0], [1, 2]));
    }

    #[test]
    fn test_int() {
        let arr = Array::from_vec(vec![1, 2, 3, 4], [2, 2]);
        assert_eq!(arr.max(), 4);
        assert_eq!(arr.min(), 1);

        let arr_min_a = arr.min_axis(-1);
        let arr_max_a = arr.max_axis(0);
        assert_eq!(arr_min_a, Array::from_vec(vec![1, 3], [2, 1]));
        assert_eq!(arr_max_a, Array::from_vec(vec![3, 4], [1, 2]));
    }
}