Test wurde für kleinere Matrizen angepasst -> Komponentenweiser Vergleich

Hausaufgaben

.gitignore

@@ -0,0 +1,11 @@
+# Ignore CMake build directories
+cmake-build-debug/
+cmake-build-release/
+
+# General build artifacts
+build/
+out/
+*.o
+*.obj
+*.log
+idea/

CMakeLists.txt

@@ -1,59 +1,84 @@
 cmake_minimum_required(VERSION 3.28)
 project(Prog3B)
+
 set(EXECUTABLE_NAME Prog3B)
 
-# Generate compile_commands.json
+# -------------------------------------------------
+# Global settings
+# -------------------------------------------------
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-
+# -------------------------------------------------
+# Main executable
+# -------------------------------------------------
 set(SRC_FILES
         src/main.cpp
         src/gamecube.cpp
         src/gamematrix.cpp
 )
+
 add_executable(${EXECUTABLE_NAME} ${SRC_FILES})
+
 target_include_directories(${EXECUTABLE_NAME} PRIVATE
         ${CMAKE_CURRENT_LIST_DIR}/includes
         ${CMAKE_CURRENT_LIST_DIR}/raylib
 )
 
-
+# -------------------------------------------------
+# Tests executable
+# -------------------------------------------------
 set(TEST_FILES
-        src/tests.cpp
         src/gamematrix.cpp
 )
+
 add_executable(tests ${TEST_FILES})
+
 target_include_directories(tests PRIVATE
         ${CMAKE_CURRENT_LIST_DIR}/includes
 )
 
-
+# -------------------------------------------------
+# Platform specific linking
+# -------------------------------------------------
 if (WIN32)
 
     message(STATUS "Configuring for Windows")
+
     target_link_libraries(${EXECUTABLE_NAME} PRIVATE
-            ${CMAKE_CURRENT_LIST_DIR}/windows/libgamematrix.a
             ${CMAKE_CURRENT_LIST_DIR}/windows/libraylib.a
-            opengl32 gdi32 winmm
+            opengl32
+            gdi32
+            winmm
     )
+
 elseif (APPLE)
 
-    message(STATUS "Configuring for MacOS")
+    message(STATUS "Configuring for macOS")
 
     target_link_libraries(${EXECUTABLE_NAME} PRIVATE
-            ${CMAKE_CURRENT_LIST_DIR}/mac_x86/libgamematrix.a
             ${CMAKE_CURRENT_LIST_DIR}/mac_x86/libraylib.a
-            "-framework IOKit"
             "-framework Cocoa"
             "-framework OpenGL"
+            "-framework IOKit"
     )
+
 else ()
-    # --- Linux ---
+
     message(STATUS "Configuring for Linux")
+
     target_link_libraries(${EXECUTABLE_NAME} PRIVATE
-            ${CMAKE_CURRENT_LIST_DIR}/linux/libgamematrix.a
             ${CMAKE_CURRENT_LIST_DIR}/linux/libraylib.a
-            GL X11 m
+            GL
+            X11
+            m
+            pthread
+            dl
     )
+
+    target_link_libraries(tests PRIVATE
+            m
+    )
+
 endif ()

includes/gamecube.h

@@ -32,3 +32,4 @@ private:
     bool flippingBackward = false;
     float rotation = 0.0f;
 };
+

includes/gamematrix.h

@@ -25,3 +25,11 @@ public:
     );
 };
 
+enum class GameState
+{
+    Idle,          // kein Würfel offen, Eingabe erlaubt
+    OneFlipped,    // ein Würfel offen
+    CheckingMatch, // zwei Würfel vollständig aufgeklappt, Vergleich läuft
+    LockInput      // Würfel drehen gerade – Eingabe kurz blockiert
+};
+

parallel2/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

parallel2/.idea/.name

@@ -0,0 +1 @@
+Uebung5

parallel2/.idea/editor.xml

@@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="BackendCodeEditorSettings">
+    <option name="/Default/CodeStyle/CodeFormatting/CppClangFormat/EnableClangFormatSupport/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_ARGUMENT/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_BINARY_EXPRESSIONS_CHAIN/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_CALLS_CHAIN/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_EXPRESSION/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_EXTENDS_LIST/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_FOR_STMT/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_PARAMETER/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_TYPE_ARGUMENT/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTILINE_TYPE_PARAMETER/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_MULTIPLE_DECLARATION/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ALIGN_TERNARY/@EntryValue" value="ALIGN_ALL" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/ANONYMOUS_METHOD_DECLARATION_BRACES/@EntryValue" value="END_OF_LINE" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/BLANK_LINES_AROUND_CLASS_DEFINITION/@EntryValue" value="1" type="int" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/BLANK_LINES_AROUND_DECLARATIONS/@EntryValue" value="0" type="int" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/BLANK_LINES_AROUND_FUNCTION_DECLARATION/@EntryValue" value="1" type="int" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/BLANK_LINES_AROUND_FUNCTION_DEFINITION/@EntryValue" value="1" type="int" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/BREAK_TEMPLATE_DECLARATION/@EntryValue" value="LINE_BREAK" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/CASE_BLOCK_BRACES/@EntryValue" value="END_OF_LINE" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/CONTINUOUS_LINE_INDENT/@EntryValue" value="Double" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INDENT_ACCESS_SPECIFIERS_FROM_CLASS/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INDENT_CASE_FROM_SWITCH/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INDENT_CLASS_MEMBERS_FROM_ACCESS_SPECIFIERS/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INDENT_COMMENT/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INDENT_SIZE/@EntryValue" value="4" type="int" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INDENT_STYLE/@EntryValue" value="Space" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INITIALIZER_BRACES/@EntryValue" value="END_OF_LINE_NO_SPACE" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INT_ALIGN_EQ/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INVOCABLE_DECLARATION_BRACES/@EntryValue" value="END_OF_LINE" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/KEEP_BLANK_LINES_IN_CODE/@EntryValue" value="2" type="int" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/KEEP_BLANK_LINES_IN_DECLARATIONS/@EntryValue" value="2" type="int" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/KEEP_USER_LINEBREAKS/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/LINE_BREAK_AFTER_COLON_IN_MEMBER_INITIALIZER_LISTS/@EntryValue" value="ON_SINGLE_LINE" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/MEMBER_INITIALIZER_LIST_STYLE/@EntryValue" value="DO_NOT_CHANGE" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/NAMESPACE_DECLARATION_BRACES/@EntryValue" value="END_OF_LINE" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/NAMESPACE_INDENTATION/@EntryValue" value="All" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/OTHER_BRACES/@EntryValue" value="END_OF_LINE" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/PLACE_CATCH_ON_NEW_LINE/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/PLACE_ELSE_ON_NEW_LINE/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/PLACE_NAMESPACE_DEFINITIONS_ON_SAME_LINE/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/PLACE_WHILE_ON_NEW_LINE/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SIMPLE_BLOCK_STYLE/@EntryValue" value="DO_NOT_CHANGE" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_CAST_EXPRESSION_PARENTHESES/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_COLON_IN_BITFIELD_DECLARATOR/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_COMMA_IN_TEMPLATE_ARGS/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_COMMA_IN_TEMPLATE_PARAMS/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_EXTENDS_COLON/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_FOR_COLON/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_FOR_SEMICOLON/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_PTR_IN_DATA_MEMBER/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_PTR_IN_DATA_MEMBERS/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_PTR_IN_METHOD/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_PTR_IN_NESTED_DECLARATOR/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_REF_IN_DATA_MEMBER/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_REF_IN_DATA_MEMBERS/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_REF_IN_METHOD/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_AFTER_UNARY_OPERATOR/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_COLON_IN_BITFIELD_DECLARATOR/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_EXTENDS_COLON/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_FOR_COLON/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_FOR_SEMICOLON/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_PTR_IN_ABSTRACT_DECL/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_PTR_IN_DATA_MEMBER/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_PTR_IN_DATA_MEMBERS/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_PTR_IN_METHOD/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_REF_IN_ABSTRACT_DECL/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_REF_IN_DATA_MEMBER/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_REF_IN_DATA_MEMBERS/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_REF_IN_METHOD/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_TEMPLATE_ARGS/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BEFORE_TEMPLATE_PARAMS/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_BETWEEN_CLOSING_ANGLE_BRACKETS_IN_TEMPLATE_ARGS/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_ARRAY_ACCESS_BRACKETS/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_CAST_EXPRESSION_PARENTHESES/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_DECLARATION_PARENTHESES/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_EMPTY_BLOCKS/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_EMPTY_INITIALIZER_BRACES/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_EMPTY_METHOD_PARENTHESES/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_EMPTY_TEMPLATE_PARAMS/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_INITIALIZER_BRACES/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_TEMPLATE_ARGS/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPACE_WITHIN_TEMPLATE_PARAMS/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/SPECIAL_ELSE_IF_TREATMENT/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/TAB_WIDTH/@EntryValue" value="4" type="int" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/TYPE_DECLARATION_BRACES/@EntryValue" value="END_OF_LINE" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_AFTER_BINARY_OPSIGN/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_AFTER_DECLARATION_LPAR/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_AFTER_INVOCATION_LPAR/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_ARGUMENTS_STYLE/@EntryValue" value="WRAP_IF_LONG" type="string" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_BEFORE_DECLARATION_LPAR/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_BEFORE_DECLARATION_RPAR/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_BEFORE_INVOCATION_LPAR/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_BEFORE_INVOCATION_RPAR/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_BEFORE_TERNARY_OPSIGNS/@EntryValue" value="true" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_PARAMETERS_STYLE/@EntryValue" value="WRAP_IF_LONG" type="string" />
+    <option name="/Default/CodeStyle/EditorConfig/EnableClangFormatSupport/@EntryValue" value="false" type="bool" />
+  </component>
+</project>

parallel2/.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CMakePythonSetting">
+    <option name="pythonIntegrationState" value="YES" />
+  </component>
+  <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
+</project>

parallel2/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/parallel2.iml" filepath="$PROJECT_DIR$/.idea/parallel2.iml" />
+    </modules>
+  </component>
+</project>

parallel2/.idea/parallel2.iml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module classpath="CMake" type="CPP_MODULE" version="4" />

parallel2/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>

parallel2/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.15)
+project(Uebung5)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# OpenMP aktivieren
+find_package(OpenMP REQUIRED)
+if(OpenMP_CXX_FOUND)
+    message(STATUS "OpenMP found")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+endif()
+
+# Executable erstellen
+add_executable(parallel2 main.cpp)

parallel2/main.cpp

@@ -0,0 +1,238 @@
+#include <iostream>
+#include <vector>
+#include <cstdlib>
+#include <ctime>
+#include <chrono>
+#include <cmath>
+#include <omp.h>
+
+
+// Matrizen erzeugen
+
+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)
+{
+    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;
+            double r2 = static_cast<double>(std::rand()) / RAND_MAX;
+            A[i][j] = min_val + r1 * (max_val - min_val);
+            B[i][j] = min_val + r2 * (max_val - min_val);
+        }
+}
+
+
+// Seriell
+
+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;
+}
+
+
+// Parallele Zeilenzerlegung
+
+std::vector<std::vector<double>> matmul_parallel_rows(const std::vector<std::vector<double>>& A,
+                                                      const std::vector<std::vector<double>>& B,
+                                                      int numThreads)
+{
+    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 num_threads(numThreads)
+    for (int i = 0; i < n; ++i)
+    {
+        std::vector<double> row(m, 0.0);
+        for (int j = 0; j < m; ++j)
+        {
+            double sum = 0.0;
+            for (int k = 0; k < p; ++k)
+                sum += A[i][k] * B[k][j]; //verhindert überschreibuung
+            row[j] = sum;
+        }
+        C[i] = row;
+    }
+
+    return C;
+}
+
+
+// Parallele Spaltenzerlegung
+
+std::vector<std::vector<double>> matmul_parallel_cols(const std::vector<std::vector<double>>& A,
+                                                      const std::vector<std::vector<double>>& B,
+                                                      int numThreads)
+{
+    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 num_threads(numThreads)
+    for (int j = 0; j < m; ++j)
+    {
+        for (int i = 0; i < n; ++i)
+        {
+            double sum = 0.0;
+            for (int k = 0; k < p; ++k)
+                sum += A[i][k] * B[k][j]; //Zwischengepeichert
+            C[i][j] = sum;
+        }
+    }
+
+    return C;
+}
+
+
+// Blockzerlegung
+
+std::vector<std::vector<double>> matmul_block(const std::vector<std::vector<double>>& A,
+                                              const std::vector<std::vector<double>>& B,
+                                              int blockSize,
+                                              int numThreads)
+{
+    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 collapse(2) num_threads(numThreads)
+    for (int ii = 0; ii < n; ii += blockSize)
+        for (int jj = 0; jj < m; jj += blockSize)
+        {
+            for (int i = ii; i < std::min(ii + blockSize, n); ++i)
+                for (int j = jj; j < std::min(jj + blockSize, m); ++j)
+                {
+                    double sum = 0.0;
+                    for (int k = 0; k < p; ++k)
+                        sum += A[i][k] * B[k][j];
+                    C[i][j] = sum;
+                }
+        }
+
+    return C;
+}
+
+
+// Matrix ausgeben
+
+void printMatrix(const std::vector<std::vector<double>>& M, const std::string& name)
+{
+    std::cout << name << " (" << M.size() << "x" << (M.empty() ? 0 : M[0].size()) << "):\n";
+    for (const auto& row : M)
+    {
+        for (double val : row)
+            std::cout << val << "\t";
+        std::cout << "\n";
+    }
+    std::cout << "\n";
+}
+
+
+//Matrix Vergleich (Komponentenweise)
+bool compareMatrices(const std::vector<std::vector<double>>& A,
+                     const std::vector<std::vector<double>>& B)
+{
+    if (A.size() != B.size() || A[0].size() != B[0].size())
+        return false;
+
+    for (size_t i = 0; i < A.size(); ++i)
+        for (size_t j = 0; j < A[0].size(); ++j)
+            if (std::abs(A[i][j] - B[i][j]) > 1e-9)
+                return false;
+    return true;
+}
+
+
+
+
+
+
+
+int main()
+{
+    int N = 4; // für Ausgabe kleiner Matrizen <5
+    int numThreads = omp_get_max_threads();
+    if (numThreads == 0) numThreads = 4;
+
+    std::vector<std::vector<double>> A, B;
+    generateRandomMatrices(N, A, B);
+
+    if (N < 5)
+    {
+        printMatrix(A, "Matrix A");
+        printMatrix(B, "Matrix B");
+    }
+
+    // Serielle Berechnung
+    auto start = std::chrono::steady_clock::now();
+    auto C_serial = matmul_serial(A, B);
+    auto end = std::chrono::steady_clock::now();
+    double timeSerial = std::chrono::duration<double>(end - start).count();
+    std::cout << "Seriell: " << timeSerial << " s\n";
+
+    if (N < 5)
+        printMatrix(C_serial, "C_serial");
+
+    // Zeilenparallel
+    start = std::chrono::steady_clock::now();
+    auto C_rows = matmul_parallel_rows(A, B, numThreads);
+    end = std::chrono::steady_clock::now();
+    double timeRows = std::chrono::duration<double>(end - start).count();
+    std::cout << "Parallel Zeilen: " << timeRows << " s | "
+              << (compareMatrices(C_serial, C_rows) ? "Match" : "Mismatch") << "\n";
+
+    if (N < 5)
+        printMatrix(C_rows, "C_rows");
+
+    // Spaltenparallel
+    start = std::chrono::steady_clock::now();
+    auto C_cols = matmul_parallel_cols(A, B, numThreads);
+    end = std::chrono::steady_clock::now();
+    double timeCols = std::chrono::duration<double>(end - start).count();
+    std::cout << "Parallel Spalten: " << timeCols << " s | "
+              << (compareMatrices(C_serial, C_cols) ? "Match" : "Mismatch") << "\n";
+
+    if (N < 5)
+        printMatrix(C_cols, "C_cols");
+
+    // Blockparallel
+    int blockSize = 2; // für kleine N passend
+    start = std::chrono::steady_clock::now();
+    auto C_block = matmul_block(A, B, blockSize, numThreads);
+    end = std::chrono::steady_clock::now();
+    double timeBlock = std::chrono::duration<double>(end - start).count();
+    std::cout << "Parallel Block (" << blockSize << "x" << blockSize << "): "
+              << timeBlock << " s | "
+              << (compareMatrices(C_serial, C_block) ? "Match" : "Mismatch") << "\n";
+
+    if (N < 5)
+        printMatrix(C_block, "C_block");
+
+    return 0;
+}

src/gamematrix.cpp

@@ -5,13 +5,10 @@
 #include "../includes/gamematrix.h"
 
 // Matrixmultiplikation
-
-
 // Rotationsmatrix um Achse x/y/z
-static std::array<std::array<double,4>,4> rot3D(double angle_deg, char axis);
+//static std::array<std::array<double,4>,4> rot3D(double angle_deg, char axis);
-
 // Verschiebung
-static std::array<std::array<double,4>,4> translate(const std::array<double, 3>& pos);
+//static std::array<std::array<double,4>,4> translate(const std::array<double, 3>& pos);
 
 
 

src/main.cpp

@@ -1,8 +1,16 @@
 #include "gamecube.h"
 #include <algorithm>
 #include <ctime>
-//Funktion innitGame
+#include <iostream>
-    //Anzahl der Paare(pairCount*2)
+//enum game
+//Ab Zeile 114 if game won
+//Ab Zeile 148 checking match?
+
+
+// -----------------------------------------------------------
+// Initialisierung
+// -----------------------------------------------------------
+
 void innitGame(int pairCount,
                 std::vector<gamecube> &cubes,
                 std::vector<Vec3> &positions )
@@ -65,8 +73,6 @@ void innitGame(int pairCount,
 // -----------------------------------------------------------
 int main()
 {
-
-
     //NEU Counter
     int counter = 0;
 
@@ -89,7 +95,7 @@ int main()
     // Spielvariablen
     // -------------------------------------------------------
     // Nur 3 Farben für 3 Paare
-    int pairCount = 6;    // <-- vorerst fixe Anzahl
+    int pairCount = 2;    // <-- vorerst fixe Anzahl
     std::vector<Vec3> positions;
     std::vector<gamecube> cubes;
 
@@ -104,27 +110,48 @@ int main()
     float flipSpeed = 5.0f;  // Drehgeschwindigkeit
     bool gameWon = false;
 
+    GameState state = GameState::Idle; //legen wir fest, in welchem Zustand das Spiel startet
+
     // -----------------------------------------------------------
     // Hauptspielschleife
     // -----------------------------------------------------------
+
     while (!WindowShouldClose())
     {
+
         // Klick-Erkennung
-        if (!gameWon && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
+        if (!gameWon
-        {
+            && (state == GameState::Idle || state == GameState::OneFlipped)
-            //Neu Counter
+            && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) {
-            counter++;
+
+            // nur im Idle- oder OneFlipped-Zustand wird reagiert<-------------------------------------------------
+                //Wenn einer Dreht, clicken blockieren
+            // ...
 
             Vector2 mouse = GetMousePosition();
 
-            for (auto &c : cubes)
+            for (auto &c : cubes)           //Hier die State Logik
             {
-                if (!c.IsFlipped() && !c.IsMatched())
+                std::cout<<("State missing");
+                if (!c.IsFlipped() && !c.IsMatched())   //<--------------- Zustandwechsel anpassen
                 {
-                    Vector2 screenPos = GetWorldToScreen({c.GetPosition().x, c.GetPosition().y, c.GetPosition().z}, camera);
+                    Vector2 screenPos = GetWorldToScreen(
+                        {c.GetPosition().x, c.GetPosition().y, c.GetPosition().z}, camera);
 
-                    if (fabs(mouse.x - screenPos.x) < 40 && fabs(mouse.y - screenPos.y) < 40)
+                    if (fabs(mouse.x - screenPos.x) < 40 &&
-                        c.FlipForward();
+                        fabs(mouse.y - screenPos.y) < 40)
+                    {
+                        c.FlipForward(); //<-----Animation Start
+                        //Neu Counter
+                        counter++;
+
+                        if (state == GameState::Idle)       //Neu (Ü4)
+                            state = GameState::OneFlipped;
+                        else
+                            state = GameState::LockInput;
+
+                        break; // 🔒 nur EIN Würfel pro Klick
+                    }
                 }
             }
         }
@@ -137,8 +164,10 @@ int main()
             // Sobald ein Würfel vollständig umgedreht ist → merken
             if (c.IsFlipped() && !c.IsMatched())
             {
-                if (!first) first = &c;
+                if (!first)
-                else if (!second && &c != first) second = &c;
+                    first = &c;
+                else if (!second && &c != first)
+                    second = &c;
             }
         }
 
@@ -150,7 +179,9 @@ int main()
             Color col1 = first->GetColor();
             Color col2 = second->GetColor();
 
-            if (col1.r == col2.r && col1.g == col2.g && col1.b == col2.b)
+            if (col1.r == col2.r &&
+                col1.g == col2.g &&
+                col1.b == col2.b)
             {
                 first->SetMatched(true);
                 second->SetMatched(true);
@@ -163,9 +194,12 @@ int main()
 
 
             first = second = nullptr;
+            state = GameState::Idle; //neu
         }
 
-        // Gewinnprüfung
+        // -----------------------------
+        // WIN CHECK
+        // -----------------------------
         if (!gameWon)
             gameWon = std::all_of(cubes.begin(), cubes.end(), [](const gamecube &c){ return c.IsMatched(); });
 

src/test.cpp

@@ -0,0 +1,211 @@
+//
+// Created by gamer on 14.12.2025.
+//
+#include "gamecube.h"
+#include <algorithm>
+#include <ctime>
+#include <iostream>
+
+// -----------------------------------------------------------
+// GameState – Zustandsmaschine
+// -----------------------------------------------------------
+enum class GameState
+{
+    Idle,          // kein Würfel offen
+    OneFlipped,    // ein Würfel offen
+    LockInput,     // Animation läuft
+    CheckingMatch  // Vergleich
+};
+
+// -----------------------------------------------------------
+// Initialisierung
+// -----------------------------------------------------------
+void innitGame(int pairCount,
+               std::vector<gamecube> &cubes,
+               std::vector<Vec3> &positions)
+{
+    cubes.clear();
+    positions.clear();
+
+    int total = pairCount * 2;
+    int cols = ceil(sqrt(total));
+    int rows = (total + cols - 1) / cols;
+    float spacing = 2.2f;
+
+    for (int r = 0; r < rows; r++)
+        for (int c = 0; c < cols; c++)
+            if ((int)positions.size() < total)
+                positions.push_back({
+                    (c - cols / 2.0f) * spacing,
+                    0,
+                    (r - rows / 2.0f) * spacing
+                });
+
+    std::vector<Color> colorPool;
+    for (int i = 0; i < pairCount; i++)
+    {
+        Color col = {
+            (unsigned char)(rand() % 256),
+            (unsigned char)(rand() % 256),
+            (unsigned char)(rand() % 256),
+            255
+        };
+        colorPool.push_back(col);
+        colorPool.push_back(col);
+    }
+
+    for (int i = total - 1; i > 0; --i)
+        std::swap(colorPool[i], colorPool[rand() % (i + 1)]);
+
+    for (int i = 0; i < total; i++)
+        cubes.emplace_back(positions[i], colorPool[i]);
+}
+
+// -----------------------------------------------------------
+// MAIN
+// -----------------------------------------------------------
+int main()
+{
+    srand(time(NULL));
+    InitWindow(800, 600, "3D Memory Game – Stable Version");
+    SetTargetFPS(60);
+
+    Camera3D camera{};
+    camera.position = {6, 6, 6};
+    camera.target = {0, 0, 0};
+    camera.up = {0, 1, 0};
+    camera.fovy = 45;
+    camera.projection = CAMERA_PERSPECTIVE;
+
+    int pairCount = 2;
+    std::vector<Vec3> positions;
+    std::vector<gamecube> cubes;
+    innitGame(pairCount, cubes, positions);
+
+    gamecube *first = nullptr;
+    gamecube *second = nullptr;
+
+    float flipSpeed = 5.0f;
+    bool gameWon = false;
+    int counter = 0;
+
+    GameState state = GameState::Idle;
+
+    // -----------------------------------------------------------
+    // GAME LOOP
+    // -----------------------------------------------------------
+    while (!WindowShouldClose())
+    {
+        // -----------------------------
+        // INPUT (nur wenn erlaubt)
+        // -----------------------------
+        if (!gameWon &&
+            (state == GameState::Idle || state == GameState::OneFlipped) &&
+            IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
+        {
+            Vector2 mouse = GetMousePosition();
+
+            for (auto &c : cubes)
+            {
+                if (!c.IsFlipped() && !c.IsMatched())
+                {
+                    Vector2 screenPos = GetWorldToScreen(
+                        {c.GetPosition().x, c.GetPosition().y, c.GetPosition().z},
+                        camera);
+
+                    if (fabs(mouse.x - screenPos.x) < 40 &&
+                        fabs(mouse.y - screenPos.y) < 40)
+                    {
+                        c.FlipForward();
+                        counter++;
+
+                        if (state == GameState::Idle)
+                            state = GameState::OneFlipped;
+                        else
+                            state = GameState::LockInput;
+
+                        break; // 🔒 nur EIN Würfel pro Klick
+                    }
+                }
+            }
+        }
+
+        // -----------------------------
+        // UPDATE – Animation
+        // -----------------------------
+        for (auto &c : cubes)
+        {
+            c.Update(flipSpeed);
+
+            if (c.IsFlipped() && !c.IsMatched())
+            {
+                if (!first)
+                    first = &c;
+                else if (!second && &c != first)
+                    second = &c;
+            }
+        }
+
+        // -----------------------------
+        // Animation beendet → Vergleich
+        // -----------------------------
+        if (state == GameState::LockInput && first && second)
+            state = GameState::CheckingMatch;
+
+        // -----------------------------
+        // MATCHING
+        // -----------------------------
+        if (state == GameState::CheckingMatch)
+        {
+            Color a = first->GetColor();
+            Color b = second->GetColor();
+
+            if (a.r == b.r && a.g == b.g && a.b == b.b)
+            {
+                first->SetMatched(true);
+                second->SetMatched(true);
+            }
+            else
+            {
+                first->FlipBackward();
+                second->FlipBackward();
+            }
+
+            first = second = nullptr;
+            state = GameState::Idle;
+        }
+
+        // -----------------------------
+        // WIN CHECK
+        // -----------------------------
+        if (!gameWon)
+            gameWon = std::all_of(
+                cubes.begin(),
+                cubes.end(),
+                [](const gamecube &c)
+                { return c.IsMatched(); });
+
+        // -----------------------------
+        // DRAW
+        // -----------------------------
+        BeginDrawing();
+        ClearBackground(RAYWHITE);
+        BeginMode3D(camera);
+
+        for (auto &c : cubes)
+            c.Draw();
+
+        EndMode3D();
+
+        if (gameWon)
+            DrawText("Congrats! You found all pairs!", 140, 260, 30, DARKBLUE);
+        else
+            DrawText("Flip 2 cubes - find matching pairs!", 10, 10, 20, DARKGRAY);
+
+        DrawText(TextFormat("Moves: %i", counter / 2), 10, 40, 20, DARKGRAY);
+        EndDrawing();
+    }
+
+    CloseWindow();
+    return 0;
+}

src/testmain.cpp

@@ -0,0 +1,163 @@
+#include "gamecube.h"
+#include <algorithm>
+#include <ctime>
+//Funktion innitGame
+    //Anzahl der Paare(pairCount*2)
+void innitGame()
+{
+
+
+}
+// -----------------------------------------------------------
+// 3D Memory Game – Hauptprogramm
+// -----------------------------------------------------------
+int main()
+{
+
+
+    //NEU Counter
+    int counter = 0;
+
+
+    // Zufall initialisieren
+    srand(time(NULL));
+
+    // Fenster und Kamera
+    InitWindow(800, 600, "3D Memory Game with Matrix3D Library");
+    SetTargetFPS(60);
+
+    Camera3D camera{};
+    camera.position = {6.0f, 6.0f, 6.0f};
+    camera.target   = {0.0f, 0.0f, 0.0f};
+    camera.up       = {0.0f, 1.0f, 0.0f};
+    camera.fovy     = 45.0f;
+    camera.projection = CAMERA_PERSPECTIVE;
+
+
+
+
+    // Nur 3 Farben für 3 Paare                 <----------------------------------------------------------
+    Color colors[] = { RED, GREEN, BLUE };
+
+    // 6 Karten-Positionen im 3x2 Raster
+    std::vector<Vec3> positions = {{-2, 0, -2}, {0, 0, -2}, {2, 0, -2},{-2, 0,  0}, {0, 0,  0}, {2, 0,  0}};
+
+    // Farben doppelt in einen Pool legen und mischen
+    std::vector<Color> colorPool;
+    for (int i = 0; i < 3; i++)
+    {
+        colorPool.push_back(colors[i]);
+        colorPool.push_back(colors[i]);
+    }
+
+    // Fisher-Yates Shuffle mit rand()
+    for (int i = colorPool.size() - 1; i > 0; --i)
+    {
+        int j = rand() % (i + 1);   // Zufallsindex von 0 bis i
+        std::swap(colorPool[i], colorPool[j]);
+    }
+
+    // Karten/Würfel erstellen
+    std::vector<gamecube> cubes;
+    for (int i = 0; i < 6; i++)
+        cubes.emplace_back(positions[i], colorPool[i]);  //<------------------------------------------------------------
+
+
+
+
+
+
+    gamecube* first  = nullptr;
+    gamecube* second = nullptr;
+    float flipSpeed = 5.0f;  // Drehgeschwindigkeit
+    bool gameWon = false;
+
+    // -----------------------------------------------------------
+    // Hauptspielschleife
+    // -----------------------------------------------------------
+    while (!WindowShouldClose())
+    {
+        // Klick-Erkennung
+        if (!gameWon && IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
+        {
+            //Neu Counter
+            counter++;
+
+            Vector2 mouse = GetMousePosition();
+
+            for (auto &c : cubes)
+            {
+                if (!c.IsFlipped() && !c.IsMatched())
+                {
+                    Vector2 screenPos = GetWorldToScreen({c.GetPosition().x, c.GetPosition().y, c.GetPosition().z}, camera);
+
+                    if (fabs(mouse.x - screenPos.x) < 40 && fabs(mouse.y - screenPos.y) < 40)
+                        c.FlipForward();
+                }
+            }
+        }
+
+        // Animation aller Würfel
+        for (auto &c : cubes)
+        {
+            c.Update(flipSpeed);
+
+            // Sobald ein Würfel vollständig umgedreht ist → merken
+            if (c.IsFlipped() && !c.IsMatched())
+            {
+                if (!first) first = &c;
+                else if (!second && &c != first) second = &c;
+            }
+        }
+
+        // Matching-Logik
+        if (first && second)
+        {
+            //counter hier macht umdrehungen
+
+            Color col1 = first->GetColor();
+            Color col2 = second->GetColor();
+
+            if (col1.r == col2.r && col1.g == col2.g && col1.b == col2.b)
+            {
+                first->SetMatched(true);
+                second->SetMatched(true);
+            }
+            else
+            {
+                first->FlipBackward();
+                second->FlipBackward();
+            }
+
+
+            first = second = nullptr;
+        }
+
+        // Gewinnprüfung
+        if (!gameWon)
+            gameWon = std::all_of(cubes.begin(), cubes.end(), [](const gamecube &c){ return c.IsMatched(); });
+
+        // -----------------------------------------------------------
+        // Zeichnen
+        // -----------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(RAYWHITE);
+        BeginMode3D(camera);
+
+        for (auto &c : cubes)
+            c.Draw();
+
+        EndMode3D();
+        if (gameWon)
+            DrawText("Congrats! You found all pairs!", 150, 260, 30, DARKBLUE);
+        else
+            DrawText("Flip 2 cubes - find matching pairs!", 10, 10, 20, DARKGRAY);
+            //Neu Counter
+            DrawText(TextFormat("Counter: %i",counter/2),10,40,20,DARKGRAY);    //counter//2 da sonst doppelt
+
+        EndDrawing();
+    }
+
+    CloseWindow();
+    return 0;
+}

Übung4/CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.20)
+
+project(prog3b_652)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_executable(prog3b main.cpp)

Übung4/main.cpp

@@ -0,0 +1,122 @@
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <thread>
+#include <chrono>
+#include <cstdlib>
+
+// =====================
+// Datei einlesen
+// =====================
+void readFile(const std::string& filename, std::vector<int>& data)
+{
+    std::ifstream file(filename);
+    int value;
+    while (file >> value)
+        data.push_back(value);
+}
+
+// =====================
+// Serielle Auswertung
+// =====================
+int countSerial(const std::vector<int>& messungen)
+{
+    if (messungen.size() < 2)
+        return 0;
+
+    int increases = 0;
+    for (size_t i = 1; i < messungen.size(); ++i)
+        if (messungen[i] > messungen[i - 1])
+            ++increases;
+
+    return increases;
+}
+
+// =====================
+// Parallele Auswertung
+// =====================
+int countParallel(const std::vector<int>& messungen, int numThreads)
+{
+    if (messungen.size() < 2)
+        return 0;
+
+    int totalComparisons = messungen.size() - 1;
+    if (numThreads > totalComparisons)
+        numThreads = totalComparisons;
+
+    std::vector<int> results(numThreads, 0);
+    std::vector<std::thread> threads;
+
+    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;
+
+        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;
+}
+
+// =====================
+// main
+// =====================
+int main()
+{
+    std::vector<int> messungen;
+
+    // ===== Variante A: Datei =====
+    readFile("measurements.txt", messungen);
+
+    // ===== Variante B: künstliche Daten (statt Datei) =====
+    /*
+    int value = 0;
+    for (size_t i = 0; i < 100000000; ++i)
+        messungen.push_back(value += (rand() % 3 - 1));
+    */
+
+    // ===== Seriell =====
+    auto start = std::chrono::steady_clock::now();
+    int serialResult = countSerial(messungen);
+    auto end = std::chrono::steady_clock::now();
+
+    std::chrono::duration<double> serialTime = end - start;
+    std::cout << "Seriell:  " << serialResult
+              << " | Took: " << serialTime.count() << " s\n";
+
+    // ===== Parallel =====
+    int numThreads = std::thread::hardware_concurrency();
+    if (numThreads == 0) numThreads = 4;
+
+    start = std::chrono::steady_clock::now();
+    int parallelResult = countParallel(messungen, numThreads);
+    end = std::chrono::steady_clock::now();
+
+    std::chrono::duration<double> parallelTime = end - start;
+    std::cout << "Parallel: " << parallelResult
+              << " | Took: " << parallelTime.count() << " s\n";
+
+    return 0;
+}