matrixlib 0.1.2

A really bad toy matrix library just so i can practice some rust. Don't use this. Use Nalgebra.
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

//! Matrices

pub mod mtuple;
pub mod ops;
pub mod ops2x2;
pub mod transform;
pub mod rw;
use crate::error::MatrixError;

#[derive(Debug)]
/// An `R` x `J` matrix struct
pub struct Matrix<const R: usize, const C: usize> {
    matrix: Vec<f64>,
}

impl<const R: usize, const C: usize> Matrix<R, C> {
    /// Creates a new `Matrix`, consuming the given vector.
    pub fn new(data: Vec<f64>) -> Result<Self, MatrixError> {
        // Check if the dimensions match
        if data.len() != C * R {
            return Err(MatrixError::InvalidDimensions);
        }

        Ok(Self { matrix: data })
    }

    /// Constructs a new identity matrix with `n` x `n` dimensions
    pub fn new_identity_matrix(n: usize) -> Matrix<R, C> {
        let matrix: Vec<f64> = (0..(n * n))
            .map(|i| if (i % n) == (i / n) { 1.0 } else { 0.0 })
            .collect();

        Self { matrix }
    }

    /// Returns the dimensions of the matrix in the form of (rows, columns).
    pub fn dimensions(&self) -> (usize, usize) {
        (R, C)
    }

    /// Returns a reference to the inernal 1D vector.
    pub fn data(&self) -> &Vec<f64> {
        &self.matrix
    }


}

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

    #[test]
    fn successful_2x2matrix_init() {
        let data = vec![0.0, 1.0, 2.0, 3.0];

        let matrix: Result<Matrix<2, 2>, _> = Matrix::new(data);

        assert!(matrix.is_ok());

        let matrix = matrix.unwrap();

        assert_eq!(matrix.dimensions(), (2, 2));
    }

    #[test]
    fn unsuccessful_2x2matrix_init() {
        let data = vec![0.0, 1.0, 2.0, 3.0];

        let matrix: Result<Matrix<2, 3>, _> = Matrix::new(data);

        assert!(matrix.is_err());
    }

    #[test]
    fn test_identity_matrices() {
        let identity2x2: Matrix<2, 2> = Matrix::new_identity_matrix(2);
        assert_eq!(identity2x2.matrix, [1.0, 0.0, 0.0, 1.0]);

        let identity3x3: Matrix<3, 3> = Matrix::new_identity_matrix(3);
        assert_eq!(
            identity3x3.matrix,
            [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0]
        );

        let identity4x4: Matrix<4, 4> = Matrix::new_identity_matrix(4);
        assert_eq!(
            identity4x4.matrix,
            [1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0,]
        )
    }

    #[test]
    fn test_dimensions() {
        let data = vec![1.0, 2.0, 3.0, 4.0];
        let matrix: Matrix<2, 2> = Matrix::new(data).unwrap();

        assert_eq!(matrix.dimensions(), (2, 2));
        
    }

    #[test]
    fn test_get_data() {
        let data = vec![1.0, 2.0, 3.0, 4.0];
        let matrix: Matrix<2, 2> = Matrix::new(data).unwrap();

        assert_eq!(matrix.data(), &vec![1.0, 2.0, 3.0, 4.0])

    }

}