Merge branch 'project_tests'

CMakeLists.txt

@@ -19,8 +19,7 @@ set(SRC_FILES
         ${CMAKE_CURRENT_LIST_DIR}/src/main.cpp
         ${CMAKE_CURRENT_LIST_DIR}/src/gamecube.cpp
         src/gamematrix.cpp
-        parallel/parallel_measurements.cpp
-        parallel/matrizenmultiplikation.cpp
+        docs/tests.cpp
 )
 
 ##Tom: prev: ${CMAKE_CURRENT_LIST_DIR}/linux -> now /include
@@ -52,4 +51,3 @@ if (APPLE)
     target_link_libraries(Prog3B "-framework Cocoa")
     target_link_libraries(Prog3B "-framework OpenGL")
 endif()
-

docs/requirements.txt

@@ -0,0 +1,60 @@
+========================================================
+Projekt: gamematrix (C++ Library)
+Rolle: Projektleiter
+Datei: requirements.txt
+Datum: 3.11.2025
+Team: Thomas und Co
+========================================================
+
+# ----------------------------
+# 1. Projektziel
+# ----------------------------
+Beschreiben Sie hier kurz das Ziel des Projekts:
+
+Ziel: Implementierung der Matrixmulitplikation, -Rotation, -Verschiebung und anschließendes Testen
+
+# ----------------------------
+# 2. Funktionale Anforderungen
+# ----------------------------
+Listen Sie alle Funktionen auf, die die Bibliothek bereitstellen soll.
+Tragen Sie ein: Funktion, Eingabe, Ausgabe, kurze Beschreibung
+
+| Funktion      | Eingabe                            | Ausgabe               | Kurzbeschreibung                       |
+|---------------|------------------------------------|-----------------------|----------------------------------------|
+| matmul        | 4x4 Matrix A, 4x4 Matrix B         | 4x4 Matrix            | Multiplikation zweier Matrizen wie in Mathe gelernt	
+| translate     | 3D Vektor                          | 4x4 Matrix            | Verschiebung
+| rot3D         | Winkel in °, Rotationsachse (x/y/z)| 4x4 Matrix            | Rotation
+| identity (optional)| ---                           | 4x4 Matrix            | _____________________________________  |
+| _____________ | __________________________________ | ____________________  | ______________________________         |
+| _____________ | __________________________________ | ____________________  | ______________________________         |
+
+# ----------------------------
+# 3. Nicht-funktionale Anforderungen
+# ----------------------------
+(z. B. Performance, Lesbarkeit, Wartbarkeit, Python-Kompatibilität via pybind11)
+
+- Lesbarkeit nach Coding Guidelines: https://elearning.ohmportal.de/pluginfile.php/395279/mod_page/content/5/Coding_Guidelines.pdf
+
+
+# ----------------------------
+# 4. Annahmen / Einschränkungen
+# ----------------------------
+(z. B. alle Matrizen sind 4x4, Winkel in Grad, nur double)
+
+- alle Matrizen sind 4x4
+- Winkel in Grad
+- nur double
+
+# ----------------------------
+# 5. Abnahmekriterien
+# ----------------------------
+Wie soll geprüft werden, dass die Anforderungen erfüllt sind?
+(z. B. Unit-Tests, Beispielrotationen, Matrizenmultiplikation)
+
+- Tests von Marco müssen fehlerfrei verlaufen
+
+========================================================
+Hinweis:
+- Diese Datei wird vom Projektleiter erstellt und gepflegt.
+- Jede Phase des Projekts soll hier dokumentiert werden.
+========================================================

docs/tests.cpp

@@ -0,0 +1,137 @@
+//
+// Created by marco on 03.11.2025.
+// Changeb by marco on 16.11.2025
+
+#include <iostream>
+#include <cmath>
+#include "gamematrix.h"
+
+using namespace Matrix3D;
+
+bool nearlyEqual(double a, double b, double eps = 1e-6) {
+    return std::abs(a - b) < eps;
+}
+
+void test_matmul_identity() {
+    Mat4 A = identity();
+    Mat4 B = identity();
+    Mat4 R = matmul(A, B);
+
+    std::cout << "Test matmul: Identity * Identity -> Identity: ";
+
+    bool ok = true;
+    for(int i=0;i<4;i++){
+        for(int j=0;j<4;j++){
+            double expected = (i==j ? 1.0 : 0.0);
+            if(!nearlyEqual(R[i][j], expected)) ok = false;
+        }
+    }
+
+    std::cout << (ok ? "OK\n" : "FAIL\n");
+}
+
+void test_matmul_example() {
+    Mat4 A = {{
+        {{1, 2, 3, 4}},
+        {{0, 1, 2, 3}},
+        {{0, 0, 1, 2}},
+        {{0, 0, 0, 1}}
+    }};
+
+    Mat4 B = {{
+        {{1, 0, 0, 0}},
+        {{1, 1, 0, 0}},
+        {{1, 1, 1, 0}},
+        {{1, 1, 1, 1}}
+    }};
+
+    Mat4 R = matmul(A, B);
+
+    std::cout << "Test matmul: Beispielmatrizen A * B: ";
+
+    // Erwartete Matrix mit Handrechnung:
+    Mat4 Expected = {{
+        {{1+2+3+4,   2+3+4,   3+4,   4}},
+        {{0+1+2+3,   1+2+3,   2+3,   3}},
+        {{0+0+1+2,   0+1+2,   1+2,   2}},
+        {{1,         1,       1,     1}}
+    }};
+
+    bool ok = true;
+    for(int i=0;i<4;i++){
+        for(int j=0;j<4;j++){
+            if(!nearlyEqual(R[i][j], Expected[i][j])) ok = false;
+        }
+    }
+
+    std::cout << (ok ? "OK\n" : "FAIL\n");
+}
+
+void test_translate() {
+    Vec3 v{1,2,3};
+    Mat4 T = translate({5,-2,1});
+    Vec3 out = T * v;
+
+    std::cout << "Test translate (Vec3{1,2,3} + {5,-2,1}): ";
+
+    if(nearlyEqual(out.x, 6) && nearlyEqual(out.y, 0) && nearlyEqual(out.z, 4))
+        std::cout << "OK\n";
+    else
+        std::cout << "FAIL (" << out.x << "," << out.y << "," << out.z << ")\n";
+}
+
+void test_rotZ_90() {
+    Vec3 v{1,0,0};
+    Mat4 Rm = rot3D(90, 'z');
+    Vec3 out = Rm * v;
+
+    std::cout << "Test rot3D Z 90° (1,0,0 -> 0,1,0): ";
+
+    if(nearlyEqual(out.x, 0) && nearlyEqual(out.y, 1))
+        std::cout << "OK\n";
+    else
+        std::cout << "FAIL (" << out.x << "," << out.y << "," << out.z << ")\n";
+}
+
+void test_rotX_180() {
+    Vec3 v{0,1,0};
+    Mat4 Rm = rot3D(180, 'x');
+    Vec3 out = Rm * v;
+
+    std::cout << "Test rot3D X 180° (0,1,0 -> 0,-1,0): ";
+
+    if(nearlyEqual(out.y, -1))
+        std::cout << "OK\n";
+    else
+        std::cout << "FAIL (" << out.x << "," << out.y << "," << out.z << ")\n";
+}
+
+void test_rotY_270() {
+    Vec3 v{1,0,0};
+    Mat4 Rm = rot3D(270, 'y');
+    Vec3 out = Rm * v;
+
+    std::cout << "Test rot3D Y 270° (1,0,0 -> 0,0,-1): ";
+
+    if(nearlyEqual(out.x, 0) && nearlyEqual(out.z, -1))
+        std::cout << "OK\n";
+    else
+        std::cout << "FAIL (" << out.x << "," << out.y << "," << out.z << ")\n";
+}
+
+int main() {
+    std::cout << "===== Matrix3D Tests =====\n";
+
+    test_matmul_identity();
+    test_matmul_example();
+
+    test_translate();
+
+    test_rotZ_90();
+    test_rotX_180();
+    test_rotY_270();
+
+    std::cout << "==========================\n";
+    return 0;
+}
+

docs/tests.txt

@@ -0,0 +1,42 @@
+========================================================
+Projekt: gamematrix (C++ Library)
+Rolle: Tester
+Datei: tests.txt
+Datum: ____________________
+Team: ____________________
+========================================================
+
+# ----------------------------
+# 1. Testplan Übersicht
+# ----------------------------
+Ziel: Überprüfung der Funktionen matmul(), translate(), rot3D().
+
+| Funktion      | Testfall                  | Eingabe                      | Erwartetes Ergebnis               | Bemerkung                  |
+|---------------|---------------------------|------------------------------|-----------------------------------|----------------------------|
+| matmul        | Identity * Identity       | 4x4 Identity Matrizen        | Identity                          | Basisfall                  |
+| matmul        | Beispielmatrizen          | A=[[...]], B=[[...]]         | C=[[...]]                         | Prüfen mit Handrechnung    |
+| translate     | Verschiebung              | Vec3 {1,2,3}                 | Matrix mit Translation 1,2,3      | Prüfen letzte Spalte       |
+| rot3D         | Rotation Z 90°            | angle_deg=90, axis='z'       | (1,0,0) -> (0,1,0)                | Prüfen Anwendung auf Vektor|
+| rot3D         | Rotation X 180°           | angle_deg=180, axis='x'      | (0,1,0) -> (0,-1,0)               | Prüfen Anwendung auf Vektor|
+| rot3D         | Rotation Y 270°           | angle_deg=270, axis='y'      | (1,0,0) -> (0,0,-1)               | Prüfen Anwendung auf Vektor|
+
+
+# ----------------------------
+# 2. Testdaten / Matrizen
+# ----------------------------
+- Matrizen für matmul: Identity, Beispiel A/B Matrizen
+- Vektoren für translate: Vec3 {x, y, z}
+- Vektoren für rot3D: Vec3 {1,0,0}, Vec3 {0,1,0}
+
+# ----------------------------
+# 3. Abnahmekriterien
+# ----------------------------
+- Alle Unit-Tests erfolgreich
+- Keine Exceptions außer gewollt (z. B. ungültige Achse)
+- Testbericht in tests.txt dokumentiert
+
+========================================================
+Hinweis:
+- Diese Datei wird vom Tester gepflegt.
+- Tester dokumentiert Input, Output, erwartetes Ergebnis und Erfolg/Fehler.
+========================================================

parallel/matrizenmultiplikation.cpp

@@ -1,91 +0,0 @@
-#include <iostream>
-#include <vector>
-#include <chrono>
-#include <omp.h>
-
-
-// Funktion erzeugt zwei Matrizen A und B der Größe n x n mit Zufallswerten
-void generateRandomMatrices(int n,
-                            std::vector<std::vector<double>>& A,
-                            std::vector<std::vector<double>>& B,
-                            double min_val = 0.0,
-                            double max_val = 10.0)
-{
-    // Zufallsgenerator initialisieren
-    std::srand(static_cast<unsigned int>(std::time(nullptr)));
-
-    A.resize(n, std::vector<double>(n));
-    B.resize(n, std::vector<double>(n));
-
-    for (int i = 0; i < n; ++i)
-        for (int j = 0; j < n; ++j)
-        {
-            double r1 = static_cast<double>(std::rand()) / RAND_MAX; // 0..1
-            double r2 = static_cast<double>(std::rand()) / RAND_MAX; // 0..1
-            A[i][j] = min_val + r1 * (max_val - min_val);
-            B[i][j] = min_val + r2 * (max_val - min_val);
-        }
-}
-
-std::vector<std::vector<double>> matmul_serial(
-    const std::vector<std::vector<double>>& A,
-    const std::vector<std::vector<double>>& B)
-{
-    int n = A.size();
-    int m = B[0].size();
-    int p = B.size();
-
-    std::vector<std::vector<double>> C(n, std::vector<double>(m, 0.0));
-
-    for (int i = 0; i < n; ++i)
-        for (int j = 0; j < m; ++j)
-            for (int k = 0; k < p; ++k)
-                C[i][j] += A[i][k] * B[k][j];
-
-    return C;
-}
-
-std::vector<std::vector<double>> matmul_parallel(
-    const std::vector<std::vector<double>>& A,
-    const std::vector<std::vector<double>>& B)
-{
-    int n = A.size();
-    int m = B[0].size();
-    int p = B.size();
-
-    std::vector<std::vector<double>> C(n, std::vector<double>(m, 0.0));
-
-    #pragma omp parallel for
-    for (int i = 0; i < n; ++i)
-        for (int j = 0; j < m; ++j)
-            for (int k = 0; k < p; ++k)
-                C[i][j] += A[i][k] * B[k][j];
-
-    return C;
-}
-
-int main()
-{
-    int N = 500;
-
-    std::vector<std::vector<double>> A, B;
-    generateRandomMatrices(N, A, B);
-
-    // Serielle Version
-    auto start = std::chrono::high_resolution_clock::now();
-    auto C_serial = matmul_serial(A, B);
-    auto end = std::chrono::high_resolution_clock::now();
-    std::cout << "Serielle Laufzeit: "
-              << std::chrono::duration<double>(end - start).count()
-              << " Sekunden\n";
-
-    // Parallele Version
-    start = std::chrono::high_resolution_clock::now();
-    auto C_parallel = matmul_parallel(A, B);
-    end = std::chrono::high_resolution_clock::now();
-    std::cout << "Parallele Laufzeit: "
-              << std::chrono::duration<double>(end - start).count()
-              << " Sekunden\n";
-
-    return 0;
-}

parallel/parallel_measurements.cpp

@@ -1,83 +0,0 @@
-
-#include <iostream>
-#include <fstream>
-#include <vector>
-#include <thread>
-#include <chrono>
-#include <string>
-
-void readFile(const std::string& filename, std::vector<int>& data) {
-    std::ifstream file(filename);
-    if (!file) {
-        std::cerr << "Fehler: Datei '" << filename << "' konnte nicht geöffnet werden!\n";
-        return;
-    }
-    int v;
-    while (file >> v) data.push_back(v);
-}
-
-int countIncreasesSerial(const std::vector<int>& data) {
-    if (data.size() < 2) return 0;
-    int increases = 0;
-    for (size_t i = 1; i < data.size(); ++i)
-        if (data[i] > data[i - 1]) ++increases;
-    return increases;
-}
-
-int countIncreasesParallel(const std::vector<int>& messungen, int numThreads = 4) {
-    int totalComparisons = static_cast<int>(messungen.size()) - 1;
-    if (totalComparisons <= 0) return 0;
-
-    std::vector<int> results(numThreads, 0);
-    std::vector<std::thread> threads;
-    threads.reserve(numThreads);
-
-    int base = totalComparisons / numThreads;
-    int remainder  = totalComparisons % numThreads;
-
-    int idx = 1;
-    for (int t = 0; t < numThreads; t++) {
-        int startIdx = idx;
-        int count = base + (t < remainder ? 1 : 0);
-        int endIdx = idx + count - 1;
-        idx = endIdx + 1;
-
-        if (count <= 0) {
-            results[t] = 0;
-            continue;
-        }
-
-        threads.emplace_back([&, t, startIdx, endIdx]() {
-            int localCount = 0;
-            for (int i = startIdx; i <= endIdx; ++i)
-                if (messungen[i] > messungen[i - 1])
-                    ++localCount;
-            results[t] = localCount;
-        });
-    }
-
-    for (auto& th : threads) th.join();
-
-    int total = 0;
-    for (int r : results) total += r;
-    return total;
-}
-
-int main() {
-    std::vector<int> messungen;
-    readFile("parallel/measurements.txt", messungen);
-    std::cout << "Gelesene Werte: " << messungen.size() << "\n";
-
-    auto t0 = std::chrono::steady_clock::now();
-    int s = countIncreasesSerial(messungen);
-    auto t1 = std::chrono::steady_clock::now();
-
-    auto p0 = std::chrono::steady_clock::now();
-    int p = countIncreasesParallel(messungen, 4);
-    auto p1 = std::chrono::steady_clock::now();
-
-    std::cout << "Seriell:   " << s << "  Dauer: " << std::chrono::duration<double>(t1 - t0).count() << "s\n";
-    std::cout << "Parallel:  " << p << "  Dauer: " << std::chrono::duration<double>(p1 - p0).count() << "s\n";
-
-    return 0;
-}