int main(){
uint64_t nodes = pow(2,SCALE);
uint64_t edges = nodes*EDGEFACTOR;
uint64_t *startVertex = malloc(edges*I64_BYTES);
uint64_t *endVertex = malloc(edges*I64_BYTES);
float initiator[] = {0.57,0.19,0.19,0.05};
generate_graph(SCALE, EDGEFACTOR, startVertex, endVertex,initiator);
char matrix[NODES][NODES] = {{0,1,0,0,0,0,0},
{0,0,1,0,0,0,0},
{0,0,0,1,0,0,0},
{0,0,0,0,1,0,0},
{0,0,0,0,0,1,0},
{0,0,0,0,0,0,1},
{0,0,0,0,0,0,0}};
char parents[] = {0,0,0,0,0,0,0};
char level[] = {0,0,0,0,0,0,0};
double time = mytime();
transpose_matrix(matrix);
bfs_2d(matrix, level, parents);
time = mytime() - time;
printf("Time: %f\n", time/1000000);
return 0;
}
void test(){
Dijs solver;
generate_graph();
int n = 20;
while(n--){
int s = rand()%g.size();
int t = rand()%g.size();
int r1 = solver.dijsNaive(s,t,g);
int r2 = solver.dijs(s,t,g);
cout<<"NaiveDijs="<<r1<<" HeapDijs="<<r2<<' '<<(r1==r2?"TRUE":"FALSE")<<endl;
}
}
void test_bellmanford(){
Dijs solver;
BellmanFord bell;
generate_graph();
int n = 20;
while(n--){
int s = rand()%g.size();
int t = rand()%g.size();
int r1 = bell.bellmanford(s,t,g);
int r2 = solver.dijs(s,t,g);
cout<<"Bellmanford="<<r1<<" HeapDijs="<<r2<<' '<<(r1==r2?"TRUE":"FALSE")<<endl;
}
}
int main(int argc, char **argv) {
int n, numgraphs, mode, iso,i;
double p = 0.0;
int kreg = 0, m = 0;
char* prefix;
char * filename = malloc(20*sizeof(char));
if (argc != 7) {
printf("'test_gen n numgraphs (p || m || kreg) mode iso fname' with :\n");
printf("n : number of vertices, numgraphs : number graphs to generate\n");
printf("p and m : as in G(n,p) and G(n,m), kreg : degree when k-regular\n");
printf("mode : 1 for G(n,p), 2 for G(n,m), 3 for G(n,m) multigraph\n");
printf(" : 4 for k-regular, 5 for k-regular multigraphs\n");
printf("iso : 1 for generating graphs isomorphic to the first generated\n");
printf("prefix : name prefix for generated graphs\n");
return 1;
} /* redundant test but it is better this way*/
n = atoi(argv[1]);
numgraphs = atoi(argv[2]);
p = atof(argv[3]);
m = atoi(argv[3]);
kreg = atoi(argv[3]);
mode = atoi(argv[4]);
iso = atoi(argv[5]);
prefix = argv[6];
srand(time(NULL));
if (!iso){
for (i = 1; i < numgraphs; i++){
sprintf(filename,"%s%04d",prefix, i );
generate_graph (n, kreg, p, m, mode, filename );
}
}
else {
generate_iso(n, kreg, p, m, mode, numgraphs, prefix);
}
return 0;
}
void init() {
N = in->N;
fill(std::begin(used), SIZE, false);
cnt = 0;
generate_graph();
}
int main(int argc, char **argv)
{
if(argc < 4) {
printf("Usage\n");
printf(" test random <heap> <vertices> [seed] [edgechance] [maxweight] [source]\n");
printf(" test dkmax <heap> <vertices>\n");
printf(" test dkmax2 <heap> <vertices>\n");
printf(" Heaptypes: bin, fib, pq\n");
exit(1);
}
char *heap_name = malloc(10*sizeof(char));
unsigned int (*dijkstra)(unsigned int num_vertices, unsigned int source, unsigned int * w, unsigned int ** edges, unsigned int *bops);
if(strcmp(argv[2], "bin") == 0) {
heap_name = "Binary";
dijkstra = dijkstra_bin;
} else if(strcmp(argv[2], "fib") == 0) {
heap_name = "Fibonacci";
dijkstra = dijkstra_fib;
} else if(strcmp(argv[2], "pq") == 0) {
heap_name = "Primitive";
dijkstra = dijkstra_pq;
} else {
printf("Unknown heap type '%s'\n", argv[2]);
exit(2);
}
unsigned int vertices = (unsigned int)strtoul(argv[3], NULL, 10);
unsigned int source = 0;
unsigned int *weights;
unsigned int **edges = malloc(vertices * sizeof(unsigned int *));
if(strcmp(argv[1], "random") == 0) {
unsigned int seed;
if(argc > 4 && argv[4]) {
seed = (unsigned int)strtoul(argv[4], NULL, 10);
srandom(seed);
} else {
srandom(time(NULL));
seed = random()%99999999;
}
unsigned int edge_chance = 15;
if(argc > 5)
edge_chance = (unsigned int)strtoul(argv[5], NULL, 10);
unsigned int max_weight = 20;
if(argc > 6)
max_weight = (unsigned int)strtoul(argv[6], NULL, 10);
source = random()%vertices;
if(argc > 7)
source = (unsigned int)strtoul(argv[7], NULL, 10);
weights = generate_graph(vertices, edge_chance, max_weight, seed);
printf("Reticulating splines.\n");
unsigned int *t_edges = malloc(vertices * sizeof(unsigned int));
int i, j;
for (i = 0; i < vertices; i++) {
unsigned int count = 0;
for (j = 0; j < vertices; j++)
if (weights[(i * vertices) + j])
t_edges[++count] = j;
edges[i] = malloc((count+1) * sizeof(unsigned int));
edges[i][0] = count;
for (j = 1; j <= count; j++)
edges[i][j] = t_edges[j];
}
free(t_edges);
} else if(strcmp(argv[1], "dkmax") == 0) {
weights = generate_decrease_key_max(vertices);
printf("Reticulating splines.\n");
unsigned int *t_edges = malloc(vertices * sizeof(unsigned int));
int i, j;
for (i = 0; i < vertices; i++) {
unsigned int count = 0;
for (j = 0; j < vertices; j++)
if (weights[(i * vertices) + j])
t_edges[++count] = j;
edges[i] = malloc((count+1) * sizeof(unsigned int));
edges[i][0] = count;
for (j = 1; j <= count; j++)
edges[i][j] = t_edges[j];
}
//free(t_edges);
} else if (strcmp(argv[1], "dkmax2") == 0){
weights = generate_decrease_key_max2(vertices);
printf("Reticulating splines.\n");
unsigned int *t_edges = malloc(vertices * sizeof(unsigned int));
edges = malloc(vertices * sizeof(unsigned int *));
int i, j;
for (i = 0; i < vertices; i++) {
unsigned int count = 0;
for (j = 0; j < vertices; j++){
if (weights[(i * vertices) + j])
t_edges[++count] = j;
}
edges[i] = malloc((count+1) * sizeof(unsigned int));
edges[i][0] = count;
for (j = 1; j <= count; j++)
edges[i][j] = t_edges[j];
}
//free(t_edges);
}
else {
printf("Unknown graph algorithm '%s'\n", argv[1]);
exit(3);
}
clock_t start;
clock_t end;
unsigned int decrease_key_calls;
printf("Calculating distances.\n");
printf(" Heap: %10s Source: %8d\n", heap_name, source);
start = clock();
decrease_key_calls = dijkstra(vertices, source, weights, edges, NULL);
end = clock();
double running_time = (double) (end-start) / (double) CLOCKS_PER_SEC;
printf(" Time: %10gs dec. key calls: %8d\n", running_time, decrease_key_calls);
log_results(heap_name, argv[1], vertices, decrease_key_calls, running_time);
}
