Bugfixes

Update tests
Add javadoc comments

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

@@ -1,7 +1,7 @@
 //Matrix/src/main/java/com/mattrixwv/BigIntegerMatrix.java
 //Mattrixwv
 // Created: 02-10-22
-//Modified: 06-30-23
+//Modified: 08-11-24
 package com.mattrixwv.matrix;
 
 
@@ -16,10 +16,23 @@ import com.mattrixwv.matrix.exceptions.InvalidScalarException;
 import com.mattrixwv.matrix.exceptions.NullMatrixException;
 
 
+/**
+ * Represents a matrix of big integers and provides various matrix operations.
+ */
 public class BigIntegerMatrix{
+	/**
+	 * The grid that represents the matrix
+	 */
 	protected BigInteger[][] 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(BigInteger[][] grid){
 		if(grid.length == 0){
 			this.grid = new BigInteger[0][0];
@@ -46,18 +59,32 @@ public class BigIntegerMatrix{
 			this.grid = newGrid;
 		}
 	}
+	/**
+	 * Creates a deep copy of the matrix grid.
+	 *
+	 * @return A new BigIntegerMatrix instance containing the copied grid.
+	 */
 	protected BigInteger[][] copyGrid(){
+		if(getNumCols() == 0){
+			return new BigInteger[grid.length][0];
+		}
+
 		//Allocate memory for the new grid
 		BigInteger[][] newGrid = new BigInteger[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;
@@ -66,7 +93,16 @@ public class BigIntegerMatrix{
 			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 BigIntegerMatrix 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 BigIntegerMatrix laplaceExpansionHelper(int row, int col){
 		//Make sure the matrix is large enough to have this operation performed
 		if((getNumRows() <= 1) || (getNumCols() <= 1)){
@@ -110,16 +146,37 @@ public class BigIntegerMatrix{
 		return new BigIntegerMatrix(newGrid);
 	}
 
-	//Constructors
+	//?Constructors
+	/**
+	 * Constructs an empty matrix (0x0).
+	 */
 	public BigIntegerMatrix(){
 		grid = new BigInteger[0][0];
 	}
+	/**
+	 * Constructs a matrix with the specified grid.
+	 *
+	 * @param grid The 2D array to initialize the matrix with.
+	 */
 	public BigIntegerMatrix(BigInteger[][] grid){
 		setGrid(grid);
 	}
+	/**
+	 * Constructs a copy of the specified matrix.
+	 *
+	 * @param matrix The matrix to copy.
+	 */
 	public BigIntegerMatrix(BigIntegerMatrix 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 BigIntegerMatrix(int rows, int cols, BigInteger fill){
 		if(rows <= 0){
 			throw new InvalidGeometryException("A filled matrix must have at least 1 row");
@@ -137,7 +194,15 @@ public class BigIntegerMatrix{
 		}
 	}
 
-	//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 BigInteger get(int row, int col){
 		//Make sure the row and column are valid
 		if(row >= grid.length){
@@ -146,7 +211,7 @@ public class BigIntegerMatrix{
 		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){
@@ -156,6 +221,13 @@ public class BigIntegerMatrix{
 		//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 BigIntegerMatrix instance containing the specified row.
+	 * @throws InvalidCoordinatesException If the row index is out of bounds.
+	 */
 	public BigIntegerMatrix getRow(int row){
 		//Make sure the row number is valid
 		if((row < 0) || (row >= grid.length)){
@@ -169,12 +241,24 @@ public class BigIntegerMatrix{
 		//Return the new matrix
 		return new BigIntegerMatrix(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 BigIntegerMatrix instance containing the specified column.
+	 * @throws InvalidCoordinatesException If the column index is out of bounds.
+	 */
 	public BigIntegerMatrix 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");
 		}
 
@@ -187,6 +271,11 @@ public class BigIntegerMatrix{
 		//Return the new matrix
 		return new BigIntegerMatrix(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;
@@ -196,7 +285,15 @@ public class BigIntegerMatrix{
 		}
 	}
 
-	//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, BigInteger value){
 		//Make sure the row number is valid
 		if((row < 0) || (row >= grid.length)){
@@ -210,6 +307,14 @@ public class BigIntegerMatrix{
 		//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, BigInteger[] elements){
 		//Make sure the row number is valid
 		if((row < 0) || (row >= grid.length)){
@@ -226,6 +331,14 @@ public class BigIntegerMatrix{
 		//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, BigIntegerMatrix matrix){
 		//Make sure the matrix isn't null
 		if(matrix == null){
@@ -239,6 +352,14 @@ public class BigIntegerMatrix{
 		//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, BigInteger[] elements){
 		//Make sure the column number is valid
 		if((col < 0) || (col >= getNumCols())){
@@ -249,7 +370,7 @@ public class BigIntegerMatrix{
 			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
@@ -257,6 +378,14 @@ public class BigIntegerMatrix{
 			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, BigIntegerMatrix matrix){
 		//Make sure the matrix isn't null
 		if(matrix == null){
@@ -276,7 +405,14 @@ public class BigIntegerMatrix{
 		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(BigInteger[] elements){
 		//Make sure the matrix isn't null
 		if(elements == null){
@@ -298,6 +434,13 @@ public class BigIntegerMatrix{
 		//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(BigIntegerMatrix matrix){
 		//Make sure the matrix isn't null
 		if(matrix == null){
@@ -311,6 +454,13 @@ public class BigIntegerMatrix{
 		//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(BigInteger[] elements){
 		//Make sure the matrix isn't null
 		if(elements == null){
@@ -334,6 +484,13 @@ public class BigIntegerMatrix{
 			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(BigIntegerMatrix matrix){
 		//Make sure the matrix isn't null
 		if(matrix == null){
@@ -352,6 +509,14 @@ public class BigIntegerMatrix{
 		//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 BigIntegerMatrix 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 BigIntegerMatrix appendRight(BigIntegerMatrix rightSide){
 		//Make sure the matrix isn't null
 		if(rightSide == null){
@@ -377,26 +542,34 @@ public class BigIntegerMatrix{
 		//Return the new matrix
 		return new BigIntegerMatrix(newGrid);
 	}
-	public BigIntegerMatrix appendBottom(BigIntegerMatrix rightSide){
+	/**
+	 * Appends the specified matrix to the bottom of the current matrix.
+	 *
+	 * @param bottomSide The matrix to append to the bottom.
+	 * @return A new BigIntegerMatrix 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 BigIntegerMatrix appendBottom(BigIntegerMatrix 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
-		BigInteger[][] newGrid = new BigInteger[getNumRows() + rightSide.getNumRows()][getNumCols()];
+		BigInteger[][] newGrid = new BigInteger[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];
 			}
 		}
 
@@ -404,7 +577,14 @@ public class BigIntegerMatrix{
 		return new BigIntegerMatrix(newGrid);
 	}
 
-	//Simple operations
+	//?Simple operations
+	/**
+	 * Generates an identity matrix of the given size.
+	 *
+	 * @param size The size of the identity matrix.
+	 * @return A new BigIntegerMatrix instance representing the identity matrix.
+	 * @throws InvalidGeometryException If the size is less than or equal to zero.
+	 */
 	public static BigIntegerMatrix generateIdentity(int size){
 		//Make sure the size is valid
 		if(size > 0){
@@ -430,8 +610,20 @@ public class BigIntegerMatrix{
 			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 BigIntegerMatrix instance with the result of the addition.
+	 * @throws InvalidGeometryException If the matrices do not have the same dimensions.
+	 */
 	public BigIntegerMatrix add(BigIntegerMatrix 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());
 		}
@@ -439,7 +631,7 @@ public class BigIntegerMatrix{
 		//Create a new grid with the same elements as the current grid
 		BigInteger[][] 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] = newGrid[row][col].add(rightSide.grid[row][col]);
@@ -449,6 +641,12 @@ public class BigIntegerMatrix{
 		//Return the new matrix
 		return new BigIntegerMatrix(newGrid);
 	}
+	/**
+	 * Adds the scalar to every element in the matrix.
+	 *
+	 * @param scalar The scalar to add.
+	 * @return A new BigIntegerMatrix instance with the result of the addition.
+	 */
 	public BigIntegerMatrix add(BigInteger scalar){
 		//Create a new grid with the same elements as the current grid
 		BigInteger[][] newGrid = copyGrid();
@@ -463,8 +661,20 @@ public class BigIntegerMatrix{
 		//Return the new matrix
 		return new BigIntegerMatrix(newGrid);
 	}
+	/**
+	 * Subtracts the specified matrix from the current matrix.
+	 *
+	 * @param rightSide The matrix to subtract.
+	 * @return A new BigIntegerMatrix instance with the result of the subtraction.
+	 * @throws InvalidGeometryException If the matrices do not have the same dimensions.
+	 */
 	public BigIntegerMatrix subtract(BigIntegerMatrix 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());
 		}
@@ -472,16 +682,22 @@ public class BigIntegerMatrix{
 		//Create a new grid with the same elements as the current gird
 		BigInteger[][] 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] = newGrid[row][col].subtract(grid[row][col]);
+				newGrid[row][col] = newGrid[row][col].subtract(rightSide.grid[row][col]);
 			}
 		}
 
 		//Return the new matrix
 		return new BigIntegerMatrix(newGrid);
 	}
+	/**
+	 * Subtracts the scalar from every element in the matrix.
+	 *
+	 * @param scalar The scalar to subtract.
+	 * @return A new BigIntegerMatrix instance with the result of the subtraction.
+	 */
 	public BigIntegerMatrix subtract(BigInteger scalar){
 		//Create a new grid with the same elements as the current grid
 		BigInteger[][] newGrid = copyGrid();
@@ -496,8 +712,20 @@ public class BigIntegerMatrix{
 		//Return the new matrix
 		return new BigIntegerMatrix(newGrid);
 	}
+	/**
+	 * Multiplies the current matrix by the specified matrix.
+	 *
+	 * @param rightSide The matrix to multiply by.
+	 * @return A new BigIntegerMatrix 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 BigIntegerMatrix multiply(BigIntegerMatrix 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());
 		}
@@ -520,6 +748,12 @@ public class BigIntegerMatrix{
 		//Return the new matrix
 		return new BigIntegerMatrix(newGrid);
 	}
+	/**
+	 * Multiplies every element in the matrix by the scalar.
+	 *
+	 * @param scalar the scalar to multiply
+	 * @return A new BigIntegerMatrix instance with the result of the multiplication
+	 */
 	public BigIntegerMatrix multiply(BigInteger scalar){
 		//Create a new grid with the same elements as the current grid
 		BigInteger[][] newGrid = copyGrid();
@@ -534,6 +768,14 @@ public class BigIntegerMatrix{
 		//Return the new matrix
 		return new BigIntegerMatrix(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 BigIntegerMatrix instance with the result of the multiplication
+	 * @throws InvalidScalarException If the power is negative
+	 * @throws InvalidGeometryException If the matrix is not square
+	 */
 	public BigIntegerMatrix pow(int power){
 		//Make sure the matrix is square so it can be multiplied
 		if(!isSquare()){
@@ -557,8 +799,21 @@ public class BigIntegerMatrix{
 		//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 BigInteger dotProduct(BigIntegerMatrix 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());
 		}
@@ -577,8 +832,21 @@ public class BigIntegerMatrix{
 		//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 BigIntegerMatrix hadamardProduct(BigIntegerMatrix 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());
 		}
@@ -597,7 +865,12 @@ public class BigIntegerMatrix{
 		return new BigIntegerMatrix(newGrid);
 	}
 
-	//Complex operations
+	//?Complex operations
+	/**
+	 * Transposes the current matrix (i.e., swaps rows and columns).
+	 *
+	 * @return A new BigIntegerMatrix instance representing the transposed matrix.
+	 */
 	public BigIntegerMatrix transpose(){
 		//Create a new grid
 		BigInteger[][] newGrid = new BigInteger[getNumCols()][getNumRows()];
@@ -612,16 +885,41 @@ public class BigIntegerMatrix{
 		//Return the new matrix
 		return new BigIntegerMatrix(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 BigInteger 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 BigInteger det2(){
 		return (grid[0][0].multiply(grid[1][1])).subtract(grid[0][1].multiply(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 BigInteger det3(){
 		return grid[0][0].multiply(grid[1][1]).multiply(grid[2][2]).add(grid[0][1].multiply(grid[1][2]).multiply(grid[2][0])).add(grid[0][2].multiply(grid[1][0]).multiply(grid[2][1])).subtract
 				(grid[2][0].multiply(grid[1][1]).multiply(grid[0][2])).subtract(grid[2][1].multiply(grid[1][2]).multiply(grid[0][0])).subtract(grid[2][2].multiply(grid[1][0]).multiply(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 BigInteger det4(){
 		BigInteger det = BigInteger.ZERO;
 
@@ -691,6 +989,12 @@ public class BigIntegerMatrix{
 
 		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 BigInteger determinant(){
 		//Make sure the matrix is square
 		if(!isSquare()){
@@ -714,9 +1018,22 @@ public class BigIntegerMatrix{
 		//Return the determinant
 		return det;
 	}
+	/**
+	 * Calculates the cofactor matrix of the current matrix.
+	 *
+	 * @return A new BigIntegerMatrix instance representing the cofactor matrix.
+	 * @throws InvalidGeometryException If the matrix is not square.
+	 * @see #cofactor()
+	 */
 	public BigIntegerMatrix cof(){
 		return cofactor();
 	}
+	/**
+	 * Calculates the cofactor matrix of the current matrix.
+	 *
+	 * @return A new BigIntegerMatrix instance representing the cofactor matrix.
+	 * @throws InvalidGeometryException If the matrix is not square.
+	 */
 	public BigIntegerMatrix cofactor(){
 		//Make sure the matrix is square
 		if(!isSquare()){
@@ -743,12 +1060,31 @@ public class BigIntegerMatrix{
 		//Return the new matrix
 		return new BigIntegerMatrix(newGrid);
 	}
+	/**
+	 * Calculates the adjoint matrix of the current matrix.
+	 *
+	 * @return A new BigIntegerMatrix instance representing the adjoint matrix.
+	 * @throws InvalidGeometryException If the matrix is not square.
+	 * @see #adjoint()
+	 */
 	public BigIntegerMatrix adj(){
 		return adjoint();
 	}
+	/**
+	 * Calculates the adjoint matrix of the current matrix.
+	 *
+	 * @return A new BigIntegerMatrix instance representing the adjoint matrix.
+	 * @throws InvalidGeometryException If the matrix is not square.
+	 */
 	public BigIntegerMatrix adjoint(){
 		return cofactor().transpose();
 	}
+	/**
+	 * Calculates the inverse of the current matrix.
+	 *
+	 * @return A new BigIntegerMatrix instance representing the inverse matrix.
+	 * @throws InvalidGeometryException If the matrix is not square or if the determinant is 0.
+	 */
 	public BigIntegerMatrix inverse(){
 		//Make sure the matrix is square
 		if(!isSquare()){
@@ -765,7 +1101,15 @@ public class BigIntegerMatrix{
 		return adjoint().multiply(BigInteger.ONE.divide(determinant));
 	}
 
-	//Object funtions
+	//?Object functions
+	/**
+	 * Determines whether the given object is equal to the current matrix.
+	 * Can determine equality using BigIntegerMatrix or BigInteger[][].
+	 *
+	 * @param rightSide The object to compare to the current matrix.
+	 * @return True if the objects are equal, false otherwise.
+	 * @see #equals(BigIntegerMatrix)
+	 */
 	@Override
 	public boolean equals(Object rightSide){
 		if(rightSide == null){
@@ -782,7 +1126,17 @@ public class BigIntegerMatrix{
 			return false;
 		}
 	}
+	/**
+	 * Determines whether the given BigIntegerMatrix is equal to the current matrix.
+	 *
+	 * @param rightMatrix The BigIntegerMatrix to compare to the current matrix.
+	 * @return True if the matrices are equal, false otherwise.
+	 */
 	private boolean equals(BigIntegerMatrix rightMatrix){
+		if(rightMatrix == null){
+			return false;
+		}
+
 		//Make sure they have the same number of elements
 		if((getNumRows() != rightMatrix.getNumRows()) || (getNumCols() != rightMatrix.getNumCols())){
 			return false;
@@ -800,15 +1154,25 @@ public class BigIntegerMatrix{
 		//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(grid[rowCnt][colCnt].toString());