Matrizen und Vektoren in Java (Library)

Ich habe ein Java-Package erstellt, das dabei hilft mit Vektoren und Matrizen in Java zu arbeiten. Die Intention war vor allem, dass ich neulich in der Nacht nicht schlafen konnte und es einfach kann^^. Matrizen haben mich außerdem in Mathe an der Uni beschäftigt und so kam eins zum anderen. Grundsätzlich ist folgendes möglich. Ihr könnt das Package als Library in bestehende Projekte einbinden und dann Matrizen mit beliebiger Dimension erstellen. Ferner gibt es spezielle extra Klassen, die von „Matrix“ erben um konkret mit Vektoren oder auch Einheitsmatrizen zu arbeiten. Den Quellcode gibt es auf GitHub [0]. Ich erhebe keinen Anspruch auf mathematische Korrektheit, allerdings sollte soweit alles passen, immerhin studiere ich das ja und habe auch ein paar Eingaben und Ausgaben des Codes selbst überprüft. Außerdem stelle ich euch einen Download-Link [1] für die Library bereit (JAR-Datei). Die Library steht unter der MIT-Lizenz.

Java (Symbolbild)

Ihr könnt Matrizen mit verschiedenen Operationen verändern, zum Beispiel Zeilen aufeinander addieren, aber auch ganze Matrizen miteinander verrechnen. Operationen innerhalb der Matrix werden auf dem Matrix-Objekt ausgeführt, für Operationen zwischen Matrizen (Matrizenmultiplikation) steht die Klasse MatrixUtils zur Verfügung. Ich habe für euch eine kleine Übersicht erstellt, die die Klassen übersichtlich zusammenfasst.

Klassenübersicht

KlasseBeschreibung
MatrixErstellen einer nxm-Matrix
VectorErstellen einer nx1-Matrix
MatrixUtilsOperationen zwischen Matrizen sowie Operationen, die die Ergebnismatrix-Dimension verändern können
VectorUtilsSpezielle Operationen zwischen Vektoren
IdentityMatrixEine Einheitsmatrix hat in jedem Fall nur Einsen auf der Hauptdiagnonalen und sonst überall Nullen. Die Klasse stellt das sicher, eine Einheitsmatrix kann nach der Initialisierung nicht mehr geändert werden.
MatrixDimensionKlasse die nur für interne Zwecke benötigt wird.

Mathematische Fähigkeiten

  • Zahlreiche Möglichkeiten um Werte in die Matrix einzufügen und innerhalb der Matrix zu ändern, zum Beispiel zwei Zeilen aufeinander addieren
  • Matrizen addieren/subtrahieren/multiplizieren/dividieren
  • Determinanten berechnen (derzeit nur bis 3×3-Matrizen sowie beliebige Dreiecksmatrizen)
  • Überprüfen ob eine Matrix invertierbar ist (es gelten die Beschränkungen der Determinanten)
  • Überprüfen ob eine Matrix eine untere/obere Dreiecksmatrix ist
  • Überprüfen ob eine Matrix irgendeine Dreiecksmatrix ist
  • Überprüfen ob eine Matrix eine Diagonalmatrix ist
  • und mehr…

Kurze Einführung in die Benutzung

1. Matrizen und Vektoren erstellen

Matrix A, B, C;
IdentityMatrix E3;
Vector a, b;

A = new Matrix(3,3); // 3x3 Matrix
// Eine Matrix, in der die Werte von 0 bis 9 stehen
A.init(1,2,3,4,5,6,7,8,9);
B = new Matrix(3,3); // 3x3 Matrix
B.set(2,2,7); // in der Mitte der 3x3 Matrix steht nun eine 7
// in der ersten Zeile stehen nun zusätzlich die Werte 1, 2, 3
B.init(1,2,3);
// 2x3-Matrix erstellen
C = new Matrix("2x3");
C.addToCol(3,7);
C.print(); // Matrix in die Konsole printen
    /*
        [0, 0, 7]
        [0, 0, 7]
     */

C.set(20,20,7); // MatrixDimensionOutOfBoundsException

a = new Vector(3); // 3 Zeilen
b = new Vector(4); // 4 Zeilen

2. Eigenschaften von Matrizen überprüfen

Matrix A, B;
IdentityMatrix E7;
A = new Matrix(3,3);
A.init(1,0,0,-5,2,0,1,7,9);
/*
 [ 1,0,0]
 [-5,2,0]
 [ 1,7,9]
 */
B = new Matrix(4,2);
B.init(1,2,3,4,5);
/*
 [1,2]
 [3,4]
 [5,0]
 [0,0]
 */
E7 = new IdentityMatrix(7); // 7x7-Einheitsmatrix
// Matrix A
System.out.println(A.isDiagonalMatrix());        // false
System.out.println(A.isInvertable());            // true
System.out.println(A.isLowerTriangularMatrix()); // false
System.out.println(A.isSquareMatrix());          // true
System.out.println(A.isTriangularMatrix());      // true
System.out.println(A.isUpperTriangularMatrix()); // true
// Matrix B
System.out.println(B.isDiagonalMatrix());        // false
System.out.println(B.isInvertable());            // false
System.out.println(B.isLowerTriangularMatrix()); // false
System.out.println(B.isSquareMatrix());          // false
System.out.println(B.isTriangularMatrix());      // false
System.out.println(B.isUpperTriangularMatrix()); // false
// Matrix E7
System.out.println(E7.isDiagonalMatrix());       // true
System.out.println(E7.isInvertable());           // true
System.out.println(E7.isLowerTriangularMatrix());// true
System.out.println(E7.isSquareMatrix());         // true
System.out.println(E7.isTriangularMatrix());     // true
System.out.println(E7.isUpperTriangularMatrix());// true

3. Matrizen verrechnen

Matrix A, B, C;
Vector a;
IdentityMatrix E3;
A = new Matrix(3,3);
A.init(-5,2,1,2,1,1,7,8,9);
B = new Matrix(3,4);
B.setAll(2);
E3 = new IdentityMatrix(3);
a = new Vector(3);
a.init(-2,-2,3);

System.out.println("---\nMatrix A:");
A.print();
System.out.println("---\nMatrix B:");
B.print();
System.out.println("---\nVektor a:");
a.print();


System.out.println("---\n2 * A  bzw. A + A:");
A = MatrixUtils.add(A,A); // same as A.multAll(2);
A.print();
C = MatrixUtils.mult(A,B);
System.out.println("---\nA * B:");
C.print();
C = MatrixUtils.mult(A,a);
System.out.println("---\nA * a:");
C.print();

System.out.println("---\nA * E3:");
C = MatrixUtils.mult(A,E3);
C.print(); // entspricht A
System.out.println(A.equals(C)); // true, da multipliziert mit Einheitsmatrix
Zugehöriger Konsolenoutput (zu drittens)
Matrix A:
[-5, 2, 1]
[2, 1, 1]
[7, 8, 9]
---
Matrix B:
[2, 2, 2, 2]
[2, 2, 2, 2]
[2, 2, 2, 2]
---
Vektor a:
[-2]
[-2]
[3]
---
2 * A bzw. A + A:
[-10, 4, 2]
[4, 2, 2]
[14, 16, 18]
---
A * B:
[-8, -8, -8, -8]
[16, 16, 16, 16]
[96, 96, 96, 96]
---
A * a:
[18]
[-6]
[-6]
---
A * E3:
[-10, 4, 2]
[4, 2, 2]
[14, 16, 18]
true

Das waren ein paar Möglichkeiten, die ihr nutzen könnt. Es gibt noch viele weitere Methoden die ihr auf den Objekten ausführen könnt und es werden sicherlich noch einige hinzukommen. Wenn ihr Fehler findet oder Verbesserungsvorschläge habt, dann immer her damit. (:

[0]: https://github.com/phip1611/Matrices-Java
[1]: https://phip1611.de/wp-content/uploads/2016/08/matrices-v2016.08.14.zip

Philipp Schuster

Ich bin Philipp, studiere Informatik an der TU Dresden und arbeite als Werkstudent im Bereich Software-Entwicklung bei T-Systems MMS. Ich bin 20 Jahre alt und beschäftige mich in meiner Freizeit gerne mit meinem Blog, Programierung, Technik, aber auch mit Joggen und vielen anderen Dingen. Get To Know Me oder schreibt mich an!

Das könnte Dich auch interessieren …

1 Antwort

  1. test sagt:

    Jetzt müssten die Klassen nur noch Thread Safe sein, damit man sie auch im produktiven Betrieb einsetzen kann. 😀

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.