2024-09-26 14:32:20 +02:00
|
|
|
#include <stdint.h>
|
2024-10-04 16:46:40 +02:00
|
|
|
#include <stdio.h>
|
2024-09-26 14:32:20 +02:00
|
|
|
#include <time.h>
|
|
|
|
#include <stdlib.h>
|
2024-10-04 17:36:40 +02:00
|
|
|
#include "matrix.h"
|
2024-09-26 14:32:20 +02:00
|
|
|
|
2024-10-04 13:05:02 +02:00
|
|
|
void random_adjacency(const uint64_t vertex_count, uint64_t matrix[vertex_count][vertex_count]) {
|
2024-09-26 14:32:20 +02:00
|
|
|
srand(time(NULL));
|
|
|
|
|
2024-10-04 16:46:40 +02:00
|
|
|
for (uint64_t row_index=0; row_index < vertex_count; row_index++) {
|
|
|
|
for (uint64_t column_index=0; column_index < vertex_count; column_index++) {
|
2024-10-04 17:36:40 +02:00
|
|
|
if (column_index == row_index) {
|
2024-10-04 01:03:39 +02:00
|
|
|
matrix[row_index][column_index] = 0;
|
2024-09-26 14:32:20 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
matrix[row_index][column_index] = rand()%2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2024-10-04 13:05:02 +02:00
|
|
|
|
2024-10-04 17:36:40 +02:00
|
|
|
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];
|
|
|
|
copy(vertex_count, vertex_count, adjacency_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 (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;
|
|
|
|
} else {
|
|
|
|
distance_matrix[row_index][column_index] = UINT64_MAX;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for(uint64_t k = 2; k < vertex_count; k++) {
|
|
|
|
matrix_multiply_basic(vertex_count, vertex_count, adjacency_matrix, vertex_count, vertex_count, 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 && distance_matrix[row_index][column_index] == UINT64_MAX) {
|
|
|
|
distance_matrix[row_index][column_index] = k;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void calculate_eccentricities(const uint64_t vertex_count, const uint64_t output_matrix[vertex_count][vertex_count]) {
|
2024-10-04 13:05:02 +02:00
|
|
|
}
|