graph.c

@@ -7,25 +7,24 @@
 void random_adjacency(const uint64_t vertex_count, uint64_t matrix[vertex_count][vertex_count]) {
     srand(time(NULL));
 
-    for (uint64_t row_index = 0; row_index < vertex_count; row_index++) {
+    for (uint64_t row_index=0; row_index < vertex_count; row_index++) {
-        for (uint64_t column_index = 0; column_index < vertex_count; column_index++) {
+        for (uint64_t column_index=0; column_index < vertex_count; column_index++) {
             if (column_index == row_index) {
                 matrix[row_index][column_index] = 0;
                 continue;
             }
-            matrix[row_index][column_index] = rand() % 2;
+            matrix[row_index][column_index] = rand()%2;
         }
     }
 }
 
 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);
 
-    for (uint64_t row_index = 0; row_index < vertex_count; row_index++) {
+    for (uint64_t row_index=0; row_index < vertex_count; row_index++) {
-        for (uint64_t column_index = 0; column_index < vertex_count; column_index++) {
+        for (uint64_t column_index=0; column_index < vertex_count; column_index++) {
-            if (row_index == column_index) {
+            if (column_index == row_index) {
                 distance_matrix[row_index][column_index] = 0;
             } else if (adjacency_matrix[row_index][column_index] == 1) {
                 distance_matrix[row_index][column_index] = 1;
@@ -35,12 +34,11 @@ void calculate_distance_matrix(const uint64_t vertex_count, const uint64_t adjac
         }
     }
 
-    for(uint64_t k = 2; k <= vertex_count; k++) {
+    for(uint64_t k = 2; k < vertex_count; k++) {
-        copy(vertex_count, vertex_count, power_matrix, temp_power_matrix);
+        matrix_multiply_basic(vertex_count, vertex_count, adjacency_matrix, vertex_count, vertex_count, power_matrix, power_matrix);
-        matrix_multiply_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 row_index=0; row_index < vertex_count; row_index++) {
-            for (uint64_t column_index = 0; column_index < vertex_count; column_index++) {
+            for (uint64_t column_index=0; column_index < vertex_count; column_index++) {
                 if (power_matrix[row_index][column_index] != 0 && distance_matrix[row_index][column_index] == UINT64_MAX) {
                     distance_matrix[row_index][column_index] = k;
                 }
@@ -49,5 +47,5 @@ void calculate_distance_matrix(const uint64_t vertex_count, const uint64_t adjac
     }
 }
 
-void calculate_eccentricities(const uint64_t vertex_count, const uint64_t output_arraay[vertex_count]) {
+void calculate_eccentricities(const uint64_t vertex_count, const uint64_t output_matrix[vertex_count][vertex_count]) {
 }

graph.h

@@ -10,4 +10,7 @@ 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]);
 
+void calculate_eccentricities(const uint64_t vertex_count,
+                             const uint64_t output_matrix[vertex_count][vertex_count]);
+
 #endif

main.c

@@ -44,26 +44,14 @@ void test() {
     print_matrix(vertex_count, vertex_count, adjacency_matrix);
     printf("\n");
 
-    // uint64_t new_matrix1[vertex_count][vertex_count];
+    // uint64_t new_matrix[row_length1][column_length1];
     //
-    // matrix_multiply_basic(vertex_count, vertex_count, adjacency_matrix,
+    // matrix_multiply_basic(row_length1, column_length1, matrix1,
-    //                       vertex_count, vertex_count, adjacency_matrix,
+    //                       row_length1, column_length1, matrix1,
-    //                       new_matrix1);
+    //                       new_matrix);
     //
     // printf("G²:\n");
-    // print_matrix(vertex_count, vertex_count, new_matrix1);
+    // print_matrix(row_length1, column_length1, new_matrix);
-    // printf("\n");
-    //
-    // uint64_t new_matrix2[vertex_count][vertex_count];
-    //
-    // copy(vertex_count, vertex_count, new_matrix1, new_matrix2);
-    //
-    // matrix_multiply_basic(vertex_count, vertex_count, new_matrix1,
-    //                       vertex_count, vertex_count, adjacency_matrix,
-    //                       new_matrix2);
-    //
-    // printf("G³:\n");
-    // print_matrix(vertex_count, vertex_count, new_matrix2);
     // printf("\n");
 
     uint64_t distance_matrix[vertex_count][vertex_count];

matrix.c

@@ -78,8 +78,9 @@ int read_csv(const char *file_name, const uint64_t row_length, const uint64_t co
 }
 
 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]));
+        for (uint64_t column_index = 0; column_index <column_length; column_index++) {
+            output_matrix[row_index][column_length] = input_matrix[row_index][column_index];
+        }
     }
 }