Bugfixes

Update tests
Add javadoc comments

src/main/java/com/mattrixwv/matrix/IntegerMatrix.java

@@ -1,7 +1,7 @@
 //Matrix/src/main/java/com/mattrixwv/IntegerMatrix.java
 //Mattrixwv
 // Created: 02-01-22
-//Modified: 06-30-23
+//Modified: 08-11-24
 package com.mattrixwv.matrix;
 
 
@@ -15,10 +15,23 @@ import com.mattrixwv.matrix.exceptions.InvalidScalarException;
 import com.mattrixwv.matrix.exceptions.NullMatrixException;
 
 
+/**
+ * Represents a matrix of integers and provides various matrix operations.
+ */
 public class IntegerMatrix{
+	/**
+	 * The grid that represents the matrix
+	 */
 	protected int[][] grid;
 
-	//Helper functions
+	//?Helper functions
+	/**
+	 * Sets the matrix grid to the specified 2D array. Validates the input to ensure
+	 * all rows are of equal length.
+	 *
+	 * @param grid The 2D array to set as the matrix grid.
+	 * @throws InvalidRowSizeException If the rows of the matrix are not all the same length.
+	 */
 	protected void setGrid(int[][] grid){
 		if(grid.length == 0){
 			this.grid = new int[0][0];
@@ -45,18 +58,32 @@ public class IntegerMatrix{
 			this.grid = newGrid;
 		}
 	}
+	/**
+	 * Creates a deep copy of the matrix grid.
+	 *
+	 * @return A new IntegerMatrix instance containing the copied grid.
+	 */
 	protected int[][] copyGrid(){
+		if(getNumCols() == 0){
+			return new int[grid.length][0];
+		}
+
 		//Allocate memory for the new grid
 		int[][] newGrid = new int[grid.length][grid[0].length];
 
 		//Copy every element from the current grid to the new one
 		for(int row = 0;row < grid.length;++row){
-			newGrid[row] = Arrays.copyOf(grid[row], grid.length);
+			newGrid[row] = Arrays.copyOf(grid[row], grid[row].length);
 		}
 
 		//Return the new grid
 		return newGrid;
 	}
+	/**
+	 * Checks if the matrix is a square matrix (i.e., the number of rows equals the number of columns).
+	 *
+	 * @return {@code true} if the matrix is square, {@code false} otherwise.
+	 */
 	public boolean isSquare(){
 		if(getNumRows() == 0){
 			return false;
@@ -65,7 +92,16 @@ public class IntegerMatrix{
 			return getNumRows() == getNumCols();
 		}
 	}
-	//Returns a matrix with the supplied row and column removed
+	/**
+	 * Creates a new matrix with the specified row and column removed.
+	 * This matrix is smaller by one row and one column than the current matrix.
+	 *
+	 * @param row The index of the row to remove.
+	 * @param col The index of the column to remove.
+	 * @return A new IntegerMatrix instance with the specified row and column removed.
+	 * @throws InvalidGeometryException If the matrix is not square or too small for Laplace expansion.
+	 * @throws InvalidCoordinatesException If the row or column index is out of bounds.
+	 */
 	protected IntegerMatrix laplaceExpansionHelper(int row, int col){
 		//Make sure the matrix is large enough to have this operation performed
 		if((getNumRows() <= 1) || (getNumCols() <= 1)){
@@ -109,16 +145,37 @@ public class IntegerMatrix{
 		return new IntegerMatrix(newGrid);
 	}
 
-	//Constructors
+	//?Constructors
+	/**
+	 * Constructs an empty matrix (0x0).
+	 */
 	public IntegerMatrix(){
 		grid = new int[0][0];
 	}
+	/**
+	 * Constructs a matrix with the specified grid.
+	 *
+	 * @param grid The 2D array to initialize the matrix with.
+	 */
 	public IntegerMatrix(int[][] grid){
 		setGrid(grid);
 	}
+	/**
+	 * Constructs a copy of the specified matrix.
+	 *
+	 * @param matrix The matrix to copy.
+	 */
 	public IntegerMatrix(IntegerMatrix matrix){
 		setGrid(matrix.grid);
 	}
+	/**
+	 * Constructs a matrix with the specified number of rows and columns, filled with the specified value.
+	 *
+	 * @param rows The number of rows.
+	 * @param cols The number of columns.
+	 * @param fill The value to fill the matrix with.
+	 * @throws InvalidGeometryException If the number of rows or columns is less than or equal to zero.
+	 */
 	public IntegerMatrix(int rows, int cols, int fill){
 		if(rows <= 0){
 			throw new InvalidGeometryException("A filled matrix must have at least 1 row");
@@ -136,7 +193,15 @@ public class IntegerMatrix{
 		}
 	}
 
-	//Gets
+	//?Gets
+	/**
+	 * Gets the value at the specified row and column.
+	 *
+	 * @param row The row index.
+	 * @param col The column index.
+	 * @return The value at the specified row and column.
+	 * @throws InvalidCoordinatesException If the row or column index is out of bounds.
+	 */
 	public int get(int row, int col){
 		//Make sure the row and column are valid
 		if(row >= grid.length){
@@ -145,7 +210,7 @@ public class IntegerMatrix{
 		else if(row < 0){
 			throw new InvalidCoordinatesException("Row cannot be less than 0");
 		}
-		else if(col >= grid[0].length){
+		else if(col >= grid[row].length){
 			throw new InvalidCoordinatesException("Column cannot be greater than the number of columns");
 		}
 		else if(col < 0){
@@ -155,6 +220,13 @@ public class IntegerMatrix{
 		//Return the location in the grid
 		return grid[row][col];
 	}
+	/**
+	 * Returns a new matrix that is a copy of the specified row.
+	 *
+	 * @param row The index of the row to retrieve.
+	 * @return A new IntegerMatrix instance containing the specified row.
+	 * @throws InvalidCoordinatesException If the row index is out of bounds.
+	 */
 	public IntegerMatrix getRow(int row){
 		//Make sure the row number is valid
 		if((row < 0) || (row >= grid.length)){
@@ -168,12 +240,24 @@ public class IntegerMatrix{
 		//Return the new matrix
 		return new IntegerMatrix(newRow);
 	}
+	/**
+	 * Returns the number of rows in the matrix.
+	 *
+	 * @return The number of rows.
+	 */
 	public int getNumRows(){
 		return grid.length;
 	}
+	/**
+	 * Returns a new matrix that is a copy of the specified column.
+	 *
+	 * @param col The index of the column to retrieve.
+	 * @return A new IntegerMatrix instance containing the specified column.
+	 * @throws InvalidCoordinatesException If the column index is out of bounds.
+	 */
 	public IntegerMatrix getCol(int col){
 		//Make sure the column number is valid
-		if((col < 0) || (grid.length == 0) || (col > grid[0].length)){
+		if((col < 0) || (grid.length == 0) || (col >= grid[0].length)){
 			throw new InvalidCoordinatesException("The column number " + col + " is not valid");
 		}
 
@@ -186,6 +270,11 @@ public class IntegerMatrix{
 		//Return the new matrix
 		return new IntegerMatrix(newColumn);
 	}
+	/**
+	 * Returns the number of columns in the matrix.
+	 *
+	 * @return The number of columns.
+	 */
 	public int getNumCols(){
 		if(grid.length > 0){
 			return grid[0].length;
@@ -195,7 +284,15 @@ public class IntegerMatrix{
 		}
 	}
 
-	//Sets
+	//?Sets
+	/**
+	 * Sets the value at the specified row and column.
+	 *
+	 * @param row   The row index.
+	 * @param col   The column index.
+	 * @param value The value to set.
+	 * @throws InvalidCoordinatesException If the row or column index is out of bounds.
+	 */
 	public void set(int row, int col, int value){
 		//Make sure the row number is valid
 		if((row < 0) || (row >= grid.length)){
@@ -209,6 +306,14 @@ public class IntegerMatrix{
 		//Save the element
 		grid[row][col] = value;
 	}
+	/**
+	 * Sets the specified row with the given array of elements.
+	 *
+	 * @param row	 The row index.
+	 * @param elements The array of elements to set.
+	 * @throws InvalidCoordinatesException If the row index is out of bounds.
+	 * @throws InvalidGeometryException	 If the length of the elements array does not match the number of columns.
+	 */
 	public void setRow(int row, int[] elements){
 		//Make sure the row number is valid
 		if((row < 0) || (row >= grid.length)){
@@ -225,6 +330,14 @@ public class IntegerMatrix{
 		//Save the elements
 		grid[row] = Arrays.copyOf(elements, elements.length);
 	}
+	/**
+	 * Sets the specified row with the given matrix containing a single row.
+	 *
+	 * @param row	 The row index.
+	 * @param matrix  The matrix containing a single row to set.
+	 * @throws NullMatrixException		   If the matrix is null.
+	 * @throws InvalidGeometryException	  If the matrix does not contain a single row.
+	 */
 	public void setRow(int row, IntegerMatrix matrix){
 		//Make sure the matrix isn't null
 		if(matrix == null){
@@ -238,6 +351,14 @@ public class IntegerMatrix{
 		//Set the row
 		setRow(row, matrix.grid[0]);
 	}
+	/**
+	 * Sets the specified column with the given array of elements.
+	 *
+	 * @param col	 The column index.
+	 * @param elements The array of elements to set.
+	 * @throws InvalidCoordinatesException If the column index is out of bounds.
+	 * @throws InvalidGeometryException	 If the length of the elements array does not match the number of rows.
+	 */
 	public void setCol(int col, int[] elements){
 		//Make sure the column number is valid
 		if((col < 0) || (col >= getNumCols())){
@@ -248,7 +369,7 @@ public class IntegerMatrix{
 			throw new InvalidGeometryException("Column cannot be null");
 		}
 		else if(elements.length != grid.length){
-			throw new InvalidCoordinatesException(elements.length, grid.length);
+			throw new InvalidGeometryException(elements.length, grid.length);
 		}
 
 		//Save the elements
@@ -256,6 +377,14 @@ public class IntegerMatrix{
 			grid[row][col] = elements[row];
 		}
 	}
+	/**
+	 * Sets the specified column with the given matrix containing a single column.
+	 *
+	 * @param col	 The column index.
+	 * @param matrix  The matrix containing a single column to set.
+	 * @throws NullMatrixException		   If the matrix is null.
+	 * @throws InvalidGeometryException	  If the matrix does not contain a single column.
+	 */
 	public void setCol(int col, IntegerMatrix matrix){
 		//Make sure the matrix isn't null
 		if(matrix == null){
@@ -275,7 +404,14 @@ public class IntegerMatrix{
 		setCol(col, vector);
 	}
 
-	//Adds
+	//?Adds
+	/**
+	 * Adds a new row with the specified array of elements to the matrix.
+	 *
+	 * @param elements The array of elements to add as a new row.
+	 * @throws NullMatrixException		   If the elements array is null.
+	 * @throws InvalidGeometryException	  If the length of the elements array does not match the number of columns.
+	 */
 	public void addRow(int[] elements){
 		//Make sure the matrix isn't null
 		if(elements == null){
@@ -297,6 +433,13 @@ public class IntegerMatrix{
 		//Add all elements to the grid
 		grid[grid.length - 1] = Arrays.copyOf(elements, elements.length);
 	}
+	/**
+	 * Adds a new row with the given matrix containing a single row to the matrix.
+	 *
+	 * @param matrix The matrix containing a single row to add.
+	 * @throws NullMatrixException		   If the matrix is null.
+	 * @throws InvalidGeometryException	  If the matrix does not contain a single row.
+	 */
 	public void addRow(IntegerMatrix matrix){
 		//Make sure the matrix isn't null
 		if(matrix == null){
@@ -310,6 +453,13 @@ public class IntegerMatrix{
 		//Add the row
 		addRow(matrix.grid[0]);
 	}
+	/**
+	 * Adds a new column with the specified array of elements to the matrix.
+	 *
+	 * @param elements The array of elements to add as a new column.
+	 * @throws NullMatrixException		   If the elements array is null.
+	 * @throws InvalidGeometryException	  If the length of the elements array does not match the number of rows.
+	 */
 	public void addCol(int[] elements){
 		//Make sure the matrix isn't null
 		if(elements == null){
@@ -333,8 +483,15 @@ public class IntegerMatrix{
 			throw new InvalidGeometryException(elements.length, getNumCols());
 		}
 	}
+	/**
+	 * Adds a new column with the given matrix containing a single column to the matrix.
+	 *
+	 * @param matrix The matrix containing a single column to add.
+	 * @throws NullMatrixException		   If the matrix is null.
+	 * @throws InvalidGeometryException	  If the matrix does not contain a single column.
+	 */
 	public void addCol(IntegerMatrix matrix){
-		//Make sure teh matrix isn't null
+		//Make sure the matrix isn't null
 		if(matrix == null){
 			throw new NullMatrixException();
 		}
@@ -351,6 +508,14 @@ public class IntegerMatrix{
 		//Add the column
 		addCol(vector);
 	}
+	/**
+	 * Appends the specified matrix to the right side of the current matrix.
+	 *
+	 * @param rightSide The matrix to append to the right side.
+	 * @return A new IntegerMatrix instance with the right-side matrix appended.
+	 * @throws NullMatrixException		   If the right-side matrix is null.
+	 * @throws InvalidGeometryException	  If the number of rows does not match.
+	 */
 	public IntegerMatrix appendRight(IntegerMatrix rightSide){
 		//Make sure the matrix isn't null
 		if(rightSide == null){
@@ -376,26 +541,34 @@ public class IntegerMatrix{
 		//Return the new matrix
 		return new IntegerMatrix(newGrid);
 	}
-	public IntegerMatrix appendBottom(IntegerMatrix rightSide){
+	/**
+	 * Appends the specified matrix to the bottom of the current matrix.
+	 *
+	 * @param bottomSide The matrix to append to the bottom.
+	 * @return A new IntegerMatrix instance with the bottom matrix appended.
+	 * @throws NullMatrixException		   If the bottom matrix is null.
+	 * @throws InvalidGeometryException	  If the number of columns does not match.
+	 */
+	public IntegerMatrix appendBottom(IntegerMatrix bottomSide){
 		//Make sure the matrix isn't null
-		if(rightSide == null){
+		if(bottomSide == null){
 			throw new NullMatrixException();
 		}
 		//Make sure the matrices have the same number of columns
-		else if(getNumCols() != rightSide.getNumCols()){
-			throw new InvalidGeometryException("Invalid number of columns. " + rightSide.getNumCols() + " must be " + getNumCols());
+		else if(getNumCols() != bottomSide.getNumCols()){
+			throw new InvalidGeometryException("Invalid number of columns. " + bottomSide.getNumCols() + " must be " + getNumCols());
 		}
 
 		//Traverse both matrices and set their values in the new matrix
-		int[][] newGrid = new int[getNumRows() + rightSide.getNumRows()][getNumCols()];
+		int[][] newGrid = new int[getNumRows() + bottomSide.getNumRows()][getNumCols()];
 		for(int col = 0;col < getNumCols();++col){
 			//Set all elements from the current grid's column
 			for(int row = 0;row < getNumRows();++row){
 				newGrid[row][col] = grid[row][col];
 			}
 			//Set all elements from the right side grid's column
-			for(int row = 0;row < rightSide.getNumRows();++row){
-				newGrid[getNumRows() + row][col] = rightSide.grid[row][col];
+			for(int row = 0;row < bottomSide.getNumRows();++row){
+				newGrid[getNumRows() + row][col] = bottomSide.grid[row][col];
 			}
 		}
 
@@ -403,7 +576,14 @@ public class IntegerMatrix{
 		return new IntegerMatrix(newGrid);
 	}
 
-	//Simple operations
+	//?Simple operations
+	/**
+	 * Generates an identity matrix of the given size.
+	 *
+	 * @param size The size of the identity matrix.
+	 * @return A new IntegerMatrix instance representing the identity matrix.
+	 * @throws InvalidGeometryException If the size is less than or equal to zero.
+	 */
 	public static IntegerMatrix generateIdentity(int size){
 		//Make sure the size is valid
 		if(size > 0){
@@ -429,8 +609,20 @@ public class IntegerMatrix{
 			throw new InvalidGeometryException("An identity matrix must have a size > 0");
 		}
 	}
+	/**
+	 * Adds the specified matrix to the current matrix.
+	 *
+	 * @param rightSide The matrix to add.
+	 * @return A new IntegerMatrix instance with the result of the addition.
+	 * @throws InvalidGeometryException If the matrices do not have the same dimensions.
+	 */
 	public IntegerMatrix add(IntegerMatrix rightSide){
-		//Make sure the matrices have compatable geometry
+		//Make sure the matrix isn't null
+		if(rightSide == null){
+			throw new NullMatrixException();
+		}
+
+		//Make sure the matrices have compatible geometry
 		if((getNumRows() != rightSide.getNumRows()) || (getNumCols() != rightSide.getNumCols())){
 			throw new InvalidGeometryException("Both matrices must have the same number of rows and columns: " + getNumRows() + "x" + getNumCols() + " + " + rightSide.getNumRows() + "x" + rightSide.getNumCols());
 		}
@@ -438,7 +630,7 @@ public class IntegerMatrix{
 		//Create a new grid with the same elements as the current grid
 		int[][] newGrid = copyGrid();
 
-		//Add each element in the righ tmatrix to the corresponding element in the left matrix
+		//Add each element in the right matrix to the corresponding element in the left matrix
 		for(int row = 0;row < newGrid.length;++row){
 			for(int col = 0;col < newGrid[0].length;++col){
 				newGrid[row][col] += rightSide.grid[row][col];
@@ -448,6 +640,12 @@ public class IntegerMatrix{
 		//Return the new matrix
 		return new IntegerMatrix(newGrid);
 	}
+	/**
+	 * Adds the scalar to every element in the matrix.
+	 *
+	 * @param scalar The scalar to add.
+	 * @return A new IntegerMatrix instance with the result of the addition.
+	 */
 	public IntegerMatrix add(int scalar){
 		//Create a new grid with the same elements as the current grid
 		int[][] newGrid = copyGrid();
@@ -462,25 +660,43 @@ public class IntegerMatrix{
 		//Return the new matrix
 		return new IntegerMatrix(newGrid);
 	}
+	/**
+	 * Subtracts the specified matrix from the current matrix.
+	 *
+	 * @param rightSide The matrix to subtract.
+	 * @return A new IntegerMatrix instance with the result of the subtraction.
+	 * @throws InvalidGeometryException If the matrices do not have the same dimensions.
+	 */
 	public IntegerMatrix subtract(IntegerMatrix rightSide){
-		//Make sure the matrices have compatable geometry
+		//Make sure the matrix isn't null
+		if(rightSide == null){
+			throw new NullMatrixException();
+		}
+
+		//Make sure the matrices have compatible geometry
 		if((getNumRows() != rightSide.getNumRows()) || (getNumCols() != rightSide.getNumCols())){
-			throw new InvalidGeometryException("Both matrices must have the same number of rows and columsn: " + getNumRows() + "x" + getNumCols() + " + " + rightSide.getNumRows() + "x" + rightSide.getNumCols());
+			throw new InvalidGeometryException("Both matrices must have the same number of rows and columns: " + getNumRows() + "x" + getNumCols() + " + " + rightSide.getNumRows() + "x" + rightSide.getNumCols());
 		}
 
 		//Create a new grid with the same elements as the current gird
 		int[][] newGrid = copyGrid();
 
-		//Subtract each element in the righ tmatrix from the corresponding element in the left matrix
+		//Subtract each element in the right matrix from the corresponding element in the left matrix
 		for(int row = 0;row < newGrid.length;++row){
 			for(int col = 0;col < newGrid[0].length;++col){
-				newGrid[row][col] -= grid[row][col];
+				newGrid[row][col] -= rightSide.grid[row][col];
 			}
 		}
 
 		//Return the new matrix
 		return new IntegerMatrix(newGrid);
 	}
+	/**
+	 * Subtracts the scalar from every element in the matrix.
+	 *
+	 * @param scalar The scalar to subtract.
+	 * @return A new IntegerMatrix instance with the result of the subtraction.
+	 */
 	public IntegerMatrix subtract(int scalar){
 		//Create a new grid with the same elements as the current grid
 		int[][] newGrid = copyGrid();
@@ -495,8 +711,20 @@ public class IntegerMatrix{
 		//Return the new matrix
 		return new IntegerMatrix(newGrid);
 	}
+	/**
+	 * Multiplies the current matrix by the specified matrix.
+	 *
+	 * @param rightSide The matrix to multiply by.
+	 * @return A new IntegerMatrix instance with the result of the multiplication.
+	 * @throws InvalidGeometryException If the number of columns in the current matrix does not match the number of rows in the right-side matrix.
+	 */
 	public IntegerMatrix multiply(IntegerMatrix rightSide){
-		//Make sure the matrices have compatable geometry
+		//Make sure the matrix isn't null
+		if(rightSide == null){
+			throw new NullMatrixException();
+		}
+
+		//Make sure the matrices have compatible geometry
 		if(getNumCols() != rightSide.getNumRows()){
 			throw new InvalidGeometryException("The left matrix must have the same number of columns as the right matrix has rows: " + getNumRows() + "x" + getNumCols() + " + " + rightSide.getNumRows() + "x" + rightSide.getNumCols());
 		}
@@ -519,6 +747,12 @@ public class IntegerMatrix{
 		//Return the new matrix
 		return new IntegerMatrix(newGrid);
 	}
+	/**
+	 * Multiplies every element in the matrix by the scalar.
+	 *
+	 * @param scalar the scalar to multiply
+	 * @return A new IntegerMatrix instance with the result of the multiplication
+	 */
 	public IntegerMatrix multiply(int scalar){
 		//Create a new grid with the same elements as the current grid
 		int[][] newGrid = copyGrid();
@@ -533,6 +767,14 @@ public class IntegerMatrix{
 		//Return the new matrix
 		return new IntegerMatrix(newGrid);
 	}
+	/**
+	 * Multiplies the current matrix by itself the given number of times.
+	 *
+	 * @param power The number of times to multiply the matrix by itself
+	 * @return A new IntegerMatrix instance with the result of the multiplication
+	 * @throws InvalidScalarException If the power is negative
+	 * @throws InvalidGeometryException If the matrix is not square
+	 */
 	public IntegerMatrix pow(int power){
 		//Make sure the matrix is square so it can be multiplied
 		if(!isSquare()){
@@ -556,8 +798,21 @@ public class IntegerMatrix{
 		//Return the new grid
 		return newMatrix;
 	}
+	/**
+	 * Calculates the dot product of the two matrices.
+	 *
+	 * @param rightSide The matrix to use on the right side of the calculation
+	 * @return The dot product of the two matrices
+	 * @throws NullMatrixException If the right matrix is null
+	 * @throws InvalidGeometryException If the matrices do not have compatible dimensions
+	 */
 	public int dotProduct(IntegerMatrix rightSide){
-		//Make sure the matrices have compatable geometry
+		//Make sure the matrix isn't null
+		if(rightSide == null){
+			throw new NullMatrixException();
+		}
+
+		//Make sure the matrices have compatible geometry
 		if(getNumCols() != rightSide.getNumRows()){
 			throw new InvalidGeometryException("The left matrix must have the same number of columns as the right matrix has rows: " + getNumRows() + "x" + getNumCols() + " + " + rightSide.getNumRows() + "x" + rightSide.getNumCols());
 		}
@@ -576,8 +831,21 @@ public class IntegerMatrix{
 		//Return the sum
 		return sum;
 	}
+	/**
+	 * Calculates the Hadamard product of the two matrices.
+	 *
+	 * @param rightSide The matrix to use on the right side of the calculation
+	 * @return The Hadamard product of the two matrices
+	 * @throws NullMatrixException If the right matrix is null
+	 * @throws InvalidGeometryException If the matrices do not have compatible dimensions
+	 */
 	public IntegerMatrix hadamardProduct(IntegerMatrix rightSide){
-		//Make sure the matrices have compatable geometry
+		//Make sure the matrix isn't null
+		if(rightSide == null){
+			throw new NullMatrixException();
+		}
+
+		//Make sure the matrices have compatible geometry
 		if((getNumRows() != rightSide.getNumRows()) || (getNumCols() != rightSide.getNumCols())){
 			throw new InvalidGeometryException("Both matrices must have the same number of rows and columns: " + getNumRows() + "x" + getNumCols() + " + " + rightSide.getNumRows() + "x" + rightSide.getNumCols());
 		}
@@ -596,7 +864,12 @@ public class IntegerMatrix{
 		return new IntegerMatrix(newGrid);
 	}
 
-	//Complex operations
+	//?Complex operations
+	/**
+	 * Transposes the current matrix (i.e., swaps rows and columns).
+	 *
+	 * @return A new IntegerMatrix instance representing the transposed matrix.
+	 */
 	public IntegerMatrix transpose(){
 		//Create a new grid
 		int[][] newGrid = new int[getNumCols()][getNumRows()];
@@ -611,16 +884,41 @@ public class IntegerMatrix{
 		//Return the new matrix
 		return new IntegerMatrix(newGrid);
 	}
+	/**
+	 * Calculates the determinant of the matrix. For matrices 4x4 or larger, a recursive approach is used.
+	 *
+	 * @return The determinant of the matrix.
+	 * @throws InvalidGeometryException If the matrix is not square.
+	 * @see #determinant()
+	 */
 	public int det(){
 		return determinant();
 	}
+	/**
+	 * Calculates the determinant of a 2x2 matrix.
+	 *
+	 * @return The determinant of the matrix.
+	 * @throws InvalidGeometryException If the matrix is not 2x2.
+	 */
 	private int det2(){
 		return (grid[0][0] * grid[1][1]) - (grid[0][1] * grid[1][0]);
 	}
+	/**
+	 * Calculates the determinant of a 3x3 matrix.
+	 *
+	 * @return The determinant of the matrix.
+	 * @throws InvalidGeometryException If the matrix is not 3x3.
+	 */
 	private int det3(){
 		return (grid[0][0] * grid[1][1] * grid[2][2]) + (grid[0][1] * grid[1][2] * grid[2][0]) + (grid[0][2] * grid[1][0] * grid[2][1]) -
 						(grid[2][0] * grid[1][1] * grid[0][2]) - (grid[2][1] * grid[1][2] * grid[0][0]) - (grid[2][2] * grid[1][0] * grid[0][1]);
 	}
+	/**
+	 * Calculates the determinant of a 4x4 or larger matrix.
+	 *
+	 * @return The determinant of the matrix.
+	 * @throws InvalidGeometryException If the matrix is not 4x4.
+	 */
 	private int det4(){
 		int det = 0;
 
@@ -690,6 +988,12 @@ public class IntegerMatrix{
 
 		return det;
 	}
+	/**
+	 * Calculates the determinant of the matrix. For matrices 4x4 or larger, a recursive approach is used.
+	 *
+	 * @return The determinant of the matrix.
+	 * @throws InvalidGeometryException If the matrix is not square.
+	 */
 	public int determinant(){
 		//Make sure the matrix is square
 		if(!isSquare()){
@@ -713,9 +1017,22 @@ public class IntegerMatrix{
 		//Return the determinant
 		return det;
 	}
+	/**
+	 * Calculates the cofactor matrix of the current matrix.
+	 *
+	 * @return A new IntegerMatrix instance representing the cofactor matrix.
+	 * @throws InvalidGeometryException If the matrix is not square.
+	 * @see #cofactor()
+	 */
 	public IntegerMatrix cof(){
 		return cofactor();
 	}
+	/**
+	 * Calculates the cofactor matrix of the current matrix.
+	 *
+	 * @return A new IntegerMatrix instance representing the cofactor matrix.
+	 * @throws InvalidGeometryException If the matrix is not square.
+	 */
 	public IntegerMatrix cofactor(){
 		//Make sure the matrix is square
 		if(!isSquare()){
@@ -742,12 +1059,31 @@ public class IntegerMatrix{
 		//Return the new matrix
 		return new IntegerMatrix(newGrid);
 	}
+	/**
+	 * Calculates the adjoint matrix of the current matrix.
+	 *
+	 * @return A new IntegerMatrix instance representing the adjoint matrix.
+	 * @throws InvalidGeometryException If the matrix is not square.
+	 * @see #adjoint()
+	 */
 	public IntegerMatrix adj(){
 		return adjoint();
 	}
+	/**
+	 * Calculates the adjoint matrix of the current matrix.
+	 *
+	 * @return A new IntegerMatrix instance representing the adjoint matrix.
+	 * @throws InvalidGeometryException If the matrix is not square.
+	 */
 	public IntegerMatrix adjoint(){
 		return cofactor().transpose();
 	}
+	/**
+	 * Calculates the inverse of the current matrix.
+	 *
+	 * @return A new IntegerMatrix instance representing the inverse matrix.
+	 * @throws InvalidGeometryException If the matrix is not square or if the determinant is 0.
+	 */
 	public IntegerMatrix inverse(){
 		//Make sure the matrix is square
 		if(!isSquare()){
@@ -764,7 +1100,15 @@ public class IntegerMatrix{
 		return adjoint().multiply(1 / determinant);
 	}
 
-	//Object funtions
+	//?Object functions
+	/**
+	 * Determines whether the given object is equal to the current matrix.
+	 * Can determine equality using IntegerMatrix or int[][].
+	 *
+	 * @param rightSide The object to compare to the current matrix.
+	 * @return True if the objects are equal, false otherwise.
+	 * @see #equals(IntegerMatrix)
+	 */
 	@Override
 	public boolean equals(Object rightSide){
 		if(rightSide == null){
@@ -781,6 +1125,12 @@ public class IntegerMatrix{
 			return false;
 		}
 	}
+	/**
+	 * Determines whether the given IntegerMatrix is equal to the current matrix.
+	 *
+	 * @param rightMatrix The IntegerMatrix to compare to the current matrix.
+	 * @return True if the matrices are equal, false otherwise.
+	 */
 	private boolean equals(IntegerMatrix rightMatrix){
 		//Make sure they have the same number of elements
 		if((getNumRows() != rightMatrix.getNumRows()) || (getNumCols() != rightMatrix.getNumCols())){
@@ -799,15 +1149,25 @@ public class IntegerMatrix{
 		//If false hasn't been returned yet then they are equal
 		return true;
 	}
+	/**
+	 * Calculates a hash code for the current matrix.
+	 *
+	 * @return The hash code for the current matrix.
+	 */
 	@Override
 	public int hashCode(){
 		return Arrays.hashCode(grid);
 	}
+	/**
+	 * Returns a string representation of the matrix, with rows and columns formatted for readability.
+	 *
+	 * @return A string representation of the matrix.
+	 */
 	@Override
 	public String toString(){
-		StringJoiner matrix = new StringJoiner("\n");
+		StringJoiner matrix = new StringJoiner("\n").setEmptyValue("[]");
 		for(int rowCnt = 0;rowCnt < getNumRows();++rowCnt){
-			StringJoiner row = new StringJoiner(",", "[", "]");
+			StringJoiner row = new StringJoiner(", ", "[", "]");
 
 			for(int colCnt = 0;colCnt < getNumCols();++colCnt){
 				row.add(Integer.toString(grid[rowCnt][colCnt]));