docs: Updated README.md

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "matrix-basic"
-version = "0.1.0"
+version = "0.5.0"
 edition = "2021"
 authors = ["Sayantan Santra <sayantan[dot]santra689[at]gmail[dot]com"]
 license = "GPL-3.0"

README.md

@@ -1,9 +1,13 @@
 [![crate.io badge](https://img.shields.io/crates/d/matrix-basic)](https://crates.io/crates/matrix-basic)
 # `matrix-basic`
 
-### A Rust crate for very basic matrix operations
+### A Rust crate for very basic matrix operations.
 
-This is a crate for very basic matrix operations with any type that supports addition, substraction,
-and multiplication. Additional properties might be needed for certain operations.
+This is a crate for very basic matrix operations with any type that supports addition, substraction, multiplication,
+negation, has a zero defined, and implements the Copy trait. Additional properties (e.g. division, existence of one etc.)
+might be needed for certain operations.
 
-I created it mostly to learn using generic types and traits.
+I created it mostly to learn how to use generic types and traits.
+
+## Usage
+Documentation is available here: [docs.rs](https://docs.rs/matrix-basic).

src/errors.rs

@@ -0,0 +1,29 @@
+use std::{
+    error::Error,
+    fmt::{self, Display, Formatter},
+};
+
+/// Error type for using in this crate. Mostly to reduce writing
+/// error description every time.
+#[derive(Debug, PartialEq)]
+pub enum MatrixError {
+    /// Provided matrix isn't square.
+    NotSquare,
+    /// provided matrix is singular.
+    Singular,
+    /// Provided array has unequal rows.
+    UnequalRows,
+}
+
+impl Display for MatrixError {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        let out = match *self {
+            Self::NotSquare => "provided matrix isn't square",
+            Self::Singular => "provided matrix is singular",
+            Self::UnequalRows => "provided array has unequal rows",
+        };
+        write!(f, "{out}")
+    }
+}
+
+impl Error for MatrixError {}

src/lib.rs

@@ -1,44 +1,70 @@
 //! This is a crate for very basic matrix operations
-//! with any type that supports addition, substraction,
-//! and multiplication. Additional properties might be
+//! with any type that implement [`Add`], [`Sub`], [`Mul`],
+//! [`Zero`], [`Neg`] and [`Copy`]. Additional properties might be
 //! needed for certain operations.
+//!
 //! I created it mostly to learn using generic types
 //! and traits.
 //!
 //! Sayantan Santra (2023)
 
+use errors::MatrixError;
 use num::{
     traits::{One, Zero},
     Integer,
 };
 use std::{
     fmt::{self, Debug, Display, Formatter},
-    ops::{Add, Mul, Sub},
+    ops::{Add, Div, Mul, Neg, Sub},
     result::Result,
 };
 
+pub mod errors;
 mod tests;
 
-/// A generic matrix struct (over any type with addition, substraction
-/// and multiplication defined on it).
+/// Trait a type must satisfy to be element of a matrix. This is
+/// mostly to reduce writing trait bounds afterwards.
+pub trait ToMatrix:
+    Mul<Output = Self>
+    + Add<Output = Self>
+    + Sub<Output = Self>
+    + Zero<Output = Self>
+    + Neg<Output = Self>
+    + Copy
+{
+}
+
+/// Blanket implementation for [`ToMatrix`] for any type that satisfies its bounds.
+impl<T> ToMatrix for T where
+    T: Mul<Output = T>
+        + Add<Output = T>
+        + Sub<Output = T>
+        + Zero<Output = T>
+        + Neg<Output = T>
+        + Copy
+{
+}
+
+/// A generic matrix struct (over any type with [`Add`], [`Sub`], [`Mul`],
+/// [`Zero`], [`Neg`] and [`Copy`] implemented).
 /// Look at [`from`](Self::from()) to see examples.
 #[derive(PartialEq, Debug, Clone)]
-pub struct Matrix<T: Mul + Add + Sub> {
+pub struct Matrix<T: ToMatrix> {
     entries: Vec<Vec<T>>,
 }
 
-impl<T: Mul + Add + Sub> Matrix<T> {
-    /// Creates a matrix from given 2D "array" in a `Vec<Vec<T>>` form.
+impl<T: ToMatrix> Matrix<T> {
+    /// Creates a matrix from given 2D "array" in a [`Vec<Vec<T>>`] form.
     /// It'll throw an error if all the given rows aren't of the same size.
     /// # Example
     /// ```
-    /// use matrix::Matrix;
-    /// let m = Matrix::from(vec![vec![1,2,3], vec![4,5,6]]);
+    /// use matrix_basic::Matrix;
+    /// let m = Matrix::from(vec![vec![1, 2, 3], vec![4, 5, 6]]);
     /// ```
     /// will create the following matrix:  
-    /// ⌈1,2,3⌉  
-    /// ⌊4,5,6⌋
-    pub fn from(entries: Vec<Vec<T>>) -> Result<Matrix<T>, &'static str> {
+    /// ⌈1, 2, 3⌉  
+    /// ⌊4, 5, 6⌋
+    pub fn from(entries: Vec<Vec<T>>) -> Result<Matrix<T>, MatrixError> {
         let mut equal_rows = true;
         let row_len = entries[0].len();
         for row in &entries {
@@ -50,25 +76,22 @@ impl<T: Mul + Add + Sub> Matrix<T> {
         if equal_rows {
             Ok(Matrix { entries })
         } else {
-            Err("Unequal rows.")
+            Err(MatrixError::UnequalRows)
         }
     }
 
-    /// Return the height of a matrix.
+    /// Returns the height of a matrix.
     pub fn height(&self) -> usize {
         self.entries.len()
     }
 
-    /// Return the width of a matrix.
+    /// Returns the width of a matrix.
     pub fn width(&self) -> usize {
         self.entries[0].len()
     }
 
-    /// Return the transpose of a matrix.
-    pub fn transpose(&self) -> Self
-    where
-        T: Copy,
-    {
+    /// Returns the transpose of a matrix.
+    pub fn transpose(&self) -> Self {
         let mut out = Vec::new();
         for i in 0..self.width() {
             let mut column = Vec::new();
@@ -80,16 +103,13 @@ impl<T: Mul + Add + Sub> Matrix<T> {
         Matrix { entries: out }
     }
 
-    /// Return a reference to the rows of a matrix as `&Vec<Vec<T>>`.
+    /// Returns a reference to the rows of a matrix as `&Vec<Vec<T>>`.
     pub fn rows(&self) -> &Vec<Vec<T>> {
         &self.entries
     }
 
     /// Return the columns of a matrix as `Vec<Vec<T>>`.
-    pub fn columns(&self) -> Vec<Vec<T>>
-    where
-        T: Copy,
-    {
+    pub fn columns(&self) -> Vec<Vec<T>> {
         self.transpose().entries
     }
 
@@ -98,19 +118,16 @@ impl<T: Mul + Add + Sub> Matrix<T> {
         self.height() == self.width()
     }
 
-    /// Return a matrix after removing the provided row and column from it.
+    /// Returns a matrix after removing the provided row and column from it.
     /// Note: Row and column numbers are 0-indexed.
     /// # Example
     /// ```
-    /// use matrix::Matrix;
-    /// let m = Matrix::from(vec![vec![1,2,3],vec![4,5,6]]).unwrap();
-    /// let n = Matrix::from(vec![vec![5,6]]).unwrap();
-    /// assert_eq!(m.submatrix(0,0),n);
+    /// use matrix_basic::Matrix;
+    /// let m = Matrix::from(vec![vec![1, 2, 3], vec![4, 5, 6]]).unwrap();
+    /// let n = Matrix::from(vec![vec![5, 6]]).unwrap();
+    /// assert_eq!(m.submatrix(0, 0), n);
     /// ```
-    pub fn submatrix(&self, row: usize, col: usize) -> Self
-    where
-        T: Copy,
-    {
+    pub fn submatrix(&self, row: usize, col: usize) -> Self {
         let mut out = Vec::new();
         for (m, row_iter) in self.entries.iter().enumerate() {
             if m == row {
@@ -127,26 +144,20 @@ impl<T: Mul + Add + Sub> Matrix<T> {
         Matrix { entries: out }
     }
 
-    /// Return the determinant of a square matrix. This method additionally requires [`Zero`],
-    /// [`One`] and [`Copy`] traits. Also, we need that the [`Mul`] and [`Add`] operations
-    /// return the same type `T`.
+    /// Returns the determinant of a square matrix.
+    /// This uses basic recursive algorithm using cofactor-minor.
+    /// See [`det_in_field`](Self::det_in_field()) for faster determinant calculation in fields.
     /// It'll throw an error if the provided matrix isn't square.
     /// # Example
     /// ```
-    /// use matrix::Matrix;
-    /// let m = Matrix::from(vec![vec![1,2],vec![3,4]]).unwrap();
-    /// assert_eq!(m.det(),Ok(-2));
+    /// use matrix_basic::Matrix;
+    /// let m = Matrix::from(vec![vec![1, 2], vec![3, 4]]).unwrap();
+    /// assert_eq!(m.det(), Ok(-2));
     /// ```
-    pub fn det(&self) -> Result<T, &'static str>
-    where
-        T: Copy,
-        T: Mul<Output = T>,
-        T: Sub<Output = T>,
-        T: Zero,
-    {
+    pub fn det(&self) -> Result<T, MatrixError> {
         if self.is_square() {
             // It's a recursive algorithm using minors.
-            // TODO: Implement a faster algorithm. Maybe use row reduction for fields.
+            // TODO: Implement a faster algorithm.
             let out = if self.width() == 1 {
                 self.entries[0][0]
             } else {
@@ -164,15 +175,152 @@ impl<T: Mul + Add + Sub> Matrix<T> {
             };
             Ok(out)
         } else {
-            Err("Provided matrix isn't square.")
+            Err(MatrixError::NotSquare)
         }
     }
 
-    /// Creates a zero matrix of a given size.
-    pub fn zero(height: usize, width: usize) -> Self
+    /// Returns the determinant of a square matrix over a field i.e. needs [`One`] and [`Div`] traits.
+    /// See [`det`](Self::det()) for determinants in rings.
+    /// This method uses row reduction as is much faster.
+    /// It'll throw an error if the provided matrix isn't square.
+    /// # Example
+    /// ```
+    /// use matrix_basic::Matrix;
+    /// let m = Matrix::from(vec![vec![1.0, 2.0], vec![3.0, 4.0]]).unwrap();
+    /// assert_eq!(m.det_in_field(), Ok(-2.0));
+    /// ```
+    pub fn det_in_field(&self) -> Result<T, MatrixError>
     where
-        T: Zero,
+        T: One,
+        T: PartialEq,
+        T: Div<Output = T>,
     {
+        if self.is_square() {
+            // Cloning is necessary as we'll be doing row operations on it.
+            let mut rows = self.entries.clone();
+            let mut multiplier = T::one();
+            let h = self.height();
+            let w = self.width();
+            for i in 0..(h - 1) {
+                // First check if the row has diagonal element 0, if yes, then swap.
+                if rows[i][i] == T::zero() {
+                    let mut zero_column = true;
+                    for j in (i + 1)..h {
+                        if rows[j][i] != T::zero() {
+                            rows.swap(i, j);
+                            multiplier = -multiplier;
+                            zero_column = false;
+                            break;
+                        }
+                    }
+                    if zero_column {
+                        return Ok(T::zero());
+                    }
+                }
+                for j in (i + 1)..h {
+                    let ratio = rows[j][i] / rows[i][i];
+                    for k in i..w {
+                        rows[j][k] = rows[j][k] - rows[i][k] * ratio;
+                    }
+                }
+            }
+            for (i, row) in rows.iter().enumerate() {
+                multiplier = multiplier * row[i];
+            }
+            Ok(multiplier)
+        } else {
+            Err(MatrixError::NotSquare)
+        }
+    }
+
+    /// Returns the row echelon form of a matrix over a field i.e. needs the [`Div`] trait.
+    /// # Example
+    /// ```
+    /// use matrix_basic::Matrix;
+    /// let m = Matrix::from(vec![vec![1.0, 2.0, 3.0], vec![3.0, 4.0, 5.0]]).unwrap();
+    /// let n = Matrix::from(vec![vec![1.0, 2.0, 3.0], vec![0.0, -2.0, -4.0]]).unwrap();
+    /// assert_eq!(m.row_echelon(), n);
+    /// ```
+    pub fn row_echelon(&self) -> Self
+    where
+        T: PartialEq,
+        T: Div<Output = T>,
+    {
+        // Cloning is necessary as we'll be doing row operations on it.
+        let mut rows = self.entries.clone();
+        let mut offset = 0;
+        let h = self.height();
+        let w = self.width();
+        for i in 0..(h - 1) {
+            // Check if all the rows below are 0
+            if i + offset >= self.width() {
+                break;
+            }
+            // First check if the row has diagonal element 0, if yes, then swap.
+            if rows[i][i + offset] == T::zero() {
+                let mut zero_column = true;
+                for j in (i + 1)..h {
+                    if rows[j][i + offset] != T::zero() {
+                        rows.swap(i, j);
+                        zero_column = false;
+                        break;
+                    }
+                }
+                if zero_column {
+                    offset += 1;
+                }
+            }
+            for j in (i + 1)..h {
+                let ratio = rows[j][i + offset] / rows[i][i + offset];
+                for k in (i + offset)..w {
+                    rows[j][k] = rows[j][k] - rows[i][k] * ratio;
+                }
+            }
+        }
+        Matrix { entries: rows }
+    }
+
+    /// Returns the column echelon form of a matrix over a field i.e. needs the [`Div`] trait.
+    /// It's just the transpose of the row echelon form of the transpose.
+    /// See [`row_echelon`](Self::row_echelon()) and [`transpose`](Self::transpose()).
+    pub fn column_echelon(&self) -> Self
+    where
+        T: PartialEq,
+        T: Div<Output = T>,
+    {
+        self.transpose().row_echelon().transpose()
+    }
+
+    /// Returns the reduced row echelon form of a matrix over a field i.e. needs the `Div`] trait.
+    /// # Example
+    /// ```
+    /// use matrix_basic::Matrix;
+    /// let m = Matrix::from(vec![vec![1.0, 2.0, 3.0], vec![3.0, 4.0, 5.0]]).unwrap();
+    /// let n = Matrix::from(vec![vec![1.0, 2.0, 3.0], vec![0.0, 1.0, 2.0]]).unwrap();
+    /// assert_eq!(m.reduced_row_echelon(), n);
+    /// ```
+    pub fn reduced_row_echelon(&self) -> Self
+    where
+        T: PartialEq,
+        T: Div<Output = T>,
+    {
+        let mut echelon = self.row_echelon();
+        let mut offset = 0;
+        for row in &mut echelon.entries {
+            while row[offset] == T::zero() {
+                offset += 1;
+            }
+            let divisor = row[offset];
+            for entry in row.iter_mut().skip(offset) {
+                *entry = *entry / divisor;
+            }
+            offset += 1;
+        }
+        echelon
+    }
+
+    /// Creates a zero matrix of a given size.
+    pub fn zero(height: usize, width: usize) -> Self {
         let mut out = Vec::new();
         for _ in 0..height {
             let mut new_row = Vec::new();
@@ -185,40 +333,172 @@ impl<T: Mul + Add + Sub> Matrix<T> {
     }
 
     /// Creates an identity matrix of a given size.
+    /// It needs the [`One`] trait.
     pub fn identity(size: usize) -> Self
     where
-        T: Zero,
         T: One,
     {
-        let mut out = Vec::new();
-        for i in 0..size {
-            let mut new_row = Vec::new();
-            for j in 0..size {
-                if i == j {
-                    new_row.push(T::one());
-                } else {
-                    new_row.push(T::zero());
+        let mut out = Matrix::zero(size, size);
+        for (i, row) in out.entries.iter_mut().enumerate() {
+            row[i] = T::one();
+        }
+        out
+    }
+
+    /// Returns the trace of a square matrix.
+    /// It'll throw an error if the provided matrix isn't square.
+    /// # Example
+    /// ```
+    /// use matrix_basic::Matrix;
+    /// let m = Matrix::from(vec![vec![1, 2], vec![3, 4]]).unwrap();
+    /// assert_eq!(m.trace(), Ok(5));
+    /// ```
+    pub fn trace(self) -> Result<T, MatrixError> {
+        if self.is_square() {
+            let mut out = self.entries[0][0];
+            for i in 1..self.height() {
+                out = out + self.entries[i][i];
+            }
+            Ok(out)
+        } else {
+            Err(MatrixError::NotSquare)
+        }
+    }
+
+    /// Returns a diagonal matrix with a given diagonal.
+    /// # Example
+    /// ```
+    /// use matrix_basic::Matrix;
+    /// let m = Matrix::diagonal_matrix(vec![1, 2, 3]);
+    /// let n = Matrix::from(vec![vec![1, 0, 0], vec![0, 2, 0], vec![0, 0, 3]]).unwrap();
+    ///
+    /// assert_eq!(m, n);
+    /// ```
+    pub fn diagonal_matrix(diag: Vec<T>) -> Self {
+        let size = diag.len();
+        let mut out = Matrix::zero(size, size);
+        for (i, row) in out.entries.iter_mut().enumerate() {
+            row[i] = diag[i];
+        }
+        out
+    }
+
+    /// Multiplies all entries of a matrix by a scalar.
+    /// Note that it modifies the supplied matrix.
+    /// # Example
+    /// ```
+    /// use matrix_basic::Matrix;
+    /// let mut m = Matrix::from(vec![vec![1, 2, 0], vec![0, 2, 5], vec![0, 0, 3]]).unwrap();
+    /// let n = Matrix::from(vec![vec![2, 4, 0], vec![0, 4, 10], vec![0, 0, 6]]).unwrap();
+    /// m.mul_scalar(2);
+    ///
+    /// assert_eq!(m, n);
+    /// ```
+    pub fn mul_scalar(&mut self, scalar: T) {
+        for row in &mut self.entries {
+            for entry in row {
+                *entry = *entry * scalar;
+            }
+        }
+    }
+
+    /// Returns the inverse of a square matrix. Throws an error if the matrix isn't square.
+    /// /// # Example
+    /// ```
+    /// use matrix_basic::Matrix;
+    /// let m = Matrix::from(vec![vec![1.0, 2.0], vec![3.0, 4.0]]).unwrap();
+    /// let n = Matrix::from(vec![vec![-2.0, 1.0], vec![1.5, -0.5]]).unwrap();
+    /// assert_eq!(m.inverse(), Ok(n));
+    /// ```
+    pub fn inverse(&self) -> Result<Self, MatrixError>
+    where
+        T: Div<Output = T>,
+        T: One,
+        T: PartialEq,
+    {
+        if self.is_square() {
+            // We'll use the basic technique of using an augmented matrix (in essence)
+            // Cloning is necessary as we'll be doing row operations on it.
+            let mut rows = self.entries.clone();
+            let h = self.height();
+            let w = self.width();
+            let mut out = Self::identity(h).entries;
+
+            // First we get row echelon form
+            for i in 0..(h - 1) {
+                // First check if the row has diagonal element 0, if yes, then swap.
+                if rows[i][i] == T::zero() {
+                    let mut zero_column = true;
+                    for j in (i + 1)..h {
+                        if rows[j][i] != T::zero() {
+                            rows.swap(i, j);
+                            out.swap(i, j);
+                            zero_column = false;
+                            break;
+                        }
+                    }
+                    if zero_column {
+                        return Err(MatrixError::Singular);
+                    }
+                }
+                for j in (i + 1)..h {
+                    let ratio = rows[j][i] / rows[i][i];
+                    for k in i..w {
+                        rows[j][k] = rows[j][k] - rows[i][k] * ratio;
+                    }
+                    // We cannot skip entries here as they might not be 0
+                    for k in 0..w {
+                        out[j][k] = out[j][k] - out[i][k] * ratio;
+                    }
                 }
             }
-            out.push(new_row);
+
+            // Then we reduce the rows
+            for i in 0..h {
+                if rows[i][i] == T::zero() {
+                    return Err(MatrixError::Singular);
+                }
+                let divisor = rows[i][i];
+                for entry in rows[i].iter_mut().skip(i) {
+                    *entry = *entry / divisor;
+                }
+                for entry in out[i].iter_mut() {
+                    *entry = *entry / divisor;
+                }
+            }
+
+            // Finally, we do upside down row reduction
+            for i in (1..h).rev() {
+                for j in (0..i).rev() {
+                    let ratio = rows[j][i];
+                    for k in 0..w {
+                        out[j][k] = out[j][k] - out[i][k] * ratio;
+                    }
+                }
+            }
+
+            Ok(Matrix { entries: out })
+        } else {
+            Err(MatrixError::NotSquare)
         }
-        Matrix { entries: out }
     }
+
+    // TODO: Canonical forms, eigenvalues, eigenvectors etc.
 }
 
-impl<T: Debug + Mul + Add + Sub> Display for Matrix<T> {
+impl<T: Debug + ToMatrix> Display for Matrix<T> {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         write!(f, "{:?}", self.entries)
     }
 }
 
-impl<T: Mul<Output = T> + Add + Sub + Copy + Zero> Mul for Matrix<T> {
-    // TODO: Implement a faster algorithm. Maybe use row reduction for fields.
+impl<T: Mul<Output = T> + ToMatrix> Mul for Matrix<T> {
+    // TODO: Implement a faster algorithm.
     type Output = Self;
-    fn mul(self, other: Self) -> Self {
+    fn mul(self, other: Self) -> Self::Output {
         let width = self.width();
         if width != other.height() {
-            panic!("Row length of first matrix must be same as column length of second matrix.");
+            panic!("row length of first matrix != column length of second matrix");
         } else {
             let mut out = Vec::new();
             for row in self.rows() {
@@ -237,9 +517,9 @@ impl<T: Mul<Output = T> + Add + Sub + Copy + Zero> Mul for Matrix<T> {
     }
 }
 
-impl<T: Add<Output = T> + Sub + Mul + Copy + Zero> Add for Matrix<T> {
+impl<T: Mul<Output = T> + ToMatrix> Add for Matrix<T> {
     type Output = Self;
-    fn add(self, other: Self) -> Self {
+    fn add(self, other: Self) -> Self::Output {
         if self.height() == other.height() && self.width() == other.width() {
             let mut out = self.entries.clone();
             for (i, row) in self.rows().iter().enumerate() {
@@ -249,24 +529,97 @@ impl<T: Add<Output = T> + Sub + Mul + Copy + Zero> Add for Matrix<T> {
             }
             Matrix { entries: out }
         } else {
-            panic!("Both matrices must be of same dimensions.");
+            panic!("provided matrices have different dimensions");
         }
     }
 }
 
-impl<T: Add + Sub<Output = T> + Mul + Copy + Zero> Sub for Matrix<T> {
+impl<T: ToMatrix> Neg for Matrix<T> {
     type Output = Self;
-    fn sub(self, other: Self) -> Self {
-        if self.height() == other.height() && self.width() == other.width() {
-            let mut out = self.entries.clone();
-            for (i, row) in self.rows().iter().enumerate() {
-                for (j, entry) in other.rows()[i].iter().enumerate() {
-                    out[i][j] = row[j] - *entry;
-                }
+    fn neg(self) -> Self::Output {
+        let mut out = self;
+        for row in &mut out.entries {
+            for entry in row {
+                *entry = -*entry;
             }
-            Matrix { entries: out }
+        }
+        out
+    }
+}
+
+impl<T: ToMatrix> Sub for Matrix<T> {
+    type Output = Self;
+    fn sub(self, other: Self) -> Self::Output {
+        if self.height() == other.height() && self.width() == other.width() {
+            self + -other
         } else {
-            panic!("Both matrices must be of same dimensions.");
+            panic!("provided matrices have different dimensions");
         }
     }
 }
+
+/// Trait for conversion between matrices of different types.
+/// It only has a [`matrix_from()`](Self::matrix_from()) method.
+/// This is needed since negative trait bound are not supported in stable Rust
+/// yet, so we'll have a conflict trying to implement [`From`].
+/// I plan to change this to the default From trait as soon as some sort
+/// of specialization system is implemented.
+/// You can track this issue [here](https://github.com/rust-lang/rust/issues/42721).
+pub trait MatrixFrom<T: ToMatrix> {
+    /// Method for getting a matrix of a new type from a matrix of type [`Matrix<T>`].
+    /// # Example
+    /// ```
+    /// use matrix_basic::Matrix;
+    /// use matrix_basic::MatrixFrom;
+    ///
+    /// let a = Matrix::from(vec![vec![1, 2, 3], vec![0, 1, 2]]).unwrap();
+    /// let b = Matrix::from(vec![vec![1.0, 2.0, 3.0], vec![0.0, 1.0, 2.0]]).unwrap();
+    /// let c = Matrix::<f64>::matrix_from(a); // Type annotation is needed here
+    ///
+    /// assert_eq!(c, b);
+    /// ```
+    fn matrix_from(input: Matrix<T>) -> Self;
+}
+
+/// Blanket implementation of [`MatrixFrom<T>`] for converting [`Matrix<S>`] to [`Matrix<T>`] whenever
+/// `S` implements [`From(T)`]. Look at [`matrix_into`](Self::matrix_into()).
+impl<T: ToMatrix, S: ToMatrix + From<T>> MatrixFrom<T> for Matrix<S> {
+    fn matrix_from(input: Matrix<T>) -> Self {
+        let mut out = Vec::new();
+        for row in input.entries {
+            let mut new_row: Vec<S> = Vec::new();
+            for entry in row {
+                new_row.push(entry.into());
+            }
+            out.push(new_row)
+        }
+        Matrix { entries: out }
+    }
+}
+
+/// Sister trait of [`MatrixFrom`]. Basically does the same thing, just with a
+/// different syntax.
+pub trait MatrixInto<T> {
+    /// Method for converting a matrix [`Matrix<T>`] to another type.
+    /// # Example
+    /// ```
+    /// use matrix_basic::Matrix;
+    /// use matrix_basic::MatrixInto;
+    ///
+    /// let a = Matrix::from(vec![vec![1, 2, 3], vec![0, 1, 2]]).unwrap();
+    /// let b = Matrix::from(vec![vec![1.0, 2.0, 3.0], vec![0.0, 1.0, 2.0]]).unwrap();
+    /// let c: Matrix<f64> = a.matrix_into(); // Type annotation is needed here
+    ///
+    ///
+    /// assert_eq!(c, b);
+    /// ```
+    fn matrix_into(self) -> T;
+}
+
+/// Blanket implementation of [`MatrixInto<T>`] for [`Matrix<S>`] whenever `T`
+/// (which is actually some)[`Matrix<U>`] implements [`MatrixFrom<S>`].
+impl<T: MatrixFrom<S>, S: ToMatrix> MatrixInto<T> for Matrix<S> {
+    fn matrix_into(self) -> T {
+        T::matrix_from(self)
+    }
+}

src/tests.rs

@@ -1,11 +1,17 @@
 #[cfg(test)]
 use crate::Matrix;
+
 #[test]
 fn mul_test() {
     let a = Matrix::from(vec![vec![1, 2, 4], vec![3, 4, 9]]).unwrap();
     let b = Matrix::from(vec![vec![1, 2], vec![2, 3], vec![5, 1]]).unwrap();
-    let c = Matrix::from(vec![vec![25, 12], vec![56, 27]]).unwrap();
+    let mut c = Matrix::from(vec![vec![25, 12], vec![56, 27]]).unwrap();
+    let d = Matrix::from(vec![vec![75, 36], vec![168, 81]]).unwrap();
+
     assert_eq!(a * b, c);
+
+    c.mul_scalar(3);
+    assert_eq!(c, d);
 }
 
 #[test]
@@ -14,22 +20,82 @@ fn add_sub_test() {
     let b = Matrix::from(vec![vec![0, 0, 1], vec![2, 1, 3]]).unwrap();
     let c = Matrix::from(vec![vec![1, 2, 4], vec![2, 2, 5]]).unwrap();
     let d = Matrix::from(vec![vec![1, 2, 2], vec![-2, 0, -1]]).unwrap();
+    let e = Matrix::from(vec![vec![-1, -2, -4], vec![-2, -2, -5]]).unwrap();
+
     assert_eq!(a.clone() + b.clone(), c);
     assert_eq!(a - b, d);
+    assert_eq!(-c, e);
 }
 
 #[test]
-fn det_test() {
+fn det_trace_test() {
     let a = Matrix::from(vec![vec![1, 2, 0], vec![0, 3, 5], vec![0, 0, 10]]).unwrap();
     let b = Matrix::from(vec![vec![1, 2, 0], vec![0, 3, 5]]).unwrap();
+    let c = Matrix::from(vec![
+        vec![0.0, 0.0, 10.0],
+        vec![0.0, 3.0, 5.0],
+        vec![1.0, 2.0, 0.0],
+    ])
+    .unwrap();
+
     assert_eq!(a.det(), Ok(30));
+    assert_eq!(c.det_in_field(), Ok(-30.0));
     assert!(b.det().is_err());
+    assert_eq!(a.trace(), Ok(14));
 }
 
 #[test]
-fn zero_one_test() {
+fn zero_one_diag_test() {
     let a = Matrix::from(vec![vec![0, 0, 0], vec![0, 0, 0]]).unwrap();
     let b = Matrix::from(vec![vec![1, 0], vec![0, 1]]).unwrap();
+
     assert_eq!(Matrix::<i32>::zero(2, 3), a);
     assert_eq!(Matrix::<i32>::identity(2), b);
+    assert_eq!(Matrix::diagonal_matrix(vec![1, 1]), b);
+}
+
+#[test]
+fn echelon_test() {
+    let m = Matrix::from(vec![vec![1.0, 2.0, 3.0], vec![1.0, 0.0, 1.0]]).unwrap();
+    let a = Matrix::from(vec![vec![1.0, 2.0, 3.0], vec![0.0, -2.0, -2.0]]).unwrap();
+    let b = Matrix::from(vec![vec![1.0, 0.0, 0.0], vec![1.0, -2.0, 0.0]]).unwrap();
+    let c = Matrix::from(vec![vec![1.0, 2.0, 3.0], vec![0.0, 1.0, 1.0]]).unwrap();
+
+    assert_eq!(m.row_echelon(), a);
+    assert_eq!(m.column_echelon(), b);
+    assert_eq!(m.reduced_row_echelon(), c);
+}
+
+#[test]
+fn conversion_test() {
+    let a = Matrix::from(vec![vec![1, 2, 3], vec![0, 1, 2]]).unwrap();
+    let b = Matrix::from(vec![vec![1.0, 2.0, 3.0], vec![0.0, 1.0, 2.0]]).unwrap();
+
+    use crate::MatrixInto;
+    assert_eq!(b, a.clone().matrix_into());
+
+    use crate::MatrixFrom;
+    let c = Matrix::<f64>::matrix_from(a);
+    assert_eq!(c, b);
+}
+
+#[test]
+fn inverse_test() {
+    let a = Matrix::from(vec![vec![1.0, 2.0], vec![1.0, 2.0]]).unwrap();
+    let b = Matrix::from(vec![
+        vec![1.0, 2.0, 3.0],
+        vec![0.0, 1.0, 4.0],
+        vec![5.0, 6.0, 0.0],
+    ])
+    .unwrap();
+    let c = Matrix::from(vec![
+        vec![-24.0, 18.0, 5.0],
+        vec![20.0, -15.0, -4.0],
+        vec![-5.0, 4.0, 1.0],
+    ])
+    .unwrap();
+
+    println!("{:?}", a.inverse());
+    assert!(a.inverse().is_err());
+    assert_eq!(b.inverse(), Ok(c));
 }