From 21fb373f65e0685d286b2d1c41fa87d3625157b3 Mon Sep 17 00:00:00 2001 From: AustrianToast Date: Wed, 9 Oct 2024 15:35:17 +0200 Subject: [PATCH] new but broken functionality --- graph.c | 122 ++++++++++++++++++++++++++++++++++++++++++++++++++++--- graph.h | 19 ++++++++- main.c | 43 +++++++++++++++++--- matrix.c | 8 ---- matrix.h | 5 --- 5 files changed, 171 insertions(+), 26 deletions(-) diff --git a/graph.c b/graph.c index 901824c..32479db 100644 --- a/graph.c +++ b/graph.c @@ -1,5 +1,6 @@ #include #include +#include #include #include #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; + } + } + } +} diff --git a/graph.h b/graph.h index fef8a30..3ea717f 100644 --- a/graph.h +++ b/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 diff --git a/main.c b/main.c index 9ba7e60..fc1ec04 100644 --- a/main.c +++ b/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(""); diff --git a/matrix.c b/matrix.c index 6d41139..4445a78 100644 --- a/matrix.c +++ b/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])); - } -} diff --git a/matrix.h b/matrix.h index 9f238f9..538c90b 100644 --- a/matrix.h +++ b/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