parallele_zeilenverlegung.cpp

@@ -2,36 +2,43 @@
 #include <chrono>
 #include <iostream>
 #include <omp.h>
-#include <cstdlib>
-#include <ctime>
 
-// Zufallsmatrizen erzeugen
+// 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)
+                            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)
         {
-            A[i][j] = static_cast<double>(rand()) / RAND_MAX * 10.0;
+            double r1 = static_cast<double>(std::rand()) / RAND_MAX; // 0..1
-            B[i][j] = static_cast<double>(rand()) / RAND_MAX * 10.0;
+            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);
         }
 }
 
-// Serielle Matrizenmultiplikation
+// Matrizenmultiplikation
-std::vector<std::vector<double>> matmul_serial(
+std::vector<std::vector<double>> matmul(const std::vector<std::vector<double>>& A,
-    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));
 
+    if (A[0].size() != B.size())
+        throw std::runtime_error("Matrixgrößen passen nicht.");
+
+    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)
@@ -40,55 +47,22 @@ std::vector<std::vector<double>> matmul_serial(
     return C;
 }
 
-// Parallele Zeilenzerlegung
-std::vector<std::vector<double>> matmul_row_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)      // Zeilen parallel
-        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;
+    int N = 500; // z.B. 500x500
     std::vector<std::vector<double>> A, B;
-    generateRandomMatrices(N, A, B);
 
-    // Serielle Version
     auto start = std::chrono::steady_clock::now();
-    auto C_serial = matmul_serial(A, B);
+
+    generateRandomMatrices(N, A, B);
+    auto C_serial = matmul(A, B);
+
     auto end = std::chrono::steady_clock::now();
-    std::cout << "Serial multiplication took: "
+    std::chrono::duration<double> diff = end - start;
-              << std::chrono::duration<double>(end - start).count() << "s\n";
+    std::cout << "Took: " << diff.count() << "s\n";
 
-    // Zeilenparallel
-    start = std::chrono::steady_clock::now();
-    auto C_row = matmul_row_parallel(A, B);
-    end = std::chrono::steady_clock::now();
-    std::cout << "Row-parallel multiplication took: "
-              << std::chrono::duration<double>(end - start).count() << "s\n";
-
-    // Vergleich
-    for (int i = 0; i < N; ++i)
-        for (int j = 0; j < N; ++j)
-            if (C_serial[i][j] != C_row[i][j])
-            {
-                std::cout << "Mismatch at " << i << "," << j << "\n";
-                return 1;
-            }
-
-    std::cout << "All results match!\n";
     return 0;
 }
+//
+// Created by Anke Bidlingmaier on 15.12.25.
+//