diff --git a/pom.xml b/pom.xml
index 687fe3c..88d101b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,102 +1,102 @@
-
-
-
- 4.0.0
-
- com.mattrixwv
- Matrix
- 1.0-SNAPSHOT
-
- Matrix
- https://www.mattrixwv.com
-
-
- UTF-8
- 11
- 11
- 11
-
-
-
-
- junit
- junit
- 4.13.2
- test
-
-
-
-
-
-
-
- org.apache.maven.plugins
- maven-enforcer-plugin
- 3.0.0-M3
-
-
- enforce-maven
-
- enforce
-
-
-
-
- 3.6.3
-
-
-
-
-
-
-
-
- maven-clean-plugin
- 3.1.0
-
-
-
- maven-resources-plugin
- 3.2.0
-
-
- maven-compiler-plugin
- 3.8.1
-
- ${java.version}
-
- -Xlint:all
-
- true
- true
-
-
-
- maven-surefire-plugin
- 3.0.0-M5
-
-
- maven-jar-plugin
- 3.2.0
-
-
- maven-install-plugin
- 3.0.0-M1
-
-
- maven-deploy-plugin
- 3.0.0-M1
-
-
-
- maven-site-plugin
- 3.9.1
-
-
- maven-project-info-reports-plugin
- 3.1.1
-
-
-
-
+
+
+
+ 4.0.0
+
+ com.mattrixwv
+ Matrix
+ 1.0-SNAPSHOT
+
+ Matrix
+ https://www.mattrixwv.com
+
+
+ UTF-8
+ 11
+ 11
+ 11
+
+
+
+
+ junit
+ junit
+ 4.13.2
+ test
+
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-enforcer-plugin
+ 3.0.0-M3
+
+
+ enforce-maven
+
+ enforce
+
+
+
+
+ 3.6.3
+
+
+
+
+
+
+
+
+ maven-clean-plugin
+ 3.1.0
+
+
+
+ maven-resources-plugin
+ 3.2.0
+
+
+ maven-compiler-plugin
+ 3.8.1
+
+ ${java.version}
+
+ -Xlint:all
+
+ true
+ true
+
+
+
+ maven-surefire-plugin
+ 3.0.0-M5
+
+
+ maven-jar-plugin
+ 3.2.0
+
+
+ maven-install-plugin
+ 3.0.0-M1
+
+
+ maven-deploy-plugin
+ 3.0.0-M1
+
+
+
+ maven-site-plugin
+ 3.9.1
+
+
+ maven-project-info-reports-plugin
+ 3.1.1
+
+
+
+
diff --git a/src/main/java/com/mattrixwv/matrix/IntegerMatrix.java b/src/main/java/com/mattrixwv/matrix/IntegerMatrix.java
index c18b3ea..0f64b18 100644
--- a/src/main/java/com/mattrixwv/matrix/IntegerMatrix.java
+++ b/src/main/java/com/mattrixwv/matrix/IntegerMatrix.java
@@ -1,739 +1,739 @@
-//Matrix/src/main/java/com/mattrixwv/IntegerMatrix.java
-//Mattrixwv
-// Created: 02-01-22
-//Modified: 02-03-22
-package com.mattrixwv.matrix;
-
-
-import java.util.StringJoiner;
-
-import com.mattrixwv.matrix.exceptions.InvalidCoordinatesException;
-import com.mattrixwv.matrix.exceptions.InvalidGeometryException;
-import com.mattrixwv.matrix.exceptions.InvalidRowSizeException;
-
-
-public class IntegerMatrix{
- protected int[][] grid;
-
- //Helper functions
- protected void setGrid(int[][] grid){
- if(grid.length == 0){
- grid = new int[0][0];
- }
- else if(grid[0].length == 0){
- grid = new int[grid.length][0];
- }
- else{
- //Make sure all rows are the same length
- int length = grid[0].length;
- for(int cnt = 1;cnt < grid.length;++cnt){
- if(grid[cnt].length != length){
- throw new InvalidRowSizeException("All rows in a matrix must be the same size");
- }
- }
-
- //Copy every element over to a new grid
- int[][] newGrid = new int[grid.length][grid[0].length];
- for(int rowCnt = 0;rowCnt < grid.length;++rowCnt){
- for(int colCnt = 0;colCnt < grid[0].length;++colCnt){
- newGrid[rowCnt][colCnt] = grid[rowCnt][colCnt];
- }
- }
-
- //Save the new grid
- this.grid = newGrid;
- }
- }
- protected int[][] copyGrid(){
- //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){
- for(int col = 0;col < grid[0].length;++col){
- newGrid[row][col] = grid[row][col];
- }
- }
-
- //Return the new grid
- return newGrid;
- }
- protected boolean isSquare(){
- if(getNumRows() == 0){
- return false;
- }
- else{
- return getNumRows() == getNumCols();
- }
- }
- //Returns a matrix with the supplied row and column removed
- protected IntegerMatrix laplaceExpansionHelper(int row, int col){
- //Make sure the matrix is square
- if(!isSquare()){
- throw new InvalidGeometryException("A matrix must be square for you to perform Laplace Expansion");
- }
- //Make sure the matrix is large enough to have this operation performed
- if((getNumRows() <= 1) || (getNumCols() <= 1)){
- throw new InvalidGeometryException("A matrix must be at least 2x2 for you to perform Laplace Expansion: " + getNumRows() + "x" + getNumCols());
- }
- //Make sure the row is valid
- if((row < 0) || (row >= getNumRows())){
- throw new InvalidCoordinatesException("An invalid row number was supplied: " + row + ". The matrix contains " + getNumRows() + " rows");
- }
- //Make sure the col is valid
- if((col < 0) || (col >= getNumCols())){
- throw new InvalidCoordinatesException("An invalid column number was supplied: " + col + ". The matrix contains " + getNumCols() + " columns");
- }
-
-
- //Create a new matrix that is one row and column smaller than the existing row
- int[][] newGrid = new int[getNumRows() - 1][getNumCols() - 1];
- //Traverse the matrix and set the values in the new matrix, skipping elements in the given row and col
- for(int workingRow = 0, newRow = 0;workingRow < getNumRows();++workingRow){
- //Skip the row we are expanding
- if(workingRow == row){
- continue;
- }
- for(int workingCol = 0, newCol = 0;workingCol < getNumCols();++workingCol){
- //Skip the column we are expanding
- if(workingCol == col){
- continue;
- }
- newGrid[newRow][newCol] = grid[workingRow][workingCol];
- ++newCol;
- }
- ++newRow;
- }
-
-
- //Return the new matrix
- return new IntegerMatrix(newGrid);
- }
-
- //Constructors
- public IntegerMatrix(){
- grid = new int[0][0];
- }
- public IntegerMatrix(int[][]grid){
- setGrid(grid);
- }
- public IntegerMatrix(IntegerMatrix matrix){
- setGrid(matrix.grid);
- }
- public IntegerMatrix(int rows, int cols, int fill){
- if(rows <= 0){
- throw new InvalidGeometryException("A filled matrix must have at least 1 row");
- }
- else if(cols <= 0){
- throw new InvalidGeometryException("A filled matrix must have at least 1 column");
- }
- else{
- grid = new int[rows][cols];
- for(int row = 0;row < rows;++row){
- for(int col = 0;col < cols;++col){
- grid[row][col] = fill;
- }
- }
- }
- }
-
- //Gets
- public int get(int row, int col){
- //Make sure the row and column are valid
- if(row >= grid.length){
- throw new InvalidCoordinatesException("Row cannot be greater than the number of rows");
- }
- else if(col >= grid[0].length){
- throw new InvalidCoordinatesException("Column cannot be greater than the number of columns");
- }
-
- //Return the location in the grid
- return grid[row][col];
- }
- public IntegerMatrix getRow(int row){
- //Make sure the row number is valid
- if((row < 0) || (row >= grid.length)){
- throw new InvalidCoordinatesException("The row number " + row + " is not valid");
- }
-
- //Generate a copy of the row
- int[][] newRow = new int[1][grid[row].length];
- for(int col = 0;col < grid[row].length;++col){
- newRow[0][col] = grid[row][col];
- }
-
- //Return the new matrix
- return new IntegerMatrix(newRow);
- }
- public int getNumRows(){
- return grid.length;
- }
- public IntegerMatrix getCol(int col){
- //Make sure the column number is valid
- if((col < 0) || (grid.length == 0) || (col > grid[0].length)){
- throw new InvalidCoordinatesException("The column number " + col + " is not valid");
- }
-
- //Generate a copy of the col
- int[][] newColumn = new int[grid.length][1];
- for(int row = 0;row < grid.length;++row){
- newColumn[row][0] = grid[row][col];
- }
-
- //Return the new matrix
- return new IntegerMatrix(newColumn);
- }
- public int getNumCols(){
- if(grid.length > 0){
- return grid[0].length;
- }
- else{
- return 0;
- }
- }
- //Sets
- public void set(int row, int col, int value){
- //Make sure the row number is valid
- if((row < 0) || (row >= grid.length)){
- throw new InvalidCoordinatesException("Invalid row number " + row);
- }
- //Make sure the column number is valid
- if((col < 0) || (col >= getNumCols())){
- throw new InvalidCoordinatesException("Invalid column number " + col);
- }
-
- //Save the element
- grid[row][col] = value;
- }
- public void setRow(int row, int[] elements){
- //Make sure the row number is valid
- if((row < 0) || (row >= grid.length)){
- throw new InvalidCoordinatesException("Invalid row number " + row);
- }
- //Make sure the number of elements is valid
- if(elements.length != getNumCols()){
- throw new InvalidGeometryException("Invalid number of elements " + elements.length + " must be " + getNumCols());
- }
-
- //Save the elements
- for(int col = 0;col < elements.length;++col){
- grid[row][col] = elements[col];
- }
- }
- public void setRow(int row, IntegerMatrix matrix){
- //Make sure the matrix has a single row
- if(matrix.getNumRows() != 1){
- throw new InvalidGeometryException("Setting a row by Matrix requires the matrix contain a single row");
- }
-
- //Set the row
- setRow(row, matrix.grid[0]);
- }
- public void setCol(int col, int[] elements){
- //Make sure the column number is valid
- if((col < 0) || (col >= getNumCols())){
- throw new InvalidCoordinatesException("Invalid column number " + col);
- }
- //Make sure the number of elements is valid
- if(elements.length != grid.length){
- throw new InvalidCoordinatesException("Invalid number of elements " + elements.length + " must be " + grid.length);
- }
-
- //Save the elements
- for(int row = 0;row < elements.length;++row){
- grid[row][col] = elements[row];
- }
- }
- public void setCol(int col, IntegerMatrix matrix){
- //Make sure the matrix has a single column
- if(matrix.getNumCols() != 1){
- throw new InvalidGeometryException("Setting a column by Matrix requires the matrix contain a single column");
- }
-
- //Set the column
- setCol(col, matrix.getCol(0));
- }
- //Adds
- public void addRow(int[] elements){
- //Make sure the number of columns is valid
- if((grid.length == 0) || (getNumCols() == elements.length)){
- int[][] newGrid = new int[grid.length + 1][elements.length];
- //Copy all existing data into the new grid
- for(int row = 0;row < grid.length;++row){
- newGrid[row] = grid[row];
- }
- grid = newGrid;
- }
- else{
- throw new InvalidGeometryException("Invalid number of elements " + elements.length + " must be " + getNumCols());
- }
-
- //Add all elements to the grid
- for(int col = 0;col < elements.length;++col){
- grid[grid.length - 1][col] = elements[col];
- }
- }
- public void addRow(IntegerMatrix matrix){
- //Make sure the matrix has a single row
- if(matrix.getNumRows() != 1){
- throw new InvalidGeometryException("Adding a row by Matrix requires the matrix contain a single row");
- }
-
- //Add the row
- addRow(matrix.grid[0]);
- }
- public void addCol(int[] elements){
- //Make sure the number of rows is valid
- if(grid.length == 0){
- grid = new int[1][elements.length];
- }
- else if(grid.length == elements.length){
- //Copy all existing data into the new grid
- for(int row = 0;row < grid.length;++row){
- int[] workingRow = new int[grid[row].length + 1];
- for(int workingCol = 0;workingCol < grid[row].length;++workingCol){
- workingRow[workingCol] = grid[row][workingCol];
- }
- grid[row] = workingRow;
- }
- }
- else{
- throw new InvalidGeometryException("Invalid number of elements " + elements.length + " must be " + getNumCols());
- }
-
- //Add all elements to the grid
- for(int row = 0;row < elements.length;++row){
- grid[row][grid[row].length - 1] = elements[row];
- }
- }
- public void addCol(IntegerMatrix matrix){
- //Make sure the matrix has a single column
- if(matrix.getNumCols() != 1){
- throw new InvalidGeometryException("Adding a column by Matrix requires the matrix contain a single column");
- }
-
- //Add the column
- addCol(matrix.getCol(0));
- }
- public IntegerMatrix appendRight(IntegerMatrix rightSide){
- //Make sure the matrices have the same number of rows
- if(getNumRows() != rightSide.getNumRows()){
- throw new InvalidGeometryException("Invalid number of rows. " + rightSide.getNumRows() + " must be " + getNumRows());
- }
-
- //Traverse both matrices and set their values in the new matrix
- int[][] newGrid = new int[getNumRows()][getNumCols() + rightSide.getNumCols()];
- for(int row = 0;row < getNumRows();++row){
- //Set all elements from the current grid's row
- for(int col = 0;col < getNumCols();++col){
- newGrid[row][col] = grid[row][col];
- }
- //Set all elements from the right side grid's row
- for(int col = 0;col < rightSide.getNumCols();++col){
- newGrid[row][getNumCols() + col] = rightSide.grid[row][col];
- }
- }
-
- //Return the new matrix
- return new IntegerMatrix(newGrid);
- }
- public IntegerMatrix appendBottom(IntegerMatrix rightSide){
- //Make sure the matrices have the same number of columns
- if(getNumCols() != rightSide.getNumCols()){
- throw new InvalidGeometryException("Invalid number of columns. " + rightSide.getNumCols() + " must be " + getNumCols());
- }
-
- //Traverse both matrices and set their values in the new matrix
- int[][] newGrid = new int[getNumRows() + rightSide.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];
- }
- }
-
- //Return the new matrix
- return new IntegerMatrix(newGrid);
- }
-
- //Simple operations
- public static IntegerMatrix generateIdentity(int size){
- //Make sure the size is valid
- if(size > 0){
- //Create a grid with the correct size
- int[][] newGrid = new int[size][size];
-
- //Go through every element and make sure it is set correctly
- for(int row = 0;row < size;++row){
- for(int col = 0;col < size;++col){
- if(col == row){
- newGrid[row][col] = 1;
- }
- else{
- newGrid[row][col] = 0;
- }
- }
- }
-
- //Return the new matrix
- return new IntegerMatrix(newGrid);
- }
- else{
- throw new InvalidGeometryException("An identity matrix must have a size > 0");
- }
- }
- public static IntegerMatrix generateFilled(int size, int fill){
- //Create a grid with the correct size
- int[][] newGrid = new int[size][size];
-
- //Set each element in the grid
- for(int row = 0;row < size;++row){
- for(int col = 0;col < size;++col){
- newGrid[row][col] = fill;
- }
- }
-
- //Return the new matrix
- return new IntegerMatrix(newGrid);
- }
- public IntegerMatrix add(IntegerMatrix rightSide){
- //Make sure the matrices have compatable 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());
- }
-
- //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
- for(int row = 0;row < newGrid.length;++row){
- for(int col = 0;col < newGrid[0].length;++col){
- newGrid[row][col] += rightSide.grid[row][col];
- }
- }
-
- //Return the new matrix
- return new IntegerMatrix(newGrid);
- }
- public IntegerMatrix add(int scalar){
- //Create a new grid with the same elements as the current grid
- int[][] newGrid = copyGrid();
-
- //Add the scalar to each element in the grid
- for(int row = 0;row < newGrid.length;++row){
- for(int col = 0;col < newGrid[0].length;++col){
- newGrid[row][col] += scalar;
- }
- }
-
- //Return the new matrix
- return new IntegerMatrix(newGrid);
- }
- public IntegerMatrix subtract(IntegerMatrix rightSide){
- //Make sure the matrices have compatable 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());
- }
-
- //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
- for(int row = 0;row < newGrid.length;++row){
- for(int col = 0;col < newGrid[0].length;++col){
- newGrid[row][col] -= grid[row][col];
- }
- }
-
- //Return the new matrix
- return new IntegerMatrix(newGrid);
- }
- public IntegerMatrix subtract(int scalar){
- //Create a new grid with the same elements as the current grid
- int[][] newGrid = copyGrid();
-
- //Subtract the scalar from each element in the grid
- for(int row = 0;row < newGrid.length;++row){
- for(int col = 0;col < newGrid[0].length;++col){
- newGrid[row][col] -= scalar;
- }
- }
-
- //Return the new matrix
- return new IntegerMatrix(newGrid);
- }
- public IntegerMatrix multiply(IntegerMatrix rightSide){
- //Make sure the matrices have compatable 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());
- }
-
- //Create a new grid with the same elements as the current grid
- int[][] newGrid = new int[getNumRows()][rightSide.getNumCols()];
-
- //Multiply each row in the left matrix with each column int he right matrix to come up with the current element
- for(int leftRow = 0;leftRow < grid.length;++leftRow){
- for(int rightCol = 0;rightCol < rightSide.getNumCols();++rightCol){
- //Get a sum of the product of each column in the current row (left) and each row in the current column (right)
- int elementProductSum = 0;
- for(int incrementCounter = 0;incrementCounter < grid.length;++incrementCounter){
- elementProductSum += grid[leftRow][incrementCounter] * rightSide.grid[incrementCounter][rightCol];
- }
- newGrid[leftRow][rightCol] = elementProductSum;
- }
- }
-
- //Return the new matrix
- return new IntegerMatrix(newGrid);
- }
- public IntegerMatrix multiply(int scalar){
- //Create a new grid with the same elements as the current grid
- int[][] newGrid = copyGrid();
-
- //Multiply every element in the grid by the scalar
- for(int row = 0;row < grid.length;++row){
- for(int col = 0;col < grid[0].length;++col){
- newGrid[row][col] *= scalar;
- }
- }
-
- //Return the new matrix
- return new IntegerMatrix(newGrid);
- }
- public int dotProduct(IntegerMatrix rightSide){
- //Make sure the matrices have compatable 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());
- }
-
- //Multiply each row in the left matrix with each column in the right matrix to come up with the current element
- //?Would be simpler, but slower, to get the product matrix to come up with the current element
- int sum = 0;
- for(int leftRow = 0;leftRow < grid.length;++leftRow){
- for(int rightCol = 0;rightCol < rightSide.getNumCols();++rightCol){
- for(int incrementCounter = 0;incrementCounter < grid.length;++incrementCounter){
- sum += grid[leftRow][incrementCounter] * rightSide.grid[incrementCounter][rightCol];
- }
- }
- }
-
- //Return the sum
- return sum;
- }
- public IntegerMatrix hadamardProduct(IntegerMatrix rightSide){
- //Make sure the matrices have compatable 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());
- }
-
- //Create a new grid with the same element as the current grid
- int[][] newGrid = copyGrid();
-
- //Multiply 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];
- }
- }
-
- //Return the new matrix
- return new IntegerMatrix(newGrid);
- }
-
- //Complex operations
- public IntegerMatrix transpose(){
- //Create a new grid
- int[][] newGrid = new int[getNumCols()][getNumRows()];
-
- //Traverse every element in the existing grid and add each column to the new grid as a row
- for(int col = 0;col < getNumCols();++col){
- for(int row = 0;row < getNumRows();++row){
- newGrid[col][row] = grid[row][col];
- }
- }
-
- //Return the new matrix
- return new IntegerMatrix(newGrid);
- }
- public int det(){
- return determinant();
- }
- public int determinant(){
- //Make sure the matrix is square
- if(!isSquare()){
- throw new InvalidGeometryException("A matrix must be square for it to have a determinant");
- }
- //?Don't have to worry about a matrix existing. isSquare takes care of 0x0 matrix
-
- //Determine the formula do use for the determinant
- int det = 0;
- switch(getNumRows()){
- //If the matrix is 1x1 return the number
- case 1 : det = grid[0][0]; break;
- //If the matrix is 2x2 use the formula
- case 2 : {
- det = (grid[0][0] * grid[1][1]) - (grid[0][1] * grid[1][0]);
- }
- break;
- //If the matrix is 3x3 use the formula
- case 3 : {
- det = (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]);
- }
- break;
- //If the matrix is larger break it down and try again
- default : {
- //Find the row/column with the largest number of 0's
- int zerosLocation = 0;
- int maxNumZeros = 0;
- boolean zerosRow = true;
- //Check the rows
- for(int row = 0;row < getNumRows();++row){
- int numZeros = 0;
- for(int col = 0;col < getNumCols();++col){
- if(grid[row][col] == 0){
- ++numZeros;
- }
- }
- if(numZeros > maxNumZeros){
- maxNumZeros = numZeros;
- zerosLocation = row;
- zerosRow = true;
- }
- }
- //Check the columns
- for(int col = 0;col < getNumCols();++col){
- int numZeros = 0;
- for(int row = 0;row < getNumRows();++row){
- if(grid[row][col] == 0){
- ++numZeros;
- }
- }
- if(numZeros > maxNumZeros){
- maxNumZeros = numZeros;
- zerosLocation = col;
- zerosRow = false;
- }
- }
-
- //If the largest number of zeros were found in a row
- if(zerosRow){
- //Set a variable to make sure the appropriate + or - is applied to the scalar
- int multiplier = 1;
- if((zerosLocation % 2) == 1){
- multiplier = -1;
- }
- //Go through every column in the optimal row using the formula
- for(int col = 0;col < getNumCols();++col){
- if(grid[zerosLocation][col] != 0){
- det += (multiplier * grid[zerosLocation][col] * laplaceExpansionHelper(zerosLocation, col).determinant());
- }
- multiplier = -multiplier;
- }
- }
- //If the largest number of zeros were found in a column
- else{
- //Set a variable to make sure the appropriate + or - is applied to the scalar
- int multiplier = 1;
- if((zerosLocation % 2) == 1){
- multiplier = -1;
- }
- //Go through every row in the coptimal column using the formula
- for(int row = 0;row < getNumRows();++row){
- if(grid[row][zerosLocation] != 0){
- det += (multiplier * grid[row][zerosLocation] * laplaceExpansionHelper(row, zerosLocation).determinant());
- }
- multiplier = -multiplier;
- }
- }
- }
- }
-
- //Return the determinant
- return det;
- }
- public IntegerMatrix cofactor(){
- //Make sure the matrix is square
- if(!isSquare()){
- throw new InvalidGeometryException("A matrix must be square to find the cofactor matrix");
- }
-
- //Create a new grid
- int[][] newGrid = new int[getNumRows()][getNumCols()];
- //If the grid is 1x1 return the grid
- if(getNumRows() == 1){
- newGrid[0][0] = grid[0][0];
- }
- //Use the formula to find the cofactor matrix
- else{
- for(int row = 0;row < getNumRows();++row){
- int multiplier = ((row % 2) == 0) ? 1 : -1;
- for(int col = 0;col < getNumCols();++col){
- newGrid[row][col] = multiplier * laplaceExpansionHelper(row, col).determinant();
- multiplier = -multiplier;
- }
- }
- }
-
- //Return the new matrix
- return new IntegerMatrix(newGrid);
- }
-
- //Object funtions
- @Override
- public boolean equals(Object rightSide){
- if(rightSide.getClass().equals(this.getClass())){
- IntegerMatrix rightMatrix = (IntegerMatrix)rightSide;
-
- //Make sure they have the same number of elements
- if(grid.length != rightMatrix.grid.length){
- return false;
- }
- else if(getNumCols() != rightMatrix.getNumCols()){
- return false;
- }
-
- //Check every element
- for(int row = 0;row < grid.length;++row){
- for(int col = 0;col < grid[0].length;++col){
- if(grid[row][col] != rightMatrix.grid[row][col]){
- return false;
- }
- }
- }
-
- //If false hasn't been returned yet then they are equal
- return true;
- }
- else if(rightSide.getClass().equals(int[][].class)){
- int[][] rightMatrix = (int[][])rightSide;
-
- return equals(new IntegerMatrix(rightMatrix));
- }
- else{
- return false;
- }
- }
- @Override
- public String toString(){
- StringJoiner matrix = new StringJoiner("\n");
- for(int rowCnt = 0;rowCnt < grid.length;++rowCnt){
- StringJoiner row = new StringJoiner(",", "[", "]");
-
- for(int colCnt = 0;colCnt < grid[0].length;++colCnt){
- row.add(Integer.toString(grid[rowCnt][colCnt]));
- }
-
- matrix.add(row.toString());
- }
- return matrix.toString();
- }
- @Override
- public IntegerMatrix clone(){
- return new IntegerMatrix(grid);
- }
-}
+//Matrix/src/main/java/com/mattrixwv/IntegerMatrix.java
+//Mattrixwv
+// Created: 02-01-22
+//Modified: 02-03-22
+package com.mattrixwv.matrix;
+
+
+import java.util.StringJoiner;
+
+import com.mattrixwv.matrix.exceptions.InvalidCoordinatesException;
+import com.mattrixwv.matrix.exceptions.InvalidGeometryException;
+import com.mattrixwv.matrix.exceptions.InvalidRowSizeException;
+
+
+public class IntegerMatrix{
+ protected int[][] grid;
+
+ //Helper functions
+ protected void setGrid(int[][] grid){
+ if(grid.length == 0){
+ grid = new int[0][0];
+ }
+ else if(grid[0].length == 0){
+ grid = new int[grid.length][0];
+ }
+ else{
+ //Make sure all rows are the same length
+ int length = grid[0].length;
+ for(int cnt = 1;cnt < grid.length;++cnt){
+ if(grid[cnt].length != length){
+ throw new InvalidRowSizeException("All rows in a matrix must be the same size");
+ }
+ }
+
+ //Copy every element over to a new grid
+ int[][] newGrid = new int[grid.length][grid[0].length];
+ for(int rowCnt = 0;rowCnt < grid.length;++rowCnt){
+ for(int colCnt = 0;colCnt < grid[0].length;++colCnt){
+ newGrid[rowCnt][colCnt] = grid[rowCnt][colCnt];
+ }
+ }
+
+ //Save the new grid
+ this.grid = newGrid;
+ }
+ }
+ protected int[][] copyGrid(){
+ //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){
+ for(int col = 0;col < grid[0].length;++col){
+ newGrid[row][col] = grid[row][col];
+ }
+ }
+
+ //Return the new grid
+ return newGrid;
+ }
+ protected boolean isSquare(){
+ if(getNumRows() == 0){
+ return false;
+ }
+ else{
+ return getNumRows() == getNumCols();
+ }
+ }
+ //Returns a matrix with the supplied row and column removed
+ protected IntegerMatrix laplaceExpansionHelper(int row, int col){
+ //Make sure the matrix is square
+ if(!isSquare()){
+ throw new InvalidGeometryException("A matrix must be square for you to perform Laplace Expansion");
+ }
+ //Make sure the matrix is large enough to have this operation performed
+ if((getNumRows() <= 1) || (getNumCols() <= 1)){
+ throw new InvalidGeometryException("A matrix must be at least 2x2 for you to perform Laplace Expansion: " + getNumRows() + "x" + getNumCols());
+ }
+ //Make sure the row is valid
+ if((row < 0) || (row >= getNumRows())){
+ throw new InvalidCoordinatesException("An invalid row number was supplied: " + row + ". The matrix contains " + getNumRows() + " rows");
+ }
+ //Make sure the col is valid
+ if((col < 0) || (col >= getNumCols())){
+ throw new InvalidCoordinatesException("An invalid column number was supplied: " + col + ". The matrix contains " + getNumCols() + " columns");
+ }
+
+
+ //Create a new matrix that is one row and column smaller than the existing row
+ int[][] newGrid = new int[getNumRows() - 1][getNumCols() - 1];
+ //Traverse the matrix and set the values in the new matrix, skipping elements in the given row and col
+ for(int workingRow = 0, newRow = 0;workingRow < getNumRows();++workingRow){
+ //Skip the row we are expanding
+ if(workingRow == row){
+ continue;
+ }
+ for(int workingCol = 0, newCol = 0;workingCol < getNumCols();++workingCol){
+ //Skip the column we are expanding
+ if(workingCol == col){
+ continue;
+ }
+ newGrid[newRow][newCol] = grid[workingRow][workingCol];
+ ++newCol;
+ }
+ ++newRow;
+ }
+
+
+ //Return the new matrix
+ return new IntegerMatrix(newGrid);
+ }
+
+ //Constructors
+ public IntegerMatrix(){
+ grid = new int[0][0];
+ }
+ public IntegerMatrix(int[][]grid){
+ setGrid(grid);
+ }
+ public IntegerMatrix(IntegerMatrix matrix){
+ setGrid(matrix.grid);
+ }
+ public IntegerMatrix(int rows, int cols, int fill){
+ if(rows <= 0){
+ throw new InvalidGeometryException("A filled matrix must have at least 1 row");
+ }
+ else if(cols <= 0){
+ throw new InvalidGeometryException("A filled matrix must have at least 1 column");
+ }
+ else{
+ grid = new int[rows][cols];
+ for(int row = 0;row < rows;++row){
+ for(int col = 0;col < cols;++col){
+ grid[row][col] = fill;
+ }
+ }
+ }
+ }
+
+ //Gets
+ public int get(int row, int col){
+ //Make sure the row and column are valid
+ if(row >= grid.length){
+ throw new InvalidCoordinatesException("Row cannot be greater than the number of rows");
+ }
+ else if(col >= grid[0].length){
+ throw new InvalidCoordinatesException("Column cannot be greater than the number of columns");
+ }
+
+ //Return the location in the grid
+ return grid[row][col];
+ }
+ public IntegerMatrix getRow(int row){
+ //Make sure the row number is valid
+ if((row < 0) || (row >= grid.length)){
+ throw new InvalidCoordinatesException("The row number " + row + " is not valid");
+ }
+
+ //Generate a copy of the row
+ int[][] newRow = new int[1][grid[row].length];
+ for(int col = 0;col < grid[row].length;++col){
+ newRow[0][col] = grid[row][col];
+ }
+
+ //Return the new matrix
+ return new IntegerMatrix(newRow);
+ }
+ public int getNumRows(){
+ return grid.length;
+ }
+ public IntegerMatrix getCol(int col){
+ //Make sure the column number is valid
+ if((col < 0) || (grid.length == 0) || (col > grid[0].length)){
+ throw new InvalidCoordinatesException("The column number " + col + " is not valid");
+ }
+
+ //Generate a copy of the col
+ int[][] newColumn = new int[grid.length][1];
+ for(int row = 0;row < grid.length;++row){
+ newColumn[row][0] = grid[row][col];
+ }
+
+ //Return the new matrix
+ return new IntegerMatrix(newColumn);
+ }
+ public int getNumCols(){
+ if(grid.length > 0){
+ return grid[0].length;
+ }
+ else{
+ return 0;
+ }
+ }
+ //Sets
+ public void set(int row, int col, int value){
+ //Make sure the row number is valid
+ if((row < 0) || (row >= grid.length)){
+ throw new InvalidCoordinatesException("Invalid row number " + row);
+ }
+ //Make sure the column number is valid
+ if((col < 0) || (col >= getNumCols())){
+ throw new InvalidCoordinatesException("Invalid column number " + col);
+ }
+
+ //Save the element
+ grid[row][col] = value;
+ }
+ public void setRow(int row, int[] elements){
+ //Make sure the row number is valid
+ if((row < 0) || (row >= grid.length)){
+ throw new InvalidCoordinatesException("Invalid row number " + row);
+ }
+ //Make sure the number of elements is valid
+ if(elements.length != getNumCols()){
+ throw new InvalidGeometryException("Invalid number of elements " + elements.length + " must be " + getNumCols());
+ }
+
+ //Save the elements
+ for(int col = 0;col < elements.length;++col){
+ grid[row][col] = elements[col];
+ }
+ }
+ public void setRow(int row, IntegerMatrix matrix){
+ //Make sure the matrix has a single row
+ if(matrix.getNumRows() != 1){
+ throw new InvalidGeometryException("Setting a row by Matrix requires the matrix contain a single row");
+ }
+
+ //Set the row
+ setRow(row, matrix.grid[0]);
+ }
+ public void setCol(int col, int[] elements){
+ //Make sure the column number is valid
+ if((col < 0) || (col >= getNumCols())){
+ throw new InvalidCoordinatesException("Invalid column number " + col);
+ }
+ //Make sure the number of elements is valid
+ if(elements.length != grid.length){
+ throw new InvalidCoordinatesException("Invalid number of elements " + elements.length + " must be " + grid.length);
+ }
+
+ //Save the elements
+ for(int row = 0;row < elements.length;++row){
+ grid[row][col] = elements[row];
+ }
+ }
+ public void setCol(int col, IntegerMatrix matrix){
+ //Make sure the matrix has a single column
+ if(matrix.getNumCols() != 1){
+ throw new InvalidGeometryException("Setting a column by Matrix requires the matrix contain a single column");
+ }
+
+ //Set the column
+ setCol(col, matrix.getCol(0));
+ }
+ //Adds
+ public void addRow(int[] elements){
+ //Make sure the number of columns is valid
+ if((grid.length == 0) || (getNumCols() == elements.length)){
+ int[][] newGrid = new int[grid.length + 1][elements.length];
+ //Copy all existing data into the new grid
+ for(int row = 0;row < grid.length;++row){
+ newGrid[row] = grid[row];
+ }
+ grid = newGrid;
+ }
+ else{
+ throw new InvalidGeometryException("Invalid number of elements " + elements.length + " must be " + getNumCols());
+ }
+
+ //Add all elements to the grid
+ for(int col = 0;col < elements.length;++col){
+ grid[grid.length - 1][col] = elements[col];
+ }
+ }
+ public void addRow(IntegerMatrix matrix){
+ //Make sure the matrix has a single row
+ if(matrix.getNumRows() != 1){
+ throw new InvalidGeometryException("Adding a row by Matrix requires the matrix contain a single row");
+ }
+
+ //Add the row
+ addRow(matrix.grid[0]);
+ }
+ public void addCol(int[] elements){
+ //Make sure the number of rows is valid
+ if(grid.length == 0){
+ grid = new int[1][elements.length];
+ }
+ else if(grid.length == elements.length){
+ //Copy all existing data into the new grid
+ for(int row = 0;row < grid.length;++row){
+ int[] workingRow = new int[grid[row].length + 1];
+ for(int workingCol = 0;workingCol < grid[row].length;++workingCol){
+ workingRow[workingCol] = grid[row][workingCol];
+ }
+ grid[row] = workingRow;
+ }
+ }
+ else{
+ throw new InvalidGeometryException("Invalid number of elements " + elements.length + " must be " + getNumCols());
+ }
+
+ //Add all elements to the grid
+ for(int row = 0;row < elements.length;++row){
+ grid[row][grid[row].length - 1] = elements[row];
+ }
+ }
+ public void addCol(IntegerMatrix matrix){
+ //Make sure the matrix has a single column
+ if(matrix.getNumCols() != 1){
+ throw new InvalidGeometryException("Adding a column by Matrix requires the matrix contain a single column");
+ }
+
+ //Add the column
+ addCol(matrix.getCol(0));
+ }
+ public IntegerMatrix appendRight(IntegerMatrix rightSide){
+ //Make sure the matrices have the same number of rows
+ if(getNumRows() != rightSide.getNumRows()){
+ throw new InvalidGeometryException("Invalid number of rows. " + rightSide.getNumRows() + " must be " + getNumRows());
+ }
+
+ //Traverse both matrices and set their values in the new matrix
+ int[][] newGrid = new int[getNumRows()][getNumCols() + rightSide.getNumCols()];
+ for(int row = 0;row < getNumRows();++row){
+ //Set all elements from the current grid's row
+ for(int col = 0;col < getNumCols();++col){
+ newGrid[row][col] = grid[row][col];
+ }
+ //Set all elements from the right side grid's row
+ for(int col = 0;col < rightSide.getNumCols();++col){
+ newGrid[row][getNumCols() + col] = rightSide.grid[row][col];
+ }
+ }
+
+ //Return the new matrix
+ return new IntegerMatrix(newGrid);
+ }
+ public IntegerMatrix appendBottom(IntegerMatrix rightSide){
+ //Make sure the matrices have the same number of columns
+ if(getNumCols() != rightSide.getNumCols()){
+ throw new InvalidGeometryException("Invalid number of columns. " + rightSide.getNumCols() + " must be " + getNumCols());
+ }
+
+ //Traverse both matrices and set their values in the new matrix
+ int[][] newGrid = new int[getNumRows() + rightSide.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];
+ }
+ }
+
+ //Return the new matrix
+ return new IntegerMatrix(newGrid);
+ }
+
+ //Simple operations
+ public static IntegerMatrix generateIdentity(int size){
+ //Make sure the size is valid
+ if(size > 0){
+ //Create a grid with the correct size
+ int[][] newGrid = new int[size][size];
+
+ //Go through every element and make sure it is set correctly
+ for(int row = 0;row < size;++row){
+ for(int col = 0;col < size;++col){
+ if(col == row){
+ newGrid[row][col] = 1;
+ }
+ else{
+ newGrid[row][col] = 0;
+ }
+ }
+ }
+
+ //Return the new matrix
+ return new IntegerMatrix(newGrid);
+ }
+ else{
+ throw new InvalidGeometryException("An identity matrix must have a size > 0");
+ }
+ }
+ public static IntegerMatrix generateFilled(int size, int fill){
+ //Create a grid with the correct size
+ int[][] newGrid = new int[size][size];
+
+ //Set each element in the grid
+ for(int row = 0;row < size;++row){
+ for(int col = 0;col < size;++col){
+ newGrid[row][col] = fill;
+ }
+ }
+
+ //Return the new matrix
+ return new IntegerMatrix(newGrid);
+ }
+ public IntegerMatrix add(IntegerMatrix rightSide){
+ //Make sure the matrices have compatable 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());
+ }
+
+ //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
+ for(int row = 0;row < newGrid.length;++row){
+ for(int col = 0;col < newGrid[0].length;++col){
+ newGrid[row][col] += rightSide.grid[row][col];
+ }
+ }
+
+ //Return the new matrix
+ return new IntegerMatrix(newGrid);
+ }
+ public IntegerMatrix add(int scalar){
+ //Create a new grid with the same elements as the current grid
+ int[][] newGrid = copyGrid();
+
+ //Add the scalar to each element in the grid
+ for(int row = 0;row < newGrid.length;++row){
+ for(int col = 0;col < newGrid[0].length;++col){
+ newGrid[row][col] += scalar;
+ }
+ }
+
+ //Return the new matrix
+ return new IntegerMatrix(newGrid);
+ }
+ public IntegerMatrix subtract(IntegerMatrix rightSide){
+ //Make sure the matrices have compatable 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());
+ }
+
+ //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
+ for(int row = 0;row < newGrid.length;++row){
+ for(int col = 0;col < newGrid[0].length;++col){
+ newGrid[row][col] -= grid[row][col];
+ }
+ }
+
+ //Return the new matrix
+ return new IntegerMatrix(newGrid);
+ }
+ public IntegerMatrix subtract(int scalar){
+ //Create a new grid with the same elements as the current grid
+ int[][] newGrid = copyGrid();
+
+ //Subtract the scalar from each element in the grid
+ for(int row = 0;row < newGrid.length;++row){
+ for(int col = 0;col < newGrid[0].length;++col){
+ newGrid[row][col] -= scalar;
+ }
+ }
+
+ //Return the new matrix
+ return new IntegerMatrix(newGrid);
+ }
+ public IntegerMatrix multiply(IntegerMatrix rightSide){
+ //Make sure the matrices have compatable 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());
+ }
+
+ //Create a new grid with the same elements as the current grid
+ int[][] newGrid = new int[getNumRows()][rightSide.getNumCols()];
+
+ //Multiply each row in the left matrix with each column int he right matrix to come up with the current element
+ for(int leftRow = 0;leftRow < grid.length;++leftRow){
+ for(int rightCol = 0;rightCol < rightSide.getNumCols();++rightCol){
+ //Get a sum of the product of each column in the current row (left) and each row in the current column (right)
+ int elementProductSum = 0;
+ for(int incrementCounter = 0;incrementCounter < grid.length;++incrementCounter){
+ elementProductSum += grid[leftRow][incrementCounter] * rightSide.grid[incrementCounter][rightCol];
+ }
+ newGrid[leftRow][rightCol] = elementProductSum;
+ }
+ }
+
+ //Return the new matrix
+ return new IntegerMatrix(newGrid);
+ }
+ public IntegerMatrix multiply(int scalar){
+ //Create a new grid with the same elements as the current grid
+ int[][] newGrid = copyGrid();
+
+ //Multiply every element in the grid by the scalar
+ for(int row = 0;row < grid.length;++row){
+ for(int col = 0;col < grid[0].length;++col){
+ newGrid[row][col] *= scalar;
+ }
+ }
+
+ //Return the new matrix
+ return new IntegerMatrix(newGrid);
+ }
+ public int dotProduct(IntegerMatrix rightSide){
+ //Make sure the matrices have compatable 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());
+ }
+
+ //Multiply each row in the left matrix with each column in the right matrix to come up with the current element
+ //?Would be simpler, but slower, to get the product matrix to come up with the current element
+ int sum = 0;
+ for(int leftRow = 0;leftRow < grid.length;++leftRow){
+ for(int rightCol = 0;rightCol < rightSide.getNumCols();++rightCol){
+ for(int incrementCounter = 0;incrementCounter < grid.length;++incrementCounter){
+ sum += grid[leftRow][incrementCounter] * rightSide.grid[incrementCounter][rightCol];
+ }
+ }
+ }
+
+ //Return the sum
+ return sum;
+ }
+ public IntegerMatrix hadamardProduct(IntegerMatrix rightSide){
+ //Make sure the matrices have compatable 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());
+ }
+
+ //Create a new grid with the same element as the current grid
+ int[][] newGrid = copyGrid();
+
+ //Multiply 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];
+ }
+ }
+
+ //Return the new matrix
+ return new IntegerMatrix(newGrid);
+ }
+
+ //Complex operations
+ public IntegerMatrix transpose(){
+ //Create a new grid
+ int[][] newGrid = new int[getNumCols()][getNumRows()];
+
+ //Traverse every element in the existing grid and add each column to the new grid as a row
+ for(int col = 0;col < getNumCols();++col){
+ for(int row = 0;row < getNumRows();++row){
+ newGrid[col][row] = grid[row][col];
+ }
+ }
+
+ //Return the new matrix
+ return new IntegerMatrix(newGrid);
+ }
+ public int det(){
+ return determinant();
+ }
+ public int determinant(){
+ //Make sure the matrix is square
+ if(!isSquare()){
+ throw new InvalidGeometryException("A matrix must be square for it to have a determinant");
+ }
+ //?Don't have to worry about a matrix existing. isSquare takes care of 0x0 matrix
+
+ //Determine the formula do use for the determinant
+ int det = 0;
+ switch(getNumRows()){
+ //If the matrix is 1x1 return the number
+ case 1 : det = grid[0][0]; break;
+ //If the matrix is 2x2 use the formula
+ case 2 : {
+ det = (grid[0][0] * grid[1][1]) - (grid[0][1] * grid[1][0]);
+ }
+ break;
+ //If the matrix is 3x3 use the formula
+ case 3 : {
+ det = (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]);
+ }
+ break;
+ //If the matrix is larger break it down and try again
+ default : {
+ //Find the row/column with the largest number of 0's
+ int zerosLocation = 0;
+ int maxNumZeros = 0;
+ boolean zerosRow = true;
+ //Check the rows
+ for(int row = 0;row < getNumRows();++row){
+ int numZeros = 0;
+ for(int col = 0;col < getNumCols();++col){
+ if(grid[row][col] == 0){
+ ++numZeros;
+ }
+ }
+ if(numZeros > maxNumZeros){
+ maxNumZeros = numZeros;
+ zerosLocation = row;
+ zerosRow = true;
+ }
+ }
+ //Check the columns
+ for(int col = 0;col < getNumCols();++col){
+ int numZeros = 0;
+ for(int row = 0;row < getNumRows();++row){
+ if(grid[row][col] == 0){
+ ++numZeros;
+ }
+ }
+ if(numZeros > maxNumZeros){
+ maxNumZeros = numZeros;
+ zerosLocation = col;
+ zerosRow = false;
+ }
+ }
+
+ //If the largest number of zeros were found in a row
+ if(zerosRow){
+ //Set a variable to make sure the appropriate + or - is applied to the scalar
+ int multiplier = 1;
+ if((zerosLocation % 2) == 1){
+ multiplier = -1;
+ }
+ //Go through every column in the optimal row using the formula
+ for(int col = 0;col < getNumCols();++col){
+ if(grid[zerosLocation][col] != 0){
+ det += (multiplier * grid[zerosLocation][col] * laplaceExpansionHelper(zerosLocation, col).determinant());
+ }
+ multiplier = -multiplier;
+ }
+ }
+ //If the largest number of zeros were found in a column
+ else{
+ //Set a variable to make sure the appropriate + or - is applied to the scalar
+ int multiplier = 1;
+ if((zerosLocation % 2) == 1){
+ multiplier = -1;
+ }
+ //Go through every row in the coptimal column using the formula
+ for(int row = 0;row < getNumRows();++row){
+ if(grid[row][zerosLocation] != 0){
+ det += (multiplier * grid[row][zerosLocation] * laplaceExpansionHelper(row, zerosLocation).determinant());
+ }
+ multiplier = -multiplier;
+ }
+ }
+ }
+ }
+
+ //Return the determinant
+ return det;
+ }
+ public IntegerMatrix cofactor(){
+ //Make sure the matrix is square
+ if(!isSquare()){
+ throw new InvalidGeometryException("A matrix must be square to find the cofactor matrix");
+ }
+
+ //Create a new grid
+ int[][] newGrid = new int[getNumRows()][getNumCols()];
+ //If the grid is 1x1 return the grid
+ if(getNumRows() == 1){
+ newGrid[0][0] = grid[0][0];
+ }
+ //Use the formula to find the cofactor matrix
+ else{
+ for(int row = 0;row < getNumRows();++row){
+ int multiplier = ((row % 2) == 0) ? 1 : -1;
+ for(int col = 0;col < getNumCols();++col){
+ newGrid[row][col] = multiplier * laplaceExpansionHelper(row, col).determinant();
+ multiplier = -multiplier;
+ }
+ }
+ }
+
+ //Return the new matrix
+ return new IntegerMatrix(newGrid);
+ }
+
+ //Object funtions
+ @Override
+ public boolean equals(Object rightSide){
+ if(rightSide.getClass().equals(this.getClass())){
+ IntegerMatrix rightMatrix = (IntegerMatrix)rightSide;
+
+ //Make sure they have the same number of elements
+ if(grid.length != rightMatrix.grid.length){
+ return false;
+ }
+ else if(getNumCols() != rightMatrix.getNumCols()){
+ return false;
+ }
+
+ //Check every element
+ for(int row = 0;row < grid.length;++row){
+ for(int col = 0;col < grid[0].length;++col){
+ if(grid[row][col] != rightMatrix.grid[row][col]){
+ return false;
+ }
+ }
+ }
+
+ //If false hasn't been returned yet then they are equal
+ return true;
+ }
+ else if(rightSide.getClass().equals(int[][].class)){
+ int[][] rightMatrix = (int[][])rightSide;
+
+ return equals(new IntegerMatrix(rightMatrix));
+ }
+ else{
+ return false;
+ }
+ }
+ @Override
+ public String toString(){
+ StringJoiner matrix = new StringJoiner("\n");
+ for(int rowCnt = 0;rowCnt < grid.length;++rowCnt){
+ StringJoiner row = new StringJoiner(",", "[", "]");
+
+ for(int colCnt = 0;colCnt < grid[0].length;++colCnt){
+ row.add(Integer.toString(grid[rowCnt][colCnt]));
+ }
+
+ matrix.add(row.toString());
+ }
+ return matrix.toString();
+ }
+ @Override
+ public IntegerMatrix clone(){
+ return new IntegerMatrix(grid);
+ }
+}
diff --git a/src/main/java/com/mattrixwv/matrix/exceptions/InvalidCoordinatesException.java b/src/main/java/com/mattrixwv/matrix/exceptions/InvalidCoordinatesException.java
index cd6059c..cbf281f 100644
--- a/src/main/java/com/mattrixwv/matrix/exceptions/InvalidCoordinatesException.java
+++ b/src/main/java/com/mattrixwv/matrix/exceptions/InvalidCoordinatesException.java
@@ -1,21 +1,21 @@
-//Matrix/src/main/java/com/mattrixwv/exceptions/InvalidCoordinatesException.java
-//Mattrixwv
-// Created: 02-01-22
-//Modified: 02-01-22
-package com.mattrixwv.matrix.exceptions;
-
-
-public class InvalidCoordinatesException extends RuntimeException{
- public InvalidCoordinatesException(){
- super();
- }
- public InvalidCoordinatesException(String message){
- super(message);
- }
- public InvalidCoordinatesException(Throwable throwable){
- super(throwable);
- }
- public InvalidCoordinatesException(String message, Throwable throwable){
- super(message, throwable);
- }
-}
+//Matrix/src/main/java/com/mattrixwv/exceptions/InvalidCoordinatesException.java
+//Mattrixwv
+// Created: 02-01-22
+//Modified: 02-01-22
+package com.mattrixwv.matrix.exceptions;
+
+
+public class InvalidCoordinatesException extends RuntimeException{
+ public InvalidCoordinatesException(){
+ super();
+ }
+ public InvalidCoordinatesException(String message){
+ super(message);
+ }
+ public InvalidCoordinatesException(Throwable throwable){
+ super(throwable);
+ }
+ public InvalidCoordinatesException(String message, Throwable throwable){
+ super(message, throwable);
+ }
+}
diff --git a/src/main/java/com/mattrixwv/matrix/exceptions/InvalidGeometryException.java b/src/main/java/com/mattrixwv/matrix/exceptions/InvalidGeometryException.java
index 3a11a9a..7ab80f8 100644
--- a/src/main/java/com/mattrixwv/matrix/exceptions/InvalidGeometryException.java
+++ b/src/main/java/com/mattrixwv/matrix/exceptions/InvalidGeometryException.java
@@ -1,21 +1,21 @@
-//Matrix/src/main/java/com/mattrixwv/exceptions/InvalidGeometryException.java
-//Mattrixwv
-// Created: 02-01-22
-//Modified: 02-02-22
-package com.mattrixwv.matrix.exceptions;
-
-
-public class InvalidGeometryException extends RuntimeException{
- public InvalidGeometryException(){
- super();
- }
- public InvalidGeometryException(String message){
- super(message);
- }
- public InvalidGeometryException(Throwable throwable){
- super(throwable);
- }
- public InvalidGeometryException(String message, Throwable throwable){
- super(message, throwable);
- }
-}
+//Matrix/src/main/java/com/mattrixwv/exceptions/InvalidGeometryException.java
+//Mattrixwv
+// Created: 02-01-22
+//Modified: 02-02-22
+package com.mattrixwv.matrix.exceptions;
+
+
+public class InvalidGeometryException extends RuntimeException{
+ public InvalidGeometryException(){
+ super();
+ }
+ public InvalidGeometryException(String message){
+ super(message);
+ }
+ public InvalidGeometryException(Throwable throwable){
+ super(throwable);
+ }
+ public InvalidGeometryException(String message, Throwable throwable){
+ super(message, throwable);
+ }
+}
diff --git a/src/main/java/com/mattrixwv/matrix/exceptions/InvalidRowSizeException.java b/src/main/java/com/mattrixwv/matrix/exceptions/InvalidRowSizeException.java
index fa6432f..ca5b66b 100644
--- a/src/main/java/com/mattrixwv/matrix/exceptions/InvalidRowSizeException.java
+++ b/src/main/java/com/mattrixwv/matrix/exceptions/InvalidRowSizeException.java
@@ -1,21 +1,21 @@
-//Matrix/src/main/java/com/mattrixwv/exceptions/InvalidRowSizeException.java
-//Mattrixwv
-// Created: 02-01-22
-//Modified: 02-01-22
-package com.mattrixwv.matrix.exceptions;
-
-
-public class InvalidRowSizeException extends RuntimeException{
- public InvalidRowSizeException(){
- super();
- }
- public InvalidRowSizeException(String message){
- super(message);
- }
- public InvalidRowSizeException(Throwable throwable){
- super(throwable);
- }
- public InvalidRowSizeException(String message, Throwable throwable){
- super(message, throwable);
- }
-}
+//Matrix/src/main/java/com/mattrixwv/exceptions/InvalidRowSizeException.java
+//Mattrixwv
+// Created: 02-01-22
+//Modified: 02-01-22
+package com.mattrixwv.matrix.exceptions;
+
+
+public class InvalidRowSizeException extends RuntimeException{
+ public InvalidRowSizeException(){
+ super();
+ }
+ public InvalidRowSizeException(String message){
+ super(message);
+ }
+ public InvalidRowSizeException(Throwable throwable){
+ super(throwable);
+ }
+ public InvalidRowSizeException(String message, Throwable throwable){
+ super(message, throwable);
+ }
+}
diff --git a/src/test/java/com/mattrixwv/matrix/TestIntegerMatrix.java b/src/test/java/com/mattrixwv/matrix/TestIntegerMatrix.java
index 03b47c2..5c3a685 100644
--- a/src/test/java/com/mattrixwv/matrix/TestIntegerMatrix.java
+++ b/src/test/java/com/mattrixwv/matrix/TestIntegerMatrix.java
@@ -1,1174 +1,1174 @@
-//Matrix/src/test/java/com/mattrixwv/matrix/TestIntegerMatrix.java
-//Mattrixwv
-// Created: 02-01-22
-//Modified: 02-03-22
-package com.mattrixwv.matrix;
-
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Test;
-
-
-public class TestIntegerMatrix{
- //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;
- IntegerMatrix matrix = new IntegerMatrix(grid1);
- assertTrue("IntegerMatrix 1x1 failed equals IntegerMatrix", matrix.equals(matrix));
- @SuppressWarnings("unlikely-arg-type")
- boolean gridEquals = matrix.equals(grid1);
- assertTrue("IntegerMatrix 1x1 failed equals int[][]", gridEquals);
-
- //2x2
- matrix = new IntegerMatrix(grid2);
- assertTrue("IntegerMatrix 2x2 failed equals IntegerMatrix", matrix.equals(matrix));
- @SuppressWarnings("unlikely-arg-type")
- boolean gridEquals2 = matrix.equals(grid2);
- assertTrue("IntegerMatrix 2x2 failed equals int[][]", gridEquals2);
-
- //3x3
- matrix = new IntegerMatrix(grid3);
- assertTrue("IntegerMatrix 3x3 failed equals IntegerMatrix", matrix.equals(matrix));
- @SuppressWarnings("unlikely-arg-type")
- boolean gridEquals3 = matrix.equals(grid3);
- assertTrue("IntegerMatrix 3x3 failed equals int[][]", gridEquals3);
-
- //4x4
- matrix = new IntegerMatrix(grid4);
- assertTrue("IntegerMatrix 4x4 failed equals IntegerMatrix", matrix.equals(matrix));
- @SuppressWarnings("unlikely-arg-type")
- boolean gridEquals4 = matrix.equals(grid4);
- assertTrue("IntegerMatrix 4x4 failed equals int[][]", gridEquals4);
-
- //10x10
- matrix = new IntegerMatrix(grid10);
- assertTrue("IntegerMatrix = 10x10 failed equals IntegerMatrix", matrix.equals(matrix));
- @SuppressWarnings("unlikely-arg-type")
- boolean gridEquals10 = matrix.equals(grid10);
- assertTrue("IntegerMatrix 10x10 failed equals int[][]", gridEquals10);
- }
-
- @Test
- public void testGets(){
- //1x1
- IntegerMatrix matrix = new IntegerMatrix(grid1);
- assertEquals("IntegerMatrix 1x1 failed get", 1, matrix.get(0, 0));
- //GetRow
- IntegerMatrix correctMatrix = new IntegerMatrix(new int[][]{{1}});
- assertEquals("IntegerMatrix 1x1 failed getRow", correctMatrix, matrix.getRow(0));
- //GetColumn
- correctMatrix = new IntegerMatrix(new int[][]{{1}});
- assertEquals("IntegerMatrix 1x1 failed getColumn", correctMatrix, matrix.getCol(0));
-
- //2x2
- matrix = new IntegerMatrix(grid2);
- assertEquals("IntegerMatrix 2x2 failed get", 1, matrix.get(0, 0));
- //GetRow
- correctMatrix = new IntegerMatrix(new int[][]{{1, 2}});
- assertEquals("IntegerMatrix 2x2 failed getRow", correctMatrix, matrix.getRow(0));
- //GetColumn
- correctMatrix = new IntegerMatrix(new int[][]{
- {1},
- {1}
- });
- assertEquals("IntegerMatrix 2x2 failed getColumns", correctMatrix, matrix.getCol(0));
-
- //3x3
- matrix = new IntegerMatrix(grid3);
- assertEquals("IntegerMatrix 3x3 failed get", 1, matrix.get(0, 0));
- //GetRow
- correctMatrix = new IntegerMatrix(new int[][]{{1, 2, 3}});
- assertEquals("IntegerMatrix 3x3 failed getRow", correctMatrix, matrix.getRow(0));
- //GetColumn
- correctMatrix = new IntegerMatrix(new int[][]{
- {1},
- {1},
- {1}
- });
- assertEquals("IntegerMatrix 3x3 failed getCol", correctMatrix, matrix.getCol(0));
-
- //4x4
- matrix = new IntegerMatrix(grid4);
- assertEquals("IntegerMatrix 4x4 failed get", 1, matrix.get(0, 0));
- //GetRow
- correctMatrix = new IntegerMatrix(new int[][]{{1, 2, 3, 4}});
- assertEquals("IntegerMatrix 4x4 failed getRow", correctMatrix, matrix.getRow(0));
- //GetColumn
- correctMatrix = new IntegerMatrix(new int[][]{
- {1},
- {1},
- {1},
- {1}
- });
- assertEquals("IntegerMatrix 4x4 failed getCol", correctMatrix, matrix.getCol(0));
-
- //10x10
- matrix = new IntegerMatrix(grid10);
- assertEquals("IntegerMatrix 10x10 failed get", 1, matrix.get(0, 0));
- //GetRow
- correctMatrix = new IntegerMatrix(new int[][]{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}});
- assertEquals("IntegerMatrix 10x10 failed getRow", correctMatrix, matrix.getRow(0));
- //GetColumn
- correctMatrix = new IntegerMatrix(new int[][]{
- {1},
- {1},
- {1},
- {1},
- {1},
- {1},
- {1},
- {1},
- {1},
- {1}
- });
- assertEquals("IntegerMatrix 10x10 failed getColumn", correctMatrix, matrix.getCol(0));
- }
-
- @Test
- public void testSets(){
- //1x1
- //Set
- IntegerMatrix matrix = new IntegerMatrix(grid1);
- IntegerMatrix correctMatrix = null;
- matrix.set(0, 0, 2);
- correctMatrix = new IntegerMatrix(new int[][]{{2}});
- assertEquals("IntegerMatrix 1x1 failed set", correctMatrix, matrix);
- //SetRow
- matrix.setRow(0, new int[]{0});
- correctMatrix = new IntegerMatrix(new int[][]{{0}});
- assertEquals("IntegerMatrix 1x1 failed setRow", correctMatrix, matrix);
- //SetColumn
- matrix.setCol(0, new int[]{1});
- correctMatrix = new IntegerMatrix(new int[][]{{1}});
- assertEquals("IntegerMatrix 1x1 failed setCol", correctMatrix, matrix);
-
- //2x2
- //Set
- matrix = new IntegerMatrix(grid2);
- matrix.set(0, 0, 3);
- correctMatrix = new IntegerMatrix(new int[][]{
- {3, 2},
- {1, 2}
- });
- assertEquals("IntegerMatrix 2x2 failed set", correctMatrix, matrix);
- //SetRow
- matrix.setRow(1, new int[]{2, 1});
- correctMatrix = new IntegerMatrix(new int[][]{
- {3, 2},
- {2, 1}
- });
- assertEquals("IntegerMatrix 2x2 failed set row", correctMatrix, matrix);
- //SetColumn
- matrix = new IntegerMatrix(grid2);
- matrix.setCol(0, new int[]{3, 3});
- correctMatrix = new IntegerMatrix(new int[][]{
- {3, 2},
- {3, 2}
- });
- assertEquals("IntegerMatrix 2x2 failed set row", correctMatrix, matrix);
-
- //3x3
- //Set
- matrix = new IntegerMatrix(grid3);
- matrix.set(0, 0, 3);
- correctMatrix = new IntegerMatrix(new int[][]{
- {3, 2, 3},
- {1, 2, 3},
- {1, 2, 3},
- });
- assertEquals("IntegerMatrix 3x3 failed set", correctMatrix, matrix);
- //SetRow
- matrix.setRow(0, new int[]{0, 1, 2});
- correctMatrix = new IntegerMatrix(new int[][]{
- {0, 1, 2},
- {1, 2, 3},
- {1, 2, 3}
- });
- assertEquals("IntegerMatrix 3x3 failed setRow", correctMatrix, matrix);
- //SetColumn
- matrix.setCol(0, new int[]{0, 0, 0});
- correctMatrix = new IntegerMatrix(new int[][]{
- {0, 1, 2},
- {0, 2, 3},
- {0, 2, 3}
- });
- assertEquals("IntegerMatrix 3x3 failed setColumn", correctMatrix, matrix);
-
- //4x4
- //Set
- matrix = new IntegerMatrix(grid4);
- matrix.set(0, 0, 3);
- correctMatrix = new IntegerMatrix(new int[][]{
- {3, 2, 3, 4},
- {1, 2, 3, 4},
- {1, 2, 3, 4},
- {1, 2, 3, 4}
- });
- assertEquals("IntegerMatrix 4x4 failed set", correctMatrix, matrix);
- //SetRow
- matrix.setRow(0, new int[]{4, 3, 2, 1});
- correctMatrix = new IntegerMatrix(new int[][]{
- {4, 3, 2, 1},
- {1, 2, 3, 4},
- {1, 2, 3, 4},
- {1, 2, 3, 4}
- });
- assertEquals("IntegerMatrix 4x4 failed setRow", correctMatrix, matrix);
- //SetColumn
- matrix.setCol(0, new int[]{0, 0, 0, 0});
- correctMatrix = new IntegerMatrix(new int[][]{
- {0, 3, 2, 1},
- {0, 2, 3, 4},
- {0, 2, 3, 4},
- {0, 2, 3, 4}
- });
- assertEquals("IntegerMatrix 4x4 failed setCol", correctMatrix, matrix);
-
- //10x10
- //Set
- matrix = new IntegerMatrix(grid10);
- matrix.set(0, 0, 3);
- correctMatrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 10x10 failed set", correctMatrix, matrix);
- //SetRow
- matrix.setRow(0, new int[]{10, 9, 8, 7, 6, 5, 4, 3, 2, 1});
- correctMatrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 10x10 failed setRow", correctMatrix, matrix);
- //SetColumn
- matrix.setCol(0, new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
- correctMatrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 10x10 failed setColumn", correctMatrix, matrix);
- }
-
- @Test
- public void testAdds(){
- //1x1
- //AddRow
- IntegerMatrix matrix = new IntegerMatrix(grid1);
- IntegerMatrix correctMatrix = null;
- matrix.addRow(new int[]{1});
- correctMatrix = new IntegerMatrix(new int[][]{{1}, {1}});
- assertEquals("IntegerMatrix 1x1 failed addRow", correctMatrix, matrix);
- //AddColumn
- matrix = new IntegerMatrix(grid1);
- matrix.addCol(new int[]{1});
- correctMatrix = new IntegerMatrix(new int[][]{{1, 1}});
- assertEquals("IntegerMatrix 1x1 failed addCol", correctMatrix, matrix);
-
- //2x2
- //AddRow
- matrix = new IntegerMatrix(grid2);
- matrix.addRow(new int[]{1, 2});
- correctMatrix = new IntegerMatrix(new int[][]{
- {1, 2},
- {1, 2},
- {1, 2}
- });
- assertEquals("IntegerMatrix 2x2 failed set row", correctMatrix, matrix);
- //AddColumn
- matrix = new IntegerMatrix(grid2);
- matrix.addCol(new int[]{3, 3});
- correctMatrix = new IntegerMatrix(new int[][]{
- {1, 2, 3},
- {1, 2, 3}
- });
- assertEquals("IntegerMatrix 2x2 failed set row", correctMatrix, matrix);
-
- //3x3
- //AddRow
- matrix = new IntegerMatrix(grid3);
- matrix.addRow(new int[]{1, 2, 3});
- correctMatrix = new IntegerMatrix(new int[][]{
- {1, 2, 3},
- {1, 2, 3},
- {1, 2, 3},
- {1, 2, 3}
- });
- assertEquals("IntegerMatrix 3x3 failed addRow", correctMatrix, matrix);
- //AddColumn
- matrix = new IntegerMatrix(grid3);
- matrix.addCol(new int[]{4, 4, 4});
- correctMatrix = new IntegerMatrix(new int[][]{
- {1, 2, 3, 4},
- {1, 2, 3, 4},
- {1, 2, 3, 4}
- });
- assertEquals("IntegerMatrix 3x3 failed addCol", correctMatrix, matrix);
-
- //4x4
- //AddRow
- matrix = new IntegerMatrix(grid4);
- matrix.addRow(new int[]{1, 2, 3, 4});
- correctMatrix = new IntegerMatrix(new int[][]{
- {1, 2, 3, 4},
- {1, 2, 3, 4},
- {1, 2, 3, 4},
- {1, 2, 3, 4},
- {1, 2, 3, 4}
- });
- assertEquals("IntegerMatrix 4x4 failed addRow", correctMatrix, matrix);
- //AddColumn
- matrix.addCol(new int[]{5, 5, 5, 5, 5});
- correctMatrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 4x4 failed addCol", correctMatrix, matrix);
-
- //10x10
- //AddRow
- matrix = new IntegerMatrix(grid10);
- matrix.addRow(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
- correctMatrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 10x10 failed addRow", correctMatrix, matrix);
- //AddColumn
- matrix = new IntegerMatrix(grid10);
- matrix.addCol(new int[]{11, 11, 11, 11, 11, 11, 11, 11, 11, 11});
- correctMatrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 10x10 failed addColumn", correctMatrix, matrix);
- }
-
- @Test
- public void testAppends(){
- //1x1
- //appendRight
- IntegerMatrix matrix = new IntegerMatrix(grid1);
- IntegerMatrix secondMatrix = new IntegerMatrix(grid1);
- IntegerMatrix correctMatrix = new IntegerMatrix(new int[][]{{1, 1}});
- assertEquals("IntegerMatrix 1x1 failed appendRight", correctMatrix, matrix.appendRight(secondMatrix));
- //appendBottom
- correctMatrix = new IntegerMatrix(new int[][]{
- {1},
- {1}
- });
- assertEquals("IntegerMatrix 1x1 failed appendBottom", correctMatrix, matrix.appendBottom(secondMatrix));
-
- //2x2
- //appendRight
- matrix = new IntegerMatrix(grid2);
- secondMatrix = new IntegerMatrix(grid2);
- correctMatrix = new IntegerMatrix(new int[][]{
- {1, 2, 1, 2},
- {1, 2, 1, 2}
- });
- assertEquals("IntegerMatrix 2x2 failed appendRight", correctMatrix, matrix.appendRight(secondMatrix));
- //appendBottom
- correctMatrix = new IntegerMatrix(new int[][]{
- {1, 2},
- {1, 2},
- {1, 2},
- {1, 2}
- });
- assertEquals("IntegerMatrix 2x2 failed appendBottom", correctMatrix, matrix.appendBottom(secondMatrix));
-
- //3x3
- //appendRight
- matrix = new IntegerMatrix(grid3);
- secondMatrix = new IntegerMatrix(grid3);
- correctMatrix = new IntegerMatrix(new int[][]{
- {1, 2, 3, 1, 2, 3},
- {1, 2, 3, 1, 2, 3},
- {1, 2, 3, 1, 2, 3}
- });
- assertEquals("IntegerMatrix 3x3 failed appendRight", correctMatrix, matrix.appendRight(secondMatrix));
- //appendBottom
- correctMatrix = new IntegerMatrix(new int[][]{
- {1, 2, 3},
- {1, 2, 3},
- {1, 2, 3},
- {1, 2, 3},
- {1, 2, 3},
- {1, 2, 3}
- });
- assertEquals("IntegerMatrix 3x3 failed appendBottom", correctMatrix, matrix.appendBottom(secondMatrix));
-
- //4x4
- //appendRight
- matrix = new IntegerMatrix(grid4);
- secondMatrix = new IntegerMatrix(grid4);
- correctMatrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 4x4 failed appendRight", correctMatrix, matrix.appendRight(secondMatrix));
- //appendBottom
- correctMatrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 4x4 failed appendBottom", correctMatrix, matrix.appendBottom(secondMatrix));
-
- //10x10
- //appendRight
- matrix = new IntegerMatrix(grid10);
- secondMatrix = new IntegerMatrix(grid10);
- correctMatrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 10x10 failed appendRight", correctMatrix, matrix.appendRight(secondMatrix));
- //appendBottom
- correctMatrix = new IntegerMatrix(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},
- });
- assertEquals("IntegerMatrix 10x10 failed appendBottom", correctMatrix, matrix.appendBottom(secondMatrix));
- }
-
- @Test
- public void testAddition(){
- //1x1
- IntegerMatrix matrix = new IntegerMatrix(grid1);
- IntegerMatrix transformMatrix = new IntegerMatrix(transformGrid1_1);
- IntegerMatrix correctMatrix = new IntegerMatrix(new int[][]{{2}});
- assertEquals("IntegerMatrix 1x1 failed add IntegerMatrix", correctMatrix, matrix.add(transformMatrix));
- assertEquals("IntegerMatrix 1x1 failed add scalar", correctMatrix, matrix.add(1));
-
- //2x2
- matrix = new IntegerMatrix(grid2);
- transformMatrix = new IntegerMatrix(transformGrid2_1);
- correctMatrix = new IntegerMatrix(new int[][]{
- {2, 2},
- {2, 2}
- });
- assertEquals("IntegerMatrix 2x2 failed add IntegerMatrix", correctMatrix, matrix.add(transformMatrix));
- correctMatrix = new IntegerMatrix(new int[][]{
- {2, 3},
- {2, 3}
- });
- assertEquals("IntegerMatrix 2x2 failed add scalar", correctMatrix, matrix.add(1));
-
- //3x3
- matrix = new IntegerMatrix(grid3);
- transformMatrix = new IntegerMatrix(transformGrid3_1);
- correctMatrix = new IntegerMatrix(new int[][]{
- {3, 3, 3},
- {3, 3, 3},
- {3, 3, 3}
- });
- assertEquals("IntegerMatrix 3x3 failed add IntegerMatrix", correctMatrix, matrix.add(transformMatrix));
- correctMatrix = new IntegerMatrix(new int[][]{
- {2, 3, 4},
- {2, 3, 4},
- {2, 3, 4}
- });
- assertEquals("IntegerMatrix 3x3 failed add scalar", correctMatrix, matrix.add(1));
-
- //4x4
- matrix = new IntegerMatrix(grid4);
- transformMatrix = new IntegerMatrix(transformGrid4_1);
- correctMatrix = new IntegerMatrix(new int[][]{
- {4, 4, 4, 4},
- {4, 4, 4, 4},
- {4, 4, 4, 4},
- {4, 4, 4, 4}
- });
- assertEquals("IntegerMatrix 4x4 failed add IntegerMatrix", correctMatrix, matrix.add(transformMatrix));
- correctMatrix = new IntegerMatrix(new int[][]{
- {2, 3, 4, 5},
- {2, 3, 4, 5},
- {2, 3, 4, 5},
- {2, 3, 4, 5}
- });
- assertEquals("IntegerMatrix 4x4 failed add scalar", correctMatrix, matrix.add(1));
-
- //10x10
- matrix = new IntegerMatrix(grid10);
- transformMatrix = new IntegerMatrix(transformGrid10_1);
- correctMatrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 5x5 failed add IntegerMatrix", correctMatrix, matrix.add(transformMatrix));
- correctMatrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 10x10 failed add IntegerMatrix", correctMatrix, matrix.add(1));
- }
-
- @Test
- public void testSubtraction(){
- //1x1
- IntegerMatrix matrix = new IntegerMatrix(grid1);
- IntegerMatrix transformMatrix = new IntegerMatrix(transformGrid1_1);
- IntegerMatrix correctMatrix = new IntegerMatrix(new int[][]{
- {0}
- });
- assertEquals("IntegerMatrix 1x1 failed subtract IntegerMatrix", correctMatrix, matrix.subtract(transformMatrix));
- assertEquals("IntegerMatrix 1x1 failed subtract scalar", correctMatrix, matrix.subtract(1));
-
- //2x2
- matrix = new IntegerMatrix(grid2);
- transformMatrix = new IntegerMatrix(grid2);
- correctMatrix = new IntegerMatrix(new int[][]{
- {0, 0},
- {0, 0}
- });
- assertEquals("IntegerMatrix 2x2 failed subtract IntegerMatrix", correctMatrix, matrix.subtract(transformMatrix));
- correctMatrix = new IntegerMatrix(new int[][]{
- {0, 1},
- {0, 1}
- });
- assertEquals("IntegerMatrix 2x2 failed subtract scalar", correctMatrix, matrix.subtract(1));
-
- //3x3
- matrix = new IntegerMatrix(grid3);
- transformMatrix = new IntegerMatrix(grid3);
- correctMatrix = new IntegerMatrix(new int[][]{
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0}
- });
- assertEquals("IntegerMatrix 3x3 failed subtract IntegerMatrix", correctMatrix, matrix.subtract(transformMatrix));
- correctMatrix = new IntegerMatrix(new int[][]{
- {0, 1, 2},
- {0, 1, 2},
- {0, 1, 2}
- });
- assertEquals("IntegerMatrix 3x3 failed subtract scalar", correctMatrix, matrix.subtract(1));
-
- //4x4
- matrix = new IntegerMatrix(grid4);
- transformMatrix = new IntegerMatrix(grid4);
- correctMatrix = new IntegerMatrix(new int[][]{
- {0, 0, 0, 0},
- {0, 0, 0, 0},
- {0, 0, 0, 0},
- {0, 0, 0, 0}
- });
- assertEquals("IntegerMatrix 4x4 failed subtract IntegerMatrix", correctMatrix, matrix.subtract(transformMatrix));
- correctMatrix = new IntegerMatrix(new int[][]{
- {0, 1, 2, 3},
- {0, 1, 2, 3},
- {0, 1, 2, 3},
- {0, 1, 2, 3}
- });
- assertEquals("IntegerMatrix 4x4 failed subtract scalar", correctMatrix, matrix.subtract(1));
-
- //10x10
- matrix = new IntegerMatrix(grid10);
- transformMatrix = new IntegerMatrix(grid10);
- correctMatrix = new IntegerMatrix(new int[][]{
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
- {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
- });
- assertEquals("IntegerMatrix 10x10 failed subtract IntegerMatrix", correctMatrix, matrix.subtract(transformMatrix));
- correctMatrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 10x10 failed subtract scalar", correctMatrix, matrix.subtract(1));
- }
-
- @Test
- public void testMultiplication(){
- //1x1
- IntegerMatrix matrix = new IntegerMatrix(grid1);
- IntegerMatrix transformMatrix = new IntegerMatrix(transformGrid1_2);
- IntegerMatrix correctMatrix = new IntegerMatrix(transformGrid1_2);
- assertEquals("IntegerMatrix 1x1 failed multiplication IntegerMatrix", correctMatrix, matrix.multiply(transformMatrix));
- assertEquals("IntegerMatrix 1x1 failed multiplication scalar", correctMatrix, matrix.multiply(2));
-
- //2x2
- matrix = new IntegerMatrix(grid2);
- transformMatrix = new IntegerMatrix(transformGrid2_2);
- correctMatrix = new IntegerMatrix(new int[][]{
- {6, 9},
- {6, 9}
- });
- assertEquals("IntegerMatrix 2x2 failed multiplication IntegerMatrix", correctMatrix, matrix.multiply(transformMatrix));
- IntegerMatrix vector = new IntegerMatrix(new int[][]{
- {2},
- {3}
- });
- correctMatrix = new IntegerMatrix(new int[][]{
- {8},
- {8}
- });
- assertEquals("IntegerMatrix 2x2 failed multiplication vector", correctMatrix, matrix.multiply(vector));
- correctMatrix = new IntegerMatrix(new int[][]{
- {2, 4},
- {2, 4}
- });
- assertEquals("IntegerMatrix 2x2 failed multiplication scalar", correctMatrix, matrix.multiply(2));
-
- //3x3
- matrix = new IntegerMatrix(grid3);
- transformMatrix = new IntegerMatrix(transformGrid3_2);
- correctMatrix = new IntegerMatrix(new int[][]{
- {12, 18, 24},
- {12, 18, 24},
- {12, 18, 24}
- });
- assertEquals("IntegerMatrix 3x3 failed multiplication IntegerMatrix", correctMatrix, matrix.multiply(transformMatrix));
- vector = new IntegerMatrix(new int[][]{
- {2},
- {3},
- {4}
- });
- correctMatrix = new IntegerMatrix(new int[][]{
- {20},
- {20},
- {20}
- });
- assertEquals("IntegerMatrix 3x3 failed multiplication vector", correctMatrix, matrix.multiply(vector));
- correctMatrix = new IntegerMatrix(new int[][]{
- {2, 4, 6},
- {2, 4, 6},
- {2, 4, 6}
- });
- assertEquals("IntegerMatrix 3x3 failed multiplication scalar", correctMatrix, matrix.multiply(2));
-
- //4x4
- matrix = new IntegerMatrix(grid4);
- transformMatrix = new IntegerMatrix(transformGrid4_2);
- correctMatrix = new IntegerMatrix(new int[][]{
- {20, 30, 40, 50},
- {20, 30, 40, 50},
- {20, 30, 40, 50},
- {20, 30, 40, 50},
- });
- assertEquals("IntegerMatrix 4x4 failed multiplication IntegerMatrix", correctMatrix, matrix.multiply(transformMatrix));
- vector = new IntegerMatrix(new int[][]{
- {2},
- {3},
- {4},
- {5}
- });
- correctMatrix = new IntegerMatrix(new int[][]{
- {40},
- {40},
- {40},
- {40}
- });
- assertEquals("IntegerMatrix 4x4 failed multiplication vector", correctMatrix, matrix.multiply(vector));
- correctMatrix = new IntegerMatrix(new int[][]{
- {2, 4, 6, 8},
- {2, 4, 6, 8},
- {2, 4, 6, 8},
- {2, 4, 6, 8}
- });
- assertEquals("IntegerMatrix 4x4 failed multiplication scalar", correctMatrix, matrix.multiply(2));
-
- //10x10
- matrix = new IntegerMatrix(grid10);
- transformMatrix = new IntegerMatrix(transformGrid10_2);
- correctMatrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 10x10 failed multiplication IntegerMatrix", correctMatrix, matrix.multiply(transformMatrix));
- vector = new IntegerMatrix(new int[][]{
- {2},
- {3},
- {4},
- {5},
- {6},
- {7},
- {8},
- {9},
- {10},
- {11}
- });
- correctMatrix = new IntegerMatrix(new int[][]{
- {440},
- {440},
- {440},
- {440},
- {440},
- {440},
- {440},
- {440},
- {440},
- {440}
- });
- assertEquals("IntegerMatrix 10x10 failed multiplication vector", correctMatrix, matrix.multiply(vector));
- correctMatrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 10x10 failed multiplication scalar", correctMatrix, matrix.multiply(2));
- }
-
- @Test
- public void testDotProduct(){
- //1x1
- IntegerMatrix matrix = new IntegerMatrix(grid1);
- IntegerMatrix transformMatrix = new IntegerMatrix(transformGrid1_2);
- assertEquals("IntegerMatrix 1x1 failed dot product IntegerMatrix", 2, matrix.dotProduct(transformMatrix));
-
- //2x2
- matrix = new IntegerMatrix(grid2);
- transformMatrix = new IntegerMatrix(transformGrid2_2);
- assertEquals("IntegerMatrix 2x2 failed dot product IntegerMatrix", 30, matrix.dotProduct(transformMatrix));
-
- //3x3
- matrix = new IntegerMatrix(grid3);
- transformMatrix = new IntegerMatrix(transformGrid3_2);
- assertEquals("IntegerMatrix 3x3 failed dot product IntegerMatrix", 162, matrix.dotProduct(transformMatrix));
-
- //4x4
- matrix = new IntegerMatrix(grid4);
- transformMatrix = new IntegerMatrix(transformGrid4_2);
- assertEquals("IntegerMatrix 4x4 failed dot product IntegerMatrix", 560, matrix.dotProduct(transformMatrix));
-
- //10x10
- matrix = new IntegerMatrix(grid10);
- transformMatrix = new IntegerMatrix(transformGrid10_2);
- assertEquals("IntegerMatrix 10x10 failed dot product IntegerMatrix", 35750, matrix.dotProduct(transformMatrix));
- }
-
- @Test
- public void testHadamardProduct(){
- //1x1
- IntegerMatrix matrix = new IntegerMatrix(grid1);
- IntegerMatrix transformMatrix = new IntegerMatrix(transformGrid1_2);
- IntegerMatrix correctMatrix = new IntegerMatrix(new int[][]{{2}});
- assertEquals("IntegerMatrix 1x1 failed dot product IntegerMatrix", correctMatrix, matrix.hadamardProduct(transformMatrix));
-
- //2x2
- matrix = new IntegerMatrix(grid2);
- transformMatrix = new IntegerMatrix(transformGrid2_2);
- correctMatrix = new IntegerMatrix(new int[][]{
- {2, 6},
- {2, 6}
- });
- assertEquals("IntegerMatrix 2x2 failed dot product IntegerMatrix", correctMatrix, matrix.hadamardProduct(transformMatrix));
-
- //3x3
- matrix = new IntegerMatrix(grid3);
- transformMatrix = new IntegerMatrix(transformGrid3_2);
- correctMatrix = new IntegerMatrix(new int[][]{
- {2, 6, 12},
- {2, 6, 12},
- {2, 6, 12}
- });
- assertEquals("IntegerMatrix 3x3 failed dot product IntegerMatrix", correctMatrix, matrix.hadamardProduct(transformMatrix));
-
- //4x4
- matrix = new IntegerMatrix(grid4);
- transformMatrix = new IntegerMatrix(transformGrid4_2);
- correctMatrix = new IntegerMatrix(new int[][]{
- {2, 6, 12, 20},
- {2, 6, 12, 20},
- {2, 6, 12, 20},
- {2, 6, 12, 20}
- });
- assertEquals("IntegerMatrix 4x4 failed dot product IntegerMatrix", correctMatrix, matrix.hadamardProduct(transformMatrix));
-
- //10x10
- matrix = new IntegerMatrix(grid10);
- transformMatrix = new IntegerMatrix(transformGrid10_2);
- correctMatrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 10x10 failed dot product IntegerMatrix", correctMatrix, matrix.hadamardProduct(transformMatrix));
- }
-
- @Test
- public void testTranspose(){
- //1x1
- IntegerMatrix matrix = new IntegerMatrix(grid1);
- IntegerMatrix correctMatrix = new IntegerMatrix(new int[][]{{1}});
- assertEquals("IntegerMatrix 1x1 failed transpose", correctMatrix, matrix.transpose());
-
- //2x2
- matrix = new IntegerMatrix(grid2);
- correctMatrix = new IntegerMatrix(new int[][]{
- {1, 1},
- {2, 2}
- });
- assertEquals("IntegerMatrix 2x2 failed transpose", correctMatrix, matrix.transpose());
-
- //3x3
- matrix = new IntegerMatrix(grid3);
- correctMatrix = new IntegerMatrix(new int[][]{
- {1, 1, 1},
- {2, 2, 2},
- {3, 3, 3}
- });
- assertEquals("IntegerMatrix 3x3 failed transpose", correctMatrix, matrix.transpose());
-
- //4x4
- matrix = new IntegerMatrix(grid4);
- correctMatrix = new IntegerMatrix(new int[][]{
- {1, 1, 1, 1},
- {2, 2, 2, 2},
- {3, 3, 3, 3},
- {4, 4, 4, 4}
- });
- assertEquals("IntegerMatrix 4x4 failed transpose", correctMatrix, matrix.transpose());
-
- //10x10
- matrix = new IntegerMatrix(grid10);
- correctMatrix = new IntegerMatrix(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},
- });
- assertEquals("IntegerMatrix 10x10 failed transpose", correctMatrix, matrix.transpose());
- }
-
- @Test
- public void testDeterminant(){
- //1x1
- IntegerMatrix matrix = new IntegerMatrix(grid1);
- assertEquals("IntegerMatrix 1x1 failed determinant", 1, matrix.determinant());
-
- //2x2
- matrix = new IntegerMatrix(grid2);
- assertEquals("IntegerMatrix 2x2 failed determinant1", 0, matrix.determinant());
- matrix = new IntegerMatrix(new int[][]{
- {1, 4},
- {4, 1}
- });
- assertEquals("IntegerMatrix 2x2 failed determinant2", -15, matrix.determinant());
-
- //3x3
- matrix = new IntegerMatrix(grid3);
- assertEquals("IntegerMatrix 3x3 failed determinant1", 0, matrix.determinant());
- matrix = new IntegerMatrix(new int[][]{
- {1, 4, 2},
- {2, 4, 1},
- {4, 1, 2}
- });
- assertEquals("IntegerMatrix 3x3 failed determinant2", -21, matrix.determinant());
-
- //4x4
- matrix = new IntegerMatrix(grid4);
- assertEquals("IntegerMatrix 4x4 failed determiant1", 0, matrix.determinant());
- matrix = new IntegerMatrix(new int[][]{
- {1, 2, 3, 4},
- {2, 3, 4, 1},
- {3, 4, 1, 2},
- {4, 1, 2, 3}
- });
- assertEquals("IntegerMatrix 4x4 failed determinant2", 160, matrix.determinant());
-
- //10x10
- matrix = new IntegerMatrix(grid10);
- assertEquals("IntegerMatrix 10x10 failed determinant1", 0, matrix.determinant());
- matrix = new IntegerMatrix(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}
- });
- assertEquals("IntegerMatrix 10x10 failed determinant2", -10000000, matrix.determinant());
- }
-
- @Test
- public void testCofactor(){
- //1x1
- IntegerMatrix matrix = new IntegerMatrix(grid1);
- IntegerMatrix correctMatrix = new IntegerMatrix(grid1);
- assertEquals("IntegerMatrix 1x1 failed cofactor", correctMatrix, matrix.cofactor());
-
- //2x2
- matrix = new IntegerMatrix(grid2);
- correctMatrix = new IntegerMatrix(new int[][]{
- {2, -1},
- {-2, 1}
- });
- assertEquals("IntegerMatrix 2x2 failed cofactor", correctMatrix, matrix.cofactor());
-
- //3x3
- matrix = new IntegerMatrix(grid3);
- correctMatrix = new IntegerMatrix(3, 3, 0);
- assertEquals("IntegerMatrix 3x3 failed cofactor1", correctMatrix, matrix.cofactor());
- matrix = new IntegerMatrix(new int[][]{
- {1, 4, 2},
- {2, 4, 1},
- {4, 1, 2}
- });
- correctMatrix = new IntegerMatrix(new int[][]{
- {7, 0, -14},
- {-6, -6, 15},
- {-4, 3, -4}
- });
- assertEquals("IntegerMatrix 3x3 failed cofactor2", correctMatrix, matrix.cofactor());
-
- //4x4
- matrix = new IntegerMatrix(grid4);
- correctMatrix = new IntegerMatrix(4, 4, 0);
- assertEquals("IntegerMatrix 4x4 failed cofactor1", correctMatrix, matrix.cofactor());
- matrix = new IntegerMatrix(new int[][]{
- {1, 2, 3, 4},
- {2, 3, 4, 1},
- {3, 4, 1, 2},
- {4, 1, 2, 3}
- });
- correctMatrix = new IntegerMatrix(new int[][]{
- {-36, 4, 4, 44},
- {4, 4, 44, -36},
- {4, 44, -36, 4},
- {44, -36, 4, 4}
- });
- assertEquals("IntegerMatrix 4x4 failed cofactor2", correctMatrix, matrix.cofactor());
-
- //10x10
- //?Skipping 10x10 test because test took > 5s by itself
- /*
- matrix = new IntegerMatrix(grid10);
- correctMatrix = new IntegerMatrix(10, 10, 0);
- assertEquals("IntegerMatrix 10x10 failed cofactor1", correctMatrix, matrix.cofactor());
- */
- }
-}
+//Matrix/src/test/java/com/mattrixwv/matrix/TestIntegerMatrix.java
+//Mattrixwv
+// Created: 02-01-22
+//Modified: 02-03-22
+package com.mattrixwv.matrix;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+
+public class TestIntegerMatrix{
+ //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;
+ IntegerMatrix matrix = new IntegerMatrix(grid1);
+ assertTrue("IntegerMatrix 1x1 failed equals IntegerMatrix", matrix.equals(matrix));
+ @SuppressWarnings("unlikely-arg-type")
+ boolean gridEquals = matrix.equals(grid1);
+ assertTrue("IntegerMatrix 1x1 failed equals int[][]", gridEquals);
+
+ //2x2
+ matrix = new IntegerMatrix(grid2);
+ assertTrue("IntegerMatrix 2x2 failed equals IntegerMatrix", matrix.equals(matrix));
+ @SuppressWarnings("unlikely-arg-type")
+ boolean gridEquals2 = matrix.equals(grid2);
+ assertTrue("IntegerMatrix 2x2 failed equals int[][]", gridEquals2);
+
+ //3x3
+ matrix = new IntegerMatrix(grid3);
+ assertTrue("IntegerMatrix 3x3 failed equals IntegerMatrix", matrix.equals(matrix));
+ @SuppressWarnings("unlikely-arg-type")
+ boolean gridEquals3 = matrix.equals(grid3);
+ assertTrue("IntegerMatrix 3x3 failed equals int[][]", gridEquals3);
+
+ //4x4
+ matrix = new IntegerMatrix(grid4);
+ assertTrue("IntegerMatrix 4x4 failed equals IntegerMatrix", matrix.equals(matrix));
+ @SuppressWarnings("unlikely-arg-type")
+ boolean gridEquals4 = matrix.equals(grid4);
+ assertTrue("IntegerMatrix 4x4 failed equals int[][]", gridEquals4);
+
+ //10x10
+ matrix = new IntegerMatrix(grid10);
+ assertTrue("IntegerMatrix = 10x10 failed equals IntegerMatrix", matrix.equals(matrix));
+ @SuppressWarnings("unlikely-arg-type")
+ boolean gridEquals10 = matrix.equals(grid10);
+ assertTrue("IntegerMatrix 10x10 failed equals int[][]", gridEquals10);
+ }
+
+ @Test
+ public void testGets(){
+ //1x1
+ IntegerMatrix matrix = new IntegerMatrix(grid1);
+ assertEquals("IntegerMatrix 1x1 failed get", 1, matrix.get(0, 0));
+ //GetRow
+ IntegerMatrix correctMatrix = new IntegerMatrix(new int[][]{{1}});
+ assertEquals("IntegerMatrix 1x1 failed getRow", correctMatrix, matrix.getRow(0));
+ //GetColumn
+ correctMatrix = new IntegerMatrix(new int[][]{{1}});
+ assertEquals("IntegerMatrix 1x1 failed getColumn", correctMatrix, matrix.getCol(0));
+
+ //2x2
+ matrix = new IntegerMatrix(grid2);
+ assertEquals("IntegerMatrix 2x2 failed get", 1, matrix.get(0, 0));
+ //GetRow
+ correctMatrix = new IntegerMatrix(new int[][]{{1, 2}});
+ assertEquals("IntegerMatrix 2x2 failed getRow", correctMatrix, matrix.getRow(0));
+ //GetColumn
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1},
+ {1}
+ });
+ assertEquals("IntegerMatrix 2x2 failed getColumns", correctMatrix, matrix.getCol(0));
+
+ //3x3
+ matrix = new IntegerMatrix(grid3);
+ assertEquals("IntegerMatrix 3x3 failed get", 1, matrix.get(0, 0));
+ //GetRow
+ correctMatrix = new IntegerMatrix(new int[][]{{1, 2, 3}});
+ assertEquals("IntegerMatrix 3x3 failed getRow", correctMatrix, matrix.getRow(0));
+ //GetColumn
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1},
+ {1},
+ {1}
+ });
+ assertEquals("IntegerMatrix 3x3 failed getCol", correctMatrix, matrix.getCol(0));
+
+ //4x4
+ matrix = new IntegerMatrix(grid4);
+ assertEquals("IntegerMatrix 4x4 failed get", 1, matrix.get(0, 0));
+ //GetRow
+ correctMatrix = new IntegerMatrix(new int[][]{{1, 2, 3, 4}});
+ assertEquals("IntegerMatrix 4x4 failed getRow", correctMatrix, matrix.getRow(0));
+ //GetColumn
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1},
+ {1},
+ {1},
+ {1}
+ });
+ assertEquals("IntegerMatrix 4x4 failed getCol", correctMatrix, matrix.getCol(0));
+
+ //10x10
+ matrix = new IntegerMatrix(grid10);
+ assertEquals("IntegerMatrix 10x10 failed get", 1, matrix.get(0, 0));
+ //GetRow
+ correctMatrix = new IntegerMatrix(new int[][]{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}});
+ assertEquals("IntegerMatrix 10x10 failed getRow", correctMatrix, matrix.getRow(0));
+ //GetColumn
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1},
+ {1},
+ {1},
+ {1},
+ {1},
+ {1},
+ {1},
+ {1},
+ {1},
+ {1}
+ });
+ assertEquals("IntegerMatrix 10x10 failed getColumn", correctMatrix, matrix.getCol(0));
+ }
+
+ @Test
+ public void testSets(){
+ //1x1
+ //Set
+ IntegerMatrix matrix = new IntegerMatrix(grid1);
+ IntegerMatrix correctMatrix = null;
+ matrix.set(0, 0, 2);
+ correctMatrix = new IntegerMatrix(new int[][]{{2}});
+ assertEquals("IntegerMatrix 1x1 failed set", correctMatrix, matrix);
+ //SetRow
+ matrix.setRow(0, new int[]{0});
+ correctMatrix = new IntegerMatrix(new int[][]{{0}});
+ assertEquals("IntegerMatrix 1x1 failed setRow", correctMatrix, matrix);
+ //SetColumn
+ matrix.setCol(0, new int[]{1});
+ correctMatrix = new IntegerMatrix(new int[][]{{1}});
+ assertEquals("IntegerMatrix 1x1 failed setCol", correctMatrix, matrix);
+
+ //2x2
+ //Set
+ matrix = new IntegerMatrix(grid2);
+ matrix.set(0, 0, 3);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {3, 2},
+ {1, 2}
+ });
+ assertEquals("IntegerMatrix 2x2 failed set", correctMatrix, matrix);
+ //SetRow
+ matrix.setRow(1, new int[]{2, 1});
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {3, 2},
+ {2, 1}
+ });
+ assertEquals("IntegerMatrix 2x2 failed set row", correctMatrix, matrix);
+ //SetColumn
+ matrix = new IntegerMatrix(grid2);
+ matrix.setCol(0, new int[]{3, 3});
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {3, 2},
+ {3, 2}
+ });
+ assertEquals("IntegerMatrix 2x2 failed set row", correctMatrix, matrix);
+
+ //3x3
+ //Set
+ matrix = new IntegerMatrix(grid3);
+ matrix.set(0, 0, 3);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {3, 2, 3},
+ {1, 2, 3},
+ {1, 2, 3},
+ });
+ assertEquals("IntegerMatrix 3x3 failed set", correctMatrix, matrix);
+ //SetRow
+ matrix.setRow(0, new int[]{0, 1, 2});
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {0, 1, 2},
+ {1, 2, 3},
+ {1, 2, 3}
+ });
+ assertEquals("IntegerMatrix 3x3 failed setRow", correctMatrix, matrix);
+ //SetColumn
+ matrix.setCol(0, new int[]{0, 0, 0});
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {0, 1, 2},
+ {0, 2, 3},
+ {0, 2, 3}
+ });
+ assertEquals("IntegerMatrix 3x3 failed setColumn", correctMatrix, matrix);
+
+ //4x4
+ //Set
+ matrix = new IntegerMatrix(grid4);
+ matrix.set(0, 0, 3);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {3, 2, 3, 4},
+ {1, 2, 3, 4},
+ {1, 2, 3, 4},
+ {1, 2, 3, 4}
+ });
+ assertEquals("IntegerMatrix 4x4 failed set", correctMatrix, matrix);
+ //SetRow
+ matrix.setRow(0, new int[]{4, 3, 2, 1});
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {4, 3, 2, 1},
+ {1, 2, 3, 4},
+ {1, 2, 3, 4},
+ {1, 2, 3, 4}
+ });
+ assertEquals("IntegerMatrix 4x4 failed setRow", correctMatrix, matrix);
+ //SetColumn
+ matrix.setCol(0, new int[]{0, 0, 0, 0});
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {0, 3, 2, 1},
+ {0, 2, 3, 4},
+ {0, 2, 3, 4},
+ {0, 2, 3, 4}
+ });
+ assertEquals("IntegerMatrix 4x4 failed setCol", correctMatrix, matrix);
+
+ //10x10
+ //Set
+ matrix = new IntegerMatrix(grid10);
+ matrix.set(0, 0, 3);
+ correctMatrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 10x10 failed set", correctMatrix, matrix);
+ //SetRow
+ matrix.setRow(0, new int[]{10, 9, 8, 7, 6, 5, 4, 3, 2, 1});
+ correctMatrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 10x10 failed setRow", correctMatrix, matrix);
+ //SetColumn
+ matrix.setCol(0, new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
+ correctMatrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 10x10 failed setColumn", correctMatrix, matrix);
+ }
+
+ @Test
+ public void testAdds(){
+ //1x1
+ //AddRow
+ IntegerMatrix matrix = new IntegerMatrix(grid1);
+ IntegerMatrix correctMatrix = null;
+ matrix.addRow(new int[]{1});
+ correctMatrix = new IntegerMatrix(new int[][]{{1}, {1}});
+ assertEquals("IntegerMatrix 1x1 failed addRow", correctMatrix, matrix);
+ //AddColumn
+ matrix = new IntegerMatrix(grid1);
+ matrix.addCol(new int[]{1});
+ correctMatrix = new IntegerMatrix(new int[][]{{1, 1}});
+ assertEquals("IntegerMatrix 1x1 failed addCol", correctMatrix, matrix);
+
+ //2x2
+ //AddRow
+ matrix = new IntegerMatrix(grid2);
+ matrix.addRow(new int[]{1, 2});
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1, 2},
+ {1, 2},
+ {1, 2}
+ });
+ assertEquals("IntegerMatrix 2x2 failed set row", correctMatrix, matrix);
+ //AddColumn
+ matrix = new IntegerMatrix(grid2);
+ matrix.addCol(new int[]{3, 3});
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1, 2, 3},
+ {1, 2, 3}
+ });
+ assertEquals("IntegerMatrix 2x2 failed set row", correctMatrix, matrix);
+
+ //3x3
+ //AddRow
+ matrix = new IntegerMatrix(grid3);
+ matrix.addRow(new int[]{1, 2, 3});
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1, 2, 3},
+ {1, 2, 3},
+ {1, 2, 3},
+ {1, 2, 3}
+ });
+ assertEquals("IntegerMatrix 3x3 failed addRow", correctMatrix, matrix);
+ //AddColumn
+ matrix = new IntegerMatrix(grid3);
+ matrix.addCol(new int[]{4, 4, 4});
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1, 2, 3, 4},
+ {1, 2, 3, 4},
+ {1, 2, 3, 4}
+ });
+ assertEquals("IntegerMatrix 3x3 failed addCol", correctMatrix, matrix);
+
+ //4x4
+ //AddRow
+ matrix = new IntegerMatrix(grid4);
+ matrix.addRow(new int[]{1, 2, 3, 4});
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1, 2, 3, 4},
+ {1, 2, 3, 4},
+ {1, 2, 3, 4},
+ {1, 2, 3, 4},
+ {1, 2, 3, 4}
+ });
+ assertEquals("IntegerMatrix 4x4 failed addRow", correctMatrix, matrix);
+ //AddColumn
+ matrix.addCol(new int[]{5, 5, 5, 5, 5});
+ correctMatrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 4x4 failed addCol", correctMatrix, matrix);
+
+ //10x10
+ //AddRow
+ matrix = new IntegerMatrix(grid10);
+ matrix.addRow(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+ correctMatrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 10x10 failed addRow", correctMatrix, matrix);
+ //AddColumn
+ matrix = new IntegerMatrix(grid10);
+ matrix.addCol(new int[]{11, 11, 11, 11, 11, 11, 11, 11, 11, 11});
+ correctMatrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 10x10 failed addColumn", correctMatrix, matrix);
+ }
+
+ @Test
+ public void testAppends(){
+ //1x1
+ //appendRight
+ IntegerMatrix matrix = new IntegerMatrix(grid1);
+ IntegerMatrix secondMatrix = new IntegerMatrix(grid1);
+ IntegerMatrix correctMatrix = new IntegerMatrix(new int[][]{{1, 1}});
+ assertEquals("IntegerMatrix 1x1 failed appendRight", correctMatrix, matrix.appendRight(secondMatrix));
+ //appendBottom
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1},
+ {1}
+ });
+ assertEquals("IntegerMatrix 1x1 failed appendBottom", correctMatrix, matrix.appendBottom(secondMatrix));
+
+ //2x2
+ //appendRight
+ matrix = new IntegerMatrix(grid2);
+ secondMatrix = new IntegerMatrix(grid2);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1, 2, 1, 2},
+ {1, 2, 1, 2}
+ });
+ assertEquals("IntegerMatrix 2x2 failed appendRight", correctMatrix, matrix.appendRight(secondMatrix));
+ //appendBottom
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1, 2},
+ {1, 2},
+ {1, 2},
+ {1, 2}
+ });
+ assertEquals("IntegerMatrix 2x2 failed appendBottom", correctMatrix, matrix.appendBottom(secondMatrix));
+
+ //3x3
+ //appendRight
+ matrix = new IntegerMatrix(grid3);
+ secondMatrix = new IntegerMatrix(grid3);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1, 2, 3, 1, 2, 3},
+ {1, 2, 3, 1, 2, 3},
+ {1, 2, 3, 1, 2, 3}
+ });
+ assertEquals("IntegerMatrix 3x3 failed appendRight", correctMatrix, matrix.appendRight(secondMatrix));
+ //appendBottom
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1, 2, 3},
+ {1, 2, 3},
+ {1, 2, 3},
+ {1, 2, 3},
+ {1, 2, 3},
+ {1, 2, 3}
+ });
+ assertEquals("IntegerMatrix 3x3 failed appendBottom", correctMatrix, matrix.appendBottom(secondMatrix));
+
+ //4x4
+ //appendRight
+ matrix = new IntegerMatrix(grid4);
+ secondMatrix = new IntegerMatrix(grid4);
+ correctMatrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 4x4 failed appendRight", correctMatrix, matrix.appendRight(secondMatrix));
+ //appendBottom
+ correctMatrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 4x4 failed appendBottom", correctMatrix, matrix.appendBottom(secondMatrix));
+
+ //10x10
+ //appendRight
+ matrix = new IntegerMatrix(grid10);
+ secondMatrix = new IntegerMatrix(grid10);
+ correctMatrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 10x10 failed appendRight", correctMatrix, matrix.appendRight(secondMatrix));
+ //appendBottom
+ correctMatrix = new IntegerMatrix(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},
+ });
+ assertEquals("IntegerMatrix 10x10 failed appendBottom", correctMatrix, matrix.appendBottom(secondMatrix));
+ }
+
+ @Test
+ public void testAddition(){
+ //1x1
+ IntegerMatrix matrix = new IntegerMatrix(grid1);
+ IntegerMatrix transformMatrix = new IntegerMatrix(transformGrid1_1);
+ IntegerMatrix correctMatrix = new IntegerMatrix(new int[][]{{2}});
+ assertEquals("IntegerMatrix 1x1 failed add IntegerMatrix", correctMatrix, matrix.add(transformMatrix));
+ assertEquals("IntegerMatrix 1x1 failed add scalar", correctMatrix, matrix.add(1));
+
+ //2x2
+ matrix = new IntegerMatrix(grid2);
+ transformMatrix = new IntegerMatrix(transformGrid2_1);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {2, 2},
+ {2, 2}
+ });
+ assertEquals("IntegerMatrix 2x2 failed add IntegerMatrix", correctMatrix, matrix.add(transformMatrix));
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {2, 3},
+ {2, 3}
+ });
+ assertEquals("IntegerMatrix 2x2 failed add scalar", correctMatrix, matrix.add(1));
+
+ //3x3
+ matrix = new IntegerMatrix(grid3);
+ transformMatrix = new IntegerMatrix(transformGrid3_1);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {3, 3, 3},
+ {3, 3, 3},
+ {3, 3, 3}
+ });
+ assertEquals("IntegerMatrix 3x3 failed add IntegerMatrix", correctMatrix, matrix.add(transformMatrix));
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {2, 3, 4},
+ {2, 3, 4},
+ {2, 3, 4}
+ });
+ assertEquals("IntegerMatrix 3x3 failed add scalar", correctMatrix, matrix.add(1));
+
+ //4x4
+ matrix = new IntegerMatrix(grid4);
+ transformMatrix = new IntegerMatrix(transformGrid4_1);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {4, 4, 4, 4},
+ {4, 4, 4, 4},
+ {4, 4, 4, 4},
+ {4, 4, 4, 4}
+ });
+ assertEquals("IntegerMatrix 4x4 failed add IntegerMatrix", correctMatrix, matrix.add(transformMatrix));
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {2, 3, 4, 5},
+ {2, 3, 4, 5},
+ {2, 3, 4, 5},
+ {2, 3, 4, 5}
+ });
+ assertEquals("IntegerMatrix 4x4 failed add scalar", correctMatrix, matrix.add(1));
+
+ //10x10
+ matrix = new IntegerMatrix(grid10);
+ transformMatrix = new IntegerMatrix(transformGrid10_1);
+ correctMatrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 5x5 failed add IntegerMatrix", correctMatrix, matrix.add(transformMatrix));
+ correctMatrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 10x10 failed add IntegerMatrix", correctMatrix, matrix.add(1));
+ }
+
+ @Test
+ public void testSubtraction(){
+ //1x1
+ IntegerMatrix matrix = new IntegerMatrix(grid1);
+ IntegerMatrix transformMatrix = new IntegerMatrix(transformGrid1_1);
+ IntegerMatrix correctMatrix = new IntegerMatrix(new int[][]{
+ {0}
+ });
+ assertEquals("IntegerMatrix 1x1 failed subtract IntegerMatrix", correctMatrix, matrix.subtract(transformMatrix));
+ assertEquals("IntegerMatrix 1x1 failed subtract scalar", correctMatrix, matrix.subtract(1));
+
+ //2x2
+ matrix = new IntegerMatrix(grid2);
+ transformMatrix = new IntegerMatrix(grid2);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {0, 0},
+ {0, 0}
+ });
+ assertEquals("IntegerMatrix 2x2 failed subtract IntegerMatrix", correctMatrix, matrix.subtract(transformMatrix));
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {0, 1},
+ {0, 1}
+ });
+ assertEquals("IntegerMatrix 2x2 failed subtract scalar", correctMatrix, matrix.subtract(1));
+
+ //3x3
+ matrix = new IntegerMatrix(grid3);
+ transformMatrix = new IntegerMatrix(grid3);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0}
+ });
+ assertEquals("IntegerMatrix 3x3 failed subtract IntegerMatrix", correctMatrix, matrix.subtract(transformMatrix));
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {0, 1, 2},
+ {0, 1, 2},
+ {0, 1, 2}
+ });
+ assertEquals("IntegerMatrix 3x3 failed subtract scalar", correctMatrix, matrix.subtract(1));
+
+ //4x4
+ matrix = new IntegerMatrix(grid4);
+ transformMatrix = new IntegerMatrix(grid4);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {0, 0, 0, 0},
+ {0, 0, 0, 0},
+ {0, 0, 0, 0},
+ {0, 0, 0, 0}
+ });
+ assertEquals("IntegerMatrix 4x4 failed subtract IntegerMatrix", correctMatrix, matrix.subtract(transformMatrix));
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {0, 1, 2, 3},
+ {0, 1, 2, 3},
+ {0, 1, 2, 3},
+ {0, 1, 2, 3}
+ });
+ assertEquals("IntegerMatrix 4x4 failed subtract scalar", correctMatrix, matrix.subtract(1));
+
+ //10x10
+ matrix = new IntegerMatrix(grid10);
+ transformMatrix = new IntegerMatrix(grid10);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+ });
+ assertEquals("IntegerMatrix 10x10 failed subtract IntegerMatrix", correctMatrix, matrix.subtract(transformMatrix));
+ correctMatrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 10x10 failed subtract scalar", correctMatrix, matrix.subtract(1));
+ }
+
+ @Test
+ public void testMultiplication(){
+ //1x1
+ IntegerMatrix matrix = new IntegerMatrix(grid1);
+ IntegerMatrix transformMatrix = new IntegerMatrix(transformGrid1_2);
+ IntegerMatrix correctMatrix = new IntegerMatrix(transformGrid1_2);
+ assertEquals("IntegerMatrix 1x1 failed multiplication IntegerMatrix", correctMatrix, matrix.multiply(transformMatrix));
+ assertEquals("IntegerMatrix 1x1 failed multiplication scalar", correctMatrix, matrix.multiply(2));
+
+ //2x2
+ matrix = new IntegerMatrix(grid2);
+ transformMatrix = new IntegerMatrix(transformGrid2_2);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {6, 9},
+ {6, 9}
+ });
+ assertEquals("IntegerMatrix 2x2 failed multiplication IntegerMatrix", correctMatrix, matrix.multiply(transformMatrix));
+ IntegerMatrix vector = new IntegerMatrix(new int[][]{
+ {2},
+ {3}
+ });
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {8},
+ {8}
+ });
+ assertEquals("IntegerMatrix 2x2 failed multiplication vector", correctMatrix, matrix.multiply(vector));
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {2, 4},
+ {2, 4}
+ });
+ assertEquals("IntegerMatrix 2x2 failed multiplication scalar", correctMatrix, matrix.multiply(2));
+
+ //3x3
+ matrix = new IntegerMatrix(grid3);
+ transformMatrix = new IntegerMatrix(transformGrid3_2);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {12, 18, 24},
+ {12, 18, 24},
+ {12, 18, 24}
+ });
+ assertEquals("IntegerMatrix 3x3 failed multiplication IntegerMatrix", correctMatrix, matrix.multiply(transformMatrix));
+ vector = new IntegerMatrix(new int[][]{
+ {2},
+ {3},
+ {4}
+ });
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {20},
+ {20},
+ {20}
+ });
+ assertEquals("IntegerMatrix 3x3 failed multiplication vector", correctMatrix, matrix.multiply(vector));
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {2, 4, 6},
+ {2, 4, 6},
+ {2, 4, 6}
+ });
+ assertEquals("IntegerMatrix 3x3 failed multiplication scalar", correctMatrix, matrix.multiply(2));
+
+ //4x4
+ matrix = new IntegerMatrix(grid4);
+ transformMatrix = new IntegerMatrix(transformGrid4_2);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {20, 30, 40, 50},
+ {20, 30, 40, 50},
+ {20, 30, 40, 50},
+ {20, 30, 40, 50},
+ });
+ assertEquals("IntegerMatrix 4x4 failed multiplication IntegerMatrix", correctMatrix, matrix.multiply(transformMatrix));
+ vector = new IntegerMatrix(new int[][]{
+ {2},
+ {3},
+ {4},
+ {5}
+ });
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {40},
+ {40},
+ {40},
+ {40}
+ });
+ assertEquals("IntegerMatrix 4x4 failed multiplication vector", correctMatrix, matrix.multiply(vector));
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {2, 4, 6, 8},
+ {2, 4, 6, 8},
+ {2, 4, 6, 8},
+ {2, 4, 6, 8}
+ });
+ assertEquals("IntegerMatrix 4x4 failed multiplication scalar", correctMatrix, matrix.multiply(2));
+
+ //10x10
+ matrix = new IntegerMatrix(grid10);
+ transformMatrix = new IntegerMatrix(transformGrid10_2);
+ correctMatrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 10x10 failed multiplication IntegerMatrix", correctMatrix, matrix.multiply(transformMatrix));
+ vector = new IntegerMatrix(new int[][]{
+ {2},
+ {3},
+ {4},
+ {5},
+ {6},
+ {7},
+ {8},
+ {9},
+ {10},
+ {11}
+ });
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {440},
+ {440},
+ {440},
+ {440},
+ {440},
+ {440},
+ {440},
+ {440},
+ {440},
+ {440}
+ });
+ assertEquals("IntegerMatrix 10x10 failed multiplication vector", correctMatrix, matrix.multiply(vector));
+ correctMatrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 10x10 failed multiplication scalar", correctMatrix, matrix.multiply(2));
+ }
+
+ @Test
+ public void testDotProduct(){
+ //1x1
+ IntegerMatrix matrix = new IntegerMatrix(grid1);
+ IntegerMatrix transformMatrix = new IntegerMatrix(transformGrid1_2);
+ assertEquals("IntegerMatrix 1x1 failed dot product IntegerMatrix", 2, matrix.dotProduct(transformMatrix));
+
+ //2x2
+ matrix = new IntegerMatrix(grid2);
+ transformMatrix = new IntegerMatrix(transformGrid2_2);
+ assertEquals("IntegerMatrix 2x2 failed dot product IntegerMatrix", 30, matrix.dotProduct(transformMatrix));
+
+ //3x3
+ matrix = new IntegerMatrix(grid3);
+ transformMatrix = new IntegerMatrix(transformGrid3_2);
+ assertEquals("IntegerMatrix 3x3 failed dot product IntegerMatrix", 162, matrix.dotProduct(transformMatrix));
+
+ //4x4
+ matrix = new IntegerMatrix(grid4);
+ transformMatrix = new IntegerMatrix(transformGrid4_2);
+ assertEquals("IntegerMatrix 4x4 failed dot product IntegerMatrix", 560, matrix.dotProduct(transformMatrix));
+
+ //10x10
+ matrix = new IntegerMatrix(grid10);
+ transformMatrix = new IntegerMatrix(transformGrid10_2);
+ assertEquals("IntegerMatrix 10x10 failed dot product IntegerMatrix", 35750, matrix.dotProduct(transformMatrix));
+ }
+
+ @Test
+ public void testHadamardProduct(){
+ //1x1
+ IntegerMatrix matrix = new IntegerMatrix(grid1);
+ IntegerMatrix transformMatrix = new IntegerMatrix(transformGrid1_2);
+ IntegerMatrix correctMatrix = new IntegerMatrix(new int[][]{{2}});
+ assertEquals("IntegerMatrix 1x1 failed dot product IntegerMatrix", correctMatrix, matrix.hadamardProduct(transformMatrix));
+
+ //2x2
+ matrix = new IntegerMatrix(grid2);
+ transformMatrix = new IntegerMatrix(transformGrid2_2);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {2, 6},
+ {2, 6}
+ });
+ assertEquals("IntegerMatrix 2x2 failed dot product IntegerMatrix", correctMatrix, matrix.hadamardProduct(transformMatrix));
+
+ //3x3
+ matrix = new IntegerMatrix(grid3);
+ transformMatrix = new IntegerMatrix(transformGrid3_2);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {2, 6, 12},
+ {2, 6, 12},
+ {2, 6, 12}
+ });
+ assertEquals("IntegerMatrix 3x3 failed dot product IntegerMatrix", correctMatrix, matrix.hadamardProduct(transformMatrix));
+
+ //4x4
+ matrix = new IntegerMatrix(grid4);
+ transformMatrix = new IntegerMatrix(transformGrid4_2);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {2, 6, 12, 20},
+ {2, 6, 12, 20},
+ {2, 6, 12, 20},
+ {2, 6, 12, 20}
+ });
+ assertEquals("IntegerMatrix 4x4 failed dot product IntegerMatrix", correctMatrix, matrix.hadamardProduct(transformMatrix));
+
+ //10x10
+ matrix = new IntegerMatrix(grid10);
+ transformMatrix = new IntegerMatrix(transformGrid10_2);
+ correctMatrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 10x10 failed dot product IntegerMatrix", correctMatrix, matrix.hadamardProduct(transformMatrix));
+ }
+
+ @Test
+ public void testTranspose(){
+ //1x1
+ IntegerMatrix matrix = new IntegerMatrix(grid1);
+ IntegerMatrix correctMatrix = new IntegerMatrix(new int[][]{{1}});
+ assertEquals("IntegerMatrix 1x1 failed transpose", correctMatrix, matrix.transpose());
+
+ //2x2
+ matrix = new IntegerMatrix(grid2);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1, 1},
+ {2, 2}
+ });
+ assertEquals("IntegerMatrix 2x2 failed transpose", correctMatrix, matrix.transpose());
+
+ //3x3
+ matrix = new IntegerMatrix(grid3);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1, 1, 1},
+ {2, 2, 2},
+ {3, 3, 3}
+ });
+ assertEquals("IntegerMatrix 3x3 failed transpose", correctMatrix, matrix.transpose());
+
+ //4x4
+ matrix = new IntegerMatrix(grid4);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {1, 1, 1, 1},
+ {2, 2, 2, 2},
+ {3, 3, 3, 3},
+ {4, 4, 4, 4}
+ });
+ assertEquals("IntegerMatrix 4x4 failed transpose", correctMatrix, matrix.transpose());
+
+ //10x10
+ matrix = new IntegerMatrix(grid10);
+ correctMatrix = new IntegerMatrix(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},
+ });
+ assertEquals("IntegerMatrix 10x10 failed transpose", correctMatrix, matrix.transpose());
+ }
+
+ @Test
+ public void testDeterminant(){
+ //1x1
+ IntegerMatrix matrix = new IntegerMatrix(grid1);
+ assertEquals("IntegerMatrix 1x1 failed determinant", 1, matrix.determinant());
+
+ //2x2
+ matrix = new IntegerMatrix(grid2);
+ assertEquals("IntegerMatrix 2x2 failed determinant1", 0, matrix.determinant());
+ matrix = new IntegerMatrix(new int[][]{
+ {1, 4},
+ {4, 1}
+ });
+ assertEquals("IntegerMatrix 2x2 failed determinant2", -15, matrix.determinant());
+
+ //3x3
+ matrix = new IntegerMatrix(grid3);
+ assertEquals("IntegerMatrix 3x3 failed determinant1", 0, matrix.determinant());
+ matrix = new IntegerMatrix(new int[][]{
+ {1, 4, 2},
+ {2, 4, 1},
+ {4, 1, 2}
+ });
+ assertEquals("IntegerMatrix 3x3 failed determinant2", -21, matrix.determinant());
+
+ //4x4
+ matrix = new IntegerMatrix(grid4);
+ assertEquals("IntegerMatrix 4x4 failed determiant1", 0, matrix.determinant());
+ matrix = new IntegerMatrix(new int[][]{
+ {1, 2, 3, 4},
+ {2, 3, 4, 1},
+ {3, 4, 1, 2},
+ {4, 1, 2, 3}
+ });
+ assertEquals("IntegerMatrix 4x4 failed determinant2", 160, matrix.determinant());
+
+ //10x10
+ matrix = new IntegerMatrix(grid10);
+ assertEquals("IntegerMatrix 10x10 failed determinant1", 0, matrix.determinant());
+ matrix = new IntegerMatrix(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}
+ });
+ assertEquals("IntegerMatrix 10x10 failed determinant2", -10000000, matrix.determinant());
+ }
+
+ @Test
+ public void testCofactor(){
+ //1x1
+ IntegerMatrix matrix = new IntegerMatrix(grid1);
+ IntegerMatrix correctMatrix = new IntegerMatrix(grid1);
+ assertEquals("IntegerMatrix 1x1 failed cofactor", correctMatrix, matrix.cofactor());
+
+ //2x2
+ matrix = new IntegerMatrix(grid2);
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {2, -1},
+ {-2, 1}
+ });
+ assertEquals("IntegerMatrix 2x2 failed cofactor", correctMatrix, matrix.cofactor());
+
+ //3x3
+ matrix = new IntegerMatrix(grid3);
+ correctMatrix = new IntegerMatrix(3, 3, 0);
+ assertEquals("IntegerMatrix 3x3 failed cofactor1", correctMatrix, matrix.cofactor());
+ matrix = new IntegerMatrix(new int[][]{
+ {1, 4, 2},
+ {2, 4, 1},
+ {4, 1, 2}
+ });
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {7, 0, -14},
+ {-6, -6, 15},
+ {-4, 3, -4}
+ });
+ assertEquals("IntegerMatrix 3x3 failed cofactor2", correctMatrix, matrix.cofactor());
+
+ //4x4
+ matrix = new IntegerMatrix(grid4);
+ correctMatrix = new IntegerMatrix(4, 4, 0);
+ assertEquals("IntegerMatrix 4x4 failed cofactor1", correctMatrix, matrix.cofactor());
+ matrix = new IntegerMatrix(new int[][]{
+ {1, 2, 3, 4},
+ {2, 3, 4, 1},
+ {3, 4, 1, 2},
+ {4, 1, 2, 3}
+ });
+ correctMatrix = new IntegerMatrix(new int[][]{
+ {-36, 4, 4, 44},
+ {4, 4, 44, -36},
+ {4, 44, -36, 4},
+ {44, -36, 4, 4}
+ });
+ assertEquals("IntegerMatrix 4x4 failed cofactor2", correctMatrix, matrix.cofactor());
+
+ //10x10
+ //?Skipping 10x10 test because test took > 5s by itself
+ /*
+ matrix = new IntegerMatrix(grid10);
+ correctMatrix = new IntegerMatrix(10, 10, 0);
+ assertEquals("IntegerMatrix 10x10 failed cofactor1", correctMatrix, matrix.cofactor());
+ */
+ }
+}