Vorlesung 8 / Aufgabe 3

VL08/Aufgabe03/Aufgabe03.java

@@ -0,0 +1,38 @@
+package VL08.Aufgabe03;
+
+/**
+ * Vorlesung 8 / Aufgabe 3
+ *
+ * @author Sebastian Brosch
+ */
+public class Aufgabe03 {
+  public static void main(String[] args) {
+
+    Matrix matrixA = new Matrix(2, 3);
+    matrixA.setValue(0, 0, 3);
+    matrixA.setValue(0, 1, 2);
+    matrixA.setValue(0, 2, 1);
+    matrixA.setValue(1, 0, 1);
+    matrixA.setValue(1, 1, 0);
+    matrixA.setValue(1, 2, 2);
+
+    Matrix matrixB = new Matrix(3, 2);
+    matrixB.setValue(0, 0, 1);
+    matrixB.setValue(0, 1, 2);
+    matrixB.setValue(1, 0, 0);
+    matrixB.setValue(1, 1, 1);
+    matrixB.setValue(2, 0, 4);
+    matrixB.setValue(2, 1, 0);
+
+    System.out.println("------------------");
+    matrixA.print();
+    System.out.println("------------------");
+    matrixB.print();
+    System.out.println("------------------");
+
+    matrixA.multiply(matrixB);
+
+    matrixA.print();
+    System.out.println("------------------");
+  }
+}

VL08/Aufgabe03/Matrix.java

@@ -0,0 +1,154 @@
+package VL08.Aufgabe03;
+
+/**
+ * A class to represent a Matrix.
+ */
+public class Matrix {
+  private int rows = 0;
+  private int columns = 0;
+  private int[][] matrix;
+
+  Matrix(int rows, int columns) {
+    this.rows = rows;
+    this.columns = columns;
+    this.matrix = new int[this.rows][this.columns];
+
+    for (int rowIndex = 0; rowIndex < this.rows; rowIndex++) {
+      for (int columnIndex = 0; columnIndex < this.columns; columnIndex++) {
+        this.matrix[rowIndex][columnIndex] = 0;
+      }
+    }
+  }
+
+  /**
+   * Method to get the number of columns.
+   *
+   * @return The number of columns.
+   */
+  int getColumns() {
+    return this.columns;
+  }
+
+  /**
+   * Method to get the number of rows.
+   *
+   * @return The number of rows.
+   */
+  int getRows() {
+    return this.rows;
+  }
+
+  /**
+   * Method to get the value of a specific field.
+   *
+   * @param row    The row of the value.
+   * @param column The column of the value.
+   * @return The value of the given row and column.
+   */
+  int getValue(int row, int column) {
+    return this.matrix[row][column];
+  }
+
+  /**
+   * Method to set the value of a specific field.
+   *
+   * @param row    The row to set the value.
+   * @param column The column to set the value.
+   * @param value  The value to be set in the field.
+   */
+  void setValue(int row, int column, int value) {
+    this.matrix[row][column] = value;
+  }
+
+  /**
+   * Methode to get the state whether the given Matrix is same size.
+   *
+   * @param matrix The Matrix to check for same size.
+   * @return The state whether the given Matrix is same size.
+   */
+  boolean isSameSize(Matrix matrix) {
+    return (this.rows == matrix.getRows()) && (this.columns == matrix.getColumns());
+  }
+
+  /**
+   * Method to add a Matrix to the current Matrix.
+   *
+   * @param matrix The Matrix to add to the current Matrix.
+   */
+  void add(Matrix matrix) {
+    if (!this.isSameSize(matrix)) {
+      return;
+    }
+
+    for (int rowIndex = 0; rowIndex < this.rows; rowIndex++) {
+      for (int columnIndex = 0; columnIndex < this.columns; columnIndex++) {
+        this.matrix[rowIndex][columnIndex] += matrix.getValue(rowIndex, columnIndex);
+      }
+    }
+  }
+
+  /**
+   * Method to multiply a scalar value to the Matrix.
+   *
+   * @param scalar The scalar value to multiply the Matrix.
+   */
+  void multiply(int scalar) {
+    for (int rowIndex = 0; rowIndex < this.rows; rowIndex++) {
+      for (int columnIndex = 0; columnIndex < this.columns; columnIndex++) {
+        this.matrix[rowIndex][columnIndex] *= scalar;
+      }
+    }
+  }
+
+  /**
+   * Method to multiply a Matrix to the Matrix.
+   *
+   * @param matrix The Matrix to multiply with this Matrix.
+   * @return State whether the multiplication of the Matrix was successful.
+   */
+  boolean multiply(Matrix matrix) {
+
+    // multiplication is not possible if there are no rows or no columns.
+    if (this.getColumns() == 0 || this.getRows() == 0) {
+      return false;
+    }
+
+    // multiplication is only possible if the number of rows of Matrix A
+    // is equals to the number of columns of Matrix B.
+    if (this.getColumns() != matrix.getRows()) {
+      return false;
+    }
+
+    int[][] tempMatrix = new int[this.matrix.length][this.matrix.length];
+
+    for (int rowIndex = 0; rowIndex < this.getRows(); rowIndex++) {
+      for (int columnIndex = 0; columnIndex < matrix.getColumns(); columnIndex++) {
+        tempMatrix[rowIndex][columnIndex] = 0;
+
+        for (int fieldIndex = 0; fieldIndex < matrix.getRows(); fieldIndex++) {
+          tempMatrix[rowIndex][columnIndex] += this.getValue(rowIndex, fieldIndex)
+              * matrix.getValue(fieldIndex, columnIndex);
+        }
+      }
+    }
+
+    this.matrix = tempMatrix;
+    this.columns = tempMatrix.length;
+    this.rows = tempMatrix.length;
+
+    return true;
+  }
+
+  /**
+   * Method to print the Matrix.
+   */
+  void print() {
+    for (int rowIndex = 0; rowIndex < this.rows; rowIndex++) {
+      for (int columnIndex = 0; columnIndex < this.columns; columnIndex++) {
+        System.out.printf("%5d", this.getValue(rowIndex, columnIndex));
+      }
+
+      System.out.print("\n");
+    }
+  }
+}