mirror of
https://bitbucket.org/Mattrixwv/matrix.git
synced 2025-12-06 15:03:58 -05:00
Added start of integer matrix
This commit is contained in:
85
pom.xml
Normal file
85
pom.xml
Normal file
@@ -0,0 +1,85 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
|
||||
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
|
||||
<groupId>com.mattrixwv</groupId>
|
||||
<artifactId>Matrix</artifactId>
|
||||
<version>1.0-SNAPSHOT</version>
|
||||
|
||||
<name>Matrix</name>
|
||||
<url>https://www.mattrixwv.com</url>
|
||||
|
||||
<properties>
|
||||
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
|
||||
<maven.compiler.source>11</maven.compiler.source>
|
||||
<maven.compiler.target>11</maven.compiler.target>
|
||||
<java.version>11</java.version>
|
||||
</properties>
|
||||
|
||||
<dependencies>
|
||||
<dependency>
|
||||
<groupId>junit</groupId>
|
||||
<artifactId>junit</artifactId>
|
||||
<version>4.13.2</version>
|
||||
<scope>test</scope>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
<build>
|
||||
<plugins>
|
||||
<!--Ensure maven is the correct version-->
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-enforcer-plugin</artifactId>
|
||||
<version>3.0.0-M3</version>
|
||||
<executions>
|
||||
<execution>
|
||||
<id>enforce-maven</id>
|
||||
<goals>
|
||||
<goal>enforce</goal>
|
||||
</goals>
|
||||
<configuration>
|
||||
<rules>
|
||||
<requireMavenVersion>
|
||||
<version>3.6.3</version>
|
||||
</requireMavenVersion>
|
||||
</rules>
|
||||
</configuration>
|
||||
</execution>
|
||||
</executions>
|
||||
</plugin>
|
||||
<!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
|
||||
<plugin>
|
||||
<artifactId>maven-clean-plugin</artifactId>
|
||||
<version>3.1.0</version>
|
||||
</plugin>
|
||||
<plugin>
|
||||
<artifactId>maven-compiler-plugin</artifactId>
|
||||
<version>3.8.1</version>
|
||||
</plugin>
|
||||
<plugin>
|
||||
<artifactId>maven-surefire-plugin</artifactId>
|
||||
<version>3.0.0-M5</version>
|
||||
</plugin>
|
||||
<plugin>
|
||||
<artifactId>maven-jar-plugin</artifactId>
|
||||
<version>3.2.0</version>
|
||||
</plugin>
|
||||
<plugin>
|
||||
<artifactId>maven-install-plugin</artifactId>
|
||||
<version>3.0.0-M1</version>
|
||||
</plugin>
|
||||
<!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
|
||||
<plugin>
|
||||
<artifactId>maven-site-plugin</artifactId>
|
||||
<version>3.9.1</version>
|
||||
</plugin>
|
||||
<plugin>
|
||||
<artifactId>maven-project-info-reports-plugin</artifactId>
|
||||
<version>3.1.1</version>
|
||||
</plugin>
|
||||
</plugins>
|
||||
</build>
|
||||
</project>
|
||||
455
src/main/java/com/mattrixwv/matrix/IntegerMatrix.java
Normal file
455
src/main/java/com/mattrixwv/matrix/IntegerMatrix.java
Normal file
@@ -0,0 +1,455 @@
|
||||
//Matrix/src/main/java/com/mattrixwv/IntegerMatrix.java
|
||||
//Mattrixwv
|
||||
// Created: 02-01-22
|
||||
//Modified: 02-01-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{
|
||||
private int[][] grid;
|
||||
|
||||
//Helper functions
|
||||
private 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;
|
||||
}
|
||||
}
|
||||
private 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;
|
||||
}
|
||||
|
||||
//Constructors
|
||||
public IntegerMatrix(){
|
||||
grid = new int[0][0];
|
||||
}
|
||||
public IntegerMatrix(int[][]grid){
|
||||
setGrid(grid);
|
||||
}
|
||||
public IntegerMatrix(IntegerMatrix matrix){
|
||||
setGrid(matrix.grid);
|
||||
}
|
||||
|
||||
//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 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];
|
||||
}
|
||||
}
|
||||
//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 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[0].length + 1];
|
||||
for(int workingCol = 0;workingCol < grid[0].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];
|
||||
}
|
||||
}
|
||||
|
||||
//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
|
||||
|
||||
//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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
//Matrix/src/main/java/com/mattrixwv/exceptions/InvalidCoordinates.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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +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);
|
||||
}
|
||||
}
|
||||
643
src/test/java/com/mattrixwv/matrix/TestIntegerMatrix.java
Normal file
643
src/test/java/com/mattrixwv/matrix/TestIntegerMatrix.java
Normal file
@@ -0,0 +1,643 @@
|
||||
//Matrix/src/test/java/com/mattrixwv/matrix/TestIntegerMatrix.java
|
||||
//Mattrixwv
|
||||
// Created: 02-01-22
|
||||
//Modified: 02-02-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 testGetsSetsAdds(){
|
||||
//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));
|
||||
//Set
|
||||
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);
|
||||
//AddRow
|
||||
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
|
||||
matrix = new IntegerMatrix(grid2);
|
||||
assertEquals("IntegerMatrix 2x2 failed get", 1, matrix.get(0, 0));
|
||||
//GetRow
|
||||
//GetColumn
|
||||
//Set
|
||||
//SetRow
|
||||
//SetColumn
|
||||
//AddRow
|
||||
//AddColumn
|
||||
|
||||
|
||||
//3x3
|
||||
matrix = new IntegerMatrix(grid3);
|
||||
assertEquals("IntegerMatrix 3x3 failed get", 1, matrix.get(0, 0));
|
||||
//GetRow
|
||||
//GetColumn
|
||||
//Set
|
||||
//SetRow
|
||||
//SetColumn
|
||||
//AddRow
|
||||
//AddColumn
|
||||
|
||||
|
||||
//4x4
|
||||
matrix = new IntegerMatrix(grid4);
|
||||
assertEquals("IntegerMatrix 4x4 failed get", 1, matrix.get(0, 0));
|
||||
//GetRow
|
||||
//GetColumn
|
||||
//Set
|
||||
//SetRow
|
||||
//SetColumn
|
||||
//AddRow
|
||||
//AddColumn
|
||||
|
||||
|
||||
//10x10
|
||||
matrix = new IntegerMatrix(grid10);
|
||||
assertEquals("IntegerMatrix 10x10 failed get", 1, matrix.get(0, 0));
|
||||
//GetRow
|
||||
//GetColumn
|
||||
//Set
|
||||
//SetRow
|
||||
//SetColumn
|
||||
//AddRow
|
||||
//AddColumn
|
||||
}
|
||||
|
||||
@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));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user