diff --git a/src/test/java/com/mattrixwv/matrix/TestModMatrix.java b/src/test/java/com/mattrixwv/matrix/TestModMatrix.java
new file mode 100644
index 0000000..7bf192b
--- /dev/null
+++ b/src/test/java/com/mattrixwv/matrix/TestModMatrix.java
@@ -0,0 +1,1311 @@
+//Matrix/src/test/java/com/mattixwv/matrix/TestModMatrix.java
+//Mattrixwv
+// Created: 02-09-22
+//Modified: 02-09-22
+package com.mattrixwv.matrix;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+
+public class TestModMatrix{
+	//Grid 1x1
+	private static final int[][] grid1 = {
+		{1}
+	};
+	private static final int[][] transformGrid1_1 = {
+		{1}
+	};
+	private static final int[][] transformGrid1_2 = {
+		{2}
+	};
+
+	//Grid 2x2
+	private static final int[][] grid2 = {
+		{1, 2},
+		{1, 2}
+	};
+	private static final int[][] transformGrid2_1 = {
+		{1, 0},
+		{1, 0}
+	};
+	private static final int[][] transformGrid2_2 = {
+		{2, 3},
+		{2, 3}
+	};
+
+	//Grid 3x3
+	private static final int[][] grid3 = {
+		{1, 2, 3},
+		{1, 2, 3},
+		{1, 2, 3}
+	};
+	private static final int[][] transformGrid3_1 = {
+		{2, 1, 0},
+		{2, 1, 0},
+		{2, 1, 0}
+	};
+	private static final int[][] transformGrid3_2 = {
+		{2, 3, 4},
+		{2, 3, 4},
+		{2, 3, 4}
+	};
+
+	//Grid 4x4
+	private static final int[][] grid4 = {
+		{1, 2, 3, 4},
+		{1, 2, 3, 4},
+		{1, 2, 3, 4},
+		{1, 2, 3, 4}
+	};
+	private static final int[][] transformGrid4_1 = {
+		{3, 2, 1, 0},
+		{3, 2, 1, 0},
+		{3, 2, 1, 0},
+		{3, 2, 1, 0}
+	};
+	private static final int[][] transformGrid4_2 = {
+		{2, 3, 4, 5},
+		{2, 3, 4, 5},
+		{2, 3, 4, 5},
+		{2, 3, 4, 5}
+	};
+
+	//Grid 10x10
+	private static final int[][] grid10 = {
+		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	};
+	private static final int[][] transformGrid10_1 = {
+		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
+		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
+		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
+		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
+		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
+		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
+		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
+		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
+		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
+		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
+	};
+	private static final int[][] transformGrid10_2 = {
+		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
+	};
+
+
+	@Test
+	public void testEquals(){
+		//1x1
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		assertTrue("ModMatrix 1x1 failed equals ModMatrix.", matrix.equals(matrix));
+		@SuppressWarnings("unlikely-arg-type")
+		boolean gridEquals = matrix.equals(grid1);
+		assertTrue("ModMatrix 1x1 failed equals int[][].", gridEquals);
+
+		//2x2
+		matrix = new ModMatrix(grid2, 26);
+		assertTrue("ModMatrix 2x2 failed equals ModMatrix.", matrix.equals(matrix));
+		@SuppressWarnings("unlikely-arg-type")
+		boolean gridEquals2 = matrix.equals(grid2);
+		assertTrue("ModMatrix 2x2 failed equals int[][].", gridEquals2);
+
+		//3x3
+		matrix = new ModMatrix(grid3, 26);
+		assertTrue("ModMatrix 3x3 failed equals ModMatrix.", matrix.equals(matrix));
+		@SuppressWarnings("unlikely-arg-type")
+		boolean gridEquals3 = matrix.equals(grid3);
+		assertTrue("ModMatrix 3x3 failed equals int[][].", gridEquals3);
+
+		//4x4
+		matrix = new ModMatrix(grid4, 26);
+		assertTrue("ModMatrix 4x4 failed equals ModMatrix.", matrix.equals(matrix));
+		@SuppressWarnings("unlikely-arg-type")
+		boolean gridEquals4 = matrix.equals(grid4);
+		assertTrue("ModMatrix 4x4 failed equals int[][].", gridEquals4);
+
+		//10x10
+		matrix = new ModMatrix(grid10, 26);
+		assertTrue("ModMatrix 10x10 failed equals ModMatrix.", matrix.equals(matrix));
+		@SuppressWarnings("unlikely-arg-type")
+		boolean gridEquals10 = matrix.equals(grid10);
+		assertTrue("ModMatrix 10x10 failed equals int[][].", gridEquals10);
+	}
+
+	@Test
+	public void testGets(){
+		//1x1
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		assertEquals("ModMatrix 1x1 failed get.", 1, matrix.get(0, 0));
+		//GetRow
+		ModMatrix correctMatrix = new ModMatrix(new int[][]{{1}}, 26);
+		assertEquals("ModMatrix 1x1 failed getRow.", correctMatrix, matrix.getRow(0));
+		//GetColumn
+		correctMatrix = new ModMatrix(new int[][]{{1}}, 26);
+		assertEquals("ModMatrix 1x1 failed getCol.", correctMatrix, matrix.getCol(0));
+
+		//2x2
+		matrix = new ModMatrix(grid2, 26);
+		assertEquals("ModMatrix 2x2 failed get.", 1, matrix.get(0, 0));
+		//GetRow
+		correctMatrix = new ModMatrix(new int[][]{{1, 2}}, 26);
+		assertEquals("ModMatrix 2x2 failed getRow.", correctMatrix, matrix.getRow(0));
+		//GetColumn
+		correctMatrix = new ModMatrix(new int[][]{
+			{1},
+			{1},
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed getCol.", correctMatrix, matrix.getCol(0));
+
+		//3x3
+		matrix = new ModMatrix(grid3, 26);
+		assertEquals("ModMatrix 3x3 failed get.", 1, matrix.get(0, 0));
+		//GetRow
+		correctMatrix = new ModMatrix(new int[][]{{1, 2, 3}}, 26);
+		assertEquals("ModMatrix 3x3 failed getRow.", correctMatrix, matrix.getRow(0));
+		//GetCol
+		correctMatrix = new ModMatrix(new int[][]{
+			{1},
+			{1},
+			{1}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed getCol.", correctMatrix, matrix.getCol(0));
+
+		//4x4
+		matrix = new ModMatrix(grid4, 26);
+		assertEquals("ModMatrix 4x4 failed get.", 1, matrix.get(0, 0));
+		//GetRow
+		correctMatrix = new ModMatrix(new int[][]{{1, 2, 3, 4}}, 26);
+		assertEquals("ModMatrix 4x4 failed getRow.", correctMatrix, matrix.getRow(0));
+		//GetCol
+		correctMatrix = new ModMatrix(new int[][]{
+			{1},
+			{1},
+			{1},
+			{1}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed getCol.", correctMatrix, matrix.getCol(0));
+
+		//10x10
+		matrix = new ModMatrix(grid10, 26);
+		assertEquals("ModMatrix 10x10 failed get.", 1, matrix.get(0, 0));
+		//GetRow
+		correctMatrix = new ModMatrix(new int[][]{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}, 26);
+		assertEquals("ModMatrix 10x10 failed getRow.", correctMatrix, matrix.getRow(0));
+		//GetColumn
+		correctMatrix = new ModMatrix(new int[][]{
+			{1},
+			{1},
+			{1},
+			{1},
+			{1},
+			{1},
+			{1},
+			{1},
+			{1},
+			{1}
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed getColumn.", correctMatrix, matrix.getCol(0));
+	}
+
+	@Test
+	public void testSets(){
+		//1x1
+		//Set
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		matrix.set(0, 0, 2);
+		ModMatrix correctMatrix = new ModMatrix(new int[][]{{2}}, 26);
+		assertEquals("ModMatrix 1x1 failed set.", correctMatrix, matrix);
+		//SetRow
+		matrix.setRow(0, new int[]{0});
+		correctMatrix = new ModMatrix(new int[][]{{0}}, 26);
+		assertEquals("ModMatrix 1x1 failed setRow.", correctMatrix, matrix);
+		//SetColumn
+		matrix.setCol(0, new int[]{1});
+		correctMatrix = new ModMatrix(new int[][]{{1}}, 26);
+		assertEquals("ModMatrix 1x1 failed setCol.", correctMatrix, matrix);
+
+		//2x2
+		//Set
+		matrix = new ModMatrix(grid2, 26);
+		matrix.set(0, 0, 3);
+		correctMatrix = new ModMatrix(new int[][]{
+			{3, 2},
+			{1, 2}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed set.", correctMatrix, matrix);
+		//SetRow
+		matrix.setRow(1, new int[]{2, 1});
+		correctMatrix = new ModMatrix(new int[][]{
+			{3, 2},
+			{2, 1}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed set row.", correctMatrix, matrix);
+		//SetColumn
+		matrix = new ModMatrix(grid2, 26);
+		matrix.setCol(0, new int[]{3, 3});
+		correctMatrix = new ModMatrix(new int[][]{
+			{3, 2},
+			{3, 2}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed set row.", correctMatrix, matrix);
+
+		//3x3
+		//Set
+		matrix = new ModMatrix(grid3, 26);
+		matrix.set(0, 0, 3);
+		correctMatrix = new ModMatrix(new int[][]{
+			{3, 2, 3},
+			{1, 2, 3},
+			{1, 2, 3},
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed set.", correctMatrix, matrix);
+		//SetRow
+		matrix.setRow(0, new int[]{0, 1, 2});
+		correctMatrix = new ModMatrix(new int[][]{
+			{0, 1, 2},
+			{1, 2, 3},
+			{1, 2, 3}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed setRow.", correctMatrix, matrix);
+		//SetColumn
+		matrix.setCol(0, new int[]{0, 0, 0});
+		correctMatrix = new ModMatrix(new int[][]{
+			{0, 1, 2},
+			{0, 2, 3},
+			{0, 2, 3}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed setColumn.", correctMatrix, matrix);
+
+		//4x4
+		//Set
+		matrix = new ModMatrix(grid4, 26);
+		matrix.set(0, 0, 3);
+		correctMatrix = new ModMatrix(new int[][]{
+			{3, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed set.", correctMatrix, matrix);
+		//SetRow
+		matrix.setRow(0, new int[]{4, 3, 2, 1});
+		correctMatrix = new ModMatrix(new int[][]{
+			{4, 3, 2, 1},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed setRow.", correctMatrix, matrix);
+		//SetColumn
+		matrix.setCol(0, new int[]{0, 0, 0, 0});
+		correctMatrix = new ModMatrix(new int[][]{
+			{0, 3, 2, 1},
+			{0, 2, 3, 4},
+			{0, 2, 3, 4},
+			{0, 2, 3, 4}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed setCol.", correctMatrix, matrix);
+
+		//10x10
+		//Set
+		matrix = new ModMatrix(grid10, 26);
+		matrix.set(0, 0, 3);
+		correctMatrix = new ModMatrix(new int[][]{
+			{3, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed set.", correctMatrix, matrix);
+		//SetRow
+		matrix.setRow(0, new int[]{10, 9, 8, 7, 6, 5, 4, 3, 2, 1});
+		correctMatrix = new ModMatrix(new int[][]{
+			{10, 9, 8, 7, 6, 5, 4, 3, 2, 1},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed setRow.", correctMatrix, matrix);
+		//SetColumn
+		matrix.setCol(0, new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
+		correctMatrix = new ModMatrix(new int[][]{
+			{0, 9, 8, 7, 6, 5, 4, 3, 2, 1},
+			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed setColumn.", correctMatrix, matrix);
+	}
+
+	@Test
+	public void testAdds(){
+		//1x1
+		//AddRow
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		matrix.addRow(new int[]{1});
+		ModMatrix correctMatrix = new ModMatrix(new int[][]{{1}, {1}}, 26);
+		assertEquals("ModMatrix 1x1 failed addRow.", correctMatrix, matrix);
+		//AddColumn
+		matrix = new ModMatrix(grid1, 26);
+		matrix.addCol(new int[]{1});
+		correctMatrix = new ModMatrix(new int[][]{{1, 1}}, 26);
+		assertEquals("ModMatrix 1x1 failed addCol.", correctMatrix, matrix);
+
+		//2x2
+		//AddRow
+		matrix = new ModMatrix(grid2, 26);
+		matrix.addRow(new int[]{1, 2});
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2},
+			{1, 2},
+			{1, 2}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed addRow.", correctMatrix, matrix);
+		//AddColumn
+		matrix = new ModMatrix(grid2, 26);
+		matrix.addCol(new int[]{3, 3});
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2, 3},
+			{1, 2, 3}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed addCol.", correctMatrix, matrix);
+
+		//3x3
+		//AddRow
+		matrix = new ModMatrix(grid3, 26);
+		matrix.addRow(new int[]{1, 2, 3});
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2, 3},
+			{1, 2, 3},
+			{1, 2, 3},
+			{1, 2, 3}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed addRow.", correctMatrix, matrix);
+		//AddColumn
+		matrix = new ModMatrix(grid3, 26);
+		matrix.addCol(new int[]{4, 4, 4});
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed addCol.", correctMatrix, matrix);
+
+		//4x4
+		//AddRow
+		matrix = new ModMatrix(grid4, 26);
+		matrix.addRow(new int[]{1, 2, 3, 4});
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed addRow.", correctMatrix, matrix);
+		//AddColumn
+		matrix.addCol(new int[]{5, 5, 5, 5, 5});
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 4, 5},
+			{1, 2, 3, 4, 5},
+			{1, 2, 3, 4, 5},
+			{1, 2, 3, 4, 5},
+			{1, 2, 3, 4, 5}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed addCol.", correctMatrix, matrix);
+
+		//10x10
+		//AddRow
+		matrix = new ModMatrix(grid10, 26);
+		matrix.addRow(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed addRow.", correctMatrix, matrix);
+		//AddColumn
+		matrix = new ModMatrix(grid10, 26);
+		matrix.addCol(new int[]{11, 11, 11, 11, 11, 11, 11, 11, 11, 11});
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed addColumn.", correctMatrix, matrix);
+	}
+
+	@Test
+	public void testAppends(){
+		//1x1
+		//appendRight
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		ModMatrix secondMatrix = new ModMatrix(grid1, 26);
+		ModMatrix correctMatrix = new ModMatrix(new int[][]{{1, 1}}, 26);
+		assertEquals("ModMatrix 1x1 failed appendRight.", correctMatrix, matrix.appendRight(secondMatrix));
+		//appendBottom
+		correctMatrix = new ModMatrix(new int[][]{
+			{1},
+			{1}
+		}, 26);
+		assertEquals("ModMatrix 1x1 failed appendBottom.", correctMatrix, matrix.appendBottom(secondMatrix));
+
+		//2x2
+		//appendRight
+		matrix = new ModMatrix(grid2, 26);
+		secondMatrix = new ModMatrix(grid2, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2, 1, 2},
+			{1, 2, 1, 2}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed appendRight.", correctMatrix, matrix.appendRight(secondMatrix));
+		//appendBottom
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2},
+			{1, 2},
+			{1, 2},
+			{1, 2}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed appendBottom.", correctMatrix, matrix.appendBottom(secondMatrix));
+
+		//3x3
+		//appendRight
+		matrix = new ModMatrix(grid3, 26);
+		secondMatrix = new ModMatrix(grid3, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 1, 2, 3},
+			{1, 2, 3, 1, 2, 3},
+			{1, 2, 3, 1, 2, 3}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed appendRight.", correctMatrix, matrix.appendRight(secondMatrix));
+		//appendBottom
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2, 3},
+			{1, 2, 3},
+			{1, 2, 3},
+			{1, 2, 3},
+			{1, 2, 3},
+			{1, 2, 3}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed appendBottom.", correctMatrix, matrix.appendBottom(secondMatrix));
+
+		//4x4
+		//appendRight
+		matrix = new ModMatrix(grid4, 26);
+		secondMatrix = new ModMatrix(grid4, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 4, 1, 2, 3, 4},
+			{1, 2, 3, 4, 1, 2, 3, 4},
+			{1, 2, 3, 4, 1, 2, 3, 4},
+			{1, 2, 3, 4, 1, 2, 3, 4}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed appendRight.", correctMatrix, matrix.appendRight(secondMatrix));
+		//appendBottom
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed appendBottom.", correctMatrix, matrix.appendBottom(secondMatrix));
+
+		//10x10
+		//appendRight
+		matrix = new ModMatrix(grid10, 26);
+		secondMatrix = new ModMatrix(grid10, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed appendRight.", correctMatrix, matrix.appendRight(secondMatrix));
+		//appendBottom
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed appendBottom.", correctMatrix, matrix.appendBottom(secondMatrix));
+	}
+
+	@Test
+	public void testAddition(){
+		//1x1
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		ModMatrix transformMatrix = new ModMatrix(transformGrid1_1, 26);
+		ModMatrix correctMatrix = new ModMatrix(new int[][]{{2}}, 26);
+		assertEquals("ModMatrix 1x1 failed add ModMatrix.", correctMatrix, matrix.add(transformMatrix));
+		assertEquals("ModMatrix 1x1 failed add scalar.", correctMatrix, matrix.add(1));
+
+		//2x2
+		matrix = new ModMatrix(grid2, 26);
+		transformMatrix = new ModMatrix(transformGrid2_1, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{2, 2},
+			{2, 2}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed add ModMatrix.", correctMatrix, matrix.add(transformMatrix));
+		correctMatrix = new ModMatrix(new int[][]{
+			{2, 3},
+			{2, 3}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed add scalar.", correctMatrix, matrix.add(1));
+
+		//3x3
+		matrix = new ModMatrix(grid3, 26);
+		transformMatrix = new ModMatrix(transformGrid3_1, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{3, 3, 3},
+			{3, 3, 3},
+			{3, 3, 3}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed add ModMatrix.", correctMatrix, matrix.add(transformMatrix));
+		correctMatrix = new ModMatrix(new int[][]{
+			{2, 3, 4},
+			{2, 3, 4},
+			{2, 3, 4}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed add scalar.", correctMatrix, matrix.add(1));
+
+		//4x4
+		matrix = new ModMatrix(grid4, 26);
+		transformMatrix = new ModMatrix(transformGrid4_1, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{4, 4, 4, 4},
+			{4, 4, 4, 4},
+			{4, 4, 4, 4},
+			{4, 4, 4, 4}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed add ModMatrix.", correctMatrix, matrix.add(transformMatrix));
+		correctMatrix = new ModMatrix(new int[][]{
+			{2, 3, 4, 5},
+			{2, 3, 4, 5},
+			{2, 3, 4, 5},
+			{2, 3, 4, 5}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed add scalar.", correctMatrix, matrix.add(1));
+
+		//10x10
+		matrix = new ModMatrix(grid10, 26);
+		transformMatrix = new ModMatrix(transformGrid10_1, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
+			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
+			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
+			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
+			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
+			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
+			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
+			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
+			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
+			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10}
+		}, 26);
+		assertEquals("ModMatrix 5x5 failed add ModMatrix.", correctMatrix, matrix.add(transformMatrix));
+		correctMatrix = new ModMatrix(new int[][]{
+			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed add ModMatrix.", correctMatrix, matrix.add(1));
+	}
+
+	@Test
+	public void testSubtraction(){
+		//1x1
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		ModMatrix transformMatrix = new ModMatrix(grid1, 26);
+		ModMatrix correctMatrix = new ModMatrix(new int[][]{
+			{0}
+		}, 26);
+		assertEquals("ModMatrix 1x1 failed subtract ModMatrix.", correctMatrix, matrix.subtract(transformMatrix));
+		assertEquals("ModMatrix 1x1 failed subtract scalar.", correctMatrix, matrix.subtract(1));
+
+		//2x2
+		matrix = new ModMatrix(grid2, 26);
+		transformMatrix = new ModMatrix(grid2, 26);
+		correctMatrix = new ModMatrix(2, 2, 0, 26);
+		assertEquals("ModMatrix 2x2 failed subtract ModMatrix.", correctMatrix, matrix.subtract(transformMatrix));
+		correctMatrix = new ModMatrix(new int[][]{
+			{0, 1},
+			{0, 1}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed subtract scalar.", correctMatrix, matrix.subtract(1));
+
+		//3x3
+		matrix = new ModMatrix(grid3, 26);
+		transformMatrix = new ModMatrix(grid3, 26);
+		correctMatrix = new ModMatrix(3, 3, 0, 26);
+		assertEquals("ModMatrix 3x3 failed subtract ModMatrix.", correctMatrix, matrix.subtract(transformMatrix));
+		correctMatrix = new ModMatrix(new int[][]{
+			{0, 1, 2},
+			{0, 1, 2},
+			{0, 1, 2}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed subtract scalar.", correctMatrix, matrix.subtract(1));
+
+		//4x4
+		matrix = new ModMatrix(grid4, 26);
+		transformMatrix = new ModMatrix(grid4, 26);
+		correctMatrix = new ModMatrix(4, 4, 0, 26);
+		assertEquals("ModMatrix 4x4 failed subtract ModMatrix.", correctMatrix, matrix.subtract(transformMatrix));
+		correctMatrix = new ModMatrix(new int[][]{
+			{0, 1, 2, 3},
+			{0, 1, 2, 3},
+			{0, 1, 2, 3},
+			{0, 1, 2, 3}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed subtract scalar.", correctMatrix, matrix.subtract(1));
+
+		//10x10
+		matrix = new ModMatrix(grid10, 26);
+		transformMatrix = new ModMatrix(grid10, 26);
+		correctMatrix = new ModMatrix(10, 10, 0, 26);
+		assertEquals("ModMatrix 10x10 failed subtract ModMatrix.", correctMatrix, matrix.subtract(transformMatrix));
+		correctMatrix = new ModMatrix(new int[][]{
+			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed subtract scalar.", correctMatrix, matrix.subtract(1));
+	}
+
+	@Test
+	public void testMultiplication(){
+		//1x1
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		ModMatrix transformMatrix = new ModMatrix(transformGrid1_2, 26);
+		ModMatrix correctMatrix = new ModMatrix(transformGrid1_2, 26);
+		assertEquals("ModMatrix 1x1 failed multiplication ModMatrix.", correctMatrix, matrix.multiply(transformMatrix));
+		assertEquals("ModMatrix 1x1 failed multiplication scalar.", correctMatrix, matrix.multiply(2));
+
+		//2x2
+		matrix = new ModMatrix(grid2, 26);
+		transformMatrix = new ModMatrix(transformGrid2_2, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{6, 9},
+			{6, 9}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed multiplication ModMatrix.", correctMatrix, matrix.multiply(transformMatrix));
+		ModMatrix vector = new ModMatrix(new int[][]{
+			{2},
+			{3}
+		}, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{8},
+			{8}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed multiplication vector.", correctMatrix, matrix.multiply(vector));
+		correctMatrix = new ModMatrix(new int[][]{
+			{2, 4},
+			{2, 4}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed multiplication scalar.", correctMatrix, matrix.multiply(2));
+
+		//3x3
+		matrix = new ModMatrix(grid3, 26);
+		transformMatrix = new ModMatrix(transformGrid3_2, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{12, 18, 24},
+			{12, 18, 24},
+			{12, 18, 24}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed multiplication ModMatrix.", correctMatrix, matrix.multiply(transformMatrix));
+		vector = new ModMatrix(new int[][]{
+			{2},
+			{3},
+			{4}
+		}, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{20},
+			{20},
+			{20}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed multiplication vector.", correctMatrix, matrix.multiply(vector));
+		correctMatrix = new ModMatrix(new int[][]{
+			{2, 4, 6},
+			{2, 4, 6},
+			{2, 4, 6}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed multiplication scalar.", correctMatrix, matrix.multiply(2));
+
+		//4x4
+		matrix = new ModMatrix(grid4, 26);
+		transformMatrix = new ModMatrix(transformGrid4_2, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{20, 30, 40, 50},
+			{20, 30, 40, 50},
+			{20, 30, 40, 50},
+			{20, 30, 40, 50},
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed multiplication ModMatrix.", correctMatrix, matrix.multiply(transformMatrix));
+		vector = new ModMatrix(new int[][]{
+			{2},
+			{3},
+			{4},
+			{5}
+		}, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{40},
+			{40},
+			{40},
+			{40}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed multiplication vector.", correctMatrix, matrix.multiply(vector));
+		correctMatrix = new ModMatrix(new int[][]{
+			{2, 4, 6, 8},
+			{2, 4, 6, 8},
+			{2, 4, 6, 8},
+			{2, 4, 6, 8}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed multiplication scalar.", correctMatrix, matrix.multiply(2));
+
+		//10x10
+		matrix = new ModMatrix(grid10, 26);
+		transformMatrix = new ModMatrix(transformGrid10_2, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
+			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
+			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
+			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
+			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
+			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
+			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
+			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
+			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
+			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605}
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed multiplication ModMatrix.", correctMatrix, matrix.multiply(transformMatrix));
+		vector = new ModMatrix(new int[][]{
+			{2},
+			{3},
+			{4},
+			{5},
+			{6},
+			{7},
+			{8},
+			{9},
+			{10},
+			{11}
+		}, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{440},
+			{440},
+			{440},
+			{440},
+			{440},
+			{440},
+			{440},
+			{440},
+			{440},
+			{440}
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed multiplication vector.", correctMatrix, matrix.multiply(vector));
+		correctMatrix = new ModMatrix(new int[][]{
+			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
+			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
+			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
+			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
+			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
+			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
+			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
+			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
+			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
+			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20}
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed multiplication scalar.", correctMatrix, matrix.multiply(2));
+	}
+
+	@Test
+	public void testDotProduct(){
+		//1x1
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		ModMatrix transformMatrix = new ModMatrix(transformGrid1_2, 26);
+		assertEquals("ModMatrix 1x1 failed dot product ModMatrix.", 2, matrix.dotProduct(transformMatrix));
+
+		//2x2
+		matrix = new ModMatrix(grid2, 26);
+		transformMatrix = new ModMatrix(transformGrid2_2, 26);
+		assertEquals("ModMatrix 2x2 failed dot product ModMatrix.", 30, matrix.dotProduct(transformMatrix));
+
+		//3x3
+		matrix = new ModMatrix(grid3, 26);
+		transformMatrix = new ModMatrix(transformGrid3_2, 26);
+		assertEquals("ModMatrix 3x3 failed dot product ModMatrix.", 162, matrix.dotProduct(transformMatrix));
+
+		//4x4
+		matrix = new ModMatrix(grid4, 26);
+		transformMatrix = new ModMatrix(transformGrid4_2, 26);
+		assertEquals("ModMatrix 4x4 failed dot product ModMatrix.", 560, matrix.dotProduct(transformMatrix));
+
+		//10x10
+		matrix = new ModMatrix(grid10, 26);
+		transformMatrix = new ModMatrix(transformGrid10_2, 26);
+		assertEquals("ModMatrix 10x10 failed dot product ModMatrix.", 35750, matrix.dotProduct(transformMatrix));
+	}
+
+	@Test
+	public void testHadamardProduct(){
+		//1x1
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		ModMatrix transformMatrix = new ModMatrix(transformGrid1_2, 26);
+		ModMatrix correctMatrix = new ModMatrix(new int[][]{{2}}, 26);
+		assertEquals("ModMatrix 1x1 failed hadamard product.", correctMatrix, matrix.hadamardProduct(transformMatrix));
+
+		//2x2
+		matrix = new ModMatrix(grid2, 26);
+		transformMatrix = new ModMatrix(transformGrid2_2, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{2, 6},
+			{2, 6}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed hadamard product.", correctMatrix, matrix.hadamardProduct(transformMatrix));
+
+		//3x3
+		matrix = new ModMatrix(grid3, 26);
+		transformMatrix = new ModMatrix(transformGrid3_2, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{2, 6, 12},
+			{2, 6, 12},
+			{2, 6, 12}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed hadamard product.", correctMatrix, matrix.hadamardProduct(transformMatrix));
+
+		//4x4
+		matrix = new ModMatrix(grid4, 26);
+		transformMatrix = new ModMatrix(transformGrid4_2, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{2, 6, 12, 20},
+			{2, 6, 12, 20},
+			{2, 6, 12, 20},
+			{2, 6, 12, 20}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed hadamard product.", correctMatrix, matrix.hadamardProduct(transformMatrix));
+
+		//10x10
+		matrix = new ModMatrix(grid10, 26);
+		transformMatrix = new ModMatrix(transformGrid10_2, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
+			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
+			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
+			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
+			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
+			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
+			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
+			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
+			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
+			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110}
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed hadamard product.", correctMatrix, matrix.hadamardProduct(transformMatrix));
+	}
+
+	@Test
+	public void testTranspose(){
+		//1x1
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		ModMatrix correctMatrix = new ModMatrix(new int[][]{{1}}, 26);
+		assertEquals("ModMatrix 1x1 failed transpose.", correctMatrix, matrix.transpose());
+
+		//2x2
+		matrix = new ModMatrix(grid2, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 1},
+			{2, 2}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed transpose.", correctMatrix, matrix.transpose());
+
+		//3x3
+		matrix = new ModMatrix(grid3, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 1, 1},
+			{2, 2, 2},
+			{3, 3, 3}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed transpose.", correctMatrix, matrix.transpose());
+
+		//4x4
+		matrix = new ModMatrix(grid4, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 1, 1, 1},
+			{2, 2, 2, 2},
+			{3, 3, 3, 3},
+			{4, 4, 4, 4}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed transpose.", correctMatrix, matrix.transpose());
+
+		//10x10
+		matrix = new ModMatrix(grid10, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
+			{2, 2, 2, 2, 2, 2, 2, 2, 2, 2},
+			{3, 3, 3, 3, 3, 3, 3, 3, 3, 3},
+			{4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
+			{5, 5, 5, 5, 5, 5, 5, 5, 5, 5},
+			{6, 6, 6, 6, 6, 6, 6, 6, 6, 6},
+			{7, 7, 7, 7, 7, 7, 7, 7, 7, 7},
+			{8, 8, 8, 8, 8, 8, 8, 8, 8, 8},
+			{9, 9, 9, 9, 9, 9, 9, 9, 9, 9},
+			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed transpose.", correctMatrix, matrix.transpose());
+	}
+
+	@Test
+	public void testDeterminant(){
+		//1x1
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		assertEquals("ModMatrix 1x1 failed determinant.", 1, matrix.determinant());
+
+		//2x2
+		matrix = new ModMatrix(grid2, 26);
+		assertEquals("ModMatrix 2x2 failed determinant1.", 0, matrix.determinant());
+		matrix = new ModMatrix(new int[][]{
+			{1, 4},
+			{4, 1}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed determinant2.", -15, matrix.determinant());
+
+		//3x3
+		matrix = new ModMatrix(grid3, 26);
+		assertEquals("ModMatrix 3x3 failed determinant1.", 0, matrix.determinant());
+		matrix = new ModMatrix(new int[][]{
+			{1, 4, 2},
+			{2, 4, 1},
+			{4, 1, 2}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed determinant2.", -21, matrix.determinant());
+
+		//4x4
+		matrix = new ModMatrix(grid4, 26);
+		assertEquals("ModMatrix 4x4 failed determiant1.", 0, matrix.determinant());
+		matrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 4},
+			{2, 3, 4, 1},
+			{3, 4, 1, 2},
+			{4, 1, 2, 3}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed determinant2.", 160, matrix.determinant());
+
+		//10x10
+		matrix = new ModMatrix(grid10, 26);
+		assertEquals("ModMatrix 10x10 failed determinant1.", 0, matrix.determinant());
+		matrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			{2, 3, 4, 5, 6, 7, 8, 9, 10, 1},
+			{3, 4, 5, 6, 7, 8, 9, 10, 1, 2},
+			{4, 5, 6, 7, 8, 9, 10, 1, 2, 3},
+			{5, 6, 7, 8, 9, 10, 1, 2, 3, 4},
+			{6, 7, 8, 9, 10, 1, 2, 3, 4, 5},
+			{7, 8, 9, 10, 1, 2, 3, 4, 5, 6},
+			{8, 9, 10, 1, 2, 3, 4, 5, 6, 7},
+			{9, 10, 1, 2, 3, 4, 5, 6, 7, 8},
+			{0,  0, 0, 0, 0, 0, 0, 0, 0, 1}
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed determinant2.", -10000000, matrix.determinant());
+	}
+
+	@Test
+	public void testCofactor(){
+		//1x1
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		ModMatrix correctMatrix = new ModMatrix(grid1, 26);
+		assertEquals("ModMatrix 1x1 failed cofactor.", correctMatrix, matrix.cofactor());
+
+		//2x2
+		matrix = new ModMatrix(grid2, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{2, -1},
+			{-2, 1}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed cofactor.", correctMatrix, matrix.cofactor());
+
+		//3x3
+		matrix = new ModMatrix(grid3, 26);
+		correctMatrix = new ModMatrix(3, 3, 0, 26);
+		assertEquals("ModMatrix 3x3 failed cofactor1.", correctMatrix, matrix.cofactor());
+		matrix = new ModMatrix(new int[][]{
+			{1, 4, 2},
+			{2, 4, 1},
+			{4, 1, 2}
+		}, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{7, 0, -14},
+			{-6, -6, 15},
+			{-4, 3, -4}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed cofactor2.", correctMatrix, matrix.cofactor());
+
+		//4x4
+		matrix = new ModMatrix(grid4, 26);
+		correctMatrix = new ModMatrix(4, 4, 0, 26);
+		assertEquals("ModMatrix 4x4 failed cofactor1.", correctMatrix, matrix.cofactor());
+		matrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 4},
+			{2, 3, 4, 1},
+			{3, 4, 1, 2},
+			{4, 1, 2, 3}
+		}, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{-36, 4, 4, 44},
+			{4, 4, 44, -36},
+			{4, 44, -36, 4},
+			{44, -36, 4, 4}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed cofactor2.", correctMatrix, matrix.cofactor());
+
+		//10x10
+		//?Skipping 10x10 test because test took > 5s by itself
+		/*
+		matrix = new ModMatrix(grid10);
+		correctMatrix = new ModMatrix(10, 10, 0);
+		assertEquals("ModMatrix 10x10 failed cofactor1.", correctMatrix, matrix.cofactor());
+		*/
+	}
+
+	@Test
+	public void testPower(){
+		//1x1
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		ModMatrix correctMatrix = new ModMatrix(new int[][]{{1}}, 26);
+		assertEquals("ModMatrix 1x1 failed power.", correctMatrix, matrix.pow(3));
+
+		//2x2
+		matrix = new ModMatrix(grid2, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{9, 18},
+			{9, 18}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed power.", correctMatrix, matrix.pow(3));
+
+		//3x3
+		matrix = new ModMatrix(grid3, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{36, 72, 108},
+			{36, 72, 108},
+			{36, 72, 108}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed power.", correctMatrix, matrix.pow(3));
+
+		//4x4
+		//0
+		matrix = new ModMatrix(grid4, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 1, 1, 1},
+			{1, 1, 1, 1},
+			{1, 1, 1, 1},
+			{1, 1, 1, 1}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed power 0.", correctMatrix, matrix.pow(0));
+		//1
+		correctMatrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed power 1.", correctMatrix, matrix.pow(1));
+		//3
+		correctMatrix = new ModMatrix(new int[][]{
+			{100, 200, 300, 400},
+			{100, 200, 300, 400},
+			{100, 200, 300, 400},
+			{100, 200, 300, 400}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed power 3.", correctMatrix, matrix.pow(3));
+
+		//10x10
+		matrix = new ModMatrix(grid10, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
+			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
+			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
+			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
+			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
+			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
+			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
+			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
+			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
+			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250}
+		}, 26);
+		assertEquals("ModMatrix 10x10 failed power.", correctMatrix, matrix.pow(3));
+	}
+
+	@Test
+	public void testAdjoint(){
+		//1x1
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		ModMatrix correctMatrix = new ModMatrix(grid1, 26);
+		assertEquals("ModMatrix 1x1 failed adjoint.", correctMatrix, matrix.adjoint());
+
+		//2x2
+		matrix = new ModMatrix(grid2, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{2, -2},
+			{-1, 1}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed adjoint.", correctMatrix, matrix.adjoint());
+
+		//3x3
+		matrix = new ModMatrix(grid3, 26);
+		correctMatrix = new ModMatrix(3, 3, 0, 26);
+		assertEquals("ModMatrix 3x3 failed adjoint.", correctMatrix, matrix.adjoint());
+
+		//4x4
+		matrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 4},
+			{2, 3, 4, 1},
+			{3, 4, 1, 2},
+			{4, 1, 2, 3}
+		}, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{-36, 4, 4, 44},
+			{4, 4, 44, -36},
+			{4, 44, -36, 4},
+			{44, -36, 4, 4}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed adjoint.", correctMatrix, matrix.adjoint());
+
+		//10x10
+		//?Skipping 10x10 test because test took > 5s by itself
+		/*
+		matrix = new ModMatrix(grid10);
+		correctMatrix = new ModMatrix(10, 10, 0);
+		assertEquals("ModMatrix 10x10 failed adjoint.", correctMatrix, matrix.adjoint());
+		*/
+	}
+
+	@Test
+	public void testInverse(){
+		//1x1
+		ModMatrix matrix = new ModMatrix(grid1, 26);
+		ModMatrix correctMatrix = new ModMatrix(grid1, 26);
+		assertEquals("ModMatrix 1x1 failed inverse.", correctMatrix, matrix.inverse());
+
+		//2x2
+		matrix = new ModMatrix(new int[][]{
+			{1, 4},
+			{4, 1}
+		}, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{19, 2},
+			{2, 19}
+		}, 26);
+		assertEquals("ModMatrix 2x2 failed inverse.", correctMatrix, matrix.inverse());
+
+		//3x3
+		matrix = new ModMatrix(new int[][]{
+			{1, 4, 2},
+			{2, 4, 1},
+			{4, 1, 2}
+		}, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{17,  4, 20},
+			{ 0,  4, 11},
+			{18,  3, 20}
+		}, 26);
+		assertEquals("ModMatrix 3x3 failed inverse.", correctMatrix, matrix.inverse());
+
+		//4x4
+		matrix = new ModMatrix(new int[][]{
+			{1, 2, 3, 4},
+			{4, 2, 1, 3},
+			{5, 1, 8, 7},
+			{5, 6, 4, 2}
+		}, 26);
+		correctMatrix = new ModMatrix(new int[][]{
+			{12, 24, 22, 19},
+			{21, 17,  3,  0},
+			{ 9,  6, 22, 13},
+			{19,  7, 22,  5}
+		}, 26);
+		assertEquals("ModMatrix 4x4 failed inverse.", correctMatrix, matrix.inverse());
+
+		//10x10
+		//?Skipped 10x10 because it would take a long time to compute
+	}
+}