simp_linalg 0.1.4

A generically defined, light-weight linear algebra library for simple addition and multiplication of vectors and matrices.
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

use crate::matrix::Matrix;

impl<T> Matrix<T> {
    /// Applies a function dependent on value
    /// to each individual element in the matrix.
    /// 
    /// # Example
    /// ```
    /// use simp_linalg::matrix::Matrix;
    /// 
    /// let matrix1 = Matrix::from(vec![vec![1, 2],
    ///                                 vec![3, 4]]);
    /// 
    /// let matrix2 = matrix1.lambda(|val| val * val);
    /// 
    /// assert_eq!(matrix2, Matrix::from(vec![vec![1, 4],
    ///                                       vec![9, 16]]));
    /// ```
    pub fn lambda<F>(&self, funct: F) -> Matrix<T>
    where
        F: Fn(&T) -> T
    {
        let mut params = Vec::with_capacity(self.rows);
        
        
        for row in &self.matrix {
            let mut new_row = Vec::with_capacity(self.cols);
            
            for col in row {
                new_row.push(funct(col))
            }
            
            params.push(new_row)
        }

        Matrix::from(params)
    }

    /// Applies a function dependent on location
    /// to each individual element in the matrix.
    /// 
    /// # Example
    /// ```
    /// use simp_linalg::matrix::Matrix;
    /// 
    /// let matrix1 = Matrix::from(vec![vec![1, 2],
    ///                                 vec![3, 4]]);
    /// 
    /// let matrix2 = matrix1.lambda_index(|row, col| row * col + row + col);
    /// 
    /// assert_eq!(matrix2, Matrix::from(vec![vec![0, 1],
    ///                                       vec![1, 3]]));
    /// ```
    pub fn lambda_index<F>(&self, funct : F) -> Matrix<T>
    where
        F: Fn(usize, usize) -> T
    {
        let mut params = Vec::with_capacity(self.rows);
        
        
        for row_idx in 0..self.rows {
            let mut new_row = Vec::with_capacity(self.cols);
            
            for col_idx in 0..self.cols {
                new_row.push(funct(row_idx, col_idx))
            }

            params.push(new_row)
        }

        Matrix::from(params)
    }

    /// Applies a function dependent on location and value
    /// to each individual element in the matrix.
    /// 
    /// # Example
    /// ```
    /// use simp_linalg::matrix::Matrix;
    /// 
    /// let matrix1 = Matrix::from(vec![vec![1, 2],
    ///                                 vec![3, 4]]);
    /// 
    /// let matrix2 = matrix1.lambda_enumerate(|row, col, val| row + col + val);
    /// 
    /// assert_eq!(matrix2, Matrix::from(vec![vec![1, 3],
    ///                                       vec![4, 6]]));
    /// ```
    pub fn lambda_enumerate<F>(&self, funct : F) -> Matrix<T>
    where
        F: Fn(usize, usize, &T) -> T
    {
        let mut params = Vec::with_capacity(self.rows);

        for (row_idx, row) in self.matrix.iter().enumerate() {
            let mut new_row = Vec::with_capacity(self.cols);

            for (col_idx, col) in row.iter().enumerate() {
                new_row.push(funct(row_idx, col_idx, col))
            }
            
            params.push(new_row)
        }

        Matrix::from(params)
    }
}