Christian Baltzer
6 years ago
12 changed files with 1207 additions and 9 deletions
-
12src/main/java/com/ugsbo/gui/BasicGuiController.java
-
12src/main/java/com/ugsbo/gui/MainApp.java
-
273src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
-
97src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java
-
228src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
-
4src/main/resources/com/ugsbo/gui/BasicGui.fxml
-
37src/main/resources/com/ugsbo/gui/matrixCalcGui.fxml
-
156src/test/java/com/ugsbo/matrixcalc/MatrixAdditionAndSubstractionTest.java
-
61src/test/java/com/ugsbo/matrixcalc/MatrixCalcDeterminatTest.java
-
170src/test/java/com/ugsbo/matrixcalc/MatrixIOUtilsTest.java
-
109src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
-
57src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java
@ -0,0 +1,273 @@ |
|||
package com.ugsbo.matrixcalc; |
|||
|
|||
import javafx.fxml.FXML; |
|||
import javafx.scene.control.*; |
|||
import javafx.scene.text.Text; |
|||
import javafx.scene.text.TextAlignment; |
|||
|
|||
import java.util.ArrayList; |
|||
|
|||
public class MatrixCalcController { |
|||
|
|||
private static final String MULTIPLICATION_STRING = "multiplication"; |
|||
private static final String ADDITION_STRING = "addition"; |
|||
private static final String SUBSTRACTION_STRING = "substract"; |
|||
private static final String TRANPOSE_STRING = "transpose"; |
|||
private static final String CALCDETERMINAT_STRING = "calcDeterminate"; |
|||
|
|||
// The fx:id Attributes will be bind here. |
|||
@FXML |
|||
private Button multiplyButton, addButton, DetAButton, DetBButton, substractButton, transposeButton; |
|||
@FXML |
|||
private Text errorText, outputText; |
|||
@FXML |
|||
private TextArea matrixATextArea, matrixBTextArea; |
|||
|
|||
private MatrixCalcMath math = new MatrixCalcMath(); |
|||
private MatrixCalcIOUtils util = new MatrixCalcIOUtils(); |
|||
|
|||
/** |
|||
* Konstructor is called before initialize() |
|||
*/ |
|||
public MatrixCalcController() { |
|||
// Setup of some Fields could be defined here. |
|||
} |
|||
|
|||
/** |
|||
* Initializes the controller class. This method is automatically called after |
|||
* the fxml file has been loaded. |
|||
*/ |
|||
@FXML |
|||
public void initialize() { |
|||
/** |
|||
* Convert Strings to matricies, multiply them and output the result. |
|||
*/ |
|||
multiplyButton.setOnMouseClicked((event) -> { |
|||
String stringMatrixA = matrixATextArea.getText(); |
|||
String stringMatrixB = matrixBTextArea.getText(); |
|||
String[] stringMatrix = { stringMatrixA, stringMatrixB }; |
|||
|
|||
checkInputAndDisplayIfInputIsNotValid(stringMatrix, 2); |
|||
|
|||
ArrayList<double[][]> matricies = new ArrayList<double[][]>(); |
|||
matricies.add(util.stringToMatrix(stringMatrixA)); |
|||
matricies.add(util.stringToMatrix(stringMatrixB)); |
|||
|
|||
invokeOperation(matricies, MULTIPLICATION_STRING); |
|||
}); |
|||
|
|||
/** |
|||
* Convert a String to a matrix, transpose it and output the result. |
|||
*/ |
|||
transposeButton.setOnMouseClicked((event) -> { |
|||
String stringMatrixA = matrixATextArea.getText(); |
|||
String[] stringMatrix = { stringMatrixA, "" }; |
|||
|
|||
checkInputAndDisplayIfInputIsNotValid(stringMatrix, 1); |
|||
|
|||
ArrayList<double[][]> matricies = new ArrayList<double[][]>(); |
|||
matricies.add(util.stringToMatrix(stringMatrixA)); |
|||
|
|||
invokeOperation(matricies, TRANPOSE_STRING); |
|||
}); |
|||
|
|||
/** |
|||
* Convert Strings to matricies, add them and output the result. |
|||
*/ |
|||
addButton.setOnMouseClicked((event) -> { |
|||
String stringMatrixA = matrixATextArea.getText(); |
|||
String stringMatrixB = matrixBTextArea.getText(); |
|||
String[] stringMatrix = { stringMatrixA, stringMatrixB }; |
|||
|
|||
checkInputAndDisplayIfInputIsNotValid(stringMatrix, 2); |
|||
|
|||
ArrayList<double[][]> matricies = new ArrayList<double[][]>(); |
|||
matricies.add(util.stringToMatrix(stringMatrixA)); |
|||
matricies.add(util.stringToMatrix(stringMatrixB)); |
|||
|
|||
invokeOperation(matricies, ADDITION_STRING); |
|||
}); |
|||
|
|||
/** |
|||
* Convert Strings to matricies, substract them and output the result. |
|||
*/ |
|||
substractButton.setOnMouseClicked((event) -> { |
|||
String stringMatrixA = matrixATextArea.getText(); |
|||
String stringMatrixB = matrixBTextArea.getText(); |
|||
String[] stringMatrix = { stringMatrixA, stringMatrixB }; |
|||
|
|||
checkInputAndDisplayIfInputIsNotValid(stringMatrix, 2); |
|||
|
|||
ArrayList<double[][]> matricies = new ArrayList<double[][]>(); |
|||
matricies.add(util.stringToMatrix(stringMatrixA)); |
|||
matricies.add(util.stringToMatrix(stringMatrixB)); |
|||
|
|||
invokeOperation(matricies, SUBSTRACTION_STRING); |
|||
}); |
|||
|
|||
/** |
|||
* Convert the String of the left inputField to a matrix, calculate the Determinate and output it. |
|||
*/ |
|||
DetAButton.setOnMouseClicked((event) -> { |
|||
String stringMatrixA = matrixATextArea.getText(); |
|||
String[] stringMatrix = { stringMatrixA, "" }; |
|||
|
|||
checkInputAndDisplayIfInputIsNotValid(stringMatrix, 1); |
|||
|
|||
ArrayList<double[][]> matricies = new ArrayList<double[][]>(); |
|||
matricies.add(util.stringToMatrix(stringMatrixA)); |
|||
|
|||
invokeOperation(matricies, CALCDETERMINAT_STRING); |
|||
}); |
|||
|
|||
/** |
|||
* Convert the String of the right inputField to a matrix, calculate the Determinate and output it. |
|||
*/ |
|||
DetBButton.setOnMouseClicked((event) -> { |
|||
String stringMatrixB = matrixBTextArea.getText(); |
|||
String[] stringMatrix = { "", stringMatrixB }; |
|||
|
|||
checkInputAndDisplayIfInputIsNotValid(stringMatrix, 1); |
|||
|
|||
ArrayList<double[][]> matricies = new ArrayList<double[][]>(); |
|||
matricies.add(util.stringToMatrix(stringMatrixB)); |
|||
|
|||
invokeOperation(matricies, CALCDETERMINAT_STRING); |
|||
}); |
|||
} |
|||
|
|||
/** |
|||
* Invokes the needed operations form the MatrixCalcMath class |
|||
* @param matricies Contains both Matricies or onely one Matrix |
|||
* @param operation One of the global Constats to select wich Operation is needed. |
|||
*/ |
|||
private void invokeOperation(ArrayList<double[][]> matricies, String operation) { |
|||
if (matricies.size() == 2) { |
|||
if (operation.equals(MULTIPLICATION_STRING)) { |
|||
try { |
|||
double[][] result = math.matrixMultiplication(matricies.get(0), matricies.get(1)); |
|||
|
|||
String DisplayableString = util.outputMatrixToOutputText(result); |
|||
|
|||
outputText.setText(DisplayableString); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} catch (IllegalArgumentException e) { |
|||
|
|||
outputText.setText(e.getMessage()); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} |
|||
} else if (operation.equals(ADDITION_STRING)) { |
|||
try { |
|||
double[][] result = math.matrixAddition(matricies.get(0), matricies.get(1)); |
|||
|
|||
String DisplayableString = util.outputMatrixToOutputText(result); |
|||
|
|||
outputText.setText(DisplayableString); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} catch (IllegalArgumentException e) { |
|||
|
|||
outputText.setText(e.getMessage()); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} |
|||
} else if (operation.equals(SUBSTRACTION_STRING)) { |
|||
try { |
|||
double[][] result = math.matrixSubstraction(matricies.get(0), matricies.get(1)); |
|||
|
|||
String DisplayableString = util.outputMatrixToOutputText(result); |
|||
|
|||
outputText.setText(DisplayableString); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} catch (IllegalArgumentException e) { |
|||
|
|||
outputText.setText(e.getMessage()); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} |
|||
} |
|||
}else if (matricies.size() == 1) { |
|||
if (operation.equals(TRANPOSE_STRING)) { |
|||
try { |
|||
double[][] result = math.matrixTransponation(matricies.get(0)); |
|||
|
|||
String DisplayableString = util.outputMatrixToOutputText(result); |
|||
|
|||
outputText.setText(DisplayableString); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} catch (IllegalArgumentException e) { |
|||
|
|||
outputText.setText(e.getMessage()); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} |
|||
} |
|||
if (operation.equals(CALCDETERMINAT_STRING)) { |
|||
try { |
|||
double result = math.calcDeterminat(matricies.get(0)); |
|||
|
|||
String DisplayableString = Double.toString(result); |
|||
|
|||
outputText.setText(DisplayableString); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} catch (IllegalArgumentException e) { |
|||
|
|||
outputText.setText(e.getMessage()); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} catch (Exception e){ |
|||
|
|||
outputText.setText(e.getMessage()); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Checks the Input and Displays it if the Input is valid. |
|||
* |
|||
* @param stringMatrix Contains both input matrices if |
|||
* numberOfMarriciesToMatch is 2. If the number |
|||
* is 1 than one of them has to be a empty String |
|||
* @param numberOfMatricesToMatch If the number is 1 onely one Marix will be |
|||
* verifyed and the other one needs to be an empty |
|||
* String in the stringMatrix |
|||
*/ |
|||
private void checkInputAndDisplayIfInputIsNotValid(String[] stringMatrix, int numberOfMatricesToMatch) { |
|||
if (numberOfMatricesToMatch == 1 && !stringMatrix[0].equals("")) { |
|||
try { |
|||
util.checkInput(stringMatrix[0]); |
|||
} catch (Exception e) { |
|||
outputText.setText(e.getMessage() + "A"); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} |
|||
} else if (numberOfMatricesToMatch == 1 && !stringMatrix[1].equals("")) { |
|||
try { |
|||
util.checkInput(stringMatrix[1]); |
|||
} catch (Exception e) { |
|||
outputText.setText(e.getMessage() + "B"); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} |
|||
} else if (numberOfMatricesToMatch == 2 && !stringMatrix[0].equals("") && !stringMatrix[1].equals("")) { |
|||
try { |
|||
util.checkInput(stringMatrix[0]); |
|||
} catch (Exception e) { |
|||
outputText.setText(e.getMessage() + "A"); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} |
|||
|
|||
try { |
|||
util.checkInput(stringMatrix[1]); |
|||
} catch (Exception e) { |
|||
outputText.setText(e.getMessage() + "B"); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} |
|||
} else if (stringMatrix[0].equals("")) { |
|||
|
|||
outputText.setText("Pease insert MatrixA"); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
|
|||
} else if (stringMatrix[1].equals("")) { |
|||
|
|||
outputText.setText("Pease insert MatrixB"); |
|||
outputText.setTextAlignment(TextAlignment.CENTER); |
|||
} |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,97 @@ |
|||
package com.ugsbo.matrixcalc; |
|||
|
|||
import java.util.ArrayList; |
|||
import java.util.regex.Matcher; |
|||
import java.util.regex.Pattern; |
|||
|
|||
public class MatrixCalcIOUtils { |
|||
/** |
|||
* Prints a given 2D-Array to the output Textfield. |
|||
* |
|||
* @param output2DArray The Array that gets Displayed |
|||
*/ |
|||
protected String outputMatrixToOutputText(double[][] output2DArray) { |
|||
// convert array to String |
|||
String DisplayableString = convertsArrayToStringInOrderToDisplayIt(output2DArray); |
|||
// Display output |
|||
return DisplayableString; |
|||
} |
|||
|
|||
/** |
|||
* Converts 2D-Array to String in order to Display it. |
|||
* |
|||
* @param array2D The array wich will be converted to an Displayable String |
|||
* @return The Displayable String |
|||
*/ |
|||
protected String convertsArrayToStringInOrderToDisplayIt(double[][] array2D) { |
|||
String displayableString = ""; |
|||
for (int i = 0; i < array2D.length; i++) { |
|||
for (int j = 0; j < array2D[0].length; j++) { |
|||
displayableString += array2D[i][j] + " "; |
|||
} |
|||
displayableString += "\n\n"; |
|||
} |
|||
return displayableString; |
|||
} |
|||
|
|||
/** |
|||
* Checks if the Input is Valid, with Regex. Returns true if the Matrix can be |
|||
* matched by the regular Expression. |
|||
* |
|||
* @param matrix It is the InputMatrix |
|||
* @return True if the Matrix is valid Input. |
|||
*/ |
|||
protected void checkInput(String matrix) throws IllegalArgumentException { |
|||
if (matrix.length() == 0) { |
|||
throw new IllegalArgumentException("Please insert a Matrix"); |
|||
} |
|||
|
|||
// Matches digits witch following spaces 1 to 3 times |
|||
String row1 = "(\\d*\\u0020*){1,3}"; |
|||
// Matches newlineCurrierReturn followed by digits witch following spaces 1 to |
|||
// 3 times |
|||
String row2 = "(\\n){0,3}(\\d*\\u0020*){0,3}"; |
|||
String row3 = "(\\n){0,3}(\\d*\\u0020*){0,3}"; |
|||
|
|||
// TODO for verion 2 get the input check more stricktly missing matrix slots are allowed. |
|||
|
|||
Pattern p = Pattern.compile(row1 + row2 + row3); |
|||
Matcher m = p.matcher(matrix); |
|||
|
|||
if(!m.matches()){ |
|||
throw new IllegalArgumentException("A Matrix is not in the right format, Matrix "); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Converts a String form the Inputfield to an 2D-Array aka Matrix. |
|||
* |
|||
* @param stringMatrix The String form the Inputfield |
|||
* @return Matrix as a 2D-Array |
|||
*/ |
|||
public double[][] stringToMatrix(String stringMatrix) { |
|||
|
|||
ArrayList<String[]> singleNumbersArr = new ArrayList<String[]>(); |
|||
|
|||
// Splitting the strings into their rows |
|||
String[] singleNumbers = null; |
|||
String[] rows = stringMatrix.split("\n"); |
|||
for (int i = 0; i < rows.length; i++) { |
|||
// Splitting rows into their Numbers |
|||
singleNumbers = rows[i].split("\\s"); |
|||
singleNumbersArr.add(singleNumbers); |
|||
} |
|||
|
|||
int rowlength = singleNumbersArr.get(0).length; |
|||
int columCount = singleNumbersArr.size(); |
|||
double[][] matrix = new double[columCount][rowlength]; |
|||
|
|||
for (int columIndex = 0; columIndex < columCount; columIndex++) { |
|||
for (int rowIndex = 0; rowIndex < singleNumbers.length; rowIndex++) { |
|||
matrix[columIndex][rowIndex] = Double.parseDouble(singleNumbersArr.get(columIndex)[rowIndex]); |
|||
} |
|||
} |
|||
return matrix; |
|||
} |
|||
|
|||
} |
|||
@ -0,0 +1,228 @@ |
|||
package com.ugsbo.matrixcalc; |
|||
|
|||
/** |
|||
* Contains all basic matrix math calculations. |
|||
*/ |
|||
public class MatrixCalcMath { |
|||
|
|||
/** |
|||
* Mutliplys matrixA and matrixB. |
|||
* |
|||
* @param matrixA The Inputmatrix A (right TextArea in the GUI) |
|||
* @param matrixB The Inputmatrix B (left TextArea in the GUI) |
|||
* @return The Matrixproduct of the matricies A and B |
|||
*/ |
|||
public double[][] matrixMultiplication(double[][] matrixA, double[][] matrixB) { |
|||
if (checkIfMatriciesAreLinked(matrixA, matrixB)) { |
|||
int rowOfResultMatrix = matrixA.length; |
|||
int columOfResultMatrix = matrixB[0].length; |
|||
int ColumsOfMatA = matrixA[0].length; |
|||
double[][] result = new double[rowOfResultMatrix][columOfResultMatrix]; |
|||
|
|||
for (int rowResult = 0; rowResult < rowOfResultMatrix; rowResult++) { |
|||
for (int columResult = 0; columResult < columOfResultMatrix; columResult++) { |
|||
for (int columOfA = 0; columOfA < ColumsOfMatA; columOfA++) { |
|||
result[rowResult][columResult] += matrixA[rowResult][columOfA] * matrixB[columOfA][columResult]; |
|||
} |
|||
} |
|||
} |
|||
return result; |
|||
} else { |
|||
throw new IllegalArgumentException("Matricies must be linked"); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* checks if matrixA and matrixB are linked to know if it is possible to |
|||
* multiply them. If they are linked it is possible. |
|||
* |
|||
* @param matrixA The Inputmatrix A (right TextArea in the GUI) |
|||
* @param matrixB The Inputmatrix B (left TextArea in the GUI) |
|||
* @return true if you can Muliply A with B false if not. |
|||
*/ |
|||
public boolean checkIfMatriciesAreLinked(double[][] matrixA, double[][] matrixB) { |
|||
if (matrixA == null) { |
|||
return false; |
|||
} |
|||
if (matrixA.length == 0) { |
|||
return false; |
|||
} |
|||
if (matrixA[0].length == matrixB.length) { |
|||
return true; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
/** |
|||
* Adds two matroices A and B. Adding matrix A to matrix B is the same as adding |
|||
* B to A. |
|||
* |
|||
* @param matrixA The Inputmatrix A (right TextArea in the GUI) |
|||
* @param matrixB The Inputmatrix B (left TextArea in the GUI) |
|||
* @return The Matrixsum of matrix A and matrix B |
|||
*/ |
|||
public double[][] matrixAddition(double[][] matrixA, double[][] matrixB) { |
|||
if (checkIfMatriciesAreTheSameDimension(matrixA, matrixB)) { |
|||
double[][] result = new double[matrixA.length][matrixA[0].length]; |
|||
for (int rows = 0; rows < matrixA.length; rows++) { |
|||
for (int colums = 0; colums < matrixA[0].length; colums++) { |
|||
result[rows][colums] = matrixA[rows][colums] + matrixB[rows][colums]; |
|||
} |
|||
} |
|||
return result; |
|||
} else { |
|||
throw new IllegalArgumentException("Matricies need to have the same Dimensions"); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* In order to adding two Matricies they must have the same Dimensions. This |
|||
* Methode checks if this is the case. |
|||
* |
|||
* @param matrixA The Inputmatrix A (right TextArea in the GUI) |
|||
* @param matrixB The Inputmatrix B (left TextArea in the GUI) |
|||
* @return true if the Dimensions of Matrix A equals the Dimensions Matrix B |
|||
*/ |
|||
public boolean checkIfMatriciesAreTheSameDimension(double[][] matrixA, double[][] matrixB) { |
|||
if (matrixA == null || matrixA.length == 0) { |
|||
return false; |
|||
} |
|||
if (matrixA[0] == null) { |
|||
return false; |
|||
} |
|||
if (matrixA.length == matrixB.length && matrixA[0].length == matrixB[0].length) { |
|||
return true; |
|||
} else { |
|||
return false; |
|||
} |
|||
|
|||
} |
|||
|
|||
/** |
|||
* Substracts matrix A by the matrix B. Substaction for Matrices is just the |
|||
* substraction of each component with thier coorsponding component. |
|||
* |
|||
* @param matrixA The Inputmatrix A (right TextArea in the GUI) |
|||
* @param matrixB The Inputmatrix B (left TextArea in the GUI |
|||
* @return matrix A substracted by matrix B |
|||
*/ |
|||
public double[][] matrixSubstraction(double[][] matrixA, double[][] matrixB) { |
|||
if (checkIfMatriciesAreTheSameDimension(matrixA, matrixB)) { |
|||
double[][] result = new double[matrixA.length][matrixA[0].length]; |
|||
for (int rows = 0; rows < matrixA.length; rows++) { |
|||
for (int colums = 0; colums < matrixA[0].length; colums++) { |
|||
result[rows][colums] = matrixA[rows][colums] - matrixB[rows][colums]; |
|||
} |
|||
} |
|||
return result; |
|||
} else { |
|||
throw new IllegalArgumentException("Matricies need to have the same Dimensions"); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Transposes the Input Matrix. Swaps rows with colums. |
|||
* |
|||
* @param matrixA The Inputmatrix A wich will be Transposed |
|||
* @return The Transposed matrix of matrix A |
|||
*/ |
|||
public double[][] matrixTransponation(double[][] matrixA) { |
|||
if (matrixA == null) { |
|||
throw new IllegalArgumentException("Matricies need to have the same Dimensions"); |
|||
} |
|||
if (matrixA.length == 0) { |
|||
throw new IllegalArgumentException("Matricies need to have the same Dimensions"); |
|||
} |
|||
if (matrixA[0] == null) { |
|||
throw new IllegalArgumentException("Matricies need to have the same Dimensions"); |
|||
} |
|||
int columCountResult = matrixA.length; |
|||
int rowCountResult = matrixA[0].length; |
|||
double[][] result = new double[rowCountResult][columCountResult]; |
|||
for (int row = 0; row < rowCountResult; row++) { |
|||
for (int colum = 0; colum < columCountResult; colum++) { |
|||
result[row][colum] = matrixA[colum][row]; |
|||
} |
|||
} |
|||
return result; |
|||
} |
|||
|
|||
/** |
|||
* Calculates the Determinant of a Matrix. |
|||
* |
|||
* @param matrixA The Inputmatrix |
|||
* @return The Determinant of the Matrix A |
|||
*/ |
|||
public double calcDeterminat(double[][] matrixA) throws IllegalArgumentException{ |
|||
// checking if a Determinant can be calculated. |
|||
double result = 0.0; |
|||
if (checkIfMatrixIsQuadradtic(matrixA)) { |
|||
if (getMatrixRowCount(matrixA) == 2) { |
|||
result = calc2by2Determinant(matrixA); |
|||
} else if (getMatrixRowCount(matrixA) == 3) { |
|||
result = calc3by3Determinant(matrixA); |
|||
|
|||
} else { |
|||
throw new IllegalArgumentException("Matrix is not 2 by 2 or 3 by 3"); |
|||
} |
|||
|
|||
} else { |
|||
throw new IllegalArgumentException("Matrix must be Quadratic"); |
|||
} |
|||
return result; |
|||
} |
|||
|
|||
/** |
|||
* Calculates the Determinat of an three by three Matrix. |
|||
* |
|||
* @param matrixA The Inputmatrix form wich the Determinat will be calculated |
|||
* @return the Determinant of the Matrix |
|||
*/ |
|||
private double calc3by3Determinant(double[][] matrixA) { |
|||
double result = matrixA[0][0] * matrixA[1][1] * matrixA[2][2] + matrixA[0][1] * matrixA[1][2] * matrixA[2][0] |
|||
+ matrixA[0][2] * matrixA[1][0] * matrixA[2][1] - matrixA[0][0] * matrixA[1][2] * matrixA[2][1] |
|||
- matrixA[0][1] * matrixA[1][0] * matrixA[2][2] - matrixA[0][2] * matrixA[1][1] * matrixA[2][0]; |
|||
return result; |
|||
} |
|||
|
|||
/** |
|||
* Calculates the Determinat of an two by two Matrix. |
|||
* |
|||
* @param matrixA The Inputmatrix form wich the Determinat will be calculated |
|||
* @return the Determinant of the Matrix |
|||
*/ |
|||
private double calc2by2Determinant(double[][] matrixA) { |
|||
double result = matrixA[0][0] * matrixA[1][1] - matrixA[0][1] * matrixA[1][0]; |
|||
return result; |
|||
} |
|||
|
|||
/** |
|||
* Returns the Number of rows of a Matrix. |
|||
* |
|||
* @param matrixA the Inputmatrix form wich the rows will be counted |
|||
* @return Number of rows |
|||
*/ |
|||
private int getMatrixRowCount(double[][] matrixA) { |
|||
return matrixA.length; |
|||
} |
|||
|
|||
/** |
|||
* Checks if the rows and colums of an Matrix are equal. If they are equal the |
|||
* Matrix is Quadratic and the function will return true. |
|||
* |
|||
* @param matrixA the Inputmatrix for wich the rows and colums will be compared |
|||
* @return isQuadratic |
|||
*/ |
|||
private boolean checkIfMatrixIsQuadradtic(double[][] matrixA) { |
|||
if (matrixA == null) { |
|||
return false; |
|||
} |
|||
if (matrixA[0] == null) { |
|||
return false; |
|||
} |
|||
if (matrixA.length == matrixA[0].length) { |
|||
return true; |
|||
} |
|||
return false; |
|||
} |
|||
} |
|||
@ -0,0 +1,37 @@ |
|||
<?xml version="1.0" encoding="UTF-8"?> |
|||
|
|||
<?import java.lang.*?> |
|||
<?import javafx.scene.control.*?> |
|||
<?import javafx.scene.layout.*?> |
|||
<?import javafx.scene.text.*?> |
|||
<?import javafx.scene.control.Button?> |
|||
<?import javafx.scene.control.TextArea?> |
|||
<?import javafx.scene.layout.AnchorPane?> |
|||
<?import javafx.scene.text.Text?> |
|||
|
|||
<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="400.0" prefWidth="600.0" xmlns="http://javafx.com/javafx/8" xmlns:fx="http://javafx.com/fxml/1" fx:controller="com.ugsbo.matrixcalc.MatrixCalcController"> |
|||
<children> |
|||
<AnchorPane prefHeight="200.0" prefWidth="200.0" AnchorPane.leftAnchor="0.0" AnchorPane.topAnchor="0.0"> |
|||
<children> |
|||
<TextArea fx:id="matrixATextArea" prefHeight="200.0" prefWidth="200.0" AnchorPane.bottomAnchor="10.0" AnchorPane.leftAnchor="10.0" AnchorPane.rightAnchor="10.0" AnchorPane.topAnchor="10.0" /> |
|||
</children> |
|||
</AnchorPane> |
|||
<AnchorPane layoutX="200.0" prefHeight="200.0" prefWidth="200.0" AnchorPane.bottomAnchor="200.0" AnchorPane.leftAnchor="200.0" AnchorPane.rightAnchor="200.0" AnchorPane.topAnchor="0.0"> |
|||
<children> |
|||
<Button fx:id="multiplyButton" layoutX="14.0" layoutY="27.0" mnemonicParsing="false" text="multiply" AnchorPane.leftAnchor="15.0" AnchorPane.topAnchor="27.0" /> |
|||
<Button fx:id="addButton" layoutX="14.0" layoutY="62.0" mnemonicParsing="false" text="add" AnchorPane.leftAnchor="15.0" AnchorPane.topAnchor="67.0" /> |
|||
<Button fx:id="substractButton" layoutX="99.0" layoutY="62.0" mnemonicParsing="false" text="Substract" AnchorPane.rightAnchor="15.0" AnchorPane.topAnchor="67.0" /> |
|||
<Button fx:id="transposeButton" layoutX="97.0" layoutY="27.0" mnemonicParsing="false" text="Transpose" AnchorPane.rightAnchor="15.0" AnchorPane.topAnchor="27.0" /> |
|||
<Button fx:id="DetAButton" layoutX="14.0" layoutY="95.0" mnemonicParsing="false" text="DetA" AnchorPane.leftAnchor="15.0" AnchorPane.topAnchor="107.0" /> |
|||
<Button fx:id="DetBButton" layoutX="120.0" layoutY="107.0" mnemonicParsing="false" text="DetB" /> |
|||
<Text fx:id="errorText" layoutX="14.0" layoutY="113.0" strokeType="OUTSIDE" strokeWidth="0.0" AnchorPane.bottomAnchor="10.0" AnchorPane.leftAnchor="10.0" AnchorPane.rightAnchor="10.0" AnchorPane.topAnchor="100.0" /> |
|||
</children> |
|||
</AnchorPane> |
|||
<AnchorPane layoutX="400.0" prefHeight="200.0" prefWidth="200.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0"> |
|||
<children> |
|||
<TextArea fx:id="matrixBTextArea" layoutX="-15.0" layoutY="30.0" prefHeight="200.0" prefWidth="200.0" AnchorPane.bottomAnchor="10.0" AnchorPane.leftAnchor="10.0" AnchorPane.rightAnchor="10.0" AnchorPane.topAnchor="10.0" /> |
|||
</children> |
|||
</AnchorPane> |
|||
<Text fx:id="outputText" layoutX="14.0" layoutY="242.0" strokeType="OUTSIDE" strokeWidth="0.0" textAlignment="JUSTIFY" wrappingWidth="554.7294921875" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="10.0" AnchorPane.rightAnchor="10.0" AnchorPane.topAnchor="210.0" /> |
|||
</children> |
|||
</AnchorPane> |
|||
@ -0,0 +1,156 @@ |
|||
package com.ugsbo.matrixcalc; |
|||
|
|||
import static org.junit.Assert.assertArrayEquals; |
|||
import static org.junit.Assert.assertFalse; |
|||
import static org.junit.Assert.assertTrue; |
|||
|
|||
import org.junit.Before; |
|||
import org.junit.Test; |
|||
|
|||
/** |
|||
* Tests the funktionality to add and substract two matricies |
|||
*/ |
|||
public class MatrixAdditionAndSubstractionTest { |
|||
|
|||
private MatrixCalcMath matrixMath; |
|||
|
|||
@Before |
|||
public void setup() { |
|||
matrixMath = new MatrixCalcMath(); |
|||
} |
|||
|
|||
@Test |
|||
public void twoMatriciesHaveTheSameDimensions() { |
|||
double[][] matrixA = new double[1][1]; |
|||
double[][] matrixB = new double[1][1]; |
|||
|
|||
boolean result = matrixMath.checkIfMatriciesAreTheSameDimension(matrixA, matrixB); |
|||
|
|||
assertTrue("Two Matricies with the same Dimension were not detected as that", result); |
|||
} |
|||
|
|||
@Test |
|||
public void twoMatriciesDONOTHaveTheSameDimensions() { |
|||
double[][] matrixA = new double[2][1]; |
|||
double[][] matrixB = new double[1][1]; |
|||
|
|||
boolean result = matrixMath.checkIfMatriciesAreTheSameDimension(matrixA, matrixB); |
|||
|
|||
assertFalse("Two Matricies without the same Dimension were detected as that", result); |
|||
} |
|||
|
|||
@Test |
|||
public void addTwoMatriciesWithSameContent() { |
|||
double[][] matrixA = { { 1.0, 1.0 }, { 1.0, 1.0 } }; |
|||
double[][] matrixB = { { 1.0, 1.0 }, { 1.0, 1.0 } }; |
|||
double[][] matrixC = { { 2.0, 2.0 }, { 2.0, 2.0 } }; |
|||
|
|||
double[][] result = matrixMath.matrixAddition(matrixA, matrixB); |
|||
|
|||
assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1); |
|||
assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1); |
|||
} |
|||
|
|||
@Test |
|||
public void addTwoMatriciesWithDiffrentContent() { |
|||
double[][] matrixA = { { 7.0, 3.0 }, { 2.0, 9.0 } }; |
|||
double[][] matrixB = { { 6.0, 3.0 }, { 7.0, 11.0 } }; |
|||
double[][] matrixC = { { 13.0, 6.0 }, { 9.0, 20.0 } }; |
|||
|
|||
double[][] result = matrixMath.matrixAddition(matrixA, matrixB); |
|||
|
|||
assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1); |
|||
assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1); |
|||
} |
|||
|
|||
@Test(expected = IllegalArgumentException.class) |
|||
public void tryToAddTowEmptyMatricies() { |
|||
// A(0,0) B(0,0) => IllegalArgumentException |
|||
double[][] matrixA = new double[0][0]; |
|||
double[][] matrixB = new double[0][0]; |
|||
|
|||
matrixMath.matrixAddition(matrixA, matrixB); |
|||
} |
|||
|
|||
@Test(expected = IllegalArgumentException.class) |
|||
public void tryToAddTowNullMatrices() { |
|||
// A(0,0) B(0,0) => IllegalArgumentException |
|||
double[][] matrixA = null; |
|||
double[][] matrixB = null; |
|||
|
|||
matrixMath.matrixAddition(matrixA, matrixB); |
|||
} |
|||
|
|||
@Test(expected = IllegalArgumentException.class) |
|||
public void tryToAddTowMatricesWithDifferentDimensions() { |
|||
// A(0,0) B(0,0) => IllegalArgumentException |
|||
double[][] matrixA = { { 1.0, 2.0 } }; |
|||
double[][] matrixB = { { 1.0 }, { 2.0 } }; |
|||
|
|||
matrixMath.matrixAddition(matrixA, matrixB); |
|||
} |
|||
|
|||
@Test |
|||
public void substractTwoMatriciesWithSameContent() { |
|||
double[][] matrixA = { { 1.0, 1.0 }, { 1.0, 1.0 } }; |
|||
double[][] matrixB = { { 1.0, 1.0 }, { 1.0, 1.0 } }; |
|||
double[][] matrixC = { { 0.0, 0.0 }, { 0.0, 0.0 } }; |
|||
|
|||
double[][] result = matrixMath.matrixSubstraction(matrixA, matrixB); |
|||
|
|||
assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1); |
|||
assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1); |
|||
} |
|||
|
|||
@Test |
|||
public void substractTwoMatriciesWithDiffrentContent() { |
|||
double[][] matrixA = { { 1.0, 2.0 }, { 3.0, 4.0 } }; |
|||
double[][] matrixB = { { 5.0, 6.0 }, { 7.0, 8.0 } }; |
|||
double[][] matrixC = { { -4.0, -4.0 }, { -4.0, -4.0 } }; |
|||
|
|||
double[][] result = matrixMath.matrixSubstraction(matrixA, matrixB); |
|||
|
|||
assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1); |
|||
assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1); |
|||
} |
|||
|
|||
@Test |
|||
public void substractTwoMatriciesWithNegativeContent() { |
|||
double[][] matrixA = { { -1.0, -2.0 }, { -3.0, -4.0 } }; |
|||
double[][] matrixB = { { 5.0, 6.0 }, { 7.0, 8.0 } }; |
|||
double[][] matrixC = { { -6.0, -8.0 }, { -10.0, -12.0 } }; |
|||
|
|||
double[][] result = matrixMath.matrixSubstraction(matrixA, matrixB); |
|||
|
|||
assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1); |
|||
assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1); |
|||
} |
|||
|
|||
@Test(expected = IllegalArgumentException.class) |
|||
public void tryToSubstractTowEmptyMatricies() { |
|||
// A(0,0) B(0,0) => IllegalArgumentException |
|||
double[][] matrixA = new double[0][0]; |
|||
double[][] matrixB = new double[0][0]; |
|||
|
|||
matrixMath.matrixSubstraction(matrixA, matrixB); |
|||
} |
|||
|
|||
@Test(expected = IllegalArgumentException.class) |
|||
public void tryToSubstractTowNullMatrices() { |
|||
// A(0,0) B(0,0) => IllegalArgumentException |
|||
double[][] matrixA = null; |
|||
double[][] matrixB = null; |
|||
|
|||
matrixMath.matrixSubstraction(matrixA, matrixB); |
|||
} |
|||
|
|||
@Test(expected = IllegalArgumentException.class) |
|||
public void tryToSubstractTowMatricesWithDifferentDimensions() { |
|||
// A(0,0) B(0,0) => IllegalArgumentException |
|||
double[][] matrixA = { { 1.0, 2.0 } }; |
|||
double[][] matrixB = { { 1.0 }, { 2.0 } }; |
|||
|
|||
matrixMath.matrixSubstraction(matrixA, matrixB); |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,61 @@ |
|||
package com.ugsbo.matrixcalc; |
|||
|
|||
import static org.junit.Assert.assertEquals; |
|||
|
|||
import org.junit.Before; |
|||
import org.junit.Test; |
|||
|
|||
/** |
|||
* Tests the funktionality to Calculate the Determinant of a Matrix. |
|||
*/ |
|||
public class MatrixCalcDeterminatTest { |
|||
|
|||
private MatrixCalcMath matrixMath; |
|||
|
|||
@Before |
|||
public void setup() { |
|||
matrixMath = new MatrixCalcMath(); |
|||
} |
|||
|
|||
@Test |
|||
public void CalculatesTheDeterminanteOfA2by2Matrix() { |
|||
// A(2,2) |
|||
double[][] matrixA = { { 1.0, 2.0 }, { 3.0, 4.0 } }; |
|||
double determinat = -2.0; |
|||
double delta = 0.01; |
|||
|
|||
double result = matrixMath.calcDeterminat(matrixA); |
|||
|
|||
assertEquals("The Determinant is not as it should be", determinat, result, delta); |
|||
} |
|||
|
|||
@Test |
|||
public void CalculatesTheDeterminanteOfA3by3Matrix() { |
|||
// A(3,3) |
|||
double[][] matrixA = { { 1.0, 2.0, 1.0 }, { 3.0, 4.0, 0.0 }, { 5.0, 6.0, 0.0 } }; |
|||
double determinat = -2.0; |
|||
double delta = 0.01; |
|||
|
|||
double result = matrixMath.calcDeterminat(matrixA); |
|||
|
|||
assertEquals("The Determinant is not as it should be", determinat, result, delta); |
|||
|
|||
} |
|||
|
|||
@Test(expected = IllegalArgumentException.class) |
|||
public void tryToCalculateA4by4Matrix_ShouldResulInIllegalArgumentException() { |
|||
// A(4,4) |
|||
double[][] matrixA = { { 1.0, 2.0, 1.0, 0.0 }, { 3.0, 4.0, 0.0, 0.0 }, { 5.0, 6.0, 0.0, 0.0 }, |
|||
{ 5.0, 6.0, 0.0, 0.0 } }; |
|||
|
|||
matrixMath.calcDeterminat(matrixA); |
|||
} |
|||
|
|||
@Test(expected = IllegalArgumentException.class) |
|||
public void tryToCalculateANonQuadraticMatrix_SouldResulInIllegalArgumentException() { |
|||
// A(2,4) |
|||
double[][] matrixA = { { 5.0, 6.0, 0.0, 0.0 }, { 5.0, 6.0, 0.0, 0.0 } }; |
|||
|
|||
matrixMath.calcDeterminat(matrixA); |
|||
} |
|||
} |
|||
@ -0,0 +1,170 @@ |
|||
package com.ugsbo.matrixcalc; |
|||
|
|||
import static org.junit.Assert.assertArrayEquals; |
|||
import static org.junit.Assert.assertEquals; |
|||
import static org.junit.Assert.assertFalse; |
|||
import static org.junit.Assert.assertTrue; |
|||
|
|||
import org.junit.Before; |
|||
import org.junit.Test; |
|||
|
|||
/** |
|||
* Tests how well worng input can be determent. |
|||
*/ |
|||
public class MatrixIOUtilsTest { |
|||
|
|||
private MatrixCalcIOUtils util; |
|||
|
|||
@Before |
|||
public void setup() { |
|||
util = new MatrixCalcIOUtils(); |
|||
} |
|||
|
|||
@Test(expected = IllegalArgumentException.class) |
|||
public void inputEmptySouldThrowAIllegalArgumentException() { |
|||
String input = ""; |
|||
|
|||
util.checkInput(input); |
|||
} |
|||
|
|||
@Test |
|||
public void checkIfA1by3MatrixIsValidInput() { |
|||
String input = "1 2 3"; |
|||
|
|||
try { |
|||
// act |
|||
util.checkInput(input); |
|||
|
|||
// assert |
|||
assertTrue("The 1 by 3 Matrix should be Matched as valid input.", true); |
|||
} catch (IllegalArgumentException e) { |
|||
assertFalse("The 1 by 3 Matrix should be Matched as valid input.", true); |
|||
} |
|||
} |
|||
|
|||
@Test |
|||
public void checkIfA2by3MatrixIsValidInput() { |
|||
// arrange |
|||
String input = "1 2 3\n1 2 3"; |
|||
|
|||
try { |
|||
// act |
|||
util.checkInput(input); |
|||
|
|||
// assert |
|||
assertTrue("The 2 by 3 Matrix should be Matched as valid input.", true); |
|||
} catch (IllegalArgumentException e) { |
|||
assertFalse("The 2 by 3 Matrix should be Matched as valid input.", true); |
|||
} |
|||
} |
|||
|
|||
@Test |
|||
public void checkIfA3by3MatrixIsValidInput() { |
|||
String input = "1 2 3\n1 2 3\n1 2 3"; |
|||
|
|||
try { |
|||
util.checkInput(input); |
|||
|
|||
assertTrue("The 3 by 3 Matrix should be Matched as valid input.", true); |
|||
} catch (IllegalArgumentException e) { |
|||
assertFalse("The 3 by 3 Matrix should be Matched as valid input.", true); |
|||
} |
|||
|
|||
} |
|||
|
|||
@Test |
|||
public void StringWithSingleDigitNumbersToMatrix_ReturnsEquivalentMatrix() { |
|||
String inputString = "1"; |
|||
double[][] expected = { { 1.0 } }; |
|||
|
|||
double[][] result = util.stringToMatrix(inputString); |
|||
|
|||
assertArrayEquals("The first row is not correct", expected[0], result[0], 0.1); |
|||
} |
|||
|
|||
@Test |
|||
public void StringWithfourDigitNumbersToMatrix_ReturnsEquivalentMatrix() { |
|||
String inputString = "1 2\n3 4"; |
|||
double[][] expected = { { 1.0, 2.0 }, { 3.0, 4.0 } }; |
|||
|
|||
double[][] result = util.stringToMatrix(inputString); |
|||
|
|||
assertArrayEquals("The first row is not correct", expected[0], result[0], 0.1); |
|||
assertArrayEquals("The second row is not correct", expected[1], result[1], 0.1); |
|||
} |
|||
|
|||
@Test |
|||
public void StringWithSixDigitNumbersToMatrix_Returns1by6Matrix() { |
|||
String inputString = "1 2 3 4 5 6"; |
|||
double[][] expected = { { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 } }; |
|||
|
|||
double[][] result = util.stringToMatrix(inputString); |
|||
|
|||
assertArrayEquals("The first row is not correct", expected[0], result[0], 0.1); |
|||
} |
|||
|
|||
@Test |
|||
public void StringWithSixDigitNumbersToMatrix_Returns2by3Matrix() { |
|||
String inputString = "1 2 3\n4 5 6"; |
|||
double[][] expected = { { 1.0, 2.0, 3.0 }, { 4.0, 5.0, 6.0 } }; |
|||
|
|||
double[][] result = util.stringToMatrix(inputString); |
|||
|
|||
assertArrayEquals("The first row is not correct", expected[0], result[0], 0.1); |
|||
assertArrayEquals("The second row is not correct", expected[1], result[1], 0.1); |
|||
} |
|||
|
|||
@Test |
|||
public void StringWithSixDigitNumbersToMatrix_Returns3by2Matrix() { |
|||
String inputString = "1 2\n3 4\n5 6"; |
|||
double[][] expected = { { 1.0, 2.0 }, { 3.0, 4.0 }, { 5.0, 6.0 } }; |
|||
|
|||
double[][] result = util.stringToMatrix(inputString); |
|||
|
|||
assertArrayEquals("The first row is not correct", expected[0], result[0], 0.1); |
|||
assertArrayEquals("The second row is not correct", expected[1], result[1], 0.1); |
|||
assertArrayEquals("The therd row is not correct", expected[2], result[2], 0.1); |
|||
} |
|||
|
|||
@Test |
|||
public void StringWithNineDigitNumbersToMatrix_Returns3by3Matrix() { |
|||
String inputString = "1 2 3\n4 5 6\n7 8 9"; |
|||
double[][] expected = { { 1.0, 2.0, 3.0 }, { 4.0, 5.0, 6.0 }, { 7.0, 8.0, 9.0 } }; |
|||
|
|||
double[][] result = util.stringToMatrix(inputString); |
|||
|
|||
assertArrayEquals("The first row is not correct", expected[0], result[0], 0.1); |
|||
assertArrayEquals("The second row is not correct", expected[1], result[1], 0.1); |
|||
assertArrayEquals("The thierd row is not correct", expected[2], result[2], 0.1); |
|||
} |
|||
|
|||
@Test |
|||
public void convertsArrayToString_SingleNumber() { |
|||
double[][] matrix = { { 1.0 } }; |
|||
String expected = "1.0 \n\n"; |
|||
|
|||
String result = util.convertsArrayToStringInOrderToDisplayIt(matrix); |
|||
|
|||
assertEquals("The Strings do not Match", expected, result); |
|||
} |
|||
|
|||
@Test |
|||
public void convertsArrayToString_FourNumbersInARow() { |
|||
double[][] matrix = { { 1.0, 2.0, 3.0, 4.0 } }; |
|||
String expected = "1.0 2.0 3.0 4.0 \n\n"; |
|||
|
|||
String result = util.convertsArrayToStringInOrderToDisplayIt(matrix); |
|||
|
|||
assertEquals("The Strings do not Match", expected, result); |
|||
} |
|||
|
|||
@Test |
|||
public void convertsArrayToString_FourNumbersInTwoRows() { |
|||
double[][] matrix = { { 1.0, 2.0 }, { 3.0, 4.0 } }; |
|||
String expected = "1.0 2.0 \n\n3.0 4.0 \n\n"; |
|||
|
|||
String result = util.convertsArrayToStringInOrderToDisplayIt(matrix); |
|||
|
|||
assertEquals("The Strings do not Match", expected, result); |
|||
} |
|||
} |
|||
@ -0,0 +1,109 @@ |
|||
package com.ugsbo.matrixcalc; |
|||
|
|||
import static org.junit.Assert.assertArrayEquals; |
|||
import static org.junit.Assert.assertFalse; |
|||
import static org.junit.Assert.assertTrue; |
|||
|
|||
import org.junit.Before; |
|||
import org.junit.Test; |
|||
|
|||
/** |
|||
* Testet die Matrix Multiplication funkionalität |
|||
*/ |
|||
public class MatrixMultiplicationTest { |
|||
|
|||
private MatrixCalcMath matrixMath; |
|||
|
|||
@Before |
|||
public void setup() { |
|||
matrixMath = new MatrixCalcMath(); |
|||
} |
|||
|
|||
@Test |
|||
public void matrixAIsLinkedToMatrixBSouldBeTrue() { |
|||
double[][] matrixA = new double[1][2]; |
|||
double[][] matrixB = new double[2][1]; |
|||
|
|||
boolean result = matrixMath.checkIfMatriciesAreLinked(matrixA, matrixB); |
|||
|
|||
assertTrue("Matrix A is Linked to B but it is not detected that way", result); |
|||
} |
|||
|
|||
@Test |
|||
public void matrixAAndMatrixBAreNullSouldReturnFalse() { |
|||
double[][] matrixA = null; |
|||
double[][] matrixB = null; |
|||
|
|||
boolean result = matrixMath.checkIfMatriciesAreLinked(matrixA, matrixB); |
|||
|
|||
assertFalse("Matrix A and B are null but detected as Linked", result); |
|||
} |
|||
|
|||
@Test |
|||
public void matrixAAndMatrixBAreNotLinkedSouldReturnFalse() { |
|||
double[][] matrixA = new double[1][1]; |
|||
double[][] matrixB = new double[2][1]; |
|||
|
|||
boolean result = matrixMath.checkIfMatriciesAreLinked(matrixA, matrixB); |
|||
|
|||
assertFalse("Matrix A and B are not Linked but detected as Linked", result); |
|||
} |
|||
|
|||
@Test |
|||
public void multiplyTwoMatriciesWithSameDimensionsAndSameContent() { |
|||
double[][] matrixA = { { 1.0, 1.0 }, { 1.0, 1.0 } }; |
|||
double[][] matrixB = { { 1.0, 1.0 }, { 1.0, 1.0 } }; |
|||
double[][] matrixC = { { 2.0, 2.0 }, { 2.0, 2.0 } }; |
|||
|
|||
double[][] result = matrixMath.matrixMultiplication(matrixA, matrixB); |
|||
|
|||
assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1); |
|||
assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1); |
|||
} |
|||
|
|||
@Test |
|||
public void multiplyTowMatriciesWithDiffrentDimensions() { |
|||
// A(2,3) B(3,2) => C(2,2) |
|||
double[][] matrixA = { { 1.0, 1.0, 1.0 }, { 1.0, 1.0, 1.0 } }; |
|||
double[][] matrixB = { { 1.0, 1.0 }, { 1.0, 1.0 }, { 1.0, 1.0 } }; |
|||
double[][] matrixC = { { 3.0, 3.0 }, { 3.0, 3.0 } }; |
|||
|
|||
double[][] result = matrixMath.matrixMultiplication(matrixA, matrixB); |
|||
|
|||
assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1); |
|||
assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1); |
|||
} |
|||
|
|||
@Test |
|||
public void multiplyTowMatriciesWithDiffrentDimensionsAndDiffentContent() { |
|||
// A(2,3) B(3,2) => C(2,2) |
|||
double[][] matrixA = { { 1.0, 2.0, 3.0 }, { 4.0, 5.0, 6.0 } }; |
|||
double[][] matrixB = { { 7.0, 8.0 }, { 9.0, 10.0 }, { 11.0, 12.0 } }; |
|||
double[][] matrixC = { { 58.0, 64.0 }, { 139.0, 154.0 } }; |
|||
|
|||
double[][] result = matrixMath.matrixMultiplication(matrixA, matrixB); |
|||
|
|||
assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1); |
|||
assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1); |
|||
} |
|||
|
|||
@Test(expected = IllegalArgumentException.class) |
|||
|
|||
public void tryToMultiplyTowEmptyMatricies() { |
|||
// A(0,0) B(0,0) => IllegalArgumentException |
|||
double[][] matrixA = new double[0][0]; |
|||
double[][] matrixB = new double[0][0]; |
|||
|
|||
matrixMath.matrixMultiplication(matrixA, matrixB); |
|||
} |
|||
|
|||
@Test(expected = IllegalArgumentException.class) |
|||
|
|||
public void tryToMultiplyTowNullObjects() { |
|||
// null null => IllegalArgumentException |
|||
double[][] matrixA = null; |
|||
double[][] matrixB = null; |
|||
|
|||
matrixMath.matrixMultiplication(matrixA, matrixB); |
|||
} |
|||
} |
|||
@ -0,0 +1,57 @@ |
|||
package com.ugsbo.matrixcalc; |
|||
|
|||
import static org.junit.Assert.assertArrayEquals; |
|||
|
|||
import org.junit.Before; |
|||
import org.junit.Test; |
|||
|
|||
/** |
|||
* Tests the funktionality to Transpose a Matix |
|||
*/ |
|||
public class MatrixTransposeTest { |
|||
|
|||
private MatrixCalcMath matrixMath; |
|||
|
|||
@Before |
|||
public void setup() { |
|||
matrixMath = new MatrixCalcMath(); |
|||
} |
|||
|
|||
@Test |
|||
public void TransformQuadraticMatrixA_ResultsInQuadraticMatrixC() { |
|||
// A(2,2) => C(2,2) |
|||
double[][] matrixA = { { 1.0, 2.0 }, { 3.0, 4.0 } }; |
|||
double[][] matrixC = { { 1.0, 3.0 }, { 2.0, 4.0 } }; |
|||
|
|||
double[][] result = matrixMath.matrixTransponation(matrixA); |
|||
|
|||
assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1); |
|||
assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1); |
|||
} |
|||
|
|||
@Test |
|||
public void Transform2by3MatrixA_ResultsIn3by2MatrixC() { |
|||
// A(2,3) => C(3,2) |
|||
double[][] matrixA = { { 1.0, 2.0, 3.0 }, { 4.0, 5.0, 6.0 } }; |
|||
double[][] matrixC = { { 1.0, 4.0 }, { 2.0, 5.0 }, { 3.0, 6.0 } }; |
|||
|
|||
double[][] result = matrixMath.matrixTransponation(matrixA); |
|||
|
|||
assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1); |
|||
assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1); |
|||
assertArrayEquals("The third row is not correct", matrixC[2], result[2], 0.1); |
|||
} |
|||
|
|||
@Test |
|||
public void Transform1by3MatrixA_ResultsIn3by1MatrixC() { |
|||
// A(1,3) => C(1,3) |
|||
double[][] matrixA = { { 1.0, 2.0, 3.0 } }; |
|||
double[][] matrixC = { { 1.0 }, { 2.0 }, { 3.0 } }; |
|||
|
|||
double[][] result = matrixMath.matrixTransponation(matrixA); |
|||
|
|||
assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1); |
|||
assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1); |
|||
assertArrayEquals("The third row is not correct", matrixC[2], result[2], 0.1); |
|||
} |
|||
} |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue