From 7cba186f82a72eedf2aed1135edd8fb833d7ed7a Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Wed, 26 Jun 2019 16:21:41 +0200
Subject: [PATCH 01/30] Added MatrixCalcGui and some dummy Methodes

---
 .../com/ugsbo/gui/BasicGuiController.java     | 12 ++--
 src/main/java/com/ugsbo/gui/MainApp.java      | 12 +++-
 .../matrixcalc/MatrixCalcController.java      | 39 +++++++++++++
 .../com/ugsbo/matrixcalc/MatrixCalcMath.java  | 58 +++++++++++++++++++
 src/main/java/module-info.java                |  1 +
 .../resources/com/ugsbo/gui/BasicGui.fxml     |  2 +-
 .../com/ugsbo/gui/matrixCalcGui.fxml          | 32 ++++++++++
 .../matrixcalc/MatrixMultiplicationTest.java  | 19 ++++++
 8 files changed, 167 insertions(+), 8 deletions(-)
 create mode 100644 src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
 create mode 100644 src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
 create mode 100644 src/main/resources/com/ugsbo/gui/matrixCalcGui.fxml
 create mode 100644 src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java

diff --git a/src/main/java/com/ugsbo/gui/BasicGuiController.java b/src/main/java/com/ugsbo/gui/BasicGuiController.java
index 6a313df..5e66758 100644
--- a/src/main/java/com/ugsbo/gui/BasicGuiController.java
+++ b/src/main/java/com/ugsbo/gui/BasicGuiController.java
@@ -5,9 +5,9 @@ import javafx.scene.control.*;
 
 public class BasicGuiController {
 
-    //Hier werden die fx:id Attribute verknuepft.
+    // Hier werden die fx:id Attribute verknuepft.
     @FXML
-    private Button app1; //Fuer ToDoManager.
+    private Button matrixCalc;
     @FXML
     private Button app2;
     @FXML
@@ -19,7 +19,7 @@ public class BasicGuiController {
      * Konstructor is called before initialize()
      */
     public BasicGuiController() {
-        //Setup of some Fields could be defined here.
+        // Setup of some Fields could be defined here.
     }
 
     /**
@@ -28,9 +28,9 @@ public class BasicGuiController {
      */
     @FXML
     public void initialize() {
-        app1.setOnMouseClicked((event) -> {
-            //MainApp.startToDoMainGui();
-            System.out.println(event);
+        matrixCalc.setOnMouseClicked((event) -> {
+            MainApp.startMatrixCalcGUI();
+            // System.out.println(event);
         });
         app2.setOnMouseClicked((event) -> {
             System.out.println(event);
diff --git a/src/main/java/com/ugsbo/gui/MainApp.java b/src/main/java/com/ugsbo/gui/MainApp.java
index 7da8f02..f420ab7 100644
--- a/src/main/java/com/ugsbo/gui/MainApp.java
+++ b/src/main/java/com/ugsbo/gui/MainApp.java
@@ -35,7 +35,7 @@ public class MainApp extends Application {
   /**
    * Loades the FXML file and the Default CSS.
    * 
-   * @param stage        The Stage will be passed over from fxml
+   * @param stage        The Stage will be passed over from JavaFx
    * @param fxmlFileName Only the Filename of the fxml file wich sould be loaded
    */
   private void createStageFromFXML(Stage stage, String fxmlFileName) {
@@ -58,4 +58,14 @@ public class MainApp extends Application {
     }
     stage.show();
   }
+
+  /**
+   * Startet eine Instanz der MatrixCalcGui.
+   */
+  public static void startMatrixCalcGUI() {
+    Stage stage = new Stage();
+    MainApp app = new MainApp();
+    app.createStageFromFXML(stage, "matrixCalcGui");
+  }
+
 }
diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
new file mode 100644
index 0000000..2c2acf0
--- /dev/null
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -0,0 +1,39 @@
+package com.ugsbo.matrixcalc;
+
+import javafx.fxml.FXML;
+import javafx.scene.control.*;
+import javafx.scene.text.Text;
+
+public class MatrixCalcController {
+
+    // Hier werden die fx:id Attribute verknuepft.
+    @FXML
+    private Button multiplyButton, addButton, swapInputButton, substractButton, transposeButton;
+    @FXML
+    private Text errorText, outputText;
+    @FXML
+    private TextArea matrixATextArea, matrixBTextArea;
+
+    /**
+     * 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() {
+        multiplyButton.setOnMouseClicked((event) -> {
+            // TODO matrixATextArea and matrixBTextArea need to be parsed to Double[][] do
+            // this in an extern Methode maybe an extern class.
+            // MatrixCalcMath math = new MatrixCalcMath();
+            // math.matrixMultiplication(matrixATextArea, matrixATextArea);
+            System.out.println(event);
+        });
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
new file mode 100644
index 0000000..4725418
--- /dev/null
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
@@ -0,0 +1,58 @@
+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) {
+        // TODO Matrix Multiplication
+        return null;
+    }
+
+    /**
+     * 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) {
+        // TODO Check if the number of Rows of Matrix A equal to the coulums of Matrix B
+        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) {
+        // TODO Sum each Element of matrix A to the corrosponding elem in B
+        return null;
+    }
+
+    /**
+     * 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) {
+        // TODO Dimension check.
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java
index a48c156..b859978 100644
--- a/src/main/java/module-info.java
+++ b/src/main/java/module-info.java
@@ -2,6 +2,7 @@ module UGSBO {
     requires javafx.controls;
     requires javafx.fxml;
 
+    opens com.ugsbo.matrixcalc to javafx.fxml;
     opens com.ugsbo.gui to javafx.fxml;
 
     exports com.ugsbo.gui;
diff --git a/src/main/resources/com/ugsbo/gui/BasicGui.fxml b/src/main/resources/com/ugsbo/gui/BasicGui.fxml
index 0fcd44d..d591c5a 100644
--- a/src/main/resources/com/ugsbo/gui/BasicGui.fxml
+++ b/src/main/resources/com/ugsbo/gui/BasicGui.fxml
@@ -27,7 +27,7 @@
       </AnchorPane>
     <AnchorPane maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" minHeight="-Infinity" minWidth="-Infinity" prefHeight="300.0" prefWidth="200.0" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="150.0" AnchorPane.rightAnchor="150.0" AnchorPane.topAnchor="50.0">
          <children>
-            <Button fx:id="app1" maxHeight="-Infinity" maxWidth="1.7976931348623157E308" minHeight="-Infinity" minWidth="-Infinity" mnemonicParsing="false" prefHeight="30.0" prefWidth="260.0" text="ToDoListe" textAlignment="CENTER" AnchorPane.leftAnchor="19.0" AnchorPane.rightAnchor="19.0" AnchorPane.topAnchor="15.0" />
+            <Button fx:id="matrixCalc" maxHeight="-Infinity" maxWidth="1.7976931348623157E308" minHeight="-Infinity" minWidth="-Infinity" mnemonicParsing="false" prefHeight="30.0" prefWidth="260.0" text="Matrix Calculator" textAlignment="CENTER" AnchorPane.leftAnchor="19.0" AnchorPane.rightAnchor="19.0" AnchorPane.topAnchor="15.0" />
             <Button fx:id="app2" maxHeight="-Infinity" minHeight="-Infinity" minWidth="-Infinity" mnemonicParsing="false" prefHeight="30.0" prefWidth="260.0" text="App2" textAlignment="CENTER" AnchorPane.leftAnchor="19.0" AnchorPane.rightAnchor="19.0" AnchorPane.topAnchor="60.0" />
             <Button fx:id="app3" maxHeight="-Infinity" minHeight="-Infinity" minWidth="-Infinity" mnemonicParsing="false" prefHeight="30.0" prefWidth="260.0" text="App3" textAlignment="CENTER" AnchorPane.leftAnchor="19.0" AnchorPane.rightAnchor="19.0" AnchorPane.topAnchor="105.0" />
             <Button fx:id="app4" maxHeight="-Infinity" minHeight="-Infinity" minWidth="-Infinity" mnemonicParsing="false" prefHeight="30.0" prefWidth="260.0" text="App4" textAlignment="CENTER" AnchorPane.leftAnchor="19.0" AnchorPane.rightAnchor="19.0" AnchorPane.topAnchor="150.0" />
diff --git a/src/main/resources/com/ugsbo/gui/matrixCalcGui.fxml b/src/main/resources/com/ugsbo/gui/matrixCalcGui.fxml
new file mode 100644
index 0000000..abe1301
--- /dev/null
+++ b/src/main/resources/com/ugsbo/gui/matrixCalcGui.fxml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.text.*?>
+<?import javafx.scene.control.*?>
+<?import java.lang.*?>
+<?import javafx.scene.layout.*?>
+
+<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="swapInputButton" layoutX="14.0" layoutY="95.0" mnemonicParsing="false" text="Swap Input" AnchorPane.leftAnchor="15.0" AnchorPane.topAnchor="107.0" />
+            <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" wrappingWidth="554.7294921875" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="10.0" AnchorPane.rightAnchor="10.0" AnchorPane.topAnchor="210.0" />
+   </children>
+</AnchorPane>
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
new file mode 100644
index 0000000..9fc0dc9
--- /dev/null
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
@@ -0,0 +1,19 @@
+package com.ugsbo.matrixcalc;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/**
+ * Testet die Matrix Multiplication funkionalität
+ */
+public class MatrixMultiplicationTest {
+    /**
+     * This Test only tests that the assertTrue funktion works like expected.
+     */
+    @Test
+    public void shouldAlwaysBeTrue() {
+        //TODO replace this test through a real one!!
+        assertTrue("The JUnit setup is not correct, this test only assertTrue.", true);
+    }
+}

From f9891c392a926260bae6b6cd18806958642f131d Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Wed, 26 Jun 2019 17:16:09 +0200
Subject: [PATCH 02/30] The funktionality Linked Matricies Check

---
 .../com/ugsbo/matrixcalc/MatrixCalcMath.java  | 10 +++++-
 .../matrixcalc/MatrixMultiplicationTest.java  | 31 +++++++++++++++----
 2 files changed, 34 insertions(+), 7 deletions(-)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
index 4725418..d18d9cd 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
@@ -27,7 +27,15 @@ public class MatrixCalcMath {
      */
     public boolean checkIfMatriciesAreLinked(Double[][] matrixA, Double[][] matrixB) {
         // TODO Check if the number of Rows of Matrix A equal to the coulums of Matrix B
-        return false;
+        if (matrixA != null) {
+            if (matrixA[0].length == matrixB.length) {
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
     }
 
     /**
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
index 9fc0dc9..913227d 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
@@ -1,5 +1,6 @@
 package com.ugsbo.matrixcalc;
 
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
 import org.junit.Test;
@@ -8,12 +9,30 @@ import org.junit.Test;
  * Testet die Matrix Multiplication funkionalität
  */
 public class MatrixMultiplicationTest {
-    /**
-     * This Test only tests that the assertTrue funktion works like expected.
-     */
+
+    @Test
+    public void MatrixAIsLinkedToMatrixBSouldBeTrue() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        Double[][] matrixA = new Double[1][2];
+        Double[][] matrixB = new Double[2][1];
+        assertTrue("Matrix A is Linked to B but it is not detected that way",
+                math.checkIfMatriciesAreLinked(matrixA, matrixB));
+    }
+
+    @Test
+    public void MatrixAAndMatrixBAreNullSouldReturnFalse() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        Double[][] matrixA = null;
+        Double[][] matrixB = null;
+        assertFalse("Matrix A and B are null but detected as Linked", math.checkIfMatriciesAreLinked(matrixA, matrixB));
+    }
+
     @Test
-    public void shouldAlwaysBeTrue() {
-        //TODO replace this test through a real one!!
-        assertTrue("The JUnit setup is not correct, this test only assertTrue.", true);
+    public void MatrixAAndMatrixBAreNotLinkedSouldReturnFalse() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        Double[][] matrixA = new Double[1][1];
+        Double[][] matrixB = new Double[2][1];
+        assertFalse("Matrix A and B are not Linked but detected as Linked",
+                math.checkIfMatriciesAreLinked(matrixA, matrixB));
     }
 }

From 28c0a349e654de84b3a6a480dbdb94c1e39f2d45 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Sat, 29 Jun 2019 16:53:46 +0200
Subject: [PATCH 03/30] Matrix Multiplication and linked check implemented

---
 .../matrixcalc/MatrixCalcController.java      |  2 +-
 .../com/ugsbo/matrixcalc/MatrixCalcMath.java  | 28 +++++--
 .../matrixcalc/MatrixMultiplicationTest.java  | 75 ++++++++++++++++---
 3 files changed, 88 insertions(+), 17 deletions(-)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index 2c2acf0..f8e1cdb 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -28,7 +28,7 @@ public class MatrixCalcController {
     @FXML
     public void initialize() {
         multiplyButton.setOnMouseClicked((event) -> {
-            // TODO matrixATextArea and matrixBTextArea need to be parsed to Double[][] do
+            // TODO matrixATextArea and matrixBTextArea need to be parsed to double[][] do
             // this in an extern Methode maybe an extern class.
             // MatrixCalcMath math = new MatrixCalcMath();
             // math.matrixMultiplication(matrixATextArea, matrixATextArea);
diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
index d18d9cd..2e29ba4 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
@@ -12,9 +12,24 @@ public class MatrixCalcMath {
      * @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) {
-        // TODO Matrix Multiplication
-        return null;
+    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("array must be linked");
+        }
     }
 
     /**
@@ -25,8 +40,7 @@ public class MatrixCalcMath {
      * @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) {
-        // TODO Check if the number of Rows of Matrix A equal to the coulums of Matrix B
+    public boolean checkIfMatriciesAreLinked(double[][] matrixA, double[][] matrixB) {
         if (matrixA != null) {
             if (matrixA[0].length == matrixB.length) {
                 return true;
@@ -46,7 +60,7 @@ public class MatrixCalcMath {
      * @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) {
+    public double[][] matrixAddition(double[][] matrixA, double[][] matrixB) {
         // TODO Sum each Element of matrix A to the corrosponding elem in B
         return null;
     }
@@ -59,7 +73,7 @@ public class MatrixCalcMath {
      * @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) {
+    public boolean checkIfMatriciesAreTheSameDimension(double[][] matrixA, double[][] matrixB) {
         // TODO Dimension check.
         return false;
     }
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
index 913227d..8dc006f 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
@@ -1,5 +1,6 @@
 package com.ugsbo.matrixcalc;
 
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
@@ -11,28 +12,84 @@ import org.junit.Test;
 public class MatrixMultiplicationTest {
 
     @Test
-    public void MatrixAIsLinkedToMatrixBSouldBeTrue() {
+    public void matrixAIsLinkedToMatrixBSouldBeTrue() {
         MatrixCalcMath math = new MatrixCalcMath();
-        Double[][] matrixA = new Double[1][2];
-        Double[][] matrixB = new Double[2][1];
+        double[][] matrixA = new double[1][2];
+        double[][] matrixB = new double[2][1];
         assertTrue("Matrix A is Linked to B but it is not detected that way",
                 math.checkIfMatriciesAreLinked(matrixA, matrixB));
     }
 
     @Test
-    public void MatrixAAndMatrixBAreNullSouldReturnFalse() {
+    public void matrixAAndMatrixBAreNullSouldReturnFalse() {
         MatrixCalcMath math = new MatrixCalcMath();
-        Double[][] matrixA = null;
-        Double[][] matrixB = null;
+        double[][] matrixA = null;
+        double[][] matrixB = null;
         assertFalse("Matrix A and B are null but detected as Linked", math.checkIfMatriciesAreLinked(matrixA, matrixB));
     }
 
     @Test
-    public void MatrixAAndMatrixBAreNotLinkedSouldReturnFalse() {
+    public void matrixAAndMatrixBAreNotLinkedSouldReturnFalse() {
         MatrixCalcMath math = new MatrixCalcMath();
-        Double[][] matrixA = new Double[1][1];
-        Double[][] matrixB = new Double[2][1];
+        double[][] matrixA = new double[1][1];
+        double[][] matrixB = new double[2][1];
         assertFalse("Matrix A and B are not Linked but detected as Linked",
                 math.checkIfMatriciesAreLinked(matrixA, matrixB));
     }
+
+    @Test
+    public void multiplyTwoMatriciesWithSameDimensionsAndSameContent() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        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 } };
+        assertArrayEquals("The first row is not correct", matrixC[0], math.matrixMultiplication(matrixA, matrixB)[0],
+                0.1);
+        assertArrayEquals("The seound row is not correct", matrixC[1], math.matrixMultiplication(matrixA, matrixB)[1],
+                0.1);
+    }
+
+    @Test
+    public void multiplyTowMatriciesWithDiffrentDimensions() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        //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 } };
+        assertArrayEquals("The first row is not correct", matrixC[0], math.matrixMultiplication(matrixA, matrixB)[0],
+                0.1);
+        assertArrayEquals("The seound row is not correct", matrixC[1], math.matrixMultiplication(matrixA, matrixB)[1],
+                0.1);
+    }
+
+    @Test
+    public void multiplyTowMatriciesWithDiffrentDimensionsAndDiffentContent() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        //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 } };
+        assertArrayEquals("The first row is not correct", matrixC[0], math.matrixMultiplication(matrixA, matrixB)[0],
+                0.1);
+        assertArrayEquals("The seound row is not correct", matrixC[1], math.matrixMultiplication(matrixA, matrixB)[1],
+                0.1);
+    }
+
+    @Test
+    public void tryToMultiplyTowEmptyMatricies() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        //A(0,0) B(0,0) => null
+        double[][] matrixA = new double[0][0];
+        double[][] matrixB = new double[0][0];
+        assertArrayEquals(null, math.matrixAddition(matrixA, matrixB));
+    }
+
+    @Test
+    public void tryToMultiplyTowNullObjects() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        //null null => null
+        double[][] matrixA = null;
+        double[][] matrixB = null;
+        assertArrayEquals(null, math.matrixAddition(matrixA, matrixB));
+    }
 }

From 149f1c8cae9fd0ae47b4842d023b928985a3ccae Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Sat, 29 Jun 2019 18:55:34 +0200
Subject: [PATCH 04/30] Removed a bug in Matrix Multiplication and added Matrix
 Adition funktionality

---
 .../com/ugsbo/matrixcalc/MatrixCalcMath.java  | 44 ++++++++----
 .../ugsbo/matrixcalc/MatrixAdditionTest.java  | 61 +++++++++++++++++
 .../matrixcalc/MatrixMultiplicationTest.java  | 68 ++++++++++++-------
 3 files changed, 136 insertions(+), 37 deletions(-)
 create mode 100644 src/test/java/com/ugsbo/matrixcalc/MatrixAdditionTest.java

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
index 2e29ba4..76f1c5c 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
@@ -1,5 +1,7 @@
 package com.ugsbo.matrixcalc;
 
+import java.io.IOException;
+
 /**
  * Contains all basic matrix math calculations.
  */
@@ -28,7 +30,8 @@ public class MatrixCalcMath {
             }
             return result;
         } else {
-            throw new IllegalArgumentException("array must be linked");
+            return null;
+            //throw new IllegalArgumentException("Matricies must be linked");
         }
     }
 
@@ -41,15 +44,16 @@ public class MatrixCalcMath {
      * @return true if you can Muliply A with B false if not.
      */
     public boolean checkIfMatriciesAreLinked(double[][] matrixA, double[][] matrixB) {
-        if (matrixA != null) {
-            if (matrixA[0].length == matrixB.length) {
-                return true;
-            } else {
-                return false;
-            }
-        } else {
+        if (matrixA == null) {
+            return false;
+        }
+        if (matrixA.length == 0) {
             return false;
         }
+        if (matrixA[0].length == matrixB.length) {
+            return true;
+        }
+        return false;
     }
 
     /**
@@ -61,8 +65,20 @@ public class MatrixCalcMath {
      * @return The Matrixsum of matrix A and matrix B
      */
     public double[][] matrixAddition(double[][] matrixA, double[][] matrixB) {
-        // TODO Sum each Element of matrix A to the corrosponding elem in B
-        return null;
+        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 {
+            return null;
+            // TODO Fragen wie man eine Exception testen kann.
+            // throw new IllegalArgumentException("Matricies need to have the same
+            // Dimensions");
+        }
     }
 
     /**
@@ -74,7 +90,11 @@ public class MatrixCalcMath {
      * @return true if the Dimensions of Matrix A equals the Dimensions Matrix B
      */
     public boolean checkIfMatriciesAreTheSameDimension(double[][] matrixA, double[][] matrixB) {
-        // TODO Dimension check.
-        return false;
+        if (matrixA.length == matrixB.length && matrixA[0].length == matrixB[0].length) {
+            return true;
+        } else {
+            return false;
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixAdditionTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixAdditionTest.java
new file mode 100644
index 0000000..4ca53bb
--- /dev/null
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixAdditionTest.java
@@ -0,0 +1,61 @@
+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.Test;
+
+/**
+ * Tests the funktionality to add two matricies
+ */
+public class MatrixAdditionTest {
+
+    @Test
+    public void twoMatriciesHaveTheSameDimensions() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        double[][] matrixA = new double[1][1];
+        double[][] matrixB = new double[1][1];
+
+        boolean result = math.checkIfMatriciesAreTheSameDimension(matrixA, matrixB);
+
+        assertTrue("Two Matricies with the same Dimension were not detected as that", result);
+    }
+
+    @Test
+    public void twoMatriciesDONOTHaveTheSameDimensions() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        double[][] matrixA = new double[2][1];
+        double[][] matrixB = new double[1][1];
+
+        boolean result = math.checkIfMatriciesAreTheSameDimension(matrixA, matrixB);
+
+        assertFalse("Two Matricies without the same Dimension were detected as that", result);
+    }
+
+    @Test
+    public void addTwoMatriciesWithSameContent() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        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 = math.matrixAddition(matrixA, matrixB);
+
+        assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
+        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+    }
+    
+    @Test
+    public void addTwoMatriciesWithDiffrentContent() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        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 = math.matrixAddition(matrixA, matrixB);
+
+        assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
+        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
index 8dc006f..c8a098b 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
@@ -1,10 +1,12 @@
 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.Test;
+import org.junit.internal.matchers.ThrowableCauseMatcher;
 
 /**
  * Testet die Matrix Multiplication funkionalität
@@ -16,8 +18,10 @@ public class MatrixMultiplicationTest {
         MatrixCalcMath math = new MatrixCalcMath();
         double[][] matrixA = new double[1][2];
         double[][] matrixB = new double[2][1];
-        assertTrue("Matrix A is Linked to B but it is not detected that way",
-                math.checkIfMatriciesAreLinked(matrixA, matrixB));
+
+        boolean result = math.checkIfMatriciesAreLinked(matrixA, matrixB);
+        
+        assertTrue("Matrix A is Linked to B but it is not detected that way", result);
     }
 
     @Test
@@ -25,7 +29,10 @@ public class MatrixMultiplicationTest {
         MatrixCalcMath math = new MatrixCalcMath();
         double[][] matrixA = null;
         double[][] matrixB = null;
-        assertFalse("Matrix A and B are null but detected as Linked", math.checkIfMatriciesAreLinked(matrixA, matrixB));
+
+        boolean result = math.checkIfMatriciesAreLinked(matrixA, matrixB);
+
+        assertFalse("Matrix A and B are null but detected as Linked", result);
     }
 
     @Test
@@ -33,8 +40,10 @@ public class MatrixMultiplicationTest {
         MatrixCalcMath math = new MatrixCalcMath();
         double[][] matrixA = new double[1][1];
         double[][] matrixB = new double[2][1];
-        assertFalse("Matrix A and B are not Linked but detected as Linked",
-                math.checkIfMatriciesAreLinked(matrixA, matrixB));
+
+        boolean result = math.checkIfMatriciesAreLinked(matrixA, matrixB);
+
+        assertFalse("Matrix A and B are not Linked but detected as Linked", result);
     }
 
     @Test
@@ -43,53 +52,62 @@ public class MatrixMultiplicationTest {
         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 } };
-        assertArrayEquals("The first row is not correct", matrixC[0], math.matrixMultiplication(matrixA, matrixB)[0],
-                0.1);
-        assertArrayEquals("The seound row is not correct", matrixC[1], math.matrixMultiplication(matrixA, matrixB)[1],
-                0.1);
+
+        double[][] result = math.matrixMultiplication(matrixA, matrixB);
+
+        assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
+        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
     }
 
     @Test
     public void multiplyTowMatriciesWithDiffrentDimensions() {
         MatrixCalcMath math = new MatrixCalcMath();
-        //A(2,3) B(3,2) => C(2,2)
-        double[][] matrixA = { { 1.0, 1.0, 1.0}, { 1.0, 1.0, 1.0 } };
+        // 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 } };
-        assertArrayEquals("The first row is not correct", matrixC[0], math.matrixMultiplication(matrixA, matrixB)[0],
-                0.1);
-        assertArrayEquals("The seound row is not correct", matrixC[1], math.matrixMultiplication(matrixA, matrixB)[1],
-                0.1);
+
+        double[][] result = math.matrixMultiplication(matrixA, matrixB);
+
+        assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
+        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
     }
 
     @Test
     public void multiplyTowMatriciesWithDiffrentDimensionsAndDiffentContent() {
         MatrixCalcMath math = new MatrixCalcMath();
-        //A(2,3) B(3,2) => C(2,2)
-        double[][] matrixA = { { 1.0, 2.0, 3.0}, { 4.0, 5.0, 6.0 } };
+        // 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 } };
-        assertArrayEquals("The first row is not correct", matrixC[0], math.matrixMultiplication(matrixA, matrixB)[0],
-                0.1);
-        assertArrayEquals("The seound row is not correct", matrixC[1], math.matrixMultiplication(matrixA, matrixB)[1],
-                0.1);
+
+        double[][] result = math.matrixMultiplication(matrixA, matrixB);
+
+        assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
+        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
     }
 
     @Test
     public void tryToMultiplyTowEmptyMatricies() {
         MatrixCalcMath math = new MatrixCalcMath();
-        //A(0,0) B(0,0) => null
+        // A(0,0) B(0,0) => null
         double[][] matrixA = new double[0][0];
         double[][] matrixB = new double[0][0];
-        assertArrayEquals(null, math.matrixAddition(matrixA, matrixB));
+
+        double[][] result = math.matrixMultiplication(matrixA, matrixB);
+
+        assertArrayEquals(null, result);
     }
 
     @Test
     public void tryToMultiplyTowNullObjects() {
         MatrixCalcMath math = new MatrixCalcMath();
-        //null null => null
+        // null null => null
         double[][] matrixA = null;
         double[][] matrixB = null;
-        assertArrayEquals(null, math.matrixAddition(matrixA, matrixB));
+
+        double[][] result = math.matrixMultiplication(matrixA, matrixB);
+
+        assertArrayEquals(null, result);
     }
 }

From e80a444fc70bf296003807b3abe6bd654dba5981 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Tue, 2 Jul 2019 09:47:15 +0200
Subject: [PATCH 05/30] Matrix substraction added, and renamed the test calss
 for it and the Matrix Addition

---
 .../com/ugsbo/matrixcalc/MatrixCalcMath.java  | 27 +++++++++++-
 ...=> MatrixAdditionAndSubstractionTest.java} | 43 ++++++++++++++++++-
 2 files changed, 67 insertions(+), 3 deletions(-)
 rename src/test/java/com/ugsbo/matrixcalc/{MatrixAdditionTest.java => MatrixAdditionAndSubstractionTest.java} (53%)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
index 76f1c5c..6ca296d 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
@@ -31,7 +31,7 @@ public class MatrixCalcMath {
             return result;
         } else {
             return null;
-            //throw new IllegalArgumentException("Matricies must be linked");
+            // throw new IllegalArgumentException("Matricies must be linked");
         }
     }
 
@@ -97,4 +97,29 @@ public class MatrixCalcMath {
         }
 
     }
+
+    /**
+     * 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 {
+            return null;
+            // TODO Fragen wie man eine Exception testen kann.
+            // throw new IllegalArgumentException("Matricies need to have the same
+            // Dimensions");
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixAdditionTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixAdditionAndSubstractionTest.java
similarity index 53%
rename from src/test/java/com/ugsbo/matrixcalc/MatrixAdditionTest.java
rename to src/test/java/com/ugsbo/matrixcalc/MatrixAdditionAndSubstractionTest.java
index 4ca53bb..44ebfa8 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixAdditionTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixAdditionAndSubstractionTest.java
@@ -7,9 +7,9 @@ import static org.junit.Assert.assertTrue;
 import org.junit.Test;
 
 /**
- * Tests the funktionality to add two matricies
+ * Tests the funktionality to add and substract two matricies
  */
-public class MatrixAdditionTest {
+public class MatrixAdditionAndSubstractionTest {
 
     @Test
     public void twoMatriciesHaveTheSameDimensions() {
@@ -58,4 +58,43 @@ public class MatrixAdditionTest {
         assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
         assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
     }
+
+    @Test
+    public void substractTwoMatriciesWithSameContent() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        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 = math.matrixSubstraction(matrixA, matrixB);
+
+        assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
+        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+    }
+
+    @Test
+    public void substractTwoMatriciesWithDiffrentContent() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        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 = math.matrixSubstraction(matrixA, matrixB);
+
+        assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
+        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+    }
+
+    @Test
+    public void substractTwoMatriciesWithNegativeContent() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        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 = math.matrixSubstraction(matrixA, matrixB);
+
+        assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
+        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+    }
 }
\ No newline at end of file

From 0318b36f94bc37948e4317e04526c121e61cc5b0 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Tue, 2 Jul 2019 10:19:38 +0200
Subject: [PATCH 06/30] Orginazied some Imports and added Matrix Transponation

---
 .../com/ugsbo/matrixcalc/MatrixCalcMath.java  | 22 ++++++++
 .../matrixcalc/MatrixMultiplicationTest.java  |  2 -
 .../ugsbo/matrixcalc/MatrixTransposeTest.java | 52 +++++++++++++++++++
 3 files changed, 74 insertions(+), 2 deletions(-)
 create mode 100644 src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
index 6ca296d..20af826 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
@@ -122,4 +122,26 @@ public class MatrixCalcMath {
             // 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) {
+            // TODO hier auch die exception.
+            return null;
+        }
+        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;
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
index c8a098b..c09e80d 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
@@ -1,12 +1,10 @@
 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.Test;
-import org.junit.internal.matchers.ThrowableCauseMatcher;
 
 /**
  * Testet die Matrix Multiplication funkionalität
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java
new file mode 100644
index 0000000..437ff1c
--- /dev/null
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java
@@ -0,0 +1,52 @@
+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.Test;
+
+/**
+ * Tests the funktionality to Transpose a Matix
+ */
+public class MatrixTransposeTest {
+
+    @Test
+    public void TransformQuadraticMatrixAResultsInQuadraticMatrixC() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        // 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 = math.matrixTransponation(matrixA);
+
+        assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
+        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+    }
+
+    @Test
+    public void Transform2by3MatrixAResultsIn3by2MatrixC() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        // 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 = math.matrixTransponation(matrixA);
+
+        assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
+        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+    }
+
+    @Test
+    public void Transform1by3MatrixAResultsIn3by1MatrixC() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        // A(1,3) => C(1,3)
+        double[][] matrixA = { { 1.0, 2.0, 3.0 } };
+        double[][] matrixC = { { 1.0 }, { 2.0 }, { 3.0 } };
+
+        double[][] result = math.matrixTransponation(matrixA);
+
+        assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
+        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+    }
+}

From 52b8a818a85b458f7049d5210982b5c748a665bc Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Wed, 3 Jul 2019 10:59:18 +0200
Subject: [PATCH 07/30] fixed project setup Junit Tests can now run automaticly
 and removed some unused imports.

---
 pom.xml                                                  | 2 +-
 src/main/java/com/ugsbo/gui/StartApplication.java        | 8 ++++++++
 src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java   | 2 +-
 src/main/java/module-info.java                           | 9 ---------
 .../java/com/ugsbo/matrixcalc/MatrixTransposeTest.java   | 2 --
 5 files changed, 10 insertions(+), 13 deletions(-)
 create mode 100644 src/main/java/com/ugsbo/gui/StartApplication.java
 delete mode 100644 src/main/java/module-info.java

diff --git a/pom.xml b/pom.xml
index 35fb9b7..afa24d1 100644
--- a/pom.xml
+++ b/pom.xml
@@ -99,7 +99,7 @@
             <release>12</release>
             <jlinkImageName>UGSBO</jlinkImageName>
             <launcher>launcher</launcher>
-            <mainClass>UGSBO/com.ugsbo.gui.MainApp</mainClass>
+            <mainClass>UGSBO/com.ugsbo.gui.StartApplication</mainClass>
           </configuration>
         </plugin>
       </plugins>
diff --git a/src/main/java/com/ugsbo/gui/StartApplication.java b/src/main/java/com/ugsbo/gui/StartApplication.java
new file mode 100644
index 0000000..38cccea
--- /dev/null
+++ b/src/main/java/com/ugsbo/gui/StartApplication.java
@@ -0,0 +1,8 @@
+package com.ugsbo.gui;
+
+public class StartApplication {
+
+    public static void main(String[] args) {
+        MainApp.main(args);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
index 20af826..662a87d 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
@@ -1,6 +1,6 @@
 package com.ugsbo.matrixcalc;
 
-import java.io.IOException;
+//import java.io.IOException;
 
 /**
  * Contains all basic matrix math calculations.
diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java
deleted file mode 100644
index b859978..0000000
--- a/src/main/java/module-info.java
+++ /dev/null
@@ -1,9 +0,0 @@
-module UGSBO {
-    requires javafx.controls;
-    requires javafx.fxml;
-
-    opens com.ugsbo.matrixcalc to javafx.fxml;
-    opens com.ugsbo.gui to javafx.fxml;
-
-    exports com.ugsbo.gui;
-}
\ No newline at end of file
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java
index 437ff1c..c6a9918 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java
@@ -1,8 +1,6 @@
 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.Test;
 

From f5c91caa85e6957c09c43e78356c9744505b52d3 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Thu, 4 Jul 2019 09:10:44 +0200
Subject: [PATCH 08/30] Added Claculateing Determinat for 2by2 and 3by3
 Matrices

---
 .../com/ugsbo/matrixcalc/MatrixCalcMath.java  | 85 ++++++++++++++++---
 .../matrixcalc/MatrixCalcDeterminatTest.java  | 45 ++++++++++
 2 files changed, 117 insertions(+), 13 deletions(-)
 create mode 100644 src/test/java/com/ugsbo/matrixcalc/MatrixCalcDeterminatTest.java

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
index 662a87d..5c1728d 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
@@ -30,8 +30,7 @@ public class MatrixCalcMath {
             }
             return result;
         } else {
-            return null;
-            // throw new IllegalArgumentException("Matricies must be linked");
+            throw new IllegalArgumentException("Matricies must be linked");
         }
     }
 
@@ -74,10 +73,7 @@ public class MatrixCalcMath {
             }
             return result;
         } else {
-            return null;
-            // TODO Fragen wie man eine Exception testen kann.
-            // throw new IllegalArgumentException("Matricies need to have the same
-            // Dimensions");
+            throw new IllegalArgumentException("Matricies need to have the same Dimensions");
         }
     }
 
@@ -90,6 +86,12 @@ public class MatrixCalcMath {
      * @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 {
@@ -116,10 +118,7 @@ public class MatrixCalcMath {
             }
             return result;
         } else {
-            return null;
-            // TODO Fragen wie man eine Exception testen kann.
-            // throw new IllegalArgumentException("Matricies need to have the same
-            // Dimensions");
+            throw new IllegalArgumentException("Matricies need to have the same Dimensions");
         }
     }
 
@@ -130,9 +129,14 @@ public class MatrixCalcMath {
      * @return The Transposed matrix of matrix A
      */
     public double[][] matrixTransponation(double[][] matrixA) {
-        if(matrixA == null) {
-            // TODO hier auch die exception.
-            return null;
+        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;
@@ -144,4 +148,59 @@ public class MatrixCalcMath {
         }
         return result;
     }
+
+    /**
+     * Calculates the Determinant of a Matrix.
+     * 
+     * @param matrixA The Inputmatrix
+     * @return The Determinant of the Matrix A
+     */
+    public double calcDeterminat(double[][] matrixA) {
+        // 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;
+    }
+
+    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;
+    }
+
+    private double calc2by2Determinant(double[][] matrixA) {
+        double result = matrixA[0][0] * matrixA[1][1] - matrixA[0][1] * matrixA[1][0];
+        return result;
+    }
+
+    private int getMatrixRowCount(double[][] matrixA) {
+        return matrixA.length;
+    }
+
+    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;
+    }
+
 }
\ No newline at end of file
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixCalcDeterminatTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixCalcDeterminatTest.java
new file mode 100644
index 0000000..5a12760
--- /dev/null
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixCalcDeterminatTest.java
@@ -0,0 +1,45 @@
+package com.ugsbo.matrixcalc;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+/**
+ * Tests the funktionality to Calculate the Determinant of a Matrix.
+ */
+public class MatrixCalcDeterminatTest {
+
+    @Test
+    public void CalculatesTheDeterminanteOfA2by2Matrix() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        // A(2,2)
+        double[][] matrixA = { { 1.0, 2.0 }, { 3.0, 4.0 } };
+        double determinat = -2.0;
+
+        double result = math.calcDeterminat(matrixA);
+
+        assertEquals("The Determinant is not as it should be", determinat, result, 0.01);
+    }
+
+    @Test
+    public void CalculatesTheDeterminanteOfA3by3Matrix() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        // 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 result = math.calcDeterminat(matrixA);
+        
+        assertEquals("The Determinant is not as it should be", determinat, result, 0.01);
+
+        
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void tryToCalculateA4by4MatrixSouldResulInIllegalArgumentException() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        // 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} };
+        
+        math.calcDeterminat(matrixA);
+    }
+}
\ No newline at end of file

From e57a53d6d05b5004b07923deb84de9892f3e5241 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Thu, 4 Jul 2019 09:12:12 +0200
Subject: [PATCH 09/30] Added and chnged tests in order to test Exceptions
 instead of if the funktion is returning null

---
 .../MatrixAdditionAndSubstractionTest.java    | 71 +++++++++++++++++--
 .../matrixcalc/MatrixMultiplicationTest.java  | 28 ++++----
 .../ugsbo/matrixcalc/MatrixTransposeTest.java |  8 ++-
 3 files changed, 84 insertions(+), 23 deletions(-)

diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixAdditionAndSubstractionTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixAdditionAndSubstractionTest.java
index 44ebfa8..e80d737 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixAdditionAndSubstractionTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixAdditionAndSubstractionTest.java
@@ -43,7 +43,7 @@ public class MatrixAdditionAndSubstractionTest {
         double[][] result = math.matrixAddition(matrixA, matrixB);
 
         assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
-        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+        assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1);
     }
     
     @Test
@@ -56,7 +56,37 @@ public class MatrixAdditionAndSubstractionTest {
         double[][] result = math.matrixAddition(matrixA, matrixB);
 
         assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
-        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+        assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void tryToAddTowEmptyMatricies() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        // A(0,0) B(0,0) => IllegalArgumentException
+        double[][] matrixA = new double[0][0];
+        double[][] matrixB = new double[0][0];
+        
+        math.matrixAddition(matrixA, matrixB);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void tryToAddTowNullMatrices() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        // A(0,0) B(0,0) => IllegalArgumentException
+        double[][] matrixA = null;
+        double[][] matrixB = null;
+        
+        math.matrixAddition(matrixA, matrixB); 
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void tryToAddTowMatricesWithDifferentDimensions() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        // A(0,0) B(0,0) => IllegalArgumentException
+        double[][] matrixA = {{1.0, 2.0}};
+        double[][] matrixB = {{1.0}, {2.0}};
+        
+        math.matrixAddition(matrixA, matrixB); 
     }
 
     @Test
@@ -69,7 +99,7 @@ public class MatrixAdditionAndSubstractionTest {
         double[][] result = math.matrixSubstraction(matrixA, matrixB);
 
         assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
-        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+        assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1);
     }
 
     @Test
@@ -82,7 +112,7 @@ public class MatrixAdditionAndSubstractionTest {
         double[][] result = math.matrixSubstraction(matrixA, matrixB);
 
         assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
-        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+        assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1);
     }
 
     @Test
@@ -95,6 +125,37 @@ public class MatrixAdditionAndSubstractionTest {
         double[][] result = math.matrixSubstraction(matrixA, matrixB);
 
         assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
-        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+        assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void tryToSubstractTowEmptyMatricies() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        // A(0,0) B(0,0) => IllegalArgumentException
+        double[][] matrixA = new double[0][0];
+        double[][] matrixB = new double[0][0];
+
+        math.matrixSubstraction(matrixA, matrixB);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void tryToSubstractTowNullMatrices() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        // A(0,0) B(0,0) => IllegalArgumentException
+        double[][] matrixA = null;
+        double[][] matrixB = null;
+
+        math.matrixSubstraction(matrixA, matrixB);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void tryToSubstractTowMatricesWithDifferentDimensions() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        // A(0,0) B(0,0) => IllegalArgumentException
+        double[][] matrixA = {{1.0, 2.0}};
+        double[][] matrixB = {{1.0}, {2.0}};
+
+        math.matrixSubstraction(matrixA, matrixB);
+
     }
 }
\ No newline at end of file
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
index c09e80d..eb02ee2 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
@@ -54,7 +54,7 @@ public class MatrixMultiplicationTest {
         double[][] result = math.matrixMultiplication(matrixA, matrixB);
 
         assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
-        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+        assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1);
     }
 
     @Test
@@ -68,7 +68,7 @@ public class MatrixMultiplicationTest {
         double[][] result = math.matrixMultiplication(matrixA, matrixB);
 
         assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
-        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+        assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1);
     }
 
     @Test
@@ -82,30 +82,28 @@ public class MatrixMultiplicationTest {
         double[][] result = math.matrixMultiplication(matrixA, matrixB);
 
         assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
-        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+        assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1);
     }
 
-    @Test
+    @Test(expected = IllegalArgumentException.class)
+
     public void tryToMultiplyTowEmptyMatricies() {
         MatrixCalcMath math = new MatrixCalcMath();
-        // A(0,0) B(0,0) => null
+        // A(0,0) B(0,0) => IllegalArgumentException
         double[][] matrixA = new double[0][0];
         double[][] matrixB = new double[0][0];
-
-        double[][] result = math.matrixMultiplication(matrixA, matrixB);
-
-        assertArrayEquals(null, result);
+        
+        math.matrixMultiplication(matrixA, matrixB);
     }
 
-    @Test
+    @Test(expected = IllegalArgumentException.class)
+
     public void tryToMultiplyTowNullObjects() {
         MatrixCalcMath math = new MatrixCalcMath();
-        // null null => null
+        // null null => IllegalArgumentException
         double[][] matrixA = null;
         double[][] matrixB = null;
-
-        double[][] result = math.matrixMultiplication(matrixA, matrixB);
-
-        assertArrayEquals(null, result);
+        
+        math.matrixMultiplication(matrixA, matrixB);
     }
 }
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java
index c6a9918..7bfa6de 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java
@@ -19,7 +19,7 @@ public class MatrixTransposeTest {
         double[][] result = math.matrixTransponation(matrixA);
 
         assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
-        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 0.1);
+        assertArrayEquals("The second row is not correct", matrixC[1], result[1], 0.1);
     }
 
     @Test
@@ -32,7 +32,8 @@ public class MatrixTransposeTest {
         double[][] result = math.matrixTransponation(matrixA);
 
         assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
-        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 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
@@ -45,6 +46,7 @@ public class MatrixTransposeTest {
         double[][] result = math.matrixTransponation(matrixA);
 
         assertArrayEquals("The first row is not correct", matrixC[0], result[0], 0.1);
-        assertArrayEquals("The seound row is not correct", matrixC[1], result[1], 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);
     }
 }

From 5f8198e0467f230d997de28e7af4e9cfd95c8c61 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Sat, 6 Jul 2019 16:32:00 +0200
Subject: [PATCH 10/30] Adding CheckInput for a matrix with basic checks

---
 .../matrixcalc/MatrixCalcController.java      | 40 +++++++++++++--
 .../matrixcalc/MatrixInputcheckTest.java      | 49 +++++++++++++++++++
 2 files changed, 84 insertions(+), 5 deletions(-)
 create mode 100644 src/test/java/com/ugsbo/matrixcalc/MatrixInputcheckTest.java

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index f8e1cdb..3dd8596 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -3,6 +3,8 @@ package com.ugsbo.matrixcalc;
 import javafx.fxml.FXML;
 import javafx.scene.control.*;
 import javafx.scene.text.Text;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public class MatrixCalcController {
 
@@ -28,12 +30,40 @@ public class MatrixCalcController {
     @FXML
     public void initialize() {
         multiplyButton.setOnMouseClicked((event) -> {
-            // TODO matrixATextArea and matrixBTextArea need to be parsed to double[][] do
-            // this in an extern Methode maybe an extern class.
-            // MatrixCalcMath math = new MatrixCalcMath();
-            // math.matrixMultiplication(matrixATextArea, matrixATextArea);
-            System.out.println(event);
+            String matrixA = matrixATextArea.getText();
+            String matrixB = matrixBTextArea.getText();
+            if (checkInput(matrixA)) {
+                // TODO matrixATextArea and matrixBTextArea need to be parsed to double[][] do
+                // this in an extern Methode maybe an extern class.
+                // MatrixCalcMath math = new MatrixCalcMath();
+                // math.matrixMultiplication(matrixATextArea, matrixATextArea);
+            }
+            // System.out.println(matrixATextArea.getText());
         });
     }
 
+    public boolean checkInput(String matrix) {
+        boolean isMatched = false;
+        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
+        // 3times
+        String row2 = "(\\n){0,3}(\\d*\\u0020*){0,3}";
+        String row3 = "(\\n){0,3}(\\d*\\u0020*){0,3}";
+
+        // TODO get the input check more stricktly missing matrix slots are allowed.
+
+        Pattern p = Pattern.compile(row1 + row2 + row3);
+        Matcher m = p.matcher(matrix);
+
+        isMatched = m.matches();
+
+        // System.out.println(isMatched);
+        return isMatched;
+    }
+
 }
\ No newline at end of file
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixInputcheckTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixInputcheckTest.java
new file mode 100644
index 0000000..483e000
--- /dev/null
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixInputcheckTest.java
@@ -0,0 +1,49 @@
+package com.ugsbo.matrixcalc;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/**
+ * Tests how well worng input can be determent.
+ */
+public class MatrixInputcheckTest {
+
+    @Test(expected = IllegalArgumentException.class)
+    public void inputEmptySouldThrowAIllegalArgumentException() {
+     MatrixCalcController contr = new MatrixCalcController();
+     String input = "";
+
+     contr.checkInput(input);
+    }
+
+    @Test
+    public void checkIfA1by3MatrixIsMatched(){
+     MatrixCalcController contr = new MatrixCalcController();
+     String input = "1 2 3";
+
+     boolean result = contr.checkInput(input);
+
+     assertTrue("The 1 by 3 Matrix was not Matched but it should be.", result);
+    }
+
+    @Test
+    public void checkIfA2by3MatrixIsMatched(){
+     MatrixCalcController contr = new MatrixCalcController();
+     String input = "1 2 3\n1 2 3";
+
+     boolean result = contr.checkInput(input);
+
+     assertTrue("The 2 by 3 Matrix was not Matched but it should be.", result);
+    }
+
+    @Test
+    public void checkIfA3by3MatrixIsMatched(){
+     MatrixCalcController contr = new MatrixCalcController();
+     String input = "1 2 3\n1 2 3\n1 2 3";
+
+     boolean result = contr.checkInput(input);
+
+     assertTrue("The 3 by 3 Matrix was not Matched but it should be.", result);
+    }
+}
\ No newline at end of file

From 05c259c0d18e62cd5923e2686d04475ce7a9e35a Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Tue, 9 Jul 2019 16:39:02 +0200
Subject: [PATCH 11/30] Added and changed some Documentaion

---
 .../matrixcalc/MatrixCalcController.java      |  7 +++++
 .../com/ugsbo/matrixcalc/MatrixCalcMath.java  | 31 ++++++++++++++++---
 .../matrixcalc/MatrixCalcDeterminatTest.java  |  9 ++++++
 3 files changed, 43 insertions(+), 4 deletions(-)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index 3dd8596..3b93482 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -42,6 +42,13 @@ public class MatrixCalcController {
         });
     }
 
+    /**
+     * Chcks 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.
+     */
     public boolean checkInput(String matrix) {
         boolean isMatched = false;
         if (matrix.length() == 0) {
diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
index 5c1728d..78ef29e 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
@@ -1,7 +1,5 @@
 package com.ugsbo.matrixcalc;
 
-//import java.io.IOException;
-
 /**
  * Contains all basic matrix math calculations.
  */
@@ -132,10 +130,10 @@ public class MatrixCalcMath {
         if (matrixA == null) {
             throw new IllegalArgumentException("Matricies need to have the same Dimensions");
         }
-        if (matrixA.length == 0){
+        if (matrixA.length == 0) {
             throw new IllegalArgumentException("Matricies need to have the same Dimensions");
         }
-        if(matrixA[0] == null){
+        if (matrixA[0] == null) {
             throw new IllegalArgumentException("Matricies need to have the same Dimensions");
         }
         int columCountResult = matrixA.length;
@@ -174,6 +172,12 @@ public class MatrixCalcMath {
         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]
@@ -181,15 +185,34 @@ public class MatrixCalcMath {
         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;
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixCalcDeterminatTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixCalcDeterminatTest.java
index 5a12760..a40ff64 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixCalcDeterminatTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixCalcDeterminatTest.java
@@ -42,4 +42,13 @@ public class MatrixCalcDeterminatTest {
         
         math.calcDeterminat(matrixA);
     }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void tryToCalculateANonQuadraticMatrixSouldResulInIllegalArgumentException() {
+        MatrixCalcMath math = new MatrixCalcMath();
+        // A(2,4)
+        double[][] matrixA = {{5.0, 6.0, 0.0, 0.0}, {5.0, 6.0, 0.0, 0.0} };
+        
+        math.calcDeterminat(matrixA);
+    }
 }
\ No newline at end of file

From f7bd4010f7fca34e25b054ef925d99e01d72e885 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Wed, 10 Jul 2019 14:14:02 +0200
Subject: [PATCH 12/30] Refactoring and renameing of some functions

---
 .../MatrixAdditionAndSubstractionTest.java    | 63 +++++++++----------
 .../matrixcalc/MatrixCalcDeterminatTest.java  | 47 ++++++++------
 .../matrixcalc/MatrixInputcheckTest.java      | 40 ++++++------
 .../matrixcalc/MatrixMultiplicationTest.java  | 38 +++++------
 .../ugsbo/matrixcalc/MatrixTransposeTest.java | 23 ++++---
 5 files changed, 111 insertions(+), 100 deletions(-)

diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixAdditionAndSubstractionTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixAdditionAndSubstractionTest.java
index e80d737..7a83419 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixAdditionAndSubstractionTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixAdditionAndSubstractionTest.java
@@ -4,6 +4,7 @@ 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;
 
 /**
@@ -11,49 +12,52 @@ import org.junit.Test;
  */
 public class MatrixAdditionAndSubstractionTest {
 
+    private MatrixCalcMath matrixMath;
+
+    @Before
+    public void setup() {
+        matrixMath = new MatrixCalcMath();
+    }
+
     @Test
     public void twoMatriciesHaveTheSameDimensions() {
-        MatrixCalcMath math = new MatrixCalcMath();
         double[][] matrixA = new double[1][1];
         double[][] matrixB = new double[1][1];
 
-        boolean result = math.checkIfMatriciesAreTheSameDimension(matrixA, matrixB);
+        boolean result = matrixMath.checkIfMatriciesAreTheSameDimension(matrixA, matrixB);
 
         assertTrue("Two Matricies with the same Dimension were not detected as that", result);
     }
 
     @Test
     public void twoMatriciesDONOTHaveTheSameDimensions() {
-        MatrixCalcMath math = new MatrixCalcMath();
         double[][] matrixA = new double[2][1];
         double[][] matrixB = new double[1][1];
 
-        boolean result = math.checkIfMatriciesAreTheSameDimension(matrixA, matrixB);
+        boolean result = matrixMath.checkIfMatriciesAreTheSameDimension(matrixA, matrixB);
 
         assertFalse("Two Matricies without the same Dimension were detected as that", result);
     }
 
     @Test
     public void addTwoMatriciesWithSameContent() {
-        MatrixCalcMath math = new MatrixCalcMath();
         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 = math.matrixAddition(matrixA, matrixB);
+        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() {
-        MatrixCalcMath math = new MatrixCalcMath();
         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 = math.matrixAddition(matrixA, matrixB);
+        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);
@@ -61,42 +65,38 @@ public class MatrixAdditionAndSubstractionTest {
 
     @Test(expected = IllegalArgumentException.class)
     public void tryToAddTowEmptyMatricies() {
-        MatrixCalcMath math = new MatrixCalcMath();
         // A(0,0) B(0,0) => IllegalArgumentException
         double[][] matrixA = new double[0][0];
         double[][] matrixB = new double[0][0];
-        
-        math.matrixAddition(matrixA, matrixB);
+
+        matrixMath.matrixAddition(matrixA, matrixB);
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void tryToAddTowNullMatrices() {
-        MatrixCalcMath math = new MatrixCalcMath();
         // A(0,0) B(0,0) => IllegalArgumentException
         double[][] matrixA = null;
         double[][] matrixB = null;
-        
-        math.matrixAddition(matrixA, matrixB); 
+
+        matrixMath.matrixAddition(matrixA, matrixB);
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void tryToAddTowMatricesWithDifferentDimensions() {
-        MatrixCalcMath math = new MatrixCalcMath();
         // A(0,0) B(0,0) => IllegalArgumentException
-        double[][] matrixA = {{1.0, 2.0}};
-        double[][] matrixB = {{1.0}, {2.0}};
-        
-        math.matrixAddition(matrixA, matrixB); 
+        double[][] matrixA = { { 1.0, 2.0 } };
+        double[][] matrixB = { { 1.0 }, { 2.0 } };
+
+        matrixMath.matrixAddition(matrixA, matrixB);
     }
 
     @Test
     public void substractTwoMatriciesWithSameContent() {
-        MatrixCalcMath math = new MatrixCalcMath();
         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 = math.matrixSubstraction(matrixA, matrixB);
+        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);
@@ -104,12 +104,11 @@ public class MatrixAdditionAndSubstractionTest {
 
     @Test
     public void substractTwoMatriciesWithDiffrentContent() {
-        MatrixCalcMath math = new MatrixCalcMath();
         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 = math.matrixSubstraction(matrixA, matrixB);
+        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);
@@ -117,12 +116,11 @@ public class MatrixAdditionAndSubstractionTest {
 
     @Test
     public void substractTwoMatriciesWithNegativeContent() {
-        MatrixCalcMath math = new MatrixCalcMath();
         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 = math.matrixSubstraction(matrixA, matrixB);
+        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);
@@ -130,32 +128,29 @@ public class MatrixAdditionAndSubstractionTest {
 
     @Test(expected = IllegalArgumentException.class)
     public void tryToSubstractTowEmptyMatricies() {
-        MatrixCalcMath math = new MatrixCalcMath();
         // A(0,0) B(0,0) => IllegalArgumentException
         double[][] matrixA = new double[0][0];
         double[][] matrixB = new double[0][0];
 
-        math.matrixSubstraction(matrixA, matrixB);
+        matrixMath.matrixSubstraction(matrixA, matrixB);
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void tryToSubstractTowNullMatrices() {
-        MatrixCalcMath math = new MatrixCalcMath();
         // A(0,0) B(0,0) => IllegalArgumentException
         double[][] matrixA = null;
         double[][] matrixB = null;
 
-        math.matrixSubstraction(matrixA, matrixB);
+        matrixMath.matrixSubstraction(matrixA, matrixB);
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void tryToSubstractTowMatricesWithDifferentDimensions() {
-        MatrixCalcMath math = new MatrixCalcMath();
         // A(0,0) B(0,0) => IllegalArgumentException
-        double[][] matrixA = {{1.0, 2.0}};
-        double[][] matrixB = {{1.0}, {2.0}};
+        double[][] matrixA = { { 1.0, 2.0 } };
+        double[][] matrixB = { { 1.0 }, { 2.0 } };
 
-        math.matrixSubstraction(matrixA, matrixB);
+        matrixMath.matrixSubstraction(matrixA, matrixB);
 
     }
 }
\ No newline at end of file
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixCalcDeterminatTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixCalcDeterminatTest.java
index a40ff64..9031ad7 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixCalcDeterminatTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixCalcDeterminatTest.java
@@ -2,6 +2,7 @@ package com.ugsbo.matrixcalc;
 
 import static org.junit.Assert.assertEquals;
 
+import org.junit.Before;
 import org.junit.Test;
 
 /**
@@ -9,46 +10,52 @@ import org.junit.Test;
  */
 public class MatrixCalcDeterminatTest {
 
+    private MatrixCalcMath matrixMath;
+
+    @Before
+    public void setup() {
+        matrixMath = new MatrixCalcMath();
+    }
+
     @Test
     public void CalculatesTheDeterminanteOfA2by2Matrix() {
-        MatrixCalcMath math = new MatrixCalcMath();
         // A(2,2)
         double[][] matrixA = { { 1.0, 2.0 }, { 3.0, 4.0 } };
         double determinat = -2.0;
+        double delta = 0.01;
 
-        double result = math.calcDeterminat(matrixA);
+        double result = matrixMath.calcDeterminat(matrixA);
 
-        assertEquals("The Determinant is not as it should be", determinat, result, 0.01);
+        assertEquals("The Determinant is not as it should be", determinat, result, delta);
     }
 
     @Test
     public void CalculatesTheDeterminanteOfA3by3Matrix() {
-        MatrixCalcMath math = new MatrixCalcMath();
         // A(3,3)
-        double[][] matrixA = { { 1.0, 2.0, 1.0 }, { 3.0, 4.0, 0.0 }, {5.0, 6.0, 0.0} };
+        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 result = math.calcDeterminat(matrixA);
-        
-        assertEquals("The Determinant is not as it should be", determinat, result, 0.01);
+        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 tryToCalculateA4by4MatrixSouldResulInIllegalArgumentException() {
-        MatrixCalcMath math = new MatrixCalcMath();
+    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} };
-        
-        math.calcDeterminat(matrixA);
+        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 tryToCalculateANonQuadraticMatrixSouldResulInIllegalArgumentException() {
-        MatrixCalcMath math = new MatrixCalcMath();
+    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} };
-        
-        math.calcDeterminat(matrixA);
+        double[][] matrixA = { { 5.0, 6.0, 0.0, 0.0 }, { 5.0, 6.0, 0.0, 0.0 } };
+
+        matrixMath.calcDeterminat(matrixA);
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixInputcheckTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixInputcheckTest.java
index 483e000..04593c5 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixInputcheckTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixInputcheckTest.java
@@ -2,6 +2,7 @@ package com.ugsbo.matrixcalc;
 
 import static org.junit.Assert.assertTrue;
 
+import org.junit.Before;
 import org.junit.Test;
 
 /**
@@ -9,41 +10,44 @@ import org.junit.Test;
  */
 public class MatrixInputcheckTest {
 
+    private MatrixCalcController controller;
+
+    @Before
+    public void setup() {
+        controller = new MatrixCalcController();
+    }
+
     @Test(expected = IllegalArgumentException.class)
     public void inputEmptySouldThrowAIllegalArgumentException() {
-     MatrixCalcController contr = new MatrixCalcController();
-     String input = "";
+        String input = "";
 
-     contr.checkInput(input);
+        controller.checkInput(input);
     }
 
     @Test
-    public void checkIfA1by3MatrixIsMatched(){
-     MatrixCalcController contr = new MatrixCalcController();
-     String input = "1 2 3";
+    public void checkIfA1by3MatrixIsValidInput() {
+        String input = "1 2 3";
 
-     boolean result = contr.checkInput(input);
+        boolean result = controller.checkInput(input);
 
-     assertTrue("The 1 by 3 Matrix was not Matched but it should be.", result);
+        assertTrue("The 1 by 3 Matrix should be Matched as valid input.", result);
     }
 
     @Test
-    public void checkIfA2by3MatrixIsMatched(){
-     MatrixCalcController contr = new MatrixCalcController();
-     String input = "1 2 3\n1 2 3";
+    public void checkIfA2by3MatrixIsValidInput() {
+        String input = "1 2 3\n1 2 3";
 
-     boolean result = contr.checkInput(input);
+        boolean result = controller.checkInput(input);
 
-     assertTrue("The 2 by 3 Matrix was not Matched but it should be.", result);
+        assertTrue("The 2 by 3 Matrix should be Matched as valid input.", result);
     }
 
     @Test
-    public void checkIfA3by3MatrixIsMatched(){
-     MatrixCalcController contr = new MatrixCalcController();
-     String input = "1 2 3\n1 2 3\n1 2 3";
+    public void checkIfA3by3MatrixIsValidInput() {
+        String input = "1 2 3\n1 2 3\n1 2 3";
 
-     boolean result = contr.checkInput(input);
+        boolean result = controller.checkInput(input);
 
-     assertTrue("The 3 by 3 Matrix was not Matched but it should be.", result);
+        assertTrue("The 3 by 3 Matrix should be Matched as valid input.", result);
     }
 }
\ No newline at end of file
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
index eb02ee2..e322d1f 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixMultiplicationTest.java
@@ -4,6 +4,7 @@ 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;
 
 /**
@@ -11,47 +12,50 @@ import org.junit.Test;
  */
 public class MatrixMultiplicationTest {
 
+    private MatrixCalcMath matrixMath;
+
+    @Before
+    public void setup() {
+        matrixMath = new MatrixCalcMath();
+    }
+
     @Test
     public void matrixAIsLinkedToMatrixBSouldBeTrue() {
-        MatrixCalcMath math = new MatrixCalcMath();
         double[][] matrixA = new double[1][2];
         double[][] matrixB = new double[2][1];
 
-        boolean result = math.checkIfMatriciesAreLinked(matrixA, matrixB);
-        
+        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() {
-        MatrixCalcMath math = new MatrixCalcMath();
         double[][] matrixA = null;
         double[][] matrixB = null;
 
-        boolean result = math.checkIfMatriciesAreLinked(matrixA, matrixB);
+        boolean result = matrixMath.checkIfMatriciesAreLinked(matrixA, matrixB);
 
         assertFalse("Matrix A and B are null but detected as Linked", result);
     }
 
     @Test
     public void matrixAAndMatrixBAreNotLinkedSouldReturnFalse() {
-        MatrixCalcMath math = new MatrixCalcMath();
         double[][] matrixA = new double[1][1];
         double[][] matrixB = new double[2][1];
 
-        boolean result = math.checkIfMatriciesAreLinked(matrixA, matrixB);
+        boolean result = matrixMath.checkIfMatriciesAreLinked(matrixA, matrixB);
 
         assertFalse("Matrix A and B are not Linked but detected as Linked", result);
     }
 
     @Test
     public void multiplyTwoMatriciesWithSameDimensionsAndSameContent() {
-        MatrixCalcMath math = new MatrixCalcMath();
         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 = math.matrixMultiplication(matrixA, matrixB);
+        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);
@@ -59,13 +63,12 @@ public class MatrixMultiplicationTest {
 
     @Test
     public void multiplyTowMatriciesWithDiffrentDimensions() {
-        MatrixCalcMath math = new MatrixCalcMath();
         // 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 = math.matrixMultiplication(matrixA, matrixB);
+        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);
@@ -73,13 +76,12 @@ public class MatrixMultiplicationTest {
 
     @Test
     public void multiplyTowMatriciesWithDiffrentDimensionsAndDiffentContent() {
-        MatrixCalcMath math = new MatrixCalcMath();
         // 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 = math.matrixMultiplication(matrixA, matrixB);
+        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);
@@ -88,22 +90,20 @@ public class MatrixMultiplicationTest {
     @Test(expected = IllegalArgumentException.class)
 
     public void tryToMultiplyTowEmptyMatricies() {
-        MatrixCalcMath math = new MatrixCalcMath();
         // A(0,0) B(0,0) => IllegalArgumentException
         double[][] matrixA = new double[0][0];
         double[][] matrixB = new double[0][0];
-        
-        math.matrixMultiplication(matrixA, matrixB);
+
+        matrixMath.matrixMultiplication(matrixA, matrixB);
     }
 
     @Test(expected = IllegalArgumentException.class)
 
     public void tryToMultiplyTowNullObjects() {
-        MatrixCalcMath math = new MatrixCalcMath();
         // null null => IllegalArgumentException
         double[][] matrixA = null;
         double[][] matrixB = null;
-        
-        math.matrixMultiplication(matrixA, matrixB);
+
+        matrixMath.matrixMultiplication(matrixA, matrixB);
     }
 }
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java
index 7bfa6de..51a5f55 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixTransposeTest.java
@@ -2,6 +2,7 @@ package com.ugsbo.matrixcalc;
 
 import static org.junit.Assert.assertArrayEquals;
 
+import org.junit.Before;
 import org.junit.Test;
 
 /**
@@ -9,27 +10,32 @@ import org.junit.Test;
  */
 public class MatrixTransposeTest {
 
+    private MatrixCalcMath matrixMath;
+
+    @Before
+    public void setup() {
+        matrixMath = new MatrixCalcMath();
+    }
+
     @Test
-    public void TransformQuadraticMatrixAResultsInQuadraticMatrixC() {
-        MatrixCalcMath math = new MatrixCalcMath();
+    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 = math.matrixTransponation(matrixA);
+        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 Transform2by3MatrixAResultsIn3by2MatrixC() {
-        MatrixCalcMath math = new MatrixCalcMath();
+    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 = math.matrixTransponation(matrixA);
+        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);
@@ -37,13 +43,12 @@ public class MatrixTransposeTest {
     }
 
     @Test
-    public void Transform1by3MatrixAResultsIn3by1MatrixC() {
-        MatrixCalcMath math = new MatrixCalcMath();
+    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 = math.matrixTransponation(matrixA);
+        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);

From c6b1fae7a62aa82a9805bc25ca970bb8f085631f Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Sun, 14 Jul 2019 18:35:54 +0200
Subject: [PATCH 13/30] String to matrix Method functional to parse 2by2
 matrices

---
 .../com/ugsbo/matrixcalc/MatrixCalcMath.java  | 483 +++++++++---------
 .../ugsbo/matrixcalc/StringToMatrixTest.java  |  41 ++
 2 files changed, 296 insertions(+), 228 deletions(-)
 create mode 100644 src/test/java/com/ugsbo/matrixcalc/StringToMatrixTest.java

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
index 78ef29e..bae9733 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
@@ -1,229 +1,256 @@
-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) {
-        // 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;
-    }
-
+package com.ugsbo.matrixcalc;
+
+import java.util.ArrayList;
+
+/**
+ * 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) {
+        // 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;
+    }
+
+    public double[][] stringToMatrix(String stringMatrix) {
+        
+        ArrayList<String[]> singleNumbersArr =  new ArrayList<String[]>();
+        
+        //Splitting the strings into thier rows
+        String[] singleNumbers = null;
+        String[] rows = stringMatrix.split("\n");
+        for (int i = 0; i < rows.length; i++) {
+            System.out.println(rows[i]);
+            singleNumbers = rows[i].split("\\s");
+            singleNumbersArr.add(singleNumbers);
+        }
+
+        int rowCount = rows.length; //row.length
+        int columCount = singleNumbersArr.size(); //output.length
+        double[][] result = new double[columCount][rowCount];
+        
+        for (int columIndex = 0; columIndex < singleNumbersArr.size(); columIndex++) {
+            for (int rowIndex = 0;  rowIndex < singleNumbers.length; rowIndex++) {
+                    result[columIndex][rowIndex] = Double.parseDouble(singleNumbersArr.get(columIndex)[rowIndex]);
+            }
+        }
+        return result;
+    }
+
 }
\ No newline at end of file
diff --git a/src/test/java/com/ugsbo/matrixcalc/StringToMatrixTest.java b/src/test/java/com/ugsbo/matrixcalc/StringToMatrixTest.java
new file mode 100644
index 0000000..104340d
--- /dev/null
+++ b/src/test/java/com/ugsbo/matrixcalc/StringToMatrixTest.java
@@ -0,0 +1,41 @@
+package com.ugsbo.matrixcalc;
+
+import static org.junit.Assert.assertArrayEquals;
+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 StringToMatrixTest {
+
+    private MatrixCalcMath matrixMath;
+
+    @Before
+    public void setup() {
+        matrixMath = new MatrixCalcMath();
+    }
+
+    @Test
+    public void StringWithSingleDigitNumbersToMatrix_ReturnsEquivalentMatrix() {
+        String inputString = "1";
+        double[][] expected = { { 1.0 } };
+        
+        double[][] result = matrixMath.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 = matrixMath.stringToMatrix(inputString);
+
+        assertArrayEquals("The first row is not correct", expected[0], result[0], 0.1);
+        assertArrayEquals("The first row is not correct", expected[1], result[1], 0.1);
+    }
+}

From 023b0dfe3858af9204b132c19c91506c39aecbad Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <lukas.reichwein@informatik.hs-fulda.de>
Date: Sun, 14 Jul 2019 19:08:16 +0200
Subject: [PATCH 14/30] String to matrix function is finished.

---
 .../com/ugsbo/matrixcalc/MatrixCalcMath.java  | 11 +++--
 .../ugsbo/matrixcalc/StringToMatrixTest.java  | 47 ++++++++++++++++++-
 2 files changed, 52 insertions(+), 6 deletions(-)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
index bae9733..98bb194 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
@@ -232,20 +232,21 @@ public class MatrixCalcMath {
         
         ArrayList<String[]> singleNumbersArr =  new ArrayList<String[]>();
         
-        //Splitting the strings into thier rows
+        //Splitting the strings into their rows
         String[] singleNumbers = null;
         String[] rows = stringMatrix.split("\n");
         for (int i = 0; i < rows.length; i++) {
-            System.out.println(rows[i]);
+            //System.out.println(rows[i]);
+        	//Splitting rows into their Numbers
             singleNumbers = rows[i].split("\\s");
             singleNumbersArr.add(singleNumbers);
         }
 
-        int rowCount = rows.length; //row.length
+        int rowlength = singleNumbersArr.get(0).length; //row.length
         int columCount = singleNumbersArr.size(); //output.length
-        double[][] result = new double[columCount][rowCount];
+        double[][] result = new double[columCount][rowlength];
         
-        for (int columIndex = 0; columIndex < singleNumbersArr.size(); columIndex++) {
+        for (int columIndex = 0; columIndex < columCount; columIndex++) {
             for (int rowIndex = 0;  rowIndex < singleNumbers.length; rowIndex++) {
                     result[columIndex][rowIndex] = Double.parseDouble(singleNumbersArr.get(columIndex)[rowIndex]);
             }
diff --git a/src/test/java/com/ugsbo/matrixcalc/StringToMatrixTest.java b/src/test/java/com/ugsbo/matrixcalc/StringToMatrixTest.java
index 104340d..2e5934d 100644
--- a/src/test/java/com/ugsbo/matrixcalc/StringToMatrixTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/StringToMatrixTest.java
@@ -36,6 +36,51 @@ public class StringToMatrixTest {
         double[][] result = matrixMath.stringToMatrix(inputString);
 
         assertArrayEquals("The first row is not correct", expected[0], result[0], 0.1);
-        assertArrayEquals("The first row is not correct", expected[1], result[1], 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 = matrixMath.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 = matrixMath.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 = matrixMath.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 = matrixMath.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);
     }
 }

From 9ad79c0f2e53cdf076758d0d8f76d05eedf37181 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <lukas.reichwein@informatik.hs-fulda.de>
Date: Sun, 14 Jul 2019 20:35:18 +0200
Subject: [PATCH 15/30] connected matrixMultiplication to the multiply Button

---
 .../matrixcalc/MatrixCalcController.java      | 31 ++++++++++++++-----
 .../com/ugsbo/gui/matrixCalcGui.fxml          | 12 +++----
 2 files changed, 30 insertions(+), 13 deletions(-)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index 3b93482..bd7fbc1 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -3,6 +3,8 @@ 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.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -29,14 +31,29 @@ public class MatrixCalcController {
      */
     @FXML
     public void initialize() {
+        /**
+         * Convert Strings to matricies, multiply them and output the result. 
+         */
         multiplyButton.setOnMouseClicked((event) -> {
-            String matrixA = matrixATextArea.getText();
-            String matrixB = matrixBTextArea.getText();
-            if (checkInput(matrixA)) {
-                // TODO matrixATextArea and matrixBTextArea need to be parsed to double[][] do
-                // this in an extern Methode maybe an extern class.
-                // MatrixCalcMath math = new MatrixCalcMath();
-                // math.matrixMultiplication(matrixATextArea, matrixATextArea);
+            String stringMatrixA = matrixATextArea.getText();
+            String stringMatrixB = matrixBTextArea.getText();
+            if (checkInput(stringMatrixA) && checkInput(stringMatrixB)) {
+                MatrixCalcMath math = new MatrixCalcMath();
+                double[][] matrixA = math.stringToMatrix(stringMatrixA);
+                double[][] matrixB = math.stringToMatrix(stringMatrixB);
+                double[][] result = math.matrixMultiplication(matrixA, matrixB);
+
+                String resultString  = "";
+                for (int i = 0; i < result.length; i++) {
+                    for (int j = 0; j < result[0].length; j++) {
+                        resultString += result[i][j] + "   ";
+                        //System.out.println(result[i][j]);
+                    }
+                    resultString += "\n\n";
+                }
+                //Display output
+                outputText.setText(resultString);
+                outputText.setTextAlignment(TextAlignment.CENTER);
             }
             // System.out.println(matrixATextArea.getText());
         });
diff --git a/src/main/resources/com/ugsbo/gui/matrixCalcGui.fxml b/src/main/resources/com/ugsbo/gui/matrixCalcGui.fxml
index abe1301..759bbba 100644
--- a/src/main/resources/com/ugsbo/gui/matrixCalcGui.fxml
+++ b/src/main/resources/com/ugsbo/gui/matrixCalcGui.fxml
@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
-<?import javafx.scene.text.*?>
-<?import javafx.scene.control.*?>
-<?import java.lang.*?>
-<?import javafx.scene.layout.*?>
+<?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">
+<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="400.0" prefWidth="600.0" xmlns="http://javafx.com/javafx/11.0.1" 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>
@@ -27,6 +27,6 @@
             <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" wrappingWidth="554.7294921875" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="10.0" AnchorPane.rightAnchor="10.0" AnchorPane.topAnchor="210.0" />
+      <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>

From 4d92178abe5b8367c4e816c8d0e69994f8a38717 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Mon, 15 Jul 2019 08:06:31 +0200
Subject: [PATCH 16/30] Refactoring, mostly extracting  code

---
 .../matrixcalc/MatrixCalcController.java      | 40 ++++++++++++++-----
 1 file changed, 29 insertions(+), 11 deletions(-)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index bd7fbc1..f307792 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -39,25 +39,43 @@ public class MatrixCalcController {
             String stringMatrixB = matrixBTextArea.getText();
             if (checkInput(stringMatrixA) && checkInput(stringMatrixB)) {
                 MatrixCalcMath math = new MatrixCalcMath();
+
                 double[][] matrixA = math.stringToMatrix(stringMatrixA);
                 double[][] matrixB = math.stringToMatrix(stringMatrixB);
                 double[][] result = math.matrixMultiplication(matrixA, matrixB);
 
-                String resultString  = "";
-                for (int i = 0; i < result.length; i++) {
-                    for (int j = 0; j < result[0].length; j++) {
-                        resultString += result[i][j] + "   ";
-                        //System.out.println(result[i][j]);
-                    }
-                    resultString += "\n\n";
-                }
-                //Display output
-                outputText.setText(resultString);
-                outputText.setTextAlignment(TextAlignment.CENTER);
+                outputMatrixToOutputText(result);
             }
             // System.out.println(matrixATextArea.getText());
         });
     }
+    /**
+     * Prints a given 2D-Array to the output text Field.
+     * @param output2DArray The Array that gets Displayed
+     */
+    private void outputMatrixToOutputText(double[][] output2DArray) {
+        //convert array to String
+        String DisplayableString = convertsArrayToStringInOrderToDisplayIt(output2DArray);
+        // Display output
+        outputText.setText(DisplayableString);
+        outputText.setTextAlignment(TextAlignment.CENTER);
+    }
+    /**
+     * Converts Array to String in oder to Display it.
+     * @param array2D the array wich will be converted to an Displayable String
+     * @return The Displayable String
+     */
+    private 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] + "   ";
+                // System.out.println(result[i][j]);
+            }
+            displayableString += "\n\n";
+        }
+        return displayableString;
+    }
 
     /**
      * Chcks if the Input is Valid, with Regex. Returns true if the Matrix can be

From e7a4fe7a7d4d7e2517c9e515c6f8281bf1a581df Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Mon, 15 Jul 2019 08:37:44 +0200
Subject: [PATCH 17/30] REFACTORING Moved some methodes in order to get a
 cleaner Struckture

---
 .../matrixcalc/MatrixCalcController.java      |  78 ++------------
 .../ugsbo/matrixcalc/MatrixCalcIOUtils.java   | 101 ++++++++++++++++++
 .../com/ugsbo/matrixcalc/MatrixCalcMath.java  |  27 -----
 ...MatrixTest.java => MatrixIOUtilsTest.java} |  82 +++++++++-----
 .../matrixcalc/MatrixInputcheckTest.java      |  53 ---------
 5 files changed, 169 insertions(+), 172 deletions(-)
 create mode 100644 src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java
 rename src/test/java/com/ugsbo/matrixcalc/{StringToMatrixTest.java => MatrixIOUtilsTest.java} (57%)
 delete mode 100644 src/test/java/com/ugsbo/matrixcalc/MatrixInputcheckTest.java

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index f307792..b674671 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -5,9 +5,6 @@ import javafx.scene.control.*;
 import javafx.scene.text.Text;
 import javafx.scene.text.TextAlignment;
 
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
 public class MatrixCalcController {
 
     // Hier werden die fx:id Attribute verknuepft.
@@ -32,80 +29,25 @@ public class MatrixCalcController {
     @FXML
     public void initialize() {
         /**
-         * Convert Strings to matricies, multiply them and output the result. 
+         * Convert Strings to matricies, multiply them and output the result.
          */
         multiplyButton.setOnMouseClicked((event) -> {
+            MatrixCalcMath math = new MatrixCalcMath();
+            MatrixCalcIOUtils util = new MatrixCalcIOUtils();
+
             String stringMatrixA = matrixATextArea.getText();
             String stringMatrixB = matrixBTextArea.getText();
-            if (checkInput(stringMatrixA) && checkInput(stringMatrixB)) {
-                MatrixCalcMath math = new MatrixCalcMath();
+            if (util.checkInput(stringMatrixA) && util.checkInput(stringMatrixB)) {
 
-                double[][] matrixA = math.stringToMatrix(stringMatrixA);
-                double[][] matrixB = math.stringToMatrix(stringMatrixB);
+                double[][] matrixA = util.stringToMatrix(stringMatrixA);
+                double[][] matrixB = util.stringToMatrix(stringMatrixB);
                 double[][] result = math.matrixMultiplication(matrixA, matrixB);
 
-                outputMatrixToOutputText(result);
+                String DisplayableString = util.outputMatrixToOutputText(result);
+                outputText.setText(DisplayableString);
+                outputText.setTextAlignment(TextAlignment.CENTER);
             }
             // System.out.println(matrixATextArea.getText());
         });
     }
-    /**
-     * Prints a given 2D-Array to the output text Field.
-     * @param output2DArray The Array that gets Displayed
-     */
-    private void outputMatrixToOutputText(double[][] output2DArray) {
-        //convert array to String
-        String DisplayableString = convertsArrayToStringInOrderToDisplayIt(output2DArray);
-        // Display output
-        outputText.setText(DisplayableString);
-        outputText.setTextAlignment(TextAlignment.CENTER);
-    }
-    /**
-     * Converts Array to String in oder to Display it.
-     * @param array2D the array wich will be converted to an Displayable String
-     * @return The Displayable String
-     */
-    private 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] + "   ";
-                // System.out.println(result[i][j]);
-            }
-            displayableString += "\n\n";
-        }
-        return displayableString;
-    }
-
-    /**
-     * Chcks 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.
-     */
-    public boolean checkInput(String matrix) {
-        boolean isMatched = false;
-        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
-        // 3times
-        String row2 = "(\\n){0,3}(\\d*\\u0020*){0,3}";
-        String row3 = "(\\n){0,3}(\\d*\\u0020*){0,3}";
-
-        // TODO get the input check more stricktly missing matrix slots are allowed.
-
-        Pattern p = Pattern.compile(row1 + row2 + row3);
-        Matcher m = p.matcher(matrix);
-
-        isMatched = m.matches();
-
-        // System.out.println(isMatched);
-        return isMatched;
-    }
-
 }
\ No newline at end of file
diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java
new file mode 100644
index 0000000..ae2bbb0
--- /dev/null
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java
@@ -0,0 +1,101 @@
+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 text Field.
+     * 
+     * @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 Array to String in oder 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] + "   ";
+                // System.out.println(result[i][j]);
+            }
+            displayableString += "\n\n";
+        }
+        return displayableString;
+    }
+
+    /**
+     * Chcks 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 boolean checkInput(String matrix) {
+        boolean isMatched = false;
+        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
+        // 3times
+        String row2 = "(\\n){0,3}(\\d*\\u0020*){0,3}";
+        String row3 = "(\\n){0,3}(\\d*\\u0020*){0,3}";
+
+        // TODO get the input check more stricktly missing matrix slots are allowed.
+
+        Pattern p = Pattern.compile(row1 + row2 + row3);
+        Matcher m = p.matcher(matrix);
+
+        isMatched = m.matches();
+
+        // System.out.println(isMatched);
+        return isMatched;
+    }
+
+    /**
+     * 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++) {
+            // System.out.println(rows[i]);
+            // Splitting rows into their Numbers
+            singleNumbers = rows[i].split("\\s");
+            singleNumbersArr.add(singleNumbers);
+        }
+
+        int rowlength = singleNumbersArr.get(0).length; // row.length
+        int columCount = singleNumbersArr.size(); // output.length
+        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;
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
index 98bb194..1666a7c 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
@@ -227,31 +227,4 @@ public class MatrixCalcMath {
         }
         return false;
     }
-
-    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++) {
-            //System.out.println(rows[i]);
-        	//Splitting rows into their Numbers
-            singleNumbers = rows[i].split("\\s");
-            singleNumbersArr.add(singleNumbers);
-        }
-
-        int rowlength = singleNumbersArr.get(0).length; //row.length
-        int columCount = singleNumbersArr.size(); //output.length
-        double[][] result = new double[columCount][rowlength];
-        
-        for (int columIndex = 0; columIndex < columCount; columIndex++) {
-            for (int rowIndex = 0;  rowIndex < singleNumbers.length; rowIndex++) {
-                    result[columIndex][rowIndex] = Double.parseDouble(singleNumbersArr.get(columIndex)[rowIndex]);
-            }
-        }
-        return result;
-    }
-
 }
\ No newline at end of file
diff --git a/src/test/java/com/ugsbo/matrixcalc/StringToMatrixTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixIOUtilsTest.java
similarity index 57%
rename from src/test/java/com/ugsbo/matrixcalc/StringToMatrixTest.java
rename to src/test/java/com/ugsbo/matrixcalc/MatrixIOUtilsTest.java
index 2e5934d..d951e03 100644
--- a/src/test/java/com/ugsbo/matrixcalc/StringToMatrixTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixIOUtilsTest.java
@@ -1,29 +1,63 @@
 package com.ugsbo.matrixcalc;
 
 import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 import org.junit.Before;
 import org.junit.Test;
 
 /**
- * Tests the funktionality to Calculate the Determinant of a Matrix.
+ * Tests how well worng input can be determent.
  */
-public class StringToMatrixTest {
+public class MatrixIOUtilsTest {
 
-    private MatrixCalcMath matrixMath;
+    private MatrixCalcIOUtils util;
 
     @Before
     public void setup() {
-        matrixMath = new MatrixCalcMath();
+        util = new MatrixCalcIOUtils();
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void inputEmptySouldThrowAIllegalArgumentException() {
+        String input = "";
+
+        util.checkInput(input);
+    }
+
+    @Test
+    public void checkIfA1by3MatrixIsValidInput() {
+        String input = "1 2 3";
+
+        boolean result = util.checkInput(input);
+
+        assertTrue("The 1 by 3 Matrix should be Matched as valid input.", result);
+    }
+
+    @Test
+    public void checkIfA2by3MatrixIsValidInput() {
+        String input = "1 2 3\n1 2 3";
+
+        boolean result = util.checkInput(input);
+
+        assertTrue("The 2 by 3 Matrix should be Matched as valid input.", result);
+    }
+
+    @Test
+    public void checkIfA3by3MatrixIsValidInput() {
+        String input = "1 2 3\n1 2 3\n1 2 3";
+
+        boolean result = util.checkInput(input);
+
+        assertTrue("The 3 by 3 Matrix should be Matched as valid input.", result);
     }
 
     @Test
     public void StringWithSingleDigitNumbersToMatrix_ReturnsEquivalentMatrix() {
         String inputString = "1";
         double[][] expected = { { 1.0 } };
-        
-        double[][] result = matrixMath.stringToMatrix(inputString);
+
+        double[][] result = util.stringToMatrix(inputString);
 
         assertArrayEquals("The first row is not correct", expected[0], result[0], 0.1);
     }
@@ -31,9 +65,9 @@ public class StringToMatrixTest {
     @Test
     public void StringWithfourDigitNumbersToMatrix_ReturnsEquivalentMatrix() {
         String inputString = "1 2\n3 4";
-        double[][] expected = { { 1.0, 2.0 }, {3.0, 4.0} };
-        
-        double[][] result = matrixMath.stringToMatrix(inputString);
+        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);
@@ -43,44 +77,44 @@ public class StringToMatrixTest {
     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 = matrixMath.stringToMatrix(inputString);
+
+        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 = matrixMath.stringToMatrix(inputString);
+        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 = matrixMath.stringToMatrix(inputString);
+        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 = matrixMath.stringToMatrix(inputString);
+
+        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);
     }
-}
+}
\ No newline at end of file
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixInputcheckTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixInputcheckTest.java
deleted file mode 100644
index 04593c5..0000000
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixInputcheckTest.java
+++ /dev/null
@@ -1,53 +0,0 @@
-package com.ugsbo.matrixcalc;
-
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Before;
-import org.junit.Test;
-
-/**
- * Tests how well worng input can be determent.
- */
-public class MatrixInputcheckTest {
-
-    private MatrixCalcController controller;
-
-    @Before
-    public void setup() {
-        controller = new MatrixCalcController();
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void inputEmptySouldThrowAIllegalArgumentException() {
-        String input = "";
-
-        controller.checkInput(input);
-    }
-
-    @Test
-    public void checkIfA1by3MatrixIsValidInput() {
-        String input = "1 2 3";
-
-        boolean result = controller.checkInput(input);
-
-        assertTrue("The 1 by 3 Matrix should be Matched as valid input.", result);
-    }
-
-    @Test
-    public void checkIfA2by3MatrixIsValidInput() {
-        String input = "1 2 3\n1 2 3";
-
-        boolean result = controller.checkInput(input);
-
-        assertTrue("The 2 by 3 Matrix should be Matched as valid input.", result);
-    }
-
-    @Test
-    public void checkIfA3by3MatrixIsValidInput() {
-        String input = "1 2 3\n1 2 3\n1 2 3";
-
-        boolean result = controller.checkInput(input);
-
-        assertTrue("The 3 by 3 Matrix should be Matched as valid input.", result);
-    }
-}
\ No newline at end of file

From dd72739d3c4b3fc6c0acf488bcc995ba6f78b5b6 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Mon, 15 Jul 2019 09:06:07 +0200
Subject: [PATCH 18/30] Tests 2D-Array to String funtionality, this
 functionallity was extracted and can now be tested.

---
 .../ugsbo/matrixcalc/MatrixIOUtilsTest.java   | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixIOUtilsTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixIOUtilsTest.java
index d951e03..b01e775 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixIOUtilsTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixIOUtilsTest.java
@@ -1,6 +1,7 @@
 package com.ugsbo.matrixcalc;
 
 import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 import org.junit.Before;
@@ -117,4 +118,34 @@ public class MatrixIOUtilsTest {
         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);
+    }
 }
\ No newline at end of file

From 2d2c08e674dfdbd81b349478af7d9840bef4f8d9 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Mon, 15 Jul 2019 09:14:12 +0200
Subject: [PATCH 19/30] connected Transponation to the tranpose Button

---
 .../ugsbo/matrixcalc/MatrixCalcController.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index b674671..ce3a7ee 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -44,10 +44,28 @@ public class MatrixCalcController {
                 double[][] result = math.matrixMultiplication(matrixA, matrixB);
 
                 String DisplayableString = util.outputMatrixToOutputText(result);
+                
                 outputText.setText(DisplayableString);
                 outputText.setTextAlignment(TextAlignment.CENTER);
             }
             // System.out.println(matrixATextArea.getText());
         });
+
+        transposeButton.setOnMouseClicked((event) -> {
+            MatrixCalcMath math = new MatrixCalcMath();
+            MatrixCalcIOUtils util = new MatrixCalcIOUtils();
+
+            String stringMatrixA = matrixATextArea.getText();
+            if (util.checkInput(stringMatrixA)) {
+
+                double[][] matrixA = util.stringToMatrix(stringMatrixA);
+                double[][] result = math.matrixTransponation(matrixA);
+
+                String DisplayableString = util.outputMatrixToOutputText(result);
+
+                outputText.setText(DisplayableString);
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            }
+        });
     }
 }
\ No newline at end of file

From 067e433763ee4cf9227d40fd1f5555b0f96cf9b4 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Mon, 15 Jul 2019 09:16:28 +0200
Subject: [PATCH 20/30] connected matrix Addition to the add Button

---
 .../matrixcalc/MatrixCalcController.java      | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index ce3a7ee..9adbce5 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -67,5 +67,24 @@ public class MatrixCalcController {
                 outputText.setTextAlignment(TextAlignment.CENTER);
             }
         });
+
+        addButton.setOnMouseClicked((event) -> {
+            MatrixCalcMath math = new MatrixCalcMath();
+            MatrixCalcIOUtils util = new MatrixCalcIOUtils();
+
+            String stringMatrixA = matrixATextArea.getText();
+            String stringMatrixB = matrixBTextArea.getText();
+            if (util.checkInput(stringMatrixA) && util.checkInput(stringMatrixB)) {
+
+                double[][] matrixA = util.stringToMatrix(stringMatrixA);
+                double[][] matrixB = util.stringToMatrix(stringMatrixB);
+                double[][] result = math.matrixAddition(matrixA, matrixB);
+
+                String DisplayableString = util.outputMatrixToOutputText(result);
+                
+                outputText.setText(DisplayableString);
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            }
+        });
     }
 }
\ No newline at end of file

From 638ecdb125849606ad988ef5f4934898b78c4ce3 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Mon, 15 Jul 2019 09:20:02 +0200
Subject: [PATCH 21/30] connected Matrix Substraction to the substract Button

---
 .../matrixcalc/MatrixCalcController.java      | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index 9adbce5..ee0cebb 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -86,5 +86,24 @@ public class MatrixCalcController {
                 outputText.setTextAlignment(TextAlignment.CENTER);
             }
         });
+
+        substractButton.setOnMouseClicked((event) -> {
+            MatrixCalcMath math = new MatrixCalcMath();
+            MatrixCalcIOUtils util = new MatrixCalcIOUtils();
+
+            String stringMatrixA = matrixATextArea.getText();
+            String stringMatrixB = matrixBTextArea.getText();
+            if (util.checkInput(stringMatrixA) && util.checkInput(stringMatrixB)) {
+
+                double[][] matrixA = util.stringToMatrix(stringMatrixA);
+                double[][] matrixB = util.stringToMatrix(stringMatrixB);
+                double[][] result = math.matrixSubstraction(matrixA, matrixB);
+
+                String DisplayableString = util.outputMatrixToOutputText(result);
+                
+                outputText.setText(DisplayableString);
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            }
+        });
     }
 }
\ No newline at end of file

From e33c57aa2d74b6cec905cf9fe93387ee92dfc871 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Mon, 15 Jul 2019 09:37:51 +0200
Subject: [PATCH 22/30] Created Buttons for Determinat calculation of MatrixA
 and MatrixB

---
 src/main/resources/com/ugsbo/gui/matrixCalcGui.fxml | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/main/resources/com/ugsbo/gui/matrixCalcGui.fxml b/src/main/resources/com/ugsbo/gui/matrixCalcGui.fxml
index 759bbba..9c9e35e 100644
--- a/src/main/resources/com/ugsbo/gui/matrixCalcGui.fxml
+++ b/src/main/resources/com/ugsbo/gui/matrixCalcGui.fxml
@@ -1,11 +1,15 @@
 <?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/11.0.1" xmlns:fx="http://javafx.com/fxml/1" fx:controller="com.ugsbo.matrixcalc.MatrixCalcController">
+<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>
@@ -18,7 +22,8 @@
             <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="swapInputButton" layoutX="14.0" layoutY="95.0" mnemonicParsing="false" text="Swap Input" AnchorPane.leftAnchor="15.0" AnchorPane.topAnchor="107.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>

From 95d3d1cb28f8a158c892ef10d4144447560843ff Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Mon, 15 Jul 2019 09:38:35 +0200
Subject: [PATCH 23/30] linked calculating the Determinants of the input
 Matrices to their Buttons

---
 .../matrixcalc/MatrixCalcController.java      | 36 ++++++++++++++++++-
 1 file changed, 35 insertions(+), 1 deletion(-)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index ee0cebb..e378eb1 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -9,7 +9,7 @@ public class MatrixCalcController {
 
     // Hier werden die fx:id Attribute verknuepft.
     @FXML
-    private Button multiplyButton, addButton, swapInputButton, substractButton, transposeButton;
+    private Button multiplyButton, addButton, DetAButton, DetBButton, substractButton, transposeButton;
     @FXML
     private Text errorText, outputText;
     @FXML
@@ -105,5 +105,39 @@ public class MatrixCalcController {
                 outputText.setTextAlignment(TextAlignment.CENTER);
             }
         });
+
+        DetAButton.setOnMouseClicked((event) -> {
+            MatrixCalcMath math = new MatrixCalcMath();
+            MatrixCalcIOUtils util = new MatrixCalcIOUtils();
+
+            String stringMatrixA = matrixATextArea.getText();
+            if (util.checkInput(stringMatrixA)) {
+
+                double[][] matrixA = util.stringToMatrix(stringMatrixA);
+                double result = math.calcDeterminat(matrixA);
+
+                String DisplayableString = Double.toString(result);
+                
+                outputText.setText(DisplayableString);
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            }
+        });
+
+        DetBButton.setOnMouseClicked((event) -> {
+            MatrixCalcMath math = new MatrixCalcMath();
+            MatrixCalcIOUtils util = new MatrixCalcIOUtils();
+
+            String stringMatrixB = matrixBTextArea.getText();
+            if (util.checkInput(stringMatrixB)) {
+
+                double[][] matrixB = util.stringToMatrix(stringMatrixB);
+                double result = math.calcDeterminat(matrixB);
+
+                String DisplayableString = Double.toString(result);
+                
+                outputText.setText(DisplayableString);
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            }
+        });
     }
 }
\ No newline at end of file

From 04bbd02fae3ca71a2a0da68d262b234968dea104 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Mon, 15 Jul 2019 10:10:33 +0200
Subject: [PATCH 24/30] Added try catch to DetB inOrder to Display the reason
 why the input is Invalid

---
 .../matrixcalc/MatrixCalcController.java      | 42 ++++++++++++++-----
 .../com/ugsbo/matrixcalc/MatrixCalcMath.java  |  4 +-
 2 files changed, 33 insertions(+), 13 deletions(-)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index e378eb1..4d812c9 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -44,7 +44,7 @@ public class MatrixCalcController {
                 double[][] result = math.matrixMultiplication(matrixA, matrixB);
 
                 String DisplayableString = util.outputMatrixToOutputText(result);
-                
+
                 outputText.setText(DisplayableString);
                 outputText.setTextAlignment(TextAlignment.CENTER);
             }
@@ -81,7 +81,7 @@ public class MatrixCalcController {
                 double[][] result = math.matrixAddition(matrixA, matrixB);
 
                 String DisplayableString = util.outputMatrixToOutputText(result);
-                
+
                 outputText.setText(DisplayableString);
                 outputText.setTextAlignment(TextAlignment.CENTER);
             }
@@ -100,7 +100,7 @@ public class MatrixCalcController {
                 double[][] result = math.matrixSubstraction(matrixA, matrixB);
 
                 String DisplayableString = util.outputMatrixToOutputText(result);
-                
+
                 outputText.setText(DisplayableString);
                 outputText.setTextAlignment(TextAlignment.CENTER);
             }
@@ -117,7 +117,7 @@ public class MatrixCalcController {
                 double result = math.calcDeterminat(matrixA);
 
                 String DisplayableString = Double.toString(result);
-                
+
                 outputText.setText(DisplayableString);
                 outputText.setTextAlignment(TextAlignment.CENTER);
             }
@@ -128,15 +128,37 @@ public class MatrixCalcController {
             MatrixCalcIOUtils util = new MatrixCalcIOUtils();
 
             String stringMatrixB = matrixBTextArea.getText();
-            if (util.checkInput(stringMatrixB)) {
+            boolean stop = false;
+            try {
 
-                double[][] matrixB = util.stringToMatrix(stringMatrixB);
-                double result = math.calcDeterminat(matrixB);
+                util.checkInput(stringMatrixB);
 
-                String DisplayableString = Double.toString(result);
-                
-                outputText.setText(DisplayableString);
+            } catch (IllegalArgumentException e) {
+                stop = true;
+
+                outputText.setText(e.getMessage());
                 outputText.setTextAlignment(TextAlignment.CENTER);
+
+                e.printStackTrace();
+            }
+            if (util.checkInput(stringMatrixB) && !stop) {
+
+                double[][] matrixB = util.stringToMatrix(stringMatrixB);
+                try {
+                    double result = math.calcDeterminat(matrixB);
+
+                    String DisplayableString = Double.toString(result);
+
+                    outputText.setText(DisplayableString);
+                    outputText.setTextAlignment(TextAlignment.CENTER);
+
+                } catch (IllegalArgumentException e) {
+
+                    outputText.setText(e.getMessage());
+                    outputText.setTextAlignment(TextAlignment.CENTER);
+
+                    e.printStackTrace();
+                }
             }
         });
     }
diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
index 1666a7c..5cd807b 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcMath.java
@@ -1,7 +1,5 @@
 package com.ugsbo.matrixcalc;
 
-import java.util.ArrayList;
-
 /**
  * Contains all basic matrix math calculations.
  */
@@ -155,7 +153,7 @@ public class MatrixCalcMath {
      * @param matrixA The Inputmatrix
      * @return The Determinant of the Matrix A
      */
-    public double calcDeterminat(double[][] matrixA) {
+    public double calcDeterminat(double[][] matrixA) throws IllegalArgumentException{
         // checking if a Determinant can be calculated.
         double result = 0.0;
         if (checkIfMatrixIsQuadradtic(matrixA)) {

From 197721b332b8d1dd203db0a1e5a22e3f33c09df0 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Mon, 15 Jul 2019 10:30:44 +0200
Subject: [PATCH 25/30] Added try catch to DetA and subtraction inOrder to
 Display the reason why the input is Invalid

---
 .../matrixcalc/MatrixCalcController.java      | 74 +++++++++++++++----
 .../ugsbo/matrixcalc/MatrixCalcIOUtils.java   |  4 +-
 2 files changed, 63 insertions(+), 15 deletions(-)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index 4d812c9..dddea79 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -93,16 +93,47 @@ public class MatrixCalcController {
 
             String stringMatrixA = matrixATextArea.getText();
             String stringMatrixB = matrixBTextArea.getText();
-            if (util.checkInput(stringMatrixA) && util.checkInput(stringMatrixB)) {
+
+            boolean stop = false;
+
+            try {
+                util.checkInput(stringMatrixA);
+            } catch (Exception e) {
+                stop = true;
+
+                outputText.setText(e.getMessage() + "A");
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            }
+
+            try {
+                util.checkInput(stringMatrixB);
+            } catch (Exception e) {
+                stop = true;
+
+                outputText.setText(e.getMessage() + "B");
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            }
+
+            if (util.checkInput(stringMatrixA) && util.checkInput(stringMatrixB) && !stop) {
 
                 double[][] matrixA = util.stringToMatrix(stringMatrixA);
                 double[][] matrixB = util.stringToMatrix(stringMatrixB);
-                double[][] result = math.matrixSubstraction(matrixA, matrixB);
 
-                String DisplayableString = util.outputMatrixToOutputText(result);
+                try {
+                    double[][] result = math.matrixSubstraction(matrixA, matrixB);
+
+                    String DisplayableString = util.outputMatrixToOutputText(result);
+
+                    outputText.setText(DisplayableString);
+                    outputText.setTextAlignment(TextAlignment.CENTER);
+                } catch (Exception e) {
+
+                    outputText.setText(e.getMessage());
+                    outputText.setTextAlignment(TextAlignment.CENTER);
+                }
+                
+
 
-                outputText.setText(DisplayableString);
-                outputText.setTextAlignment(TextAlignment.CENTER);
             }
         });
 
@@ -111,16 +142,35 @@ public class MatrixCalcController {
             MatrixCalcIOUtils util = new MatrixCalcIOUtils();
 
             String stringMatrixA = matrixATextArea.getText();
-            if (util.checkInput(stringMatrixA)) {
 
-                double[][] matrixA = util.stringToMatrix(stringMatrixA);
-                double result = math.calcDeterminat(matrixA);
+            boolean stop = false;
+            try {
 
-                String DisplayableString = Double.toString(result);
+                util.checkInput(stringMatrixA);
 
-                outputText.setText(DisplayableString);
+            } catch (IllegalArgumentException e) {
+                stop = true;
+
+                outputText.setText(e.getMessage());
                 outputText.setTextAlignment(TextAlignment.CENTER);
             }
+            if (util.checkInput(stringMatrixA) && !stop) {
+
+                double[][] matrixA = util.stringToMatrix(stringMatrixA);
+                try {
+                    double result = math.calcDeterminat(matrixA);
+
+                    String DisplayableString = Double.toString(result);
+
+                    outputText.setText(DisplayableString);
+                    outputText.setTextAlignment(TextAlignment.CENTER);
+
+                } catch (IllegalArgumentException e) {
+
+                    outputText.setText(e.getMessage());
+                    outputText.setTextAlignment(TextAlignment.CENTER);
+                }
+            }
         });
 
         DetBButton.setOnMouseClicked((event) -> {
@@ -138,8 +188,6 @@ public class MatrixCalcController {
 
                 outputText.setText(e.getMessage());
                 outputText.setTextAlignment(TextAlignment.CENTER);
-
-                e.printStackTrace();
             }
             if (util.checkInput(stringMatrixB) && !stop) {
 
@@ -156,8 +204,6 @@ public class MatrixCalcController {
 
                     outputText.setText(e.getMessage());
                     outputText.setTextAlignment(TextAlignment.CENTER);
-
-                    e.printStackTrace();
                 }
             }
         });
diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java
index ae2bbb0..ab3ab7e 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java
@@ -42,7 +42,7 @@ public class MatrixCalcIOUtils {
      * @param matrix It is the InputMatrix
      * @return true if the Matrix is valid Input.
      */
-    protected boolean checkInput(String matrix) {
+    protected boolean checkInput(String matrix) throws IllegalArgumentException {
         boolean isMatched = false;
         if (matrix.length() == 0) {
             throw new IllegalArgumentException("Please insert a Matrix");
@@ -61,6 +61,8 @@ public class MatrixCalcIOUtils {
         Matcher m = p.matcher(matrix);
 
         isMatched = m.matches();
+        // TODO change the funktion to void and just throw exceptions if something went
+        // worng
 
         // System.out.println(isMatched);
         return isMatched;

From 0871928e84c916edfc21314894cc951fb94cb4aa Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Mon, 15 Jul 2019 11:00:47 +0200
Subject: [PATCH 26/30] Added IllegalArgumentException to checkInput instead of
 returning false, get tests and invoking methodes adapted

---
 .../matrixcalc/MatrixCalcController.java      | 43 +++++++------------
 .../ugsbo/matrixcalc/MatrixCalcIOUtils.java   | 14 +++---
 .../ugsbo/matrixcalc/MatrixIOUtilsTest.java   | 31 ++++++++++---
 3 files changed, 45 insertions(+), 43 deletions(-)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index dddea79..12524fe 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -37,7 +37,11 @@ public class MatrixCalcController {
 
             String stringMatrixA = matrixATextArea.getText();
             String stringMatrixB = matrixBTextArea.getText();
-            if (util.checkInput(stringMatrixA) && util.checkInput(stringMatrixB)) {
+            try {
+                
+            } catch (Exception e) {
+                //TODO: handle exception
+            }
 
                 double[][] matrixA = util.stringToMatrix(stringMatrixA);
                 double[][] matrixB = util.stringToMatrix(stringMatrixB);
@@ -47,7 +51,6 @@ public class MatrixCalcController {
 
                 outputText.setText(DisplayableString);
                 outputText.setTextAlignment(TextAlignment.CENTER);
-            }
             // System.out.println(matrixATextArea.getText());
         });
 
@@ -56,7 +59,11 @@ public class MatrixCalcController {
             MatrixCalcIOUtils util = new MatrixCalcIOUtils();
 
             String stringMatrixA = matrixATextArea.getText();
-            if (util.checkInput(stringMatrixA)) {
+            try {
+                
+            } catch (Exception e) {
+                //TODO: handle exception
+            }
 
                 double[][] matrixA = util.stringToMatrix(stringMatrixA);
                 double[][] result = math.matrixTransponation(matrixA);
@@ -65,7 +72,6 @@ public class MatrixCalcController {
 
                 outputText.setText(DisplayableString);
                 outputText.setTextAlignment(TextAlignment.CENTER);
-            }
         });
 
         addButton.setOnMouseClicked((event) -> {
@@ -74,7 +80,11 @@ public class MatrixCalcController {
 
             String stringMatrixA = matrixATextArea.getText();
             String stringMatrixB = matrixBTextArea.getText();
-            if (util.checkInput(stringMatrixA) && util.checkInput(stringMatrixB)) {
+            try {
+                
+            } catch (Exception e) {
+                //TODO: handle exception
+            }
 
                 double[][] matrixA = util.stringToMatrix(stringMatrixA);
                 double[][] matrixB = util.stringToMatrix(stringMatrixB);
@@ -84,7 +94,6 @@ public class MatrixCalcController {
 
                 outputText.setText(DisplayableString);
                 outputText.setTextAlignment(TextAlignment.CENTER);
-            }
         });
 
         substractButton.setOnMouseClicked((event) -> {
@@ -94,13 +103,9 @@ public class MatrixCalcController {
             String stringMatrixA = matrixATextArea.getText();
             String stringMatrixB = matrixBTextArea.getText();
 
-            boolean stop = false;
-
             try {
                 util.checkInput(stringMatrixA);
             } catch (Exception e) {
-                stop = true;
-
                 outputText.setText(e.getMessage() + "A");
                 outputText.setTextAlignment(TextAlignment.CENTER);
             }
@@ -108,14 +113,10 @@ public class MatrixCalcController {
             try {
                 util.checkInput(stringMatrixB);
             } catch (Exception e) {
-                stop = true;
-
                 outputText.setText(e.getMessage() + "B");
                 outputText.setTextAlignment(TextAlignment.CENTER);
             }
 
-            if (util.checkInput(stringMatrixA) && util.checkInput(stringMatrixB) && !stop) {
-
                 double[][] matrixA = util.stringToMatrix(stringMatrixA);
                 double[][] matrixB = util.stringToMatrix(stringMatrixB);
 
@@ -131,10 +132,6 @@ public class MatrixCalcController {
                     outputText.setText(e.getMessage());
                     outputText.setTextAlignment(TextAlignment.CENTER);
                 }
-                
-
-
-            }
         });
 
         DetAButton.setOnMouseClicked((event) -> {
@@ -143,18 +140,14 @@ public class MatrixCalcController {
 
             String stringMatrixA = matrixATextArea.getText();
 
-            boolean stop = false;
             try {
 
                 util.checkInput(stringMatrixA);
 
             } catch (IllegalArgumentException e) {
-                stop = true;
-
                 outputText.setText(e.getMessage());
                 outputText.setTextAlignment(TextAlignment.CENTER);
             }
-            if (util.checkInput(stringMatrixA) && !stop) {
 
                 double[][] matrixA = util.stringToMatrix(stringMatrixA);
                 try {
@@ -170,7 +163,6 @@ public class MatrixCalcController {
                     outputText.setText(e.getMessage());
                     outputText.setTextAlignment(TextAlignment.CENTER);
                 }
-            }
         });
 
         DetBButton.setOnMouseClicked((event) -> {
@@ -178,18 +170,14 @@ public class MatrixCalcController {
             MatrixCalcIOUtils util = new MatrixCalcIOUtils();
 
             String stringMatrixB = matrixBTextArea.getText();
-            boolean stop = false;
             try {
 
                 util.checkInput(stringMatrixB);
 
             } catch (IllegalArgumentException e) {
-                stop = true;
-
                 outputText.setText(e.getMessage());
                 outputText.setTextAlignment(TextAlignment.CENTER);
             }
-            if (util.checkInput(stringMatrixB) && !stop) {
 
                 double[][] matrixB = util.stringToMatrix(stringMatrixB);
                 try {
@@ -205,7 +193,6 @@ public class MatrixCalcController {
                     outputText.setText(e.getMessage());
                     outputText.setTextAlignment(TextAlignment.CENTER);
                 }
-            }
         });
     }
 }
\ No newline at end of file
diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java
index ab3ab7e..20c5130 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java
@@ -42,8 +42,7 @@ public class MatrixCalcIOUtils {
      * @param matrix It is the InputMatrix
      * @return true if the Matrix is valid Input.
      */
-    protected boolean checkInput(String matrix) throws IllegalArgumentException {
-        boolean isMatched = false;
+    protected void checkInput(String matrix) throws IllegalArgumentException {
         if (matrix.length() == 0) {
             throw new IllegalArgumentException("Please insert a Matrix");
         }
@@ -59,13 +58,10 @@ public class MatrixCalcIOUtils {
 
         Pattern p = Pattern.compile(row1 + row2 + row3);
         Matcher m = p.matcher(matrix);
-
-        isMatched = m.matches();
-        // TODO change the funktion to void and just throw exceptions if something went
-        // worng
-
-        // System.out.println(isMatched);
-        return isMatched;
+        
+        if(!m.matches()){
+            throw new IllegalArgumentException("A Matrix is not in the right format, Matrix ");
+        }
     }
 
     /**
diff --git a/src/test/java/com/ugsbo/matrixcalc/MatrixIOUtilsTest.java b/src/test/java/com/ugsbo/matrixcalc/MatrixIOUtilsTest.java
index b01e775..6f501f7 100644
--- a/src/test/java/com/ugsbo/matrixcalc/MatrixIOUtilsTest.java
+++ b/src/test/java/com/ugsbo/matrixcalc/MatrixIOUtilsTest.java
@@ -2,6 +2,7 @@ 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;
@@ -30,27 +31,45 @@ public class MatrixIOUtilsTest {
     public void checkIfA1by3MatrixIsValidInput() {
         String input = "1 2 3";
 
-        boolean result = util.checkInput(input);
+        try {
+            // act
+            util.checkInput(input);
 
-        assertTrue("The 1 by 3 Matrix should be Matched as valid input.", result);
+            // 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";
 
-        boolean result = util.checkInput(input);
+        try {
+            // act
+            util.checkInput(input);
 
-        assertTrue("The 2 by 3 Matrix should be Matched as valid input.", result);
+            // 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";
 
-        boolean result = util.checkInput(input);
+        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);
+        }
 
-        assertTrue("The 3 by 3 Matrix should be Matched as valid input.", result);
     }
 
     @Test

From 1e2f5969d95bba6c5ff1d3fb872d0e3e42d7c287 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <codeisnotevil@gmail.com>
Date: Mon, 15 Jul 2019 14:37:30 +0200
Subject: [PATCH 27/30] REFACTORING, mainly extracting multiple try catch
 blocks to get the code more Readable.

---
 .../matrixcalc/MatrixCalcController.java      | 216 +++++++++---------
 1 file changed, 114 insertions(+), 102 deletions(-)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index 12524fe..fe95879 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -15,6 +15,9 @@ public class MatrixCalcController {
     @FXML
     private TextArea matrixATextArea, matrixBTextArea;
 
+    private MatrixCalcMath math = new MatrixCalcMath();
+    private MatrixCalcIOUtils util = new MatrixCalcIOUtils();
+
     /**
      * Konstructor is called before initialize()
      */
@@ -32,167 +35,176 @@ public class MatrixCalcController {
          * Convert Strings to matricies, multiply them and output the result.
          */
         multiplyButton.setOnMouseClicked((event) -> {
-            MatrixCalcMath math = new MatrixCalcMath();
-            MatrixCalcIOUtils util = new MatrixCalcIOUtils();
-
             String stringMatrixA = matrixATextArea.getText();
             String stringMatrixB = matrixBTextArea.getText();
-            try {
-                
-            } catch (Exception e) {
-                //TODO: handle exception
-            }
+            String[] stringMatrix = { stringMatrixA, stringMatrixB };
 
-                double[][] matrixA = util.stringToMatrix(stringMatrixA);
-                double[][] matrixB = util.stringToMatrix(stringMatrixB);
-                double[][] result = math.matrixMultiplication(matrixA, matrixB);
+            checkInputAndDisplayIfInputIsNotValid(stringMatrix, 2);
 
-                String DisplayableString = util.outputMatrixToOutputText(result);
+            double[][] matrixA = util.stringToMatrix(stringMatrixA);
+            double[][] matrixB = util.stringToMatrix(stringMatrixB);
+            double[][] result = math.matrixMultiplication(matrixA, matrixB);
 
-                outputText.setText(DisplayableString);
-                outputText.setTextAlignment(TextAlignment.CENTER);
+            String DisplayableString = util.outputMatrixToOutputText(result);
+
+            outputText.setText(DisplayableString);
+            outputText.setTextAlignment(TextAlignment.CENTER);
             // System.out.println(matrixATextArea.getText());
         });
 
         transposeButton.setOnMouseClicked((event) -> {
-            MatrixCalcMath math = new MatrixCalcMath();
-            MatrixCalcIOUtils util = new MatrixCalcIOUtils();
-
             String stringMatrixA = matrixATextArea.getText();
-            try {
-                
-            } catch (Exception e) {
-                //TODO: handle exception
-            }
+            String[] stringMatrix = { stringMatrixA, "" };
 
-                double[][] matrixA = util.stringToMatrix(stringMatrixA);
-                double[][] result = math.matrixTransponation(matrixA);
+            checkInputAndDisplayIfInputIsNotValid(stringMatrix, 1);
 
-                String DisplayableString = util.outputMatrixToOutputText(result);
+            double[][] matrixA = util.stringToMatrix(stringMatrixA);
+            double[][] result = math.matrixTransponation(matrixA);
 
-                outputText.setText(DisplayableString);
-                outputText.setTextAlignment(TextAlignment.CENTER);
+            String DisplayableString = util.outputMatrixToOutputText(result);
+
+            outputText.setText(DisplayableString);
+            outputText.setTextAlignment(TextAlignment.CENTER);
         });
 
         addButton.setOnMouseClicked((event) -> {
-            MatrixCalcMath math = new MatrixCalcMath();
-            MatrixCalcIOUtils util = new MatrixCalcIOUtils();
-
             String stringMatrixA = matrixATextArea.getText();
             String stringMatrixB = matrixBTextArea.getText();
-            try {
-                
-            } catch (Exception e) {
-                //TODO: handle exception
-            }
+            String[] stringMatrix = { stringMatrixA, stringMatrixB };
 
-                double[][] matrixA = util.stringToMatrix(stringMatrixA);
-                double[][] matrixB = util.stringToMatrix(stringMatrixB);
-                double[][] result = math.matrixAddition(matrixA, matrixB);
+            checkInputAndDisplayIfInputIsNotValid(stringMatrix, 2);
 
-                String DisplayableString = util.outputMatrixToOutputText(result);
+            double[][] matrixA = util.stringToMatrix(stringMatrixA);
+            double[][] matrixB = util.stringToMatrix(stringMatrixB);
+            double[][] result = math.matrixAddition(matrixA, matrixB);
 
-                outputText.setText(DisplayableString);
-                outputText.setTextAlignment(TextAlignment.CENTER);
+            String DisplayableString = util.outputMatrixToOutputText(result);
+
+            outputText.setText(DisplayableString);
+            outputText.setTextAlignment(TextAlignment.CENTER);
         });
 
         substractButton.setOnMouseClicked((event) -> {
-            MatrixCalcMath math = new MatrixCalcMath();
-            MatrixCalcIOUtils util = new MatrixCalcIOUtils();
-
             String stringMatrixA = matrixATextArea.getText();
             String stringMatrixB = matrixBTextArea.getText();
+            String[] stringMatrix = { stringMatrixA, stringMatrixB };
+            
+            checkInputAndDisplayIfInputIsNotValid(stringMatrix, 2);
 
-            try {
-                util.checkInput(stringMatrixA);
-            } catch (Exception e) {
-                outputText.setText(e.getMessage() + "A");
-                outputText.setTextAlignment(TextAlignment.CENTER);
-            }
+            double[][] matrixA = util.stringToMatrix(stringMatrixA);
+            double[][] matrixB = util.stringToMatrix(stringMatrixB);
 
             try {
-                util.checkInput(stringMatrixB);
-            } catch (Exception e) {
-                outputText.setText(e.getMessage() + "B");
-                outputText.setTextAlignment(TextAlignment.CENTER);
-            }
-
-                double[][] matrixA = util.stringToMatrix(stringMatrixA);
-                double[][] matrixB = util.stringToMatrix(stringMatrixB);
-
-                try {
-                    double[][] result = math.matrixSubstraction(matrixA, matrixB);
+                double[][] result = math.matrixSubstraction(matrixA, matrixB);
 
-                    String DisplayableString = util.outputMatrixToOutputText(result);
+                String DisplayableString = util.outputMatrixToOutputText(result);
 
-                    outputText.setText(DisplayableString);
-                    outputText.setTextAlignment(TextAlignment.CENTER);
-                } catch (Exception e) {
+                outputText.setText(DisplayableString);
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            } catch (Exception e) {
 
-                    outputText.setText(e.getMessage());
-                    outputText.setTextAlignment(TextAlignment.CENTER);
-                }
+                outputText.setText(e.getMessage());
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            }
         });
 
         DetAButton.setOnMouseClicked((event) -> {
-            MatrixCalcMath math = new MatrixCalcMath();
-            MatrixCalcIOUtils util = new MatrixCalcIOUtils();
-
             String stringMatrixA = matrixATextArea.getText();
+            String[] stringMatrix = { stringMatrixA, "" };
+
+            checkInputAndDisplayIfInputIsNotValid(stringMatrix, 1);
+
+            double[][] matrixA = util.stringToMatrix(stringMatrixA);
 
             try {
+                double result = math.calcDeterminat(matrixA);
+
+                String DisplayableString = Double.toString(result);
 
-                util.checkInput(stringMatrixA);
+                outputText.setText(DisplayableString);
+                outputText.setTextAlignment(TextAlignment.CENTER);
 
             } catch (IllegalArgumentException e) {
+
                 outputText.setText(e.getMessage());
                 outputText.setTextAlignment(TextAlignment.CENTER);
             }
-
-                double[][] matrixA = util.stringToMatrix(stringMatrixA);
-                try {
-                    double result = math.calcDeterminat(matrixA);
-
-                    String DisplayableString = Double.toString(result);
-
-                    outputText.setText(DisplayableString);
-                    outputText.setTextAlignment(TextAlignment.CENTER);
-
-                } catch (IllegalArgumentException e) {
-
-                    outputText.setText(e.getMessage());
-                    outputText.setTextAlignment(TextAlignment.CENTER);
-                }
         });
 
         DetBButton.setOnMouseClicked((event) -> {
-            MatrixCalcMath math = new MatrixCalcMath();
-            MatrixCalcIOUtils util = new MatrixCalcIOUtils();
-
             String stringMatrixB = matrixBTextArea.getText();
+            String[] stringMatrix = { "", stringMatrixB };
+
+            checkInputAndDisplayIfInputIsNotValid(stringMatrix, 1);
+
+            double[][] matrixB = util.stringToMatrix(stringMatrixB);
+
             try {
+                double result = math.calcDeterminat(matrixB);
 
-                util.checkInput(stringMatrixB);
+                String DisplayableString = Double.toString(result);
+
+                outputText.setText(DisplayableString);
+                outputText.setTextAlignment(TextAlignment.CENTER);
 
             } catch (IllegalArgumentException e) {
+
                 outputText.setText(e.getMessage());
                 outputText.setTextAlignment(TextAlignment.CENTER);
             }
+        });
+    }
 
-                double[][] matrixB = util.stringToMatrix(stringMatrixB);
-                try {
-                    double result = math.calcDeterminat(matrixB);
+    // TODO Wirte tests for the extracted Methode.
+    /**
+     * 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 otherone 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);
+            }
 
-                    String DisplayableString = Double.toString(result);
+            try {
+                util.checkInput(stringMatrix[1]);
+            } catch (Exception e) {
+                outputText.setText(e.getMessage() + "B");
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            }
+        } else if (stringMatrix[0].equals("")) {
 
-                    outputText.setText(DisplayableString);
-                    outputText.setTextAlignment(TextAlignment.CENTER);
+            outputText.setText("Pease insert MatrixA");
+            outputText.setTextAlignment(TextAlignment.CENTER);
 
-                } catch (IllegalArgumentException e) {
+        } else if (stringMatrix[1].equals("")) {
+
+            outputText.setText("Pease insert MatrixB");
+            outputText.setTextAlignment(TextAlignment.CENTER);
+        }
 
-                    outputText.setText(e.getMessage());
-                    outputText.setTextAlignment(TextAlignment.CENTER);
-                }
-        });
     }
 }
\ No newline at end of file

From a1ec4a577c92756d2becbda530966c5ba0b73c4f Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <lukas.reichwein@informatik.hs-fulda.de>
Date: Mon, 15 Jul 2019 15:06:58 +0200
Subject: [PATCH 28/30] Added try catch around the operations of addition,
 transponation and multiplication.

---
 .../matrixcalc/MatrixCalcController.java      | 48 +++++++++++++------
 1 file changed, 34 insertions(+), 14 deletions(-)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index fe95879..8800989 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -43,13 +43,19 @@ public class MatrixCalcController {
 
             double[][] matrixA = util.stringToMatrix(stringMatrixA);
             double[][] matrixB = util.stringToMatrix(stringMatrixB);
-            double[][] result = math.matrixMultiplication(matrixA, matrixB);
 
-            String DisplayableString = util.outputMatrixToOutputText(result);
+            try {
+                double[][] result = math.matrixMultiplication(matrixA, matrixB);
 
-            outputText.setText(DisplayableString);
-            outputText.setTextAlignment(TextAlignment.CENTER);
-            // System.out.println(matrixATextArea.getText());
+                String DisplayableString = util.outputMatrixToOutputText(result);
+    
+                outputText.setText(DisplayableString);
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            } catch (IllegalArgumentException e) {
+                
+                outputText.setText(e.getMessage());
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            }
         });
 
         transposeButton.setOnMouseClicked((event) -> {
@@ -59,12 +65,19 @@ public class MatrixCalcController {
             checkInputAndDisplayIfInputIsNotValid(stringMatrix, 1);
 
             double[][] matrixA = util.stringToMatrix(stringMatrixA);
-            double[][] result = math.matrixTransponation(matrixA);
 
-            String DisplayableString = util.outputMatrixToOutputText(result);
+            try {
+                double[][] result = math.matrixTransponation(matrixA);
 
-            outputText.setText(DisplayableString);
-            outputText.setTextAlignment(TextAlignment.CENTER);
+                String DisplayableString = util.outputMatrixToOutputText(result);
+    
+                outputText.setText(DisplayableString);
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            } catch (IllegalArgumentException e) {
+                
+                outputText.setText(e.getMessage());
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            }
         });
 
         addButton.setOnMouseClicked((event) -> {
@@ -76,12 +89,19 @@ public class MatrixCalcController {
 
             double[][] matrixA = util.stringToMatrix(stringMatrixA);
             double[][] matrixB = util.stringToMatrix(stringMatrixB);
-            double[][] result = math.matrixAddition(matrixA, matrixB);
 
-            String DisplayableString = util.outputMatrixToOutputText(result);
+            try {
+                double[][] result = math.matrixAddition(matrixA, matrixB);
 
-            outputText.setText(DisplayableString);
-            outputText.setTextAlignment(TextAlignment.CENTER);
+                String DisplayableString = util.outputMatrixToOutputText(result);
+    
+                outputText.setText(DisplayableString);
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            } catch (IllegalArgumentException e) {
+                
+                outputText.setText(e.getMessage());
+                outputText.setTextAlignment(TextAlignment.CENTER);
+            }
         });
 
         substractButton.setOnMouseClicked((event) -> {
@@ -101,7 +121,7 @@ public class MatrixCalcController {
 
                 outputText.setText(DisplayableString);
                 outputText.setTextAlignment(TextAlignment.CENTER);
-            } catch (Exception e) {
+            } catch (IllegalArgumentException e) {
 
                 outputText.setText(e.getMessage());
                 outputText.setTextAlignment(TextAlignment.CENTER);

From 2077778546fd2703f3f6a0744e241a4771abf074 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <lukas.reichwein@informatik.hs-fulda.de>
Date: Mon, 15 Jul 2019 15:55:49 +0200
Subject: [PATCH 29/30] REFACTORING, extracted more form the event Heandler to
 get even more Readabillity

---
 .../matrixcalc/MatrixCalcController.java      | 199 ++++++++++--------
 1 file changed, 116 insertions(+), 83 deletions(-)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index 8800989..21b470f 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -5,8 +5,20 @@ 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";
+
     // Hier werden die fx:id Attribute verknuepft.
     @FXML
     private Button multiplyButton, addButton, DetAButton, DetBButton, substractButton, transposeButton;
@@ -41,21 +53,11 @@ public class MatrixCalcController {
 
             checkInputAndDisplayIfInputIsNotValid(stringMatrix, 2);
 
-            double[][] matrixA = util.stringToMatrix(stringMatrixA);
-            double[][] matrixB = util.stringToMatrix(stringMatrixB);
-
-            try {
-                double[][] result = math.matrixMultiplication(matrixA, matrixB);
+            ArrayList<double[][]> matricies = new ArrayList<double[][]>();
+            matricies.add(util.stringToMatrix(stringMatrixA));
+            matricies.add(util.stringToMatrix(stringMatrixB));
 
-                String DisplayableString = util.outputMatrixToOutputText(result);
-    
-                outputText.setText(DisplayableString);
-                outputText.setTextAlignment(TextAlignment.CENTER);
-            } catch (IllegalArgumentException e) {
-                
-                outputText.setText(e.getMessage());
-                outputText.setTextAlignment(TextAlignment.CENTER);
-            }
+            invokeOperation(matricies, MULTIPLICATION_STRING);
         });
 
         transposeButton.setOnMouseClicked((event) -> {
@@ -64,20 +66,10 @@ public class MatrixCalcController {
 
             checkInputAndDisplayIfInputIsNotValid(stringMatrix, 1);
 
-            double[][] matrixA = util.stringToMatrix(stringMatrixA);
+            ArrayList<double[][]> matricies = new ArrayList<double[][]>();
+            matricies.add(util.stringToMatrix(stringMatrixA));
 
-            try {
-                double[][] result = math.matrixTransponation(matrixA);
-
-                String DisplayableString = util.outputMatrixToOutputText(result);
-    
-                outputText.setText(DisplayableString);
-                outputText.setTextAlignment(TextAlignment.CENTER);
-            } catch (IllegalArgumentException e) {
-                
-                outputText.setText(e.getMessage());
-                outputText.setTextAlignment(TextAlignment.CENTER);
-            }
+            invokeOperation(matricies, TRANPOSE_STRING);
         });
 
         addButton.setOnMouseClicked((event) -> {
@@ -87,45 +79,25 @@ public class MatrixCalcController {
 
             checkInputAndDisplayIfInputIsNotValid(stringMatrix, 2);
 
-            double[][] matrixA = util.stringToMatrix(stringMatrixA);
-            double[][] matrixB = util.stringToMatrix(stringMatrixB);
-
-            try {
-                double[][] result = math.matrixAddition(matrixA, matrixB);
+            ArrayList<double[][]> matricies = new ArrayList<double[][]>();
+            matricies.add(util.stringToMatrix(stringMatrixA));
+            matricies.add(util.stringToMatrix(stringMatrixB));
 
-                String DisplayableString = util.outputMatrixToOutputText(result);
-    
-                outputText.setText(DisplayableString);
-                outputText.setTextAlignment(TextAlignment.CENTER);
-            } catch (IllegalArgumentException e) {
-                
-                outputText.setText(e.getMessage());
-                outputText.setTextAlignment(TextAlignment.CENTER);
-            }
+            invokeOperation(matricies, ADDITION_STRING);
         });
 
         substractButton.setOnMouseClicked((event) -> {
             String stringMatrixA = matrixATextArea.getText();
             String stringMatrixB = matrixBTextArea.getText();
             String[] stringMatrix = { stringMatrixA, stringMatrixB };
-            
-            checkInputAndDisplayIfInputIsNotValid(stringMatrix, 2);
-
-            double[][] matrixA = util.stringToMatrix(stringMatrixA);
-            double[][] matrixB = util.stringToMatrix(stringMatrixB);
 
-            try {
-                double[][] result = math.matrixSubstraction(matrixA, matrixB);
-
-                String DisplayableString = util.outputMatrixToOutputText(result);
+            checkInputAndDisplayIfInputIsNotValid(stringMatrix, 2);
 
-                outputText.setText(DisplayableString);
-                outputText.setTextAlignment(TextAlignment.CENTER);
-            } catch (IllegalArgumentException e) {
+            ArrayList<double[][]> matricies = new ArrayList<double[][]>();
+            matricies.add(util.stringToMatrix(stringMatrixA));
+            matricies.add(util.stringToMatrix(stringMatrixB));
 
-                outputText.setText(e.getMessage());
-                outputText.setTextAlignment(TextAlignment.CENTER);
-            }
+            invokeOperation(matricies, SUBSTRACTION_STRING);
         });
 
         DetAButton.setOnMouseClicked((event) -> {
@@ -134,21 +106,10 @@ public class MatrixCalcController {
 
             checkInputAndDisplayIfInputIsNotValid(stringMatrix, 1);
 
-            double[][] matrixA = util.stringToMatrix(stringMatrixA);
+            ArrayList<double[][]> matricies = new ArrayList<double[][]>();
+            matricies.add(util.stringToMatrix(stringMatrixA));
 
-            try {
-                double result = math.calcDeterminat(matrixA);
-
-                String DisplayableString = Double.toString(result);
-
-                outputText.setText(DisplayableString);
-                outputText.setTextAlignment(TextAlignment.CENTER);
-
-            } catch (IllegalArgumentException e) {
-
-                outputText.setText(e.getMessage());
-                outputText.setTextAlignment(TextAlignment.CENTER);
-            }
+            invokeOperation(matricies, CALCDETERMINAT_STRING);
         });
 
         DetBButton.setOnMouseClicked((event) -> {
@@ -157,22 +118,94 @@ public class MatrixCalcController {
 
             checkInputAndDisplayIfInputIsNotValid(stringMatrix, 1);
 
-            double[][] matrixB = util.stringToMatrix(stringMatrixB);
-
-            try {
-                double result = math.calcDeterminat(matrixB);
+            ArrayList<double[][]> matricies = new ArrayList<double[][]>();
+            matricies.add(util.stringToMatrix(stringMatrixB));
 
-                String DisplayableString = Double.toString(result);
-
-                outputText.setText(DisplayableString);
-                outputText.setTextAlignment(TextAlignment.CENTER);
-
-            } catch (IllegalArgumentException e) {
+            invokeOperation(matricies, CALCDETERMINAT_STRING);
+        });
+    }
 
-                outputText.setText(e.getMessage());
-                outputText.setTextAlignment(TextAlignment.CENTER);
+    /**
+     * Invokes the right operations form the MatrixCalcMath class 
+     * @param matricies contains both 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);
+                }
+            }
+        }
     }
 
     // TODO Wirte tests for the extracted Methode.

From 8339da416d517d7cd518061a7975c77eff2119d9 Mon Sep 17 00:00:00 2001
From: Lukas Reichwein <lukas.reichwein@informatik.hs-fulda.de>
Date: Mon, 15 Jul 2019 18:15:36 +0200
Subject: [PATCH 30/30] correct some typos, and finishing up to get verion 1 of
 the Matrix Calculator ready to merge

---
 .../matrixcalc/MatrixCalcController.java      | 32 ++++++++++++-------
 .../ugsbo/matrixcalc/MatrixCalcIOUtils.java   | 20 ++++++------
 2 files changed, 30 insertions(+), 22 deletions(-)

diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
index 21b470f..f857eb0 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcController.java
@@ -9,17 +9,13 @@ 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";
 
-    // Hier werden die fx:id Attribute verknuepft.
+    // The fx:id Attributes will be bind here.
     @FXML
     private Button multiplyButton, addButton, DetAButton, DetBButton, substractButton, transposeButton;
     @FXML
@@ -60,6 +56,9 @@ public class MatrixCalcController {
             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, "" };
@@ -72,6 +71,9 @@ public class MatrixCalcController {
             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();
@@ -86,6 +88,9 @@ public class MatrixCalcController {
             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();
@@ -100,6 +105,9 @@ public class MatrixCalcController {
             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, "" };
@@ -112,6 +120,9 @@ public class MatrixCalcController {
             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 };
@@ -126,9 +137,9 @@ public class MatrixCalcController {
     }
 
     /**
-     * Invokes the right operations form the MatrixCalcMath class 
-     * @param matricies contains both or onely one Matrix
-     * @param operation One of the Global Constats to select wich Operation is needed.
+     * 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) {
@@ -208,15 +219,14 @@ public class MatrixCalcController {
         }
     }
 
-    // TODO Wirte tests for the extracted Methode.
     /**
-     * Checks the Input and Displays it if the Input is Valid.
+     * 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 otherone needs to be an empty
+     *                                verifyed and the other one needs to be an empty
      *                                String in the stringMatrix
      */
     private void checkInputAndDisplayIfInputIsNotValid(String[] stringMatrix, int numberOfMatricesToMatch) {
diff --git a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java
index 20c5130..e929081 100644
--- a/src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java
+++ b/src/main/java/com/ugsbo/matrixcalc/MatrixCalcIOUtils.java
@@ -6,7 +6,7 @@ import java.util.regex.Pattern;
 
 public class MatrixCalcIOUtils {
     /**
-     * Prints a given 2D-Array to the output text Field.
+     * Prints a given 2D-Array to the output Textfield.
      * 
      * @param output2DArray The Array that gets Displayed
      */
@@ -18,9 +18,9 @@ public class MatrixCalcIOUtils {
     }
 
     /**
-     * Converts Array to String in oder to Display it.
+     * Converts 2D-Array to String in order to Display it.
      * 
-     * @param array2D the array wich will be converted to an Displayable String
+     * @param array2D The array wich will be converted to an Displayable String
      * @return The Displayable String
      */
     protected String convertsArrayToStringInOrderToDisplayIt(double[][] array2D) {
@@ -28,7 +28,6 @@ public class MatrixCalcIOUtils {
         for (int i = 0; i < array2D.length; i++) {
             for (int j = 0; j < array2D[0].length; j++) {
                 displayableString += array2D[i][j] + "   ";
-                // System.out.println(result[i][j]);
             }
             displayableString += "\n\n";
         }
@@ -36,11 +35,11 @@ public class MatrixCalcIOUtils {
     }
 
     /**
-     * Chcks if the Input is Valid, with Regex. Returns true if the Matrix can be
+     * 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.
+     * @return True if the Matrix is valid Input.
      */
     protected void checkInput(String matrix) throws IllegalArgumentException {
         if (matrix.length() == 0) {
@@ -50,11 +49,11 @@ public class MatrixCalcIOUtils {
         // 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
-        // 3times
+        // 3 times
         String row2 = "(\\n){0,3}(\\d*\\u0020*){0,3}";
         String row3 = "(\\n){0,3}(\\d*\\u0020*){0,3}";
 
-        // TODO get the input check more stricktly missing matrix slots are allowed.
+        // 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);
@@ -78,14 +77,13 @@ public class MatrixCalcIOUtils {
         String[] singleNumbers = null;
         String[] rows = stringMatrix.split("\n");
         for (int i = 0; i < rows.length; i++) {
-            // System.out.println(rows[i]);
             // Splitting rows into their Numbers
             singleNumbers = rows[i].split("\\s");
             singleNumbersArr.add(singleNumbers);
         }
 
-        int rowlength = singleNumbersArr.get(0).length; // row.length
-        int columCount = singleNumbersArr.size(); // output.length
+        int rowlength = singleNumbersArr.get(0).length;
+        int columCount = singleNumbersArr.size();
         double[][] matrix = new double[columCount][rowlength];
 
         for (int columIndex = 0; columIndex < columCount; columIndex++) {