new but broken functionality

graph.c

@@ -1,5 +1,6 @@
 #include <stdint.h>
 #include <stdio.h>
+#include <string.h>
 #include <time.h>
 #include <stdlib.h>
 #include "matrix.h"
@@ -21,7 +22,7 @@ void random_adjacency(const uint64_t vertex_count, uint64_t matrix[vertex_count]
 void calculate_distance_matrix(const uint64_t vertex_count, const uint64_t adjacency_matrix[vertex_count][vertex_count], uint64_t distance_matrix[vertex_count][vertex_count]) {
     uint64_t power_matrix[vertex_count][vertex_count];
     uint64_t temp_power_matrix[vertex_count][vertex_count];
-    copy(vertex_count, vertex_count, adjacency_matrix, power_matrix);
+    memcpy(power_matrix, adjacency_matrix, vertex_count * vertex_count * sizeof(uint64_t));
 
     for (uint64_t row_index = 0; row_index < vertex_count; row_index++) {
         for (uint64_t column_index = 0; column_index < vertex_count; column_index++) {
@@ -36,7 +37,7 @@ void calculate_distance_matrix(const uint64_t vertex_count, const uint64_t adjac
     }
 
     for(uint64_t k = 2; k <= vertex_count; k++) {
-        copy(vertex_count, vertex_count, power_matrix, temp_power_matrix);
+        memcpy(temp_power_matrix, power_matrix, vertex_count * vertex_count * sizeof(uint64_t));
         gemm_basic(vertex_count, vertex_count, adjacency_matrix, vertex_count, vertex_count, temp_power_matrix, power_matrix);
 
         for (uint64_t row_index = 0; row_index < vertex_count; row_index++) {
@@ -91,10 +92,6 @@ uint64_t get_diameter(const uint64_t vertex_count, const uint64_t eccentricities
     uint64_t diamter = 0;
 
     for (uint64_t index = 0; index < vertex_count; index++) {
-        // in case of a disconnected graph
-        if (eccentricities[index] == UINT64_MAX) {
-            return UINT64_MAX;
-        }
         if (eccentricities[index] > diamter) {
             diamter = eccentricities[index];
         }
@@ -115,4 +112,117 @@ void get_centre(const uint64_t vertex_count, const uint64_t eccentricities[verte
     }
 }
 
+void calculate_path_matrix(const uint64_t vertex_count, const uint64_t adjacency_matrix[vertex_count][vertex_count], uint64_t path_matrix[vertex_count][vertex_count]) {
+    uint64_t power_matrix[vertex_count][vertex_count];
+    uint64_t temp_power_matrix[vertex_count][vertex_count];
+    memcpy(power_matrix, adjacency_matrix, vertex_count * vertex_count * sizeof(uint64_t));
 
+    for (uint64_t row_index = 0; row_index < vertex_count; row_index++) {
+        for (uint64_t column_index = 0; column_index < vertex_count; column_index++) {
+            if (row_index == column_index || adjacency_matrix[row_index][column_index] == 1) {
+                path_matrix[row_index][column_index] = 1;
+            } else {
+                path_matrix[row_index][column_index] = 0;
+            }
+        }
+    }
+
+    for(uint64_t k = 2; k <= vertex_count; k++) {
+        memcpy(temp_power_matrix, power_matrix, vertex_count * vertex_count * sizeof(uint64_t));
+        gemm_basic(vertex_count, vertex_count, adjacency_matrix, vertex_count, vertex_count, temp_power_matrix, power_matrix);
+
+        for (uint64_t row_index = 0; row_index < vertex_count; row_index++) {
+            for (uint64_t column_index = 0; column_index < vertex_count; column_index++) {
+                if (power_matrix[row_index][column_index] != 0) {
+                    path_matrix[row_index][column_index] = 1;
+                }
+            }
+        }
+    }
+}
+
+/* TODO
+ * Remove stupid solution for connected graph inside the if statement and implement an actual solution for checking of duplicate components
+ */
+void find_components_basic(const uint64_t vertex_count, const uint64_t path_matrix[vertex_count][vertex_count], uint64_t components[vertex_count][vertex_count]) {
+    for (uint64_t row_index = 0; row_index < vertex_count; row_index++) {
+        for (uint64_t column_index = 0; column_index < vertex_count; column_index++) {
+            if (path_matrix[row_index][column_index] == 1 && components[0][column_index] != column_index + 1) {
+                components[row_index][column_index] = column_index + 1;
+            } else {
+                components[row_index][column_index] = UINT64_MAX;
+            }
+        }
+    }
+}
+
+uint64_t amount_of_components(const uint64_t vertex_count, const uint64_t components[vertex_count][vertex_count]) {
+    uint64_t amount_of_components = 0;
+    int is_valid_component = 0;
+
+    for (uint64_t row_index = 0; row_index < vertex_count; row_index++) {
+        for (uint64_t column_index = 0; column_index < vertex_count; column_index++) {
+            if (components[row_index][column_index] != UINT64_MAX) {
+                is_valid_component = 1;
+            }
+        }
+        if (is_valid_component) {
+            amount_of_components++;
+        }
+    }
+
+    return amount_of_components;
+}
+
+void find_bridges_basic(const uint64_t vertex_count, const uint64_t adjacency_matrix[vertex_count][vertex_count],
+                        const uint64_t components[vertex_count][vertex_count], uint64_t bridges[vertex_count][2]) {
+    uint64_t path_matrix[vertex_count][vertex_count];
+    uint64_t temp_adjacency_matrix[vertex_count][vertex_count];
+    calculate_path_matrix(vertex_count, temp_adjacency_matrix, path_matrix);
+    uint64_t temp_components[vertex_count][vertex_count];
+
+    for (uint64_t row_index = 0; row_index < vertex_count; row_index++) {
+        for (uint64_t column_index = 0; column_index < vertex_count; column_index++) {
+            if (row_index == column_index) {
+                continue;
+            }
+
+            bridges[row_index][0] = UINT64_MAX;
+            bridges[row_index][1] = UINT64_MAX;
+
+            memcpy(temp_adjacency_matrix, adjacency_matrix, vertex_count * vertex_count * sizeof(uint64_t));
+
+            temp_adjacency_matrix[row_index][column_index] = 0;
+            temp_adjacency_matrix[column_index][row_index] = 0;
+
+            calculate_path_matrix(vertex_count, temp_adjacency_matrix, path_matrix);
+            find_components_basic(vertex_count, path_matrix, temp_components);
+
+            puts("temp_components:");
+            for (uint64_t row_index = 0; row_index < vertex_count; row_index++) {
+                printf("\tComponent %lu: {", row_index + 1);
+                for (uint64_t column_index = 0; column_index < vertex_count; column_index++) {
+                    if (temp_components[row_index][column_index] != UINT64_MAX) {
+                        printf("%lu, ", temp_components[row_index][column_index]);
+                    }
+                }
+                puts("}");
+            }
+            puts("");
+            printf("amount_of_components: %lu\n", amount_of_components(vertex_count, temp_components));
+
+            // TODO
+            // I need a way to compare the amount of components
+            if (1) {
+                continue;
+            }
+            if (column_index < row_index) {
+                bridges[row_index][0] = column_index + 1;
+                bridges[row_index][1] = row_index + 1;
+            } else {
+                bridges[row_index][0] = row_index + 1;
+                bridges[row_index][1] = column_index + 1;
+            }
+        }
+    }
+}

graph.h

@@ -16,17 +16,32 @@ int get_eccentricities(const uint64_t vertex_count,
                               const uint64_t distance_matrix[vertex_count][vertex_count],
                               uint64_t eccentricities[vertex_count]);
 
-// returns the radius
+// returns the radius or UINT64_MAX in case of a disconnected graph
 uint64_t get_radius(const uint64_t vertex_count,
                     const uint64_t eccentricities[vertex_count]);
 
-// returns the diameter
+// returns the diameter or UINT64_MAX in case of a disconnected graph
 uint64_t get_diameter(const uint64_t vertex_count,
                       const uint64_t eccentricities[vertex_count]);
 
+// in case of a disconnected graph, all nodes will be inside centre
 void get_centre(const uint64_t vertex_count,
                 const uint64_t eccentricities[vertex_count],
                 const uint64_t radius,
                 uint64_t centre[vertex_count]);
 
+void calculate_path_matrix(const uint64_t vertex_count,
+                           const uint64_t adjacency_matrix[vertex_count][vertex_count],
+                           uint64_t path_matrix[vertex_count][vertex_count]);
+
+// please do not use this yet as the output is currently almost unreadable
+void find_components_basic(const uint64_t vertex_count,
+                           const uint64_t path_matrix[vertex_count][vertex_count],
+                           uint64_t components[vertex_count][vertex_count]);
+
+void find_bridges_basic(const uint64_t vertex_count,
+                        const uint64_t adjacency_matrix[vertex_count][vertex_count],
+                        const uint64_t components[vertex_count][vertex_count],
+                        uint64_t bridges[vertex_count][2]);
+
 #endif

main.c

@@ -40,13 +40,16 @@ void benchmark() {
 }
 
 void test() {
-    const uint64_t vertex_count = 7;
+    const uint64_t vertex_count = 5;
     uint64_t adjacency_matrix[vertex_count][vertex_count];
     uint64_t distance_matrix[vertex_count][vertex_count];
+    uint64_t path_matrix[vertex_count][vertex_count];
     uint64_t eccentricities[vertex_count];
     uint64_t radius, diameter, centre[vertex_count];
+    uint64_t components[vertex_count][vertex_count];
+    uint64_t bridges[vertex_count][2];
 
-    read_csv("csv/7n.csv", vertex_count, vertex_count, adjacency_matrix);
+    read_csv("csv/graph.csv", vertex_count, vertex_count, adjacency_matrix);
 
     puts("G:");
     print_matrix(vertex_count, vertex_count, adjacency_matrix);
@@ -62,7 +65,7 @@ void test() {
 
     puts("eccentricities:");
     for (uint64_t index = 0; index < vertex_count; index++) {
-        printf("Vertex %lu: %lu, ", index + 1,  eccentricities[index]);
+        printf("\tVertex %lu: %lu\n", index + 1,  eccentricities[index]);
     }
     puts("");
 
@@ -72,10 +75,40 @@ void test() {
 
     printf("radius: %lu\n", radius);
     printf("diameter: %lu\n", diameter);
-    printf("centre: ");
+    puts("centre:");
     for (uint64_t index = 0; index < vertex_count; index++) {
         if (centre[index] == 1) {
-            printf("Vertex: %lu, ", index);
+            printf("\tVertex %lu\n", index + 1);
+        }
+    }
+    puts("");
+
+    calculate_path_matrix(vertex_count, adjacency_matrix, path_matrix);
+
+    puts("path_matrix:");
+    print_matrix(vertex_count, vertex_count, path_matrix);
+    puts("");
+
+    find_components_basic(vertex_count, path_matrix, components);
+
+    puts("components:");
+    for (uint64_t row_index = 0; row_index < vertex_count; row_index++) {
+        printf("\tComponent %lu: {", row_index + 1);
+        for (uint64_t column_index = 0; column_index < vertex_count; column_index++) {
+            if (components[row_index][column_index] != UINT64_MAX) {
+                printf("%lu, ", components[row_index][column_index]);
+            }
+        }
+        puts("}");
+    }
+    puts("");
+
+    find_bridges_basic(vertex_count, path_matrix, components, bridges);
+
+    puts("bridges:");
+    for (uint64_t index = 0; index < vertex_count; index++) {
+        if (bridges[index][0] != UINT64_MAX) {
+            printf("\tBridge %lu: {%lu, %lu}", index + 1, bridges[index][0], bridges[index][1]);
         }
     }
     puts("");

matrix.c

@@ -17,7 +17,6 @@ void print_matrix(const uint64_t row_length, const uint64_t column_length, const
 int gemm_basic(const uint64_t row_length1, const uint64_t column_length1, const uint64_t matrix1[row_length1][column_length1],
                           const uint64_t row_length2, const uint64_t column_length2, const uint64_t matrix2[row_length2][column_length2],
                           uint64_t output_matrix[row_length1][column_length2]) {
-
     if (row_length1 != column_length2) {
         return 1;
     }
@@ -76,10 +75,3 @@ int read_csv(const char *file_name, const uint64_t row_length, const uint64_t co
 
     return 0;
 }
-
-void copy(const uint64_t row_length, const uint64_t column_length, const uint64_t input_matrix[row_length][column_length], uint64_t output_matrix[row_length][column_length]) {
-    // loop should technically not be needed, but I cannot figure out the required size of __n.
-    for (uint64_t row_index = 0; row_index < row_length; row_index++) {
-        memcpy(output_matrix[row_index], input_matrix[row_index], sizeof(output_matrix[row_index]));
-    }
-}

matrix.h

@@ -26,9 +26,4 @@ int read_csv(char *file_name,
              uint64_t column_length,
              uint64_t output_matrix[row_length][column_length]);
 
-void copy(const uint64_t row_length,
-          const uint64_t column_length,
-          const uint64_t input_matrix[row_length][column_length],
-          uint64_t output_matrix[row_length][column_length]);
-
 #endif