matrix-rs

Library for using matrices in rust. Uses const generics to ensure compile-time matrix safety.

Examples:

```rust use matrix_rs::*;

fn matrix3x31to9() -> Matrix<3, 3> { matrix! { 1 2 3, 4 5 6, 7 8 9 } }

[test]

fn testmatrixmacro() { let macromatrix = matrix! { 99 12 0, 55 33485 30 }; asserteq!(macro_matrix, Matrix::from([[99, 12, 0], [55, 33485, 30]])) }

[test]

fn testmatrixdisplay() { println!("{}", matrix3x31to9()) }

[test]

fn testmatrixzero() { let zeromatrix = SquareMatrix::<3>::zero(); asserteq!( zero_matrix, matrix! { 0 0 0, 0 0 0, 0 0 0 } ); }

[test]

fn testmatrixidentity() { let identitymatrix = SquareMatrix::<3>::identity(); asserteq!( identity_matrix, matrix! { 1 0 0, 0 1 0, 0 0 1 } ); }

[test]

fn testmatrixissquare() { let squarematrix = SquareMatrix::<5>::zero(); assert!(squarematrix.issquare(), "Square matrix not square (how).") }

[test]

fn testmatrixaddition() { let m1 = matrix3x31to9(); let m2 = matrix3x31to9(); let m3 = m1 + m2;

assert_eq!(
    m3,
    matrix! {
        2  4  6,
        8  10 12,
        14 16 18
    }
);

}

[test]

fn testmatrixsubtraction() { let m1 = matrix3x31to9(); let m2 = matrix3x31to9(); let m3 = m1 - m2; assert_eq!(m3, Matrix::zero()); }

[test]

fn testmatrixmultiplication() { let m1a = matrix! { 5 }; let m1b = matrix! { 3 }; asserteq!( m1a * m1_b, Matrix::from([[15]]), "(1x1) * (1x1) matrix multiplication failed." );

let m2_a = matrix! {
    1 2 3,
    4 5 6
};
let m2_b = matrix! {
    1 2,
    3 4,
    5 6
};

assert_eq!(
    m2_a * m2_b,
    matrix! {
        22 28,
        49 64
    },
    "(2x3) * (3x2) matrix multiplication failed."
);

}

[test]

fn testmatrixdeterminant() { let m0 = Matrix::<0, 0>::zero(); assert_eq!(m0.determinant(), 1.0, "(0x0) matrix determinant failed.");

let m1 = matrix! { 123 };
assert_eq!(m1.determinant(), 123.0, "(1x1) matrix determinant failed.");

let m2 = matrix! {
    11 7,
    2  5
};
assert_eq!(m2.determinant(), 41.0, "(2x2) matrix determinant failed.");

let m3 = matrix! {
    7 4  5,
    3 10 1,
    9 0  7
};
assert_eq!(m3.determinant(), -8.0, "(3x3) matrix determinant failed.");

let m4 = matrix! {
    7 8  4 5,
    6 22 1 4,
    7 12 3 2,
    0 5  9 3
};
assert_eq!(m4.determinant(), 2921.0, "(4x4) matrix determinant failed.");

}

[test]

fn testmatrixinverse() { let matrixwheredeterminantis0 = SquareMatrix::<3>::zero(); assert!(!matrixwheredeterminantis0.has_inverse()); }

[test]

fn testmatrixtranspose() { let transposedmatrix = matrix! { 1 2 3, 4 5 6 } .transpose(); asserteq!( transposed_matrix, matrix! { 1 4, 2 5, 3 6 } ) }

```