Matrix

• items - Items of the matrix in row by row order
• order - Order of the matrix

Examples

```rust use math_matrix::Matrix;

let matrix = Matrix::new(vec![1, 2, 3, 4, 5, 6], (3, 2)); let invalid_matrix = Matrix::new(vec![1, 2, 3], (3, 2));

asserteq!(matrix.isok(), true); asserteq!(matrix.unwrap().order, (3, 2)); asserteq!(invalidmatrix.isok(), false); ```

Matrixes from functions

Using functions to describe the matrix

```rust // Function generated matrix // i^2 + 3j - 7 let function_generated = Matrix::generate(|i, j| (i * i + 3 * j) as i32 - 7, (5, 5)); // -3 0 3 6 9 // 0 3 6 9 12 // 5 8 11 14 17 // 12 15 18 21 24 // 21 24 27 30 33

asserteq!(functiongenerated[(1, 1)], -3); asserteq!(functiongenerated[(2, 1)], 0); asserteq!(functiongenerated[(3, 3)], 11); asserteq!(functiongenerated[(4, 3)], 18); ```

Built in matrices

• Row matrix - A matrix with only 1 row
• Column matrix - A matrix with only 1 column
• Null matrix - A matrix with all zeros
• Square matrix - A matrix with equal number of rows and columns
• Diagonal matrix - A matrix with items only along the diagonal
• Scalar matrix - A diagonal matrix with only 1 value
• Identity matrix - A scalar matrix with the value of 1

```rust // Row matrix let rowmatrix = Matrix::rowmatrix(vec![1, 2, 3, 4, 5, 6, 7]); asserteq!(rowmatrix[(1, 5)], 5); asserteq!(rowmatrix.get(2, 5).is_err(), true);

// Column matrix let columnmatrix = Matrix::columnmatrix(vec![1, 2, 3, 4, 5, 6]); asserteq!(columnmatrix[(3, 1)], 3); asserteq!(columnmatrix.get(3, 5).is_err(), true);

// Null matrix let nullmatrix = Matrix::nullmatrix((10, 10)); asserteq!(nullmatrix[(5, 5)], 0); asserteq!(nullmatrix[(10, 10)], 0); asserteq!(nullmatrix[(9, 6)], 0);

// Square matrix let squarematrix = Matrix::squarematrix(vec![1, 2, 3, 4]); let invalidsquarematrix = Matrix::square_matrix(vec![1, 2, 3]);

asserteq!(squarematrix.unwrap().order, (2, 2)); asserteq!(invalidsquarematrix.isok(), false);

// Diagonal matrix let diagonalmatrix = Matrix::diagonalmatrix(vec![1, 2, 3, 4, 5, 6, 7, 8]);

asserteq!(diagonalmatrix.order, (8, 8)); asserteq!(diagonalmatrix[(4, 5)], 0); asserteq!(diagonalmatrix[(5, 5)], 5); asserteq!(diagonalmatrix[(7, 8)], 0);

/// Scalar matrix let scalarmatrix = Matrix::scalarmatrix(5, 6);

asserteq!(scalarmatrix.order, (6, 6)); asserteq!(scalarmatrix[(3, 4)], 0); asserteq!(scalarmatrix[(5, 5)], 5); asserteq!(scalarmatrix[(3, 3)], 5);

/// Identity matrix let identitymatrix = Matrix::identitymatrix(5);

asserteq!(identitymatrix.order, (5, 5)); asserteq!(identitymatrix[(3, 4)], 0); asserteq!(identitymatrix[(5, 5)], 1); asserteq!(identitymatrix[(3, 3)], 1); ```

Traces

Traces are the diagonal items of a square matrix

```rust // Traces let randommatrix = Matrix::new(vec![6, 4, 87, 3, 6, 89, 6, 8, 4, 2, 45, 2, 5, 7, 9, 9], (4, 4)).unwrap(); let trace = randommatrix.trace(); // trace: [ 6, 89, 45, 9 ]

let notracematrix = Matrix::new(vec![6, 4, 87, 3, 6, 89, 6, 8, 4, 2, 45, 2, 5, 7, 9], (5, 3)).unwrap(); let invalidtrace = notrace_matrix.trace();

asserteq!(invalidtrace.isok(), false); asserteq!(trace.isok(), true); let trace = trace.unwrap(); asserteq!(trace[0], 6); assert_eq!(trace[2], 45); ```

Getting and Setting items

• get_row - Returns nth row
• get_column - Returns nth column
• get - Get the item from the matrix
• set - Set the item from the matrix

```rust let mut matrix = Matrix::new(vec![6, 4, 87, 3, 6, 89, 6, 8, 4, 2, 45, 2, 5, 7, 9], (5, 3)).unwrap(); // 6 4 87 // 3 6 89 // 6 8 4 // 2 45 2 // 5 7 9

asserteq!(matrix.getrow(1).unwrap(), vec![6, 4, 87]); asserteq!(matrix.getcolumn(1).unwrap(), vec![6, 3, 6, 2, 5]); asserteq!(matrix.getcolumn(2).unwrap(), vec![4, 6, 8, 45, 7]); asserteq!(matrix.get(3, 2).unwrap(), 8); asserteq!(matrix.get(5, 1).unwrap(), 5);

matrix.set(5, 1, 99);

assert_eq!(matrix.get(5, 1).unwrap(), 99); ```