From df8386f75b0538075d72d52693836bb8878f505b Mon Sep 17 00:00:00 2001 From: KatolaZ Date: Mon, 19 Oct 2015 16:23:00 +0100 Subject: First commit of MAMMULT code --- dynamics/ising/Makefile | 11 + dynamics/ising/iltree.c | 201 +++++++++ dynamics/ising/iltree.h | 55 +++ dynamics/ising/multiplex_ising.c | 313 ++++++++++++++ dynamics/ising/utils.c | 494 ++++++++++++++++++++++ dynamics/ising/utils.h | 58 +++ dynamics/randomwalks/Makefile | 20 + dynamics/randomwalks/entropyrate2add.c | 147 +++++++ dynamics/randomwalks/entropyrate2int.c | 151 +++++++ dynamics/randomwalks/entropyrate2mult.c | 149 +++++++ dynamics/randomwalks/iltree.c | 201 +++++++++ dynamics/randomwalks/iltree.h | 55 +++ dynamics/randomwalks/statdistr2.c | 231 ++++++++++ dynamics/randomwalks/utils.c | 494 ++++++++++++++++++++++ dynamics/randomwalks/utils.h | 58 +++ models/correlations/Makefile | 15 + models/correlations/fit_utils.c | 382 +++++++++++++++++ models/correlations/fit_utils.h | 25 ++ models/correlations/rank_utils.c | 217 ++++++++++ models/correlations/rank_utils.h | 44 ++ models/correlations/tune_qnn_adaptive.c | 208 +++++++++ models/correlations/tune_rho.c | 142 +++++++ models/growth/Makefile | 26 ++ models/growth/nibilab_linear_delay.c | 414 ++++++++++++++++++ models/growth/nibilab_linear_delay_mix.c | 457 ++++++++++++++++++++ models/growth/nibilab_linear_delta.c | 403 ++++++++++++++++++ models/growth/nibilab_linear_random_times.c | 417 ++++++++++++++++++ models/growth/nibilab_nonlinear.c | 493 +++++++++++++++++++++ models/growth/node_deg_over_time.py | 82 ++++ models/nullmodels/model_MDM.py | 66 +++ models/nullmodels/model_MSM.py | 65 +++ models/nullmodels/model_hypergeometric.py | 56 +++ models/nullmodels/model_layer_growth.py | 121 ++++++ structure/activity/degs_to_activity_overlap.py | 36 ++ structure/activity/degs_to_binary.py | 45 ++ structure/activity/hamming_dist.py | 41 ++ structure/activity/layer_activity.py | 27 ++ structure/activity/layer_activity_vectors.py | 44 ++ structure/activity/multiplexity.py | 41 ++ structure/activity/node_activity.py | 51 +++ structure/activity/node_activity_vectors.py | 68 +++ structure/activity/node_degree_vectors.py | 68 +++ structure/correlations/Makefile | 15 + structure/correlations/compute_pearson.py | 33 ++ structure/correlations/compute_rho.py | 118 ++++++ structure/correlations/compute_tau.py | 133 ++++++ structure/correlations/dump_k_q.c | 50 +++ structure/correlations/fit_knn.c | 59 +++ structure/correlations/fit_utils.c | 382 +++++++++++++++++ structure/correlations/fit_utils.h | 25 ++ structure/correlations/knn_q_from_degrees.py | 49 +++ structure/correlations/knn_q_from_layers.py | 98 +++++ structure/correlations/rank_nodes.py | 74 ++++ structure/correlations/rank_nodes_thresh.py | 87 ++++ structure/correlations/rank_occurrence.py | 45 ++ structure/correlations/rank_utils.c | 217 ++++++++++ structure/correlations/rank_utils.h | 44 ++ structure/metrics/aggregate_layers_w.py | 37 ++ structure/metrics/avg_edge_overlap.py | 47 ++ structure/metrics/cartography_from_columns.py | 44 ++ structure/metrics/cartography_from_deg_vectors.py | 37 ++ structure/metrics/cartography_from_layers.py | 54 +++ structure/metrics/edge_overlap.py | 43 ++ structure/metrics/intersect_layers.py | 47 ++ structure/metrics/overlap_degree.py | 47 ++ structure/reinforcement/reinforcement.py | 61 +++ 66 files changed, 8538 insertions(+) create mode 100644 dynamics/ising/Makefile create mode 100755 dynamics/ising/iltree.c create mode 100755 dynamics/ising/iltree.h create mode 100644 dynamics/ising/multiplex_ising.c create mode 100755 dynamics/ising/utils.c create mode 100755 dynamics/ising/utils.h create mode 100644 dynamics/randomwalks/Makefile create mode 100755 dynamics/randomwalks/entropyrate2add.c create mode 100755 dynamics/randomwalks/entropyrate2int.c create mode 100755 dynamics/randomwalks/entropyrate2mult.c create mode 100755 dynamics/randomwalks/iltree.c create mode 100755 dynamics/randomwalks/iltree.h create mode 100755 dynamics/randomwalks/statdistr2.c create mode 100755 dynamics/randomwalks/utils.c create mode 100755 dynamics/randomwalks/utils.h create mode 100644 models/correlations/Makefile create mode 100644 models/correlations/fit_utils.c create mode 100644 models/correlations/fit_utils.h create mode 100644 models/correlations/rank_utils.c create mode 100644 models/correlations/rank_utils.h create mode 100644 models/correlations/tune_qnn_adaptive.c create mode 100644 models/correlations/tune_rho.c create mode 100644 models/growth/Makefile create mode 100644 models/growth/nibilab_linear_delay.c create mode 100644 models/growth/nibilab_linear_delay_mix.c create mode 100644 models/growth/nibilab_linear_delta.c create mode 100644 models/growth/nibilab_linear_random_times.c create mode 100644 models/growth/nibilab_nonlinear.c create mode 100644 models/growth/node_deg_over_time.py create mode 100644 models/nullmodels/model_MDM.py create mode 100644 models/nullmodels/model_MSM.py create mode 100644 models/nullmodels/model_hypergeometric.py create mode 100644 models/nullmodels/model_layer_growth.py create mode 100644 structure/activity/degs_to_activity_overlap.py create mode 100644 structure/activity/degs_to_binary.py create mode 100644 structure/activity/hamming_dist.py create mode 100644 structure/activity/layer_activity.py create mode 100644 structure/activity/layer_activity_vectors.py create mode 100644 structure/activity/multiplexity.py create mode 100644 structure/activity/node_activity.py create mode 100644 structure/activity/node_activity_vectors.py create mode 100644 structure/activity/node_degree_vectors.py create mode 100644 structure/correlations/Makefile create mode 100644 structure/correlations/compute_pearson.py create mode 100644 structure/correlations/compute_rho.py create mode 100644 structure/correlations/compute_tau.py create mode 100644 structure/correlations/dump_k_q.c create mode 100644 structure/correlations/fit_knn.c create mode 100644 structure/correlations/fit_utils.c create mode 100644 structure/correlations/fit_utils.h create mode 100644 structure/correlations/knn_q_from_degrees.py create mode 100644 structure/correlations/knn_q_from_layers.py create mode 100644 structure/correlations/rank_nodes.py create mode 100644 structure/correlations/rank_nodes_thresh.py create mode 100644 structure/correlations/rank_occurrence.py create mode 100644 structure/correlations/rank_utils.c create mode 100644 structure/correlations/rank_utils.h create mode 100644 structure/metrics/aggregate_layers_w.py create mode 100644 structure/metrics/avg_edge_overlap.py create mode 100644 structure/metrics/cartography_from_columns.py create mode 100644 structure/metrics/cartography_from_deg_vectors.py create mode 100644 structure/metrics/cartography_from_layers.py create mode 100644 structure/metrics/edge_overlap.py create mode 100644 structure/metrics/intersect_layers.py create mode 100644 structure/metrics/overlap_degree.py create mode 100644 structure/reinforcement/reinforcement.py diff --git a/dynamics/ising/Makefile b/dynamics/ising/Makefile new file mode 100644 index 0000000..1c09fa1 --- /dev/null +++ b/dynamics/ising/Makefile @@ -0,0 +1,11 @@ +CFLAGS="-O3" +CC="gcc" +MFLAG=-lm + +all: multiplex_ising + +multiplex_ising: multiplex_ising.c + $(CC) $(CFLAGS) -o multiplex_ising multiplex_ising.c utils.c iltree.c $(MFLAG) + +clean: + rm multiplex_ising diff --git a/dynamics/ising/iltree.c b/dynamics/ising/iltree.c new file mode 100755 index 0000000..5a693d0 --- /dev/null +++ b/dynamics/ising/iltree.c @@ -0,0 +1,201 @@ +/* + * + * A simple insert-lookup static btree datatype + * + */ + +#include +#include "iltree.h" +#include + + +void __recursive_preorder(node_t *cur, ilfunc_t *funs){ + + if(cur->left){ + __recursive_preorder(cur->left, funs); + } + funs->print(cur->info, funs->fileout); + if(cur->right){ + __recursive_preorder(cur->right, funs); + } +} + +/* + * + * Recursive push of nodes in the nodecache :-) + * + */ + +void __recursive_destroy(node_t *cur, ilfunc_t *funs){ + if(cur->left){ + __recursive_destroy(cur->left, funs); + cur->left = NULL; + } + if(cur->right){ + __recursive_destroy(cur->right, funs); + cur->right = NULL; + } +} + + +int __recursive_insert(node_t *cur, node_t *elem, ilfunc_t *f){ + + int res ; + res = f->compare(cur->info, elem->info); + /* printf("res: %d\n", res); */ + if ( res > 0){ + if (cur->left){ + return __recursive_insert(cur->left, elem, f); + } + else{ + cur->left = elem; + return 0; + } + } + else if (res < 0){ + if (cur->right){ + return __recursive_insert(cur->right, elem, f); + } + else{ + cur->right = elem; + return 0; + } + } + printf("warning!!!!! duplicate entry!!!!!!\n\n"); + return -1; +} + + + +void* __recursive_lookup(node_t *cur, void *v, ilfunc_t *f){ + + int res; + + res = f->compare(cur->info, v); + + if (res > 0){ + if(cur->left) + return __recursive_lookup(cur->left, v, f); + else + return NULL; + + } + else if (res < 0){ + if(cur->right) + return __recursive_lookup(cur->right, v, f); + else + return NULL; + } + else + return cur->info; +} + +void __recursive_map(node_t *cur, void (*func)(void*)){ + + if (cur->left) + __recursive_map(cur->left, func); + func(cur->info); + if (cur->right) + __recursive_map(cur->right, func); +} + +void __recursive_map_args(node_t *cur, void (*func)(void*, void*), void *args){ + + if (cur->left) + __recursive_map_args(cur->left, func, args); + func(cur->info, args); + if (cur->right) + __recursive_map_args(cur->right, func, args); +} + + + +iltree_t iltree_create(iltree_t t){ + if (!t) { + t = (iltree_t)malloc(sizeof(iltree_struct_t)); + } + t->root = NULL; + return t; +} + + +void iltree_set_funs(iltree_t t, ilfunc_t *funs){ + + t->funs = *funs; +} + + +void iltree_insert(iltree_t t, void *elem){ + + node_t *n; + + n = (node_t*)malloc(sizeof(node_t)); + n->info = t->funs.alloc(); + t->funs.copy(elem, n->info); + n->left = n->right = NULL; + if (t->root == NULL){ + t->root = n; + } + else{ + __recursive_insert(t->root, n, & (t->funs)); + } +} + + +void iltree_destroy(iltree_t t){ + + if(t->root) + __recursive_destroy(t->root, & (t->funs)); + free(t); +} + + + + +void iltree_view_pre(iltree_t t){ + + if (t->root){ + /*printf("----\n");*/ + __recursive_preorder(t->root, & (t->funs)); + /*printf("----\n");*/ + } + else + printf("----- Empty tree!!!! -----\n"); + +} + + + +void* iltree_lookup(iltree_t t , void *elem){ + + node_t n; + + if(t->root) + return __recursive_lookup(t->root, elem, & (t->funs) ); + else + return NULL; +} + + +void iltree_map(iltree_t t, void (*func)(void*)){ + + __recursive_map(t->root, func); + +} + + +void iltree_map_args(iltree_t t, void (*func)(void*, void*), void *args){ + + __recursive_map_args(t->root, func, args); + +} + +void* iltree_get_fileout(iltree_t t){ + + return t->funs.fileout; +} + +void iltree_set_fileout(iltree_t t, void *f){ + + t->funs.fileout = f; +} diff --git a/dynamics/ising/iltree.h b/dynamics/ising/iltree.h new file mode 100755 index 0000000..3e835e4 --- /dev/null +++ b/dynamics/ising/iltree.h @@ -0,0 +1,55 @@ +#ifndef __ILTREE_H__ +#define __ILTREE_H__ + + +typedef struct node{ + void* info; + struct node* left; + struct node* right; +} node_t; + +typedef struct{ + void* (*alloc)(); + void (*dealloc)(void*); + void (*copy)(void *src, void *dst); + int (*compare)(void*, void*); + void (*print)(void*, void*); + void *fileout; +} ilfunc_t; + + +typedef struct { + node_t* root; + ilfunc_t funs; +} iltree_struct_t; + + + +typedef iltree_struct_t* iltree_t; + + +void iltree_set_funs(iltree_t, ilfunc_t *); + +void iltree_destroy(iltree_t); + +void iltree_empty(iltree_t); + +void iltree_insert(iltree_t, void*); + +void* iltree_lookup(iltree_t, void*); + +void iltree_view_pre(iltree_t); + +iltree_t iltree_create(iltree_t); + +void iltree_empty_cache(iltree_t); + +void iltree_map(iltree_t, void (*func)(void*)); + +void iltree_map_args(iltree_t, void (*func)(void*, void*), void*); + +void* iltree_get_fileout(iltree_t t); + +void iltree_set_fileout(iltree_t t, void *f); + +#endif /* __ILTREE_H__*/ diff --git a/dynamics/ising/multiplex_ising.c b/dynamics/ising/multiplex_ising.c new file mode 100644 index 0000000..8dbbf68 --- /dev/null +++ b/dynamics/ising/multiplex_ising.c @@ -0,0 +1,313 @@ +#include +#include +#include +#include + +#include "utils.h" +#include "iltree.h" + + + +typedef struct{ + double T; + double J; + double Jcoup; + double p0; + double p1; + double h0; + double h1; + unsigned int num_epochs; +} param_t; + + +typedef struct{ + unsigned int N; + unsigned int K; + unsigned int *J_slap; + unsigned int *r_slap; + int *s; +} net_t; + +typedef struct{ + double m0; + double m1; + double C; + double b0; + double b1; + double q0; + double q1; + double IFC0; + double IFC1; + double M; +} stats_t; + +void init_spins(int *s, int N, double p){ + + int i; + double val; + + for (i=0; ip0); + init_spins(layers[1].s, N, sys->p1); + } + +void shuffle_ids(int * v, int N){ + + int tmp, val, i; + + for (i=N-1; i >=0; i --){ + val = rand() % (i+1); + tmp = v[i]; + v[i] = v[val]; + v[val] = tmp; + } +} + +void compute_stats (net_t *layers, stats_t *stats, int *spinold0, int *spinold1){ + + int i, N; + + N = layers[0].N; + + stats->M =stats->m0 = stats->m1 = stats->C = stats->b0 = stats->b1 = stats->q0 = stats->q1 = stats->IFC0 = stats->IFC1 = 0; + + double *bubblevec0, *bubblevec1; + bubblevec0 = (double *)malloc(N * sizeof(double)); + bubblevec1 = (double *)malloc(N * sizeof(double)); + + + double bubble0, bubble1, deg; + int j; + for (i=0; im0 += layers[0].s[i]; + stats->m1 += layers[1].s[i]; + stats->C += layers[0].s[i] * layers[1].s[i]; + + + bubble0=0; + for(j=layers[0].r_slap[i]; + j< layers[0].r_slap[i + 1]; + j ++){ + bubble0+= layers[0].s[i] * layers[0].s[ layers[0].J_slap[j] ] ; + stats->IFC0 += fabs(layers[0].s[i] * layers[0].s[ layers[0].J_slap[j] ]-1.)/2.; + } + deg = (layers[0].r_slap[i + 1] - layers[0].r_slap[i])*1.0; + bubblevec0[i]=bubble0/deg; + bubble1=0; + for(j=layers[1].r_slap[i]; + j< layers[1].r_slap[i + 1]; + j ++){ + bubble1+= layers[1].s[i] * layers[1].s[ layers[1].J_slap[j] ] ; + stats->IFC1 += fabs(layers[1].s[i] * layers[1].s[ layers[1].J_slap[j] ]-1.)/2.; + } + deg = (layers[1].r_slap[i + 1] - layers[1].r_slap[i])*1.0; + bubblevec1[i]=bubble1/deg; + + stats->q0 += layers[0].s[i]*spinold0[i]; + stats->q1 += layers[1].s[i]*spinold1[i]; + } + + stats->b0=0; + for (i=0; ib0 = stats->b0 + bubblevec0[i]; + } + stats->b0 /= N; + stats->b1=0; + for (i=0; ib1 = stats->b1 + bubblevec1[i]; + } + stats->b1 /= N; + + stats->m0 /= N; + stats->m1 /= N; + stats->C /= N; + stats->q0 /= N; + stats->q1 /= N; + stats->IFC0 /= layers[0].K; + stats->IFC1 /= layers[1].K; + + stats->M = (fabs(stats->m0)+fabs(stats->m1))/2.0; + } + +void dump_spins(int *s1, int *s2, int N){ + + int i; + + for(i=0; inum_epochs; e++){ + num_flips = 0; + shuffle_ids(ids, N2); + for (i=0; i< N2; i++){ + id = ids[i] % N; + l = ids[i]/N; + //printf("i: %d id: %d l:%d\n", ids[i], id, l); + E_old = 0; + E_new = 0; + for(j=layers[l].r_slap[id]; + j< layers[l].r_slap[id + 1]; + j ++){ + E_old -= layers[l].s[id] * layers[l].s[ layers[l].J_slap[j] ]; + E_new -= -layers[l].s[id] * layers[l].s[ layers[l].J_slap[j] ]; + } + E_old *= sys->J; + E_new *= sys->J; + + if (l==0) { + E_old -= sys->h0 * layers[l].s[id]; + E_new -= sys->h0 * (-layers[l].s[id]); + } + else { + E_old -= sys->h1 * layers[l].s[id]; + E_new -= sys->h1 * (-layers[l].s[id]); + } + + E_old -= sys->Jcoup * layers[l].s[id] * layers[1-l].s[id]; + E_new -= sys->Jcoup * -(layers[l].s[id]) * layers[1-l].s[id]; + + E_old = 2*E_old; + E_new = 2*E_new; + if (E_new <= E_old){ /* The new configuration has smaller energy -> flip! */ + layers[l].s[id] = - layers[l].s[id]; + } + else if (sys->T > 0){ /* The new conf has higher energy -> flop with e-(\Delta E)/T */ + val = 1.0 * rand() / RAND_MAX; + exp_val = exp( - (1.0*(E_new - E_old)) / sys->T); + if (val < exp_val){ + layers[l].s[id] = - layers[l].s[id]; + } + } + } + + if (e==(sys->num_epochs-2)) { + int u; + for (u=0; uT, sys->J, sys->Jcoup, sys->h0, sys->h1, sys->p0, + sys->p1, s->m0, s->m1, s->C); + fflush(stdout); +} + + +int main(int argc, char *argv[]){ + + + net_t layers[2]; + param_t sys; + stats_t stats; + unsigned int *J_slap, *r_slap; + + FILE *fin; + + if (argc < 10){ + printf("Usage: %s

\n", argv[0]); + exit(1); + } + + sys.T = atof(argv[3]); + sys.J = atof(argv[4]); + sys.Jcoup = atof(argv[5]); + sys.p0 = atof(argv[8]); + sys.p1 = atof(argv[9]); + sys.h0 = atof(argv[6]); + sys.h1 = atof(argv[7]); + sys.num_epochs = atoi(argv[10]); + + srand(time(NULL)); + + J_slap = r_slap = NULL; + + fin = openfile_or_exit(argv[1], "r", 2); + read_slap(fin, &(layers[0].K), &(layers[0].N), &J_slap, &r_slap); + layers[0].J_slap = J_slap; + layers[0].r_slap = r_slap; + fclose(fin); + + J_slap = r_slap = NULL; + + fin = openfile_or_exit(argv[2], "r", 2); + read_slap(fin, &(layers[1].K), &(layers[1].N), &J_slap, &r_slap); + layers[1].J_slap = J_slap; + layers[1].r_slap = r_slap; + fclose(fin); + + if (layers[0].N != layers[1].N){ + printf("Error!!! Both layers must have the same number of nodes!!!!\n"); + exit(3); + } + + /* allocate space for the spins on each layer */ + layers[0].s = malloc(layers[0].N * sizeof(double)); + layers[1].s = malloc(layers[1].N * sizeof(double)); + + /* inizialize the spins */ + init_spins_once(&sys, layers); + + + make_simulation(&sys, layers, &stats); + + + +} diff --git a/dynamics/ising/utils.c b/dynamics/ising/utils.c new file mode 100755 index 0000000..952fcd7 --- /dev/null +++ b/dynamics/ising/utils.c @@ -0,0 +1,494 @@ +#include "iltree.h" +#include +#include +#include +#include + +#include "utils.h" + +void* alloc_double(){ + return malloc(sizeof(long double)); +} + +void dealloc_double(void *elem){ + free(elem); +} + +void copy_double(void *elem1, void *elem2){ + *((long double*)elem2) = *((long double*)elem1); +} + +int compare_double(void *elem1, void *elem2){ + return *((long double*)elem1) - *((long double*)elem2); +} + +void print_double(void *elem, void *fileout){ + + long double k, i, j; + long double x; + + k = *((long double*)elem); + + x = (1 + sqrtl(1 + 8 * (k-1))) / 2; + i = floorl(x) + 1; + j = k - ( (i-1)*1.0 * (i-2) ) /2; + //printf("x: %Lf\n i: %0.0Lf j: %0.0Lf\n", x, i, j); + fprintf((FILE*)fileout, "%0.0Lf %0.0Lf\n", i-1, j-1); +} + +iltree_t init_tree(iltree_t t, void *fileout){ + + ilfunc_t funs= { + .alloc = alloc_double, + .dealloc = dealloc_double, + .copy = copy_double, + .compare = compare_double, + .print = print_double, + .fileout = fileout + }; + + t = iltree_create(t); + iltree_set_funs(t, &funs); + return t; +} + + +/* @@@@ CAMBIARE IL PRIMO PARAMETRO IN UN FILE* PER RENDERLA COERENTE + ALLE ALTRE FUNZIONI DI READ!!!!*/ +int read_deg_distr(FILE *filein, unsigned int **degs, unsigned int **Nk, double **p){ + + int n_degs = 0; + int size = 10; + char *line; + char buff[256]; + int k_i, num_i; + double p_i; + char *ptr; + + line = NULL; + + *degs = realloc(*degs, size*sizeof(unsigned int)); + *Nk = realloc(*Nk, size*sizeof(unsigned int)); + *p = realloc(*p, size*sizeof(double)); + + + while(fgets(buff, 256, filein)){ + ptr = strtok(buff, " "); + if (ptr[0] == '#') + continue; + k_i = atoi(ptr); + ptr = strtok(NULL, " " ); + num_i = atoi(ptr); + ptr = strtok(NULL, " \n"); + p_i = atof(ptr); + if (n_degs == size){ + size += 10; + *degs = realloc(*degs, size*sizeof(unsigned int)); + *Nk = realloc(*Nk, size*sizeof(unsigned int)); + *p = realloc(*p, size*sizeof(double)); + } + (*degs)[n_degs] = k_i; + (*Nk)[n_degs] = num_i; + (*p)[n_degs] = p_i; + n_degs += 1; + } + *degs = realloc(*degs, n_degs*sizeof(unsigned int)); + *Nk = realloc(*Nk, n_degs*sizeof(unsigned int)); + *p = realloc(*p, n_degs*sizeof(double)); + return n_degs; +} + + +int read_deg_seq(FILE *filein, unsigned int **nodes){ + + int size, N, k; + char buff[256]; + char *ptr; + + N = 0; + size = 10; + + *nodes = (unsigned int*)malloc(size * sizeof(unsigned int)); + + while(fgets(buff, 256, filein)){ + ptr = strtok(buff, " "); + if (ptr[0] == '#') + continue; + k = atoi(ptr); + + if (N == size){ + size += 10; + *nodes = realloc(*nodes, size*sizeof(unsigned int)); + } + (*nodes)[N] = k; + N += 1; + } + *nodes = realloc(*nodes, N * sizeof(unsigned int)); + return N; +} + +int read_stubs(FILE *filein, unsigned int **S){ + + int size, K; + char buff[256]; + char *ptr; + + K=0; + size = 20; + *S = malloc(size * sizeof(unsigned int)); + + while(fgets(buff, 256, filein)){ + if (K == size){ + size += 20; + *S = realloc(*S, size*sizeof(unsigned int)); + } + ptr = strtok(buff, " "); /* read the first node */ + (*S)[K++] = atoi(ptr); + ptr = strtok(NULL, " "); /* read the second node */ + (*S)[K++] = atoi(ptr); + } + *S = realloc(*S, K * sizeof(unsigned int)); + return K; +} + +/* + * Read a file in ij format + */ +int read_ij(FILE *filein, unsigned int **I, unsigned int **J){ + + unsigned int size, K; + char buff[256]; + char *ptr; + + size = 20; + K = 0; + + *I = malloc(size * sizeof(unsigned int)); + *J = malloc(size * sizeof(unsigned int)); + while(fgets(buff, 256, filein)){ + if (buff[0] == '#') + continue; + if (K == size){ + size += 20; + *I = realloc(*I, size*sizeof(unsigned int)); + *J = realloc(*J, size*sizeof(unsigned int)); + } + ptr = strtok(buff, " "); /* read the first node */ + (*I)[K] = atoi(ptr); + ptr = strtok(NULL, " "); /* read the second node */ + (*J)[K] = atoi(ptr); + K += 1; + } + + *I = realloc(*I, K * sizeof(unsigned int)); + *J = realloc(*J, K * sizeof(unsigned int)); + return K; +} + +/*funzione pesata di moreno*/ + +int read_ij_w(FILE *filein, unsigned int **I, unsigned int **J , double **W){ + + unsigned int size, K; + char buff[256]; + char *ptr; + + size = 20; + K = 0; + + *I = malloc(size * sizeof(unsigned int)); + *J = malloc(size * sizeof(unsigned int)); + *W = malloc(size * sizeof(double)); + + while(fgets(buff, 256, filein)){ + if (buff[0] == '#') + continue; + if (K == size){ + size += 20; + *I = realloc(*I, size*sizeof(unsigned int)); + *J = realloc(*J, size*sizeof(unsigned int)); + *W = realloc(*W, size*sizeof(double)); + if (*W==NULL) { + printf ("Errore"); + exit(-1); + } + } + ptr = strtok(buff, " "); /* read the first node */ + (*I)[K] = atoi(ptr); + ptr = strtok(NULL, " "); /* read the second node */ + (*J)[K] = atoi(ptr); + ptr = strtok(NULL, " "); /* read the weight */ + (*W)[K] = atof(ptr); + K += 1; + } + + *I = realloc(*I, K * sizeof(unsigned int)); + *J = realloc(*J, K * sizeof(unsigned int)); + *W = realloc(*W, K * sizeof(double)); + return K; +} + + + +void read_slap(FILE *filein, unsigned int *K, unsigned int *N, + unsigned int **J_slap, unsigned int **r_slap){ + + unsigned int *I=NULL, *J=NULL; + unsigned int i, k; + + k = read_ij(filein, &I, &J); + *K = 2 * k; + I = realloc(I, 2*k * sizeof(unsigned int)); + J = realloc(J, 2*k * sizeof(unsigned int)); + for (i=k; i<2*k; i ++){ + I[i] = J[i-k]; + J[i] = I[i-k]; + } + + *N = convert_ij2slap(I, J, 2*k, r_slap, J_slap); + free(I); + free(J); + return; +} + +/*funzione pesata di moreno*/ + +void read_slap_w(FILE *filein, unsigned int *K, unsigned int *N, + unsigned int **J_slap, unsigned int **r_slap, double **w_slap){ + + unsigned int *I=NULL, *J=NULL; + double *W=NULL; + unsigned int i, k; + + k = read_ij_w(filein, &I, &J, &W); + *K = 2 * k; + I = realloc(I, 2*k * sizeof(unsigned int)); + J = realloc(J, 2*k * sizeof(unsigned int)); + W = realloc(W, 2*k * sizeof(double)); + + for (i=k; i<2*k; i ++){ + I[i] = J[i-k]; + J[i] = I[i-k]; + W[i] = W[i-k]; + } + + *N = convert_ij2slap_w(I, J, W, 2*k, r_slap, J_slap, w_slap); + free(I); + free(J); + free(W); + return; +} + +unsigned int find_max(unsigned int *v, unsigned int N){ + + unsigned int i, max; + + max = v[0]; + i = 0; + while(++i < N){ + if (v[i] > max) + max = v[i]; + } + return max; +} + + +int convert_ij2slap(unsigned int *I, unsigned int *J, unsigned int K, + unsigned int ** r_slap, unsigned int **J_slap){ + + unsigned int tmp, max; + unsigned int N; + unsigned int i, pos; + unsigned int *p; + + max = find_max(I, K) + 1; + tmp = find_max(J, K) + 1; + if (tmp > max){ + max = tmp ; + } + + *r_slap = malloc( (max+1) * sizeof(unsigned int)); + p = malloc(max * sizeof(unsigned int)); + + *J_slap = malloc(K * sizeof(unsigned int)); + + memset(*r_slap, 0, (max+1) * sizeof(unsigned int)); + for(i=0; i max){ + max = tmp ; + } + + *r_slap = malloc( (max+1) * sizeof(unsigned int)); + p = malloc(max * sizeof(unsigned int)); + + *J_slap = malloc(K * sizeof(unsigned int)); + *w_slap = malloc(K * sizeof(double)); + + memset(*r_slap, 0, (max+1) * sizeof(unsigned int)); + for(i=0; i i){ + fprintf(fileout, "%d %d\n", i, J_slap[j]); + } + } + } +} + + +/* Check if j is a neighbour of i */ +int is_neigh(unsigned int *J_slap, unsigned int *r_slap, unsigned int N, + unsigned int i, unsigned int j){ + + unsigned int l; + unsigned int count; + count = 0; + for(l=r_slap[i]; l +#include +#include +#include "utils.h" + + +int main(int argc, char *argv[]){ + + if (argc < 6){ + printf("Usage: %s \n", argv[0]); + exit(1); + } + + + FILE *filein0,*filein1, *filein, *fileout; + unsigned int N0, K0,N1, K1, N, K; + unsigned int *J_slap0, *r_slap0, *J_slap1, *r_slap1, *J_slap, *r_slap; + double *w_slap; + + + int i, j; + double c_i, d_i, f_i, f_i_2; + double alpha = (atof(argv[5])); + double beta = (atof(argv[6])); + + + int ov; + int deg0, deg1; + double degM, part, f_j, f_j_2; + double degMrid, maxdegM = 200.0; + double num1, num2, den, h; + int number_nodes=(atoi(argv[4])); + double M=2.0; + + filein0 = openfile_or_exit(argv[1], "r", 2); + read_slap(filein0, &K0, &N0, &J_slap0, &r_slap0); + + filein1 = openfile_or_exit(argv[2], "r", 2); + read_slap(filein1, &K1, &N1, &J_slap1, &r_slap1); + + + filein = openfile_or_exit(argv[3], "r", 2); + read_slap_w(filein, &K, &N, &J_slap, &r_slap,&w_slap); + + int r_slap0_n[N+1],r_slap1_n[N+1]; + for (i=0; i<=N; i++) { + if (i<=N0) { + r_slap0_n[i]=r_slap0[i]; + } + else { + r_slap0_n[i]=r_slap0[N0]; + } + if (i<=N1) { + r_slap1_n[i]=r_slap1[i]; + } + else { + r_slap1_n[i]=r_slap1[N1]; + } + + } + + + + double c_i_vec[N]; + double d_i_vec[N]; + double f_i_vec[N]; + + for (i=0; i0.0000000001) { + f_j = pow (deg0, alpha); + } + else { + f_j = 0; + } + if (deg1>0.0000000001) { + f_j_2 = pow (deg1, beta); + } + else { + f_j_2=0; + } + c_i+=ov*(f_j+f_j_2); + + d_i+=ov*(f_j+f_j_2)*log((ov*(f_j+f_j_2))); + + + + + } + c_i_vec[i]=c_i; + d_i_vec[i]=d_i; + deg0=r_slap0_n[i+1]-r_slap0_n[i]; + deg1=r_slap1_n[i+1]-r_slap1_n[i]; + + degM=(deg0+deg1)*1.0; + + part = (M/(M-1))* (1-(pow((deg0/degM),2))-(pow((deg1/degM),2)) ); + + if (deg0>0.0000000001) { + f_i = pow (deg0, alpha); + } + else { + f_i = 0; + } + if (deg1>0.0000000001) { + f_i_2 = pow (deg1, beta); + } + else { + f_i_2=0; + } + f_i_vec[i]=f_i+f_i_2; + + } + num1=0; + num2=0; + den=0; + for (i=0; i0.0) { + num1+=f_i_vec[i]*c_i_vec[i]*log(c_i_vec[i]); + } + + + num2=num2+f_i_vec[i]*d_i_vec[i]; + den=den+f_i_vec[i]*c_i_vec[i]; + + + + + } + + h=(num1-num2)/den; + printf("%f %f %f\n", h, alpha, beta); + +} diff --git a/dynamics/randomwalks/entropyrate2int.c b/dynamics/randomwalks/entropyrate2int.c new file mode 100755 index 0000000..757c7b7 --- /dev/null +++ b/dynamics/randomwalks/entropyrate2int.c @@ -0,0 +1,151 @@ +#include +#include +#include +#include "utils.h" + + +int main(int argc, char *argv[]){ + + if (argc < 6){ + printf("Usage: %s \n", argv[0]); + exit(1); + } + + + FILE *filein0,*filein1,*filein2,*filein3,*filein4,*filein5,*filein6,*filein7,*filein8,*filein9, *filein, *fileout; + unsigned int N0, K0,N1, K1,N2, K2,N3, K3,N4, K4,N5, K5,N6, K6,N7, K7,N8, K8,N9, K9, N, K; + unsigned int *J_slap0, *r_slap0, *J_slap1, *r_slap1,*J_slap2, *r_slap2, *J_slap3, *r_slap3,*J_slap4, *r_slap4, *J_slap5, *r_slap5,*J_slap6, *r_slap6, *J_slap7, *r_slap7,*J_slap8, *r_slap8, *J_slap9, *r_slap9, *J_slap, *r_slap; + double *w_slap; + + + int i, j; + double c_i, d_i, f_i, f_i_2; + double alpha = (atof(argv[5])); + double beta = (atof(argv[6])); + + int ov; + int deg0, deg1,deg2, deg3,deg4, deg5,deg6, deg7,deg8, deg9; + double degM, part, f_j, f_j_2; + double degMrid, maxdegM = 200.0; + double num1, num2, den, h; + int number_nodes=(atoi(argv[4])); + double M=2.0; + + filein0 = openfile_or_exit(argv[1], "r", 2); + read_slap(filein0, &K0, &N0, &J_slap0, &r_slap0); + + filein1 = openfile_or_exit(argv[2], "r", 2); + read_slap(filein1, &K1, &N1, &J_slap1, &r_slap1); + + filein = openfile_or_exit(argv[3], "r", 2); + read_slap_w(filein, &K, &N, &J_slap, &r_slap,&w_slap); + + int r_slap0_n[N+1],r_slap1_n[N+1],r_slap2_n[N+1],r_slap3_n[N+1],r_slap4_n[N+1],r_slap5_n[N+1],r_slap6_n[N+1],r_slap7_n[N+1],r_slap8_n[N+1],r_slap9_n[N+1]; + for (i=0; i<=N; i++) { + if (i<=N0) { + r_slap0_n[i]=r_slap0[i]; + } + else { + r_slap0_n[i]=r_slap0[N0]; + } + if (i<=N1) { + r_slap1_n[i]=r_slap1[i]; + } + else { + r_slap1_n[i]=r_slap1[N1]; + } + + + } + + + + double c_i_vec[N]; + double d_i_vec[N]; + double f_i_vec[N]; + + + for (i=0; i0.0000000001) { + f_j = pow (part, alpha); + } + else { + f_j = 0; + } + f_j_2 = pow (degM, beta); + c_i+=ov*f_j*f_j_2; + if (part>0.0000000001) { + d_i+=ov*f_j*f_j_2*log((ov*f_j*f_j_2)); + } + + + + } + c_i_vec[i]=c_i; + d_i_vec[i]=d_i; + + deg0=r_slap0_n[i+1]-r_slap0_n[i]; + deg1=r_slap1_n[i+1]-r_slap1_n[i]; + + + + + + + + + + degM=(deg0+deg1)*1.0; + + part = (M/(M-1))* (1-(pow((deg0/degM),2))-(pow((deg1/degM),2))); + + + + if (part>0.0000000001) { + f_i = pow (part, alpha); + } + else { + f_i = 0; + } + f_i_2 = pow (degM, beta); + + f_i_vec[i]=f_i*f_i_2; + + } + num1=0; + num2=0; + den=0; + for (i=0; i0.0) { + + num1+=f_i_vec[i]*c_i_vec[i]*log(c_i_vec[i]); + } + + + num2=num2+f_i_vec[i]*d_i_vec[i]; + den=den+f_i_vec[i]*c_i_vec[i]; + + + } + + h=(num1-num2)/den*1.0; + printf("%f %f %f\n", h, alpha, beta); + +} diff --git a/dynamics/randomwalks/entropyrate2mult.c b/dynamics/randomwalks/entropyrate2mult.c new file mode 100755 index 0000000..cded4eb --- /dev/null +++ b/dynamics/randomwalks/entropyrate2mult.c @@ -0,0 +1,149 @@ +#include +#include +#include +#include "utils.h" + + +int main(int argc, char *argv[]){ + + + if (argc < 6){ + printf("Usage: %s \n", argv[0]); + exit(1); + } + + + FILE *filein0,*filein1, *filein, *fileout; + unsigned int N0, K0,N1, K1, N, K; + unsigned int *J_slap0, *r_slap0, *J_slap1, *r_slap1, *J_slap, *r_slap; + double *w_slap; + + + int i, j; + double c_i, d_i, f_i, f_i_2; + double alpha = (atof(argv[5])); + double beta = (atof(argv[6])); + + + int ov; + int deg0, deg1; + double degM, part, f_j, f_j_2; + double degMrid, maxdegM = 200.0; + double num1, num2, den, h; + int number_nodes=(atoi(argv[4])); + double M=2.0; + + filein0 = openfile_or_exit(argv[1], "r", 2); + read_slap(filein0, &K0, &N0, &J_slap0, &r_slap0); + + filein1 = openfile_or_exit(argv[2], "r", 2); + read_slap(filein1, &K1, &N1, &J_slap1, &r_slap1); + + + filein = openfile_or_exit(argv[3], "r", 2); + read_slap_w(filein, &K, &N, &J_slap, &r_slap,&w_slap); + + int r_slap0_n[N+1],r_slap1_n[N+1]; + for (i=0; i<=N; i++) { + if (i<=N0) { + r_slap0_n[i]=r_slap0[i]; + } + else { + r_slap0_n[i]=r_slap0[N0]; + } + if (i<=N1) { + r_slap1_n[i]=r_slap1[i]; + } + else { + r_slap1_n[i]=r_slap1[N1]; + } + + } + + + + double c_i_vec[N]; + double d_i_vec[N]; + double f_i_vec[N]; + + + for (i=0; i0.0000000001) { + f_j = pow (deg0, alpha); + } + else { + f_j = 0; + } + if (deg1>0.0000000001) { + f_j_2 = pow (deg1, beta); + } + else { + f_j_2=0; + } + c_i+=ov*f_j*f_j_2; + if (deg0>0.0000000001 && deg1>0.0000000001) { + d_i+=ov*f_j*f_j_2*log((ov*f_j*f_j_2)); + } + + + /*chiudo il for*/ + } + c_i_vec[i]=c_i; + d_i_vec[i]=d_i; + deg0=r_slap0_n[i+1]-r_slap0_n[i]; + deg1=r_slap1_n[i+1]-r_slap1_n[i]; + + degM=(deg0+deg1)*1.0; + + part = (M/(M-1))* (1-(pow((deg0/degM),2))-(pow((deg1/degM),2)) ); + + if (deg0>0.0000000001) { + f_i = pow (deg0, alpha); + } + else { + f_i = 0; + } + if (deg1>0.0000000001) { + f_i_2 = pow (deg1, beta); + } + else { + f_i_2=0; + } + f_i_vec[i]=f_i*f_i_2; + + } + num1=0; + num2=0; + den=0; + for (i=0; i0.0) { + num1+=f_i_vec[i]*c_i_vec[i]*log(c_i_vec[i]); + } + + + num2=num2+f_i_vec[i]*d_i_vec[i]; + den=den+f_i_vec[i]*c_i_vec[i]; + + + + + } + + h=(num1-num2)/den; + printf("%f %f %f\n", h, alpha, beta); + +} diff --git a/dynamics/randomwalks/iltree.c b/dynamics/randomwalks/iltree.c new file mode 100755 index 0000000..5a693d0 --- /dev/null +++ b/dynamics/randomwalks/iltree.c @@ -0,0 +1,201 @@ +/* + * + * A simple insert-lookup static btree datatype + * + */ + +#include +#include "iltree.h" +#include + + +void __recursive_preorder(node_t *cur, ilfunc_t *funs){ + + if(cur->left){ + __recursive_preorder(cur->left, funs); + } + funs->print(cur->info, funs->fileout); + if(cur->right){ + __recursive_preorder(cur->right, funs); + } +} + +/* + * + * Recursive push of nodes in the nodecache :-) + * + */ + +void __recursive_destroy(node_t *cur, ilfunc_t *funs){ + if(cur->left){ + __recursive_destroy(cur->left, funs); + cur->left = NULL; + } + if(cur->right){ + __recursive_destroy(cur->right, funs); + cur->right = NULL; + } +} + + +int __recursive_insert(node_t *cur, node_t *elem, ilfunc_t *f){ + + int res ; + res = f->compare(cur->info, elem->info); + /* printf("res: %d\n", res); */ + if ( res > 0){ + if (cur->left){ + return __recursive_insert(cur->left, elem, f); + } + else{ + cur->left = elem; + return 0; + } + } + else if (res < 0){ + if (cur->right){ + return __recursive_insert(cur->right, elem, f); + } + else{ + cur->right = elem; + return 0; + } + } + printf("warning!!!!! duplicate entry!!!!!!\n\n"); + return -1; +} + + + +void* __recursive_lookup(node_t *cur, void *v, ilfunc_t *f){ + + int res; + + res = f->compare(cur->info, v); + + if (res > 0){ + if(cur->left) + return __recursive_lookup(cur->left, v, f); + else + return NULL; + + } + else if (res < 0){ + if(cur->right) + return __recursive_lookup(cur->right, v, f); + else + return NULL; + } + else + return cur->info; +} + +void __recursive_map(node_t *cur, void (*func)(void*)){ + + if (cur->left) + __recursive_map(cur->left, func); + func(cur->info); + if (cur->right) + __recursive_map(cur->right, func); +} + +void __recursive_map_args(node_t *cur, void (*func)(void*, void*), void *args){ + + if (cur->left) + __recursive_map_args(cur->left, func, args); + func(cur->info, args); + if (cur->right) + __recursive_map_args(cur->right, func, args); +} + + + +iltree_t iltree_create(iltree_t t){ + if (!t) { + t = (iltree_t)malloc(sizeof(iltree_struct_t)); + } + t->root = NULL; + return t; +} + + +void iltree_set_funs(iltree_t t, ilfunc_t *funs){ + + t->funs = *funs; +} + + +void iltree_insert(iltree_t t, void *elem){ + + node_t *n; + + n = (node_t*)malloc(sizeof(node_t)); + n->info = t->funs.alloc(); + t->funs.copy(elem, n->info); + n->left = n->right = NULL; + if (t->root == NULL){ + t->root = n; + } + else{ + __recursive_insert(t->root, n, & (t->funs)); + } +} + + +void iltree_destroy(iltree_t t){ + + if(t->root) + __recursive_destroy(t->root, & (t->funs)); + free(t); +} + + + + +void iltree_view_pre(iltree_t t){ + + if (t->root){ + /*printf("----\n");*/ + __recursive_preorder(t->root, & (t->funs)); + /*printf("----\n");*/ + } + else + printf("----- Empty tree!!!! -----\n"); + +} + + + +void* iltree_lookup(iltree_t t , void *elem){ + + node_t n; + + if(t->root) + return __recursive_lookup(t->root, elem, & (t->funs) ); + else + return NULL; +} + + +void iltree_map(iltree_t t, void (*func)(void*)){ + + __recursive_map(t->root, func); + +} + + +void iltree_map_args(iltree_t t, void (*func)(void*, void*), void *args){ + + __recursive_map_args(t->root, func, args); + +} + +void* iltree_get_fileout(iltree_t t){ + + return t->funs.fileout; +} + +void iltree_set_fileout(iltree_t t, void *f){ + + t->funs.fileout = f; +} diff --git a/dynamics/randomwalks/iltree.h b/dynamics/randomwalks/iltree.h new file mode 100755 index 0000000..3e835e4 --- /dev/null +++ b/dynamics/randomwalks/iltree.h @@ -0,0 +1,55 @@ +#ifndef __ILTREE_H__ +#define __ILTREE_H__ + + +typedef struct node{ + void* info; + struct node* left; + struct node* right; +} node_t; + +typedef struct{ + void* (*alloc)(); + void (*dealloc)(void*); + void (*copy)(void *src, void *dst); + int (*compare)(void*, void*); + void (*print)(void*, void*); + void *fileout; +} ilfunc_t; + + +typedef struct { + node_t* root; + ilfunc_t funs; +} iltree_struct_t; + + + +typedef iltree_struct_t* iltree_t; + + +void iltree_set_funs(iltree_t, ilfunc_t *); + +void iltree_destroy(iltree_t); + +void iltree_empty(iltree_t); + +void iltree_insert(iltree_t, void*); + +void* iltree_lookup(iltree_t, void*); + +void iltree_view_pre(iltree_t); + +iltree_t iltree_create(iltree_t); + +void iltree_empty_cache(iltree_t); + +void iltree_map(iltree_t, void (*func)(void*)); + +void iltree_map_args(iltree_t, void (*func)(void*, void*), void*); + +void* iltree_get_fileout(iltree_t t); + +void iltree_set_fileout(iltree_t t, void *f); + +#endif /* __ILTREE_H__*/ diff --git a/dynamics/randomwalks/statdistr2.c b/dynamics/randomwalks/statdistr2.c new file mode 100755 index 0000000..10528da --- /dev/null +++ b/dynamics/randomwalks/statdistr2.c @@ -0,0 +1,231 @@ +#include +#include +#include +#include "utils.h" + + +int main(int argc, char *argv[]){ + + + if (argc < 6){ + printf("Usage: %s \n", argv[0]); + exit(1); + } + + + /*dichiarazioni enzo*/ + FILE *filein0,*filein1, *filein, *fileout; + unsigned int N0, K0,N1, K1, N, K; + unsigned int *J_slap0, *r_slap0, *J_slap1, *r_slap1, *J_slap, *r_slap; + double *w_slap; + + /*dichiarazioni mie*/ + /*r_slap e' lungo N+1, da 0 a N compresi*/ + int i, j; + double f_j, f_j_2; + double alpha = (atof(argv[5])); + double beta = (atof(argv[6])); + + /*il bias*/ + int ov; + int deg0, deg1; + double degM, prodM, part, intM; + double degMrid, maxdegM = 200.0; + + int number_nodes=(atoi(argv[4])); + double M=2.0; + + filein0 = openfile_or_exit(argv[1], "r", 2); + read_slap(filein0, &K0, &N0, &J_slap0, &r_slap0); + + filein1 = openfile_or_exit(argv[2], "r", 2); + read_slap(filein1, &K1, &N1, &J_slap1, &r_slap1); + + + filein = openfile_or_exit(argv[3], "r", 2); + read_slap_w(filein, &K, &N, &J_slap, &r_slap,&w_slap); + + int r_slap0_n[N+1],r_slap1_n[N+1]; + for (i=0; i<=N; i++) { + if (i<=N0) { + r_slap0_n[i]=r_slap0[i]; + } + else { + r_slap0_n[i]=r_slap0[N0]; + } + if (i<=N1) { + r_slap1_n[i]=r_slap1[i]; + } + else { + r_slap1_n[i]=r_slap1[N1]; + } + + } + + + + double cf_i_vec_add[N]; + double cf_i_vec_mult[N]; + double cf_i_vec_part[N]; + double cf_i_vec_int[N]; + + double tot_add=0, tot_mult=0, tot_part=0, tot_int=0; + double c_i_add, c_i_mult, c_i_part, c_i_int; + double f_add, f_mult, f_int; + /*ciclo sui nodi dell'aggregato*/ + for (i=0; i0.0000000001) { + f_j = pow (deg0, alpha); + } + else { + f_j = 0; + } + if (deg1>0.0000000001) { + f_j_2 = pow (deg1, beta); + } + else { + f_j_2=0; + } + + c_i_add+=ov*(f_j+f_j_2); + + if (deg0>0.0000000001) { + f_j = pow (deg0, alpha); + } + else { + f_j = 0; + } + if (deg1>0.0000000001) { + f_j_2 = pow (deg1, beta); + } + else { + f_j_2=0; + } + + c_i_mult+=ov*(f_j*f_j_2); + //c_i_part+=ov*part; + + part = (M/(M-1))* (1-(pow((deg0/degM),2))-(pow((deg1/degM),2)) ); + if (part>0.0000000001) { + f_j = pow (part, alpha); + } + else { + f_j = 0; + } + f_j_2 = pow (degM, beta); + + c_i_int+=ov*(f_j*f_j_2); + + /*chiudo il for*/ + } + + deg0=r_slap0_n[i+1]-r_slap0_n[i]; + deg1=r_slap1_n[i+1]-r_slap1_n[i]; + + degM=(deg0+deg1)*1.0; + prodM=(deg0*deg1)*1.0; + part = (M/(M-1))* (1-(pow((deg0/degM),2))-(pow((deg1/degM),2)) ); + + intM=degM*part; + + if (deg0>0.0000000001) { + f_j = pow (deg0, alpha); + } + else { + f_j = 0; + } + if (deg1>0.0000000001) { + f_j_2 = pow (deg1, beta); + } + else { + f_j_2=0; + } + + + cf_i_vec_add[i]=c_i_add*(f_j+f_j_2); + + + if (deg0>0.0000000001) { + f_j = pow (deg0, alpha); + } + else { + f_j = 0; + } + if (deg1>0.0000000001) { + f_j_2 = pow (deg1, beta); + } + else { + f_j_2=0; + } + + + + cf_i_vec_mult[i]=c_i_mult*(f_j*f_j_2); + //cf_i_vec_part[i]=c_i_part*part; + if (part>0.0000000001) { + f_j = pow (part, alpha); + } + else { + f_j = 0; + } + f_j_2 = pow (degM, beta); + + + + cf_i_vec_int[i]=c_i_int*(f_j*f_j_2); + + tot_add+=cf_i_vec_add[i]; + tot_mult+=cf_i_vec_mult[i]; + tot_part+=cf_i_vec_part[i]; + tot_int+=cf_i_vec_int[i]; + } + + + double vec_add[N]; + double vec_mult[N]; + double vec_part[N]; + double vec_int[N]; + double tot_add_rid=0, tot_mult_rid=0, tot_part_rid=0, tot_int_rid=0; + + for (i=0; i +#include +#include +#include + +#include "utils.h" + +void* alloc_double(){ + return malloc(sizeof(long double)); +} + +void dealloc_double(void *elem){ + free(elem); +} + +void copy_double(void *elem1, void *elem2){ + *((long double*)elem2) = *((long double*)elem1); +} + +int compare_double(void *elem1, void *elem2){ + return *((long double*)elem1) - *((long double*)elem2); +} + +void print_double(void *elem, void *fileout){ + + long double k, i, j; + long double x; + + k = *((long double*)elem); + + x = (1 + sqrtl(1 + 8 * (k-1))) / 2; + i = floorl(x) + 1; + j = k - ( (i-1)*1.0 * (i-2) ) /2; + //printf("x: %Lf\n i: %0.0Lf j: %0.0Lf\n", x, i, j); + fprintf((FILE*)fileout, "%0.0Lf %0.0Lf\n", i-1, j-1); +} + +iltree_t init_tree(iltree_t t, void *fileout){ + + ilfunc_t funs= { + .alloc = alloc_double, + .dealloc = dealloc_double, + .copy = copy_double, + .compare = compare_double, + .print = print_double, + .fileout = fileout + }; + + t = iltree_create(t); + iltree_set_funs(t, &funs); + return t; +} + + +/* @@@@ CAMBIARE IL PRIMO PARAMETRO IN UN FILE* PER RENDERLA COERENTE + ALLE ALTRE FUNZIONI DI READ!!!!*/ +int read_deg_distr(FILE *filein, unsigned int **degs, unsigned int **Nk, double **p){ + + int n_degs = 0; + int size = 10; + char *line; + char buff[256]; + int k_i, num_i; + double p_i; + char *ptr; + + line = NULL; + + *degs = realloc(*degs, size*sizeof(unsigned int)); + *Nk = realloc(*Nk, size*sizeof(unsigned int)); + *p = realloc(*p, size*sizeof(double)); + + + while(fgets(buff, 256, filein)){ + ptr = strtok(buff, " "); + if (ptr[0] == '#') + continue; + k_i = atoi(ptr); + ptr = strtok(NULL, " " ); + num_i = atoi(ptr); + ptr = strtok(NULL, " \n"); + p_i = atof(ptr); + if (n_degs == size){ + size += 10; + *degs = realloc(*degs, size*sizeof(unsigned int)); + *Nk = realloc(*Nk, size*sizeof(unsigned int)); + *p = realloc(*p, size*sizeof(double)); + } + (*degs)[n_degs] = k_i; + (*Nk)[n_degs] = num_i; + (*p)[n_degs] = p_i; + n_degs += 1; + } + *degs = realloc(*degs, n_degs*sizeof(unsigned int)); + *Nk = realloc(*Nk, n_degs*sizeof(unsigned int)); + *p = realloc(*p, n_degs*sizeof(double)); + return n_degs; +} + + +int read_deg_seq(FILE *filein, unsigned int **nodes){ + + int size, N, k; + char buff[256]; + char *ptr; + + N = 0; + size = 10; + + *nodes = (unsigned int*)malloc(size * sizeof(unsigned int)); + + while(fgets(buff, 256, filein)){ + ptr = strtok(buff, " "); + if (ptr[0] == '#') + continue; + k = atoi(ptr); + + if (N == size){ + size += 10; + *nodes = realloc(*nodes, size*sizeof(unsigned int)); + } + (*nodes)[N] = k; + N += 1; + } + *nodes = realloc(*nodes, N * sizeof(unsigned int)); + return N; +} + +int read_stubs(FILE *filein, unsigned int **S){ + + int size, K; + char buff[256]; + char *ptr; + + K=0; + size = 20; + *S = malloc(size * sizeof(unsigned int)); + + while(fgets(buff, 256, filein)){ + if (K == size){ + size += 20; + *S = realloc(*S, size*sizeof(unsigned int)); + } + ptr = strtok(buff, " "); /* read the first node */ + (*S)[K++] = atoi(ptr); + ptr = strtok(NULL, " "); /* read the second node */ + (*S)[K++] = atoi(ptr); + } + *S = realloc(*S, K * sizeof(unsigned int)); + return K; +} + +/* + * Read a file in ij format + */ +int read_ij(FILE *filein, unsigned int **I, unsigned int **J){ + + unsigned int size, K; + char buff[256]; + char *ptr; + + size = 20; + K = 0; + + *I = malloc(size * sizeof(unsigned int)); + *J = malloc(size * sizeof(unsigned int)); + while(fgets(buff, 256, filein)){ + if (buff[0] == '#') + continue; + if (K == size){ + size += 20; + *I = realloc(*I, size*sizeof(unsigned int)); + *J = realloc(*J, size*sizeof(unsigned int)); + } + ptr = strtok(buff, " "); /* read the first node */ + (*I)[K] = atoi(ptr); + ptr = strtok(NULL, " "); /* read the second node */ + (*J)[K] = atoi(ptr); + K += 1; + } + + *I = realloc(*I, K * sizeof(unsigned int)); + *J = realloc(*J, K * sizeof(unsigned int)); + return K; +} + +/*funzione pesata di moreno*/ + +int read_ij_w(FILE *filein, unsigned int **I, unsigned int **J , double **W){ + + unsigned int size, K; + char buff[256]; + char *ptr; + + size = 20; + K = 0; + + *I = malloc(size * sizeof(unsigned int)); + *J = malloc(size * sizeof(unsigned int)); + *W = malloc(size * sizeof(double)); + + while(fgets(buff, 256, filein)){ + if (buff[0] == '#') + continue; + if (K == size){ + size += 20; + *I = realloc(*I, size*sizeof(unsigned int)); + *J = realloc(*J, size*sizeof(unsigned int)); + *W = realloc(*W, size*sizeof(double)); + if (*W==NULL) { + printf ("Errore"); + exit(-1); + } + } + ptr = strtok(buff, " "); /* read the first node */ + (*I)[K] = atoi(ptr); + ptr = strtok(NULL, " "); /* read the second node */ + (*J)[K] = atoi(ptr); + ptr = strtok(NULL, " "); /* read the weight */ + (*W)[K] = atof(ptr); + K += 1; + } + + *I = realloc(*I, K * sizeof(unsigned int)); + *J = realloc(*J, K * sizeof(unsigned int)); + *W = realloc(*W, K * sizeof(double)); + return K; +} + + + +void read_slap(FILE *filein, unsigned int *K, unsigned int *N, + unsigned int **J_slap, unsigned int **r_slap){ + + unsigned int *I=NULL, *J=NULL; + unsigned int i, k; + + k = read_ij(filein, &I, &J); + *K = 2 * k; + I = realloc(I, 2*k * sizeof(unsigned int)); + J = realloc(J, 2*k * sizeof(unsigned int)); + for (i=k; i<2*k; i ++){ + I[i] = J[i-k]; + J[i] = I[i-k]; + } + + *N = convert_ij2slap(I, J, 2*k, r_slap, J_slap); + free(I); + free(J); + return; +} + +/*funzione pesata di moreno*/ + +void read_slap_w(FILE *filein, unsigned int *K, unsigned int *N, + unsigned int **J_slap, unsigned int **r_slap, double **w_slap){ + + unsigned int *I=NULL, *J=NULL; + double *W=NULL; + unsigned int i, k; + + k = read_ij_w(filein, &I, &J, &W); + *K = 2 * k; + I = realloc(I, 2*k * sizeof(unsigned int)); + J = realloc(J, 2*k * sizeof(unsigned int)); + W = realloc(W, 2*k * sizeof(double)); + + for (i=k; i<2*k; i ++){ + I[i] = J[i-k]; + J[i] = I[i-k]; + W[i] = W[i-k]; + } + + *N = convert_ij2slap_w(I, J, W, 2*k, r_slap, J_slap, w_slap); + free(I); + free(J); + free(W); + return; +} + +unsigned int find_max(unsigned int *v, unsigned int N){ + + unsigned int i, max; + + max = v[0]; + i = 0; + while(++i < N){ + if (v[i] > max) + max = v[i]; + } + return max; +} + + +int convert_ij2slap(unsigned int *I, unsigned int *J, unsigned int K, + unsigned int ** r_slap, unsigned int **J_slap){ + + unsigned int tmp, max; + unsigned int N; + unsigned int i, pos; + unsigned int *p; + + max = find_max(I, K) + 1; + tmp = find_max(J, K) + 1; + if (tmp > max){ + max = tmp ; + } + + *r_slap = malloc( (max+1) * sizeof(unsigned int)); + p = malloc(max * sizeof(unsigned int)); + + *J_slap = malloc(K * sizeof(unsigned int)); + + memset(*r_slap, 0, (max+1) * sizeof(unsigned int)); + for(i=0; i max){ + max = tmp ; + } + + *r_slap = malloc( (max+1) * sizeof(unsigned int)); + p = malloc(max * sizeof(unsigned int)); + + *J_slap = malloc(K * sizeof(unsigned int)); + *w_slap = malloc(K * sizeof(double)); + + memset(*r_slap, 0, (max+1) * sizeof(unsigned int)); + for(i=0; i i){ + fprintf(fileout, "%d %d\n", i, J_slap[j]); + } + } + } +} + + +/* Check if j is a neighbour of i */ +int is_neigh(unsigned int *J_slap, unsigned int *r_slap, unsigned int N, + unsigned int i, unsigned int j){ + + unsigned int l; + unsigned int count; + count = 0; + for(l=r_slap[i]; l +#include +#include + +#include + +/** + * + * Load a sequence from a file, which contains one element on each line + * + */ + +void load_sequence(char *fname, double **v, int *N){ + + int size; + char buff[256]; + + FILE *f; + + f = fopen(fname, "r"); + if (!f){ + fprintf(stderr, "Error opening file %s!!!! Exiting...\n", fname); + exit(1); + } + + *N =0; + size = 10; + if (*v == NULL) + *v = malloc(size * sizeof(double)); + else{ + *v = realloc(*v, size * sizeof(double)); + } + + while (fgets(buff, 255, f)){ + (*v)[*N] = atof(buff); + *N += 1; + if (*N == size){ + size += 10; + *v = realloc(*v, size * sizeof(double)); + } + } + *v = realloc(*v, (*N) * sizeof(double)); + fclose(f); +} + + +/** + * + * Load a sequence, getting the "col"-th column of the input file + * + */ + +void load_sequence_col(char *fname, double **v, int *N, int col){ + + int size, n; + char buff[256]; + char *ptr; + + FILE *f; + + f = fopen(fname, "r"); + if (!f){ + fprintf(stderr, "Error opening file %s!!!! Exiting...\n", fname); + exit(1); + } + + *N =0; + size = 10; + if (*v == NULL) + *v = malloc(size * sizeof(double)); + else{ + *v = realloc(*v, size * sizeof(double)); + } + + while (fgets(buff, 255, f)){ + ptr = strtok(buff, " "); + if (col > 0){ + n = 0; + while (n max_v) + max_v = v[i]; + else if (v[i] > 0 && v[i] < min_v) + min_v = v[i]; + } + + size = 10; + if (*x == NULL){ + *x = malloc(size * sizeof(double)); + } + else{ + *x = realloc(*x, size * sizeof(double)); + } + + val = min_v; + last_size = min_v; + (*x)[0] = min_v; + num_x = 1; + + while(val < max_v){ + new_size = last_size * alpha; + val = last_size + new_size; + last_size = new_size; + last_val = val; + (*x)[num_x] = val; + num_x += 1; + if (num_x == size){ + size += 10; + *x = realloc(*x, size * sizeof(double)); + } + } + + if (*y == NULL){ + *y = malloc(num_x * sizeof(double)); + } + else{ + *y = realloc(*y, num_x * sizeof(double)); + } + for (i=0; i < num_x; i++){ + (*y)[i] = 0; + } + + + + for(i=0; i (*x)[j]){ + j ++; + } + (*y)[j] += 1; + } + *num = num_x; +} + +/** + * + * Make the exponential binning of a distribution, with a giving + * exponent alpha. The value of y[i] is the average of the values in + * the vector "w" whose corresponding v lies between x[i-1] and x[i]... + * + */ + + +void exp_bin_avg(double *v, double *w, int N, double alpha, double **x, double **y, int *num){ + + double min_v, max_v, val, last_val; + int i, j, size, num_x; + double last_size, new_size; + int *cnt; + + + min_v = max_v = v[0]; + + for (i=1; i max_v) + max_v = v[i]; + else if (v[i] > 0 && v[i] < min_v) + min_v = v[i]; + } + + size = 10; + if (*x == NULL){ + *x = malloc(size * sizeof(double)); + } + else{ + *x = realloc(*x, size * sizeof(double)); + } + + val = min_v; + last_size = min_v; + (*x)[0] = min_v; + num_x = 1; + + while(val < max_v){ + new_size = last_size * alpha; + val = last_size + new_size; + last_size = new_size; + last_val = val; + (*x)[num_x] = val; + num_x += 1; + if (num_x == size){ + size += 10; + *x = realloc(*x, size * sizeof(double)); + } + } + + + cnt = malloc(num_x * sizeof(int)); + + if (*y == NULL){ + *y = malloc(num_x * sizeof(double)); + } + else{ + *y = realloc(*y, num_x * sizeof(double)); + } + for (i=0; i < num_x; i++){ + (*y)[i] = 0; + cnt[i] = 0; + } + + for(i=0; i (*x)[j]){ + j ++; + } + if(j == num_x){ + printf("Error!!!!! Trying to assing a non-existing bin!!! -- fit_utils.c:exp_bin_avg!!!\n"); + exit(37); + } + (*y)[j] += w[i]; + cnt[j] += 1; + } + *num = num_x; + + for(i=0; i< num_x; i++){ + if (cnt[i] > 0){ + (*y)[i] = (*y)[i] / cnt[i]; + } + } + free(cnt); +} + + +/** + * + * Print a distribution on stdout + * + */ + +void dump_distr(double *x, double *y, int N){ + int i; + + for(i=0; i 0 + * + */ + +void compact_distr(double *x, double *y, int *num){ + + int i, j; + + i = j = 0; + while(j < *num){ + while(j < *num && y[j] == 0){ + j ++; + } + if (j==*num){ + break; + } + x[i] = x[j]; + y[i] = y[j]; + i ++; + j ++; + } + *num = i; +} + + +/** + * + * Apply the function "f" on all the elemnts of a vector, in-place + * + */ + +void map_vec(double *v, int N, double (*f)(double)){ + int i; + + for (i=0; i +#include +#include +#include +#include + +#include "rank_utils.h" + +void load_ranking(char *fname, int *N, double **R){ + + char buff[256]; + int size = 10; + FILE *f; + + if (*R == NULL){ + *R = malloc(size * sizeof (double)); + } + f = fopen(fname, "r"); + if (!f){ + printf("Unable to open file: %s!!! Exiting\n"); + exit(1); + } + + *N = 0; + + while (fgets(buff, 255, f)){ + if (* N == size){ + size += 10; + *R = realloc(*R, size * sizeof(double)); + } + (*R)[*N] = atof(buff); + *N += 1; + } +} + +double avg_array(double *v, int N){ + + double sum = 0.0; + int i; + + for (i = 0; i < N; i ++){ + sum += v[i]; + } + return sum/N; +} + +double compute_C(double *R1, double *R2, int N){ + double mu1, mu2, sum1, sum2; + + mu1 = avg_array(R1, N); + mu2 = avg_array(R2, N); + + sum1 = mu1 * N; + sum2 = mu2 * N; + + return N * mu1 * mu2 - mu2 * sum1 - mu1 * sum2; +} + + +double compute_D(double *R1, double *R2, int N){ + + double mu1, mu2, s1, s2; + int i; + + mu1 = avg_array(R1, N); + mu2 = avg_array(R1, N); + + s1 = s2 = 0.0; + + for (i=0 ; i < N; i ++){ + s1 += pow((R1[i] - mu1), 2); + s2 += pow((R2[i] - mu2), 2); + } + + return sqrt(s1 * s2); +} + + +double compute_rho(double *R1, double *R2, int N, int *pairing){ + + double rho = 0; + int i; + + for (i=0; i < N; i ++){ + rho += R1[i] * R2[ pairing[i] ]; + } + + rho = (rho + compute_C(R1, R2, N))/ compute_D(R1, R2, N); + return rho; +} + +void dump_ranking(double *R, int N){ + int i; + + for (i=0; i < N; i ++){ + printf("%d: %f\n", i, R[i] ); + } +} + + +void init_pairing_natural(int *pairing, int N){ + int i; + + for (i = 0; i< N; i ++){ + pairing[i] = i; + } +} + +void init_pairing_inverse(int *pairing, int N){ + int i; + + for (i = 0; i< N; i ++){ + pairing[i] = N-i-1; + } +} + +void select_pairing(int *pairing, int N, int argc, char *argv[], int pos){ + + if (argc < pos + 1 || !strncasecmp("rnd", argv[pos], 3)){ + init_pairing_random(pairing, N); + } + else if (!strncasecmp("nat", argv[pos], 3)){ + init_pairing_natural(pairing, N); + } + else if (!strncasecmp("inv", argv[pos], 3)){ + init_pairing_inverse(pairing, N); + } + else{ + printf ("Pairing strategy \"%s\" unknown!!! Exiting...\n", argv[pos]); + exit(1); + } + +} + + +void shuffle_sequence(int *s, int N){ + + int i, j, tmp; + + for (i=N-1; i>=0; i--){ + j = rand() % (i+1); + tmp = s[j]; + s[j] = s[i]; + s[i] = tmp; + } +} + + + +void init_pairing_random(int *pairing, int N){ + + init_pairing_natural(pairing, N); + shuffle_sequence(pairing, N); + +} + +/* Loads a pairing from a file, in the format: + * + * rank1 rank2 + * ........... + */ +void load_pairing(int **pairing, int N, char *fname){ + + FILE *f; + int i, j, num; + char buff[256]; + char *ptr; + + f = fopen(fname, "r"); + if (!f){ + printf("Error opening file \"%s\"!!!! Exiting....\n", fname); + exit(2); + } + + if (*pairing == NULL){ + *pairing = malloc(N * sizeof(int)); + init_pairing_natural(*pairing, N); + } + + num = 0; + while(num < N){ + fgets(buff, 255, f); + if (buff[0] == '#') + continue; + ptr = strtok(buff, " "); /* read the first node */ + i = atoi(ptr); + ptr = strtok(NULL, " "); /* read the second node */ + j = atoi(ptr); + (*pairing)[i] = j; + num += 1; + } +} + + +void dump_pairing(int *pairing, int N){ + int i; + + for(i=0; i< N; i ++){ + printf("%d %d\n", i, pairing[i]); + } +} + +void copy_pairing(int *p1, int *p2, int N){ + int i; + + for (i=0 ; i < N; i ++){ + p2[i] = p1[i]; + } +} diff --git a/models/correlations/rank_utils.h b/models/correlations/rank_utils.h new file mode 100644 index 0000000..521582a --- /dev/null +++ b/models/correlations/rank_utils.h @@ -0,0 +1,44 @@ +#ifndef __RANK_UTILS_H__ +#define __RANK_UTILS_H__ + +/* Load a ranking */ +void load_ranking(char *fname, int *N, double **R); + +/* Compute the average of an array */ +double avg_array(double *v, int N); + +/* Compute the term "C" in the rho correlation coefficient */ +double compute_C(double *R1, double *R2, int N); + +/* Compute the term "D" in the rho correlation coefficient */ +double compute_D(double *R1, double *R2, int N); + +/* Compute the Spearman's rank correlation coefficient \rho */ +double compute_rho(double *R1, double *R2, int N, int *pairing); + +void dump_ranking(double *R, int N); + +void init_pairing_natural(int *pairing, int N); + +void init_pairing_inverse(int *pairing, int N); + +void init_pairing_random(int *pairing, int N); + +void select_pairing(int *pairing, int N, int argc, char *argv[], int pos); + +void shuffle_sequence(int *s, int N); + +void dump_pairing(int *pairing, int N); + +void copy_pairing(int *pairing1, int *pairing2, int N); + + +#endif /* __RANK_UTILS_H__ */ + + + + + + + + diff --git a/models/correlations/tune_qnn_adaptive.c b/models/correlations/tune_qnn_adaptive.c new file mode 100644 index 0000000..71643a1 --- /dev/null +++ b/models/correlations/tune_qnn_adaptive.c @@ -0,0 +1,208 @@ +/** + * + * Tune the inter-layer degree correlation function \bar{q}(k) of a + * two-layer multiplex, in order to make it as similar as possible to + * a power law with exponent $\mu$, where $\mu$ is given as input + * + * This version of the program is (or, better, "shoud be") able to + * tune also the value of the pre-factor "a" + * + */ + + +#include +#include +#include +#include +#include + +#include "rank_utils.h" + + + + +inline double compute_delta(double q, double k, double mu, double a){ + + return fabs(log(q) - mu * log(k) - log(a)); + //return fabs (q - a*pow(k,mu)); +} + + + + + + +void tune_qnn_adaptive(double *R1, double *R2, int N, int *pairing, double eps, + double beta, double mu_target){ + + double act_mu, test_mu, F, F_new, F_old; + double delta1_old, delta2_old, delta1_new, delta2_new; + double val, prob; + double mu, a, err, dummy_a; + int *new_pairing; + int p1, p2, tmp_val; + int tot; + char swap = 0; + + new_pairing = malloc(N * sizeof(int)); + copy_pairing(pairing, new_pairing, N); + + a = 1.0; + + F = 10000; + + //fprintf("%f %f %f %f %f\n", eps, beta, mu_target, act_mu, F); + + tot = 0; + while (F > eps){ + /* sample two positions of "pairing" and shuffle them in "new_pairing" */ + + p1 = rand() % N; + p2 = rand() % N; + while (p2 == p1){ + p2 = rand() % N; + } + tmp_val = new_pairing[p1]; + new_pairing[p1] = new_pairing[p2]; + new_pairing[p2] = tmp_val; + + delta1_old = compute_delta(R2[pairing[p1]], R1[p1], mu_target, a); + delta2_old = compute_delta(R2[pairing[p2]], R1[p2], mu_target, a); + + delta1_new = compute_delta(R2[new_pairing[p1]], R1[p1], mu_target, a); + delta2_new = compute_delta(R2[new_pairing[p2]], R1[p2], mu_target, a); + + //F_new = log(delta1_new * delta2_new); + //F_old = log(delta1_old * delta2_old); + + F_new = delta1_new + delta2_new; + F_old = delta1_old + delta2_old; + + + if (F_new <= F_old){/* Accept this swap with probability 1 */ + tmp_val = pairing[p1]; + pairing[p1] = pairing[p2]; + pairing[p2] = tmp_val; + //act_mu = test_mu; + swap = 1; + } + else{/* Accept the swap with a certain probability */ + val = 1.0 * rand() / RAND_MAX; + + //prob = pow(fabs(F - F_new)/(F+F_new), beta); + prob = exp(-(F_new - F_old)/beta); + //fprintf(stderr, "-- %g %g %g -> %f \n", F_new, F_old, F_new - F_old, prob); + if (val < prob){ /* Accept the swap */ + tmp_val = pairing[p1]; + pairing[p1] = pairing[p2]; + pairing[p2] = tmp_val; + //act_mu = test_mu; + swap = 1; + } + else{ /* Rollback the swap */ + tmp_val = new_pairing[p1]; + new_pairing[p1] = new_pairing[p2]; + new_pairing[p2] = tmp_val; + swap = 0; + } + + } + + + ///F = fabs(act_mu - mu_target); + ///if (tot % 200 == 0){ + //fprintf(stderr, "%d %g\n", tot, act_mu); + + //fprintf(stderr, "%d: %f %f ---- %f %f ---- %f %f ---- %d \n", + //tot, delta1_old, delta2_old, delta1_new, delta2_new, F_old, F_new, swap); + + ///} + tot += 1; + if (tot %200 == 0){ + fit_current_trend(R1, R2, N, pairing, &mu, &a, &err); + fprintf(stderr, "mu: %g a: %g corr: %g\n", mu, a, err); + //a = a - 0.01 *(a - exp(a)); + a = exp(a); + } + fit_current_trend(R1, R2, N, pairing, &mu, &dummy_a, &err); + F = fabs(mu - mu_target); + } +} + +void dump_qnn(double *R1, double *R2, int N, int *pairing){ + + int i; + int *qnn, *num; + + qnn = malloc(N * sizeof(int)); + num = malloc(N * sizeof(int)); + + for (i=0; i0){ + printf("%d %f\n", i, 1.0*qnn[i]/num[i]); + } + } + free(num); + free(qnn); +} + + +void dump_degs(double *R1, double *R2, int N, int *pairing){ + + int i; + + for(i=0; i [RND|NAT|INV]\n", argv[0]); + exit(1); + } + + mu_target = atof(argv[3]); + eps = atof(argv[4]); + beta = atof(argv[5]); + + load_ranking(argv[1], &N1, &R1); + load_ranking(argv[2], &N2, &R2); + + if (N1 != N2){ + printf("Error!!!! The two files must have the same number of lines!!!! Exiting...\n"); + exit(1); + } + + pairing = malloc(N1 * sizeof(int)); + + select_pairing(pairing, N1, argc, argv, 6); + + tune_qnn_adaptive(R1, R2, N1, pairing, eps, beta, mu_target); + + dump_pairing(pairing, N1); + //dump_qnn(R1, R2, N1, pairing); + //dump_degs(R1, R2, N1, pairing); + +} diff --git a/models/correlations/tune_rho.c b/models/correlations/tune_rho.c new file mode 100644 index 0000000..4495b0e --- /dev/null +++ b/models/correlations/tune_rho.c @@ -0,0 +1,142 @@ +/** + * + * Tune the Spearman's \rho correlation coefficient between two rankings + * given as input, using a simulated-anneling procedure + * + */ + + +#include +#include +#include +#include +#include + +#include "rank_utils.h" + +//void select_pairing(int *pairing, int N, int argc, char *argv[]){ +// +// if (argc < 7 || !strncasecmp("rnd", argv[6], 3)){ +// init_pairing_random(pairing, N); +// } +// else if (!strncasecmp("nat", argv[6], 3)){ +// init_pairing_natural(pairing, N); +// } +// else if (!strncasecmp("inv", argv[6], 3)){ +// init_pairing_inverse(pairing, N); +// } +// else{ +// printf ("Pairing strategy \"%s\" unknown!!! Exiting...\n", argv[6]); +// exit(1); +// } +// +//} + +void tune_rho(double *R1, double *R2, int N, int *pairing, double eps, + double beta, double rho_target){ + + double act_rho, test_rho, F, F_new; + double val, prob; + int *new_pairing; + int p1, p2, tmp_val; + int tot; + + new_pairing = malloc(N * sizeof(int)); + copy_pairing(pairing, new_pairing, N); + + act_rho = compute_rho(R1, R2, N, pairing); + + F = fabs(act_rho - rho_target); + + //fprintf("%f %f %f %f %f\n", eps, beta, rho_target, act_rho, F); + + tot = 0; + while (F > eps){ + /* sample two positions of "pairing" and shuffle them in "new_pairing" */ + p1 = rand() % N; + p2 = rand() % N; + while (p2 == p1){ + p2 = rand() % N; + } + tmp_val = new_pairing[p1]; + new_pairing[p1] = new_pairing[p2]; + new_pairing[p2] = tmp_val; + test_rho = compute_rho(R1, R2, N, new_pairing); + F_new = fabs(test_rho - rho_target); + if (F_new < F){/* Accept this swap with probability 1 */ + tmp_val = pairing[p1]; + pairing[p1] = pairing[p2]; + pairing[p2] = tmp_val; + act_rho = test_rho; + } + else{/* Accept the swap with a certain probability */ + val = 1.0 * rand() / RAND_MAX; + + //prob = pow(fabs(F - F_new)/(F+F_new), beta); + prob = exp(-(F_new - F)/beta); + //fprintf(stderr, "-- %f\n", prob); + if (val < prob){ /* Accept the swap */ + tmp_val = pairing[p1]; + pairing[p1] = pairing[p2]; + pairing[p2] = tmp_val; + act_rho = test_rho; + } + else{ /* Rollback the swap */ + tmp_val = new_pairing[p1]; + new_pairing[p1] = new_pairing[p2]; + new_pairing[p2] = tmp_val; + } + + } + F = fabs(act_rho - rho_target); + if (tot % 200 == 0){ + fprintf(stderr, "%d %g\n", tot, act_rho); + } + tot += 1; + } +} + + + + +int main (int argc, char *argv[]){ + + int N1, N2; + double *R1 = NULL; + double *R2 = NULL; + double eps, beta, rho, rho_target; + + int *pairing = NULL; + + srand(time(NULL)); + + if (argc < 6){ + printf("Usage: %s [RND|NAT|INV]\n", argv[0]); + exit(1); + } + + rho_target = atof(argv[3]); + eps = atof(argv[4]); + beta = atof(argv[5]); + + load_ranking(argv[1], &N1, &R1); + load_ranking(argv[2], &N2, &R2); + + if (N1 != N2){ + printf("Error!!!! The two files must have the same number of lines!!!! Exiting...\n"); + exit(1); + } + + pairing = malloc(N1 * sizeof(int)); + + select_pairing(pairing, N1, argc, argv, 6); + + rho = compute_rho(R1, R2, N1, pairing); + + fprintf(stderr, "%g\n", rho); + + tune_rho(R1, R2, N1, pairing, eps, beta, rho_target); + + dump_pairing(pairing, N1); + +} diff --git a/models/growth/Makefile b/models/growth/Makefile new file mode 100644 index 0000000..d0b461d --- /dev/null +++ b/models/growth/Makefile @@ -0,0 +1,26 @@ +CFLAGS="-O3" +CC="gcc" +MFLAG=-lm + +all: nibilab_linear_delta nibilab_linear_delay nibilab_linear_delay_mix \ + nibilab_linear_random_times nibilab_nonlinear + +nibilab_linear_delta: nibilab_linear_delta.c + $(CC) $(CFLAGS) -o nibilab_linear_delta nibilab_linear_delta.c $(MFLAG) + +nibilab_linear_delay: nibilab_linear_delay.c + $(CC) $(CFLAGS) -o nibilab_linear_delay nibilab_linear_delay.c $(MFLAG) + +nibilab_linear_delay_mix: nibilab_linear_delay_mix.c + $(CC) $(CFLAGS) -o nibilab_linear_delay_mix nibilab_linear_delay_mix.c $(MFLAG) + +nibilab_linear_random_times: nibilab_linear_random_times.c + $(CC) $(CFLAGS) -o nibilab_linear_random_times nibilab_linear_random_times.c $(MFLAG) + +nibilab_nonlinear: nibilab_nonlinear.c + $(CC) $(CFLAGS) -o nibilab_nonlinear nibilab_nonlinear.c $(MFLAG) + + +clean: + rm nibilab_linear_delta nibilab_linear_delay nibilab_linear_delay_mix \ + nibilab_linear_random_times nibilab_nonlinear diff --git a/models/growth/nibilab_linear_delay.c b/models/growth/nibilab_linear_delay.c new file mode 100644 index 0000000..518b09d --- /dev/null +++ b/models/growth/nibilab_linear_delay.c @@ -0,0 +1,414 @@ +/** + * + * NiBiLaB model (Nicosia, Bianconi, Latora, Barthelemy) of multiplex + * linear preferential attachment + * + * A new node arrives on layer 1 at each time step, but its replica on + * layer 2 arrives after a power-law distributed delay \tau + * + */ + +#include +#include +#include +#include +#include + + +typedef struct{ + int size; + int N; + int *val; +} int_array_t; + + +typedef struct{ + int K; + int N; + int size; + int *i; + int *j; + int *degrees; + int *arrived; + double *cumul; + int_array_t *times; +} ij_net_t; + + + +typedef struct{ + double a; + double b; + double c; + double d; +} coupling_t; + + +typedef struct{ + int N; + double x_min; + double *distr; + double gamma; +} distr_t; + + +int init_network(ij_net_t *G, int m0){ + + int n; + + for(n=0; ni[n] = n; + G->j[n] = n+1 % m0; + G->degrees[n] = 2; + G->arrived[n] = n; + } + G->K = m0; + G->N = m0; + return n; +} + + + +void dump_network(ij_net_t *G){ + + int i; + for(i=0; i< G->K; i ++){ + printf("%d %d\n",G->i[i], G->j[i]); + } +} + + +void dump_network_to_file(ij_net_t *G, char *fname){ + + + FILE *f; + int i; + + + f = fopen(fname, "w+"); + + for(i=0; i< G->K; i ++){ + fprintf(f, "%d %d\n",G->i[i], G->j[i]); + } + fclose(f); +} + + + +double f1(double v1, double v2, coupling_t *matr){ + return v1 * matr->a + v2 * matr->b; +} + +double f2(double v1, double v2, coupling_t *matr){ + return v1 * matr->c + v2 * matr->d; +} + + +void compute_cumul(ij_net_t *G1, ij_net_t *G2, coupling_t *matr){ + + int i; + double val; + + G1->cumul[0] = f1(G1->degrees[ G1->arrived[0] ], G2->degrees[ G1->arrived[0] ], matr) ; + G2->cumul[0] = f2(G1->degrees[ G2->arrived[0] ], G2->degrees[ G2->arrived[0] ], matr) ; + + for(i=1; iN; i ++){ + val = f1(G1->degrees[ G1->arrived[i] ], G2->degrees[ G1->arrived[i] ],matr) ; + G1->cumul[i] = G1->cumul[i-1] + val; + } + for(i=1; iN; i ++){ + val = f2(G1->degrees[ G2->arrived[i] ], G2->degrees[ G2->arrived[i] ], matr) ; + G2->cumul[i] = G2->cumul[i-1] + val; + } +} + +void dump_cumul(ij_net_t *G){ + + int i; + + for (i=0; iN; i ++){ + printf("%d %2.6f\n", G->times[i], G->cumul[i]); + } + +} + + + +int select_neigh_cumul(ij_net_t *G){ + + double r; + int j; + + r = (rand() * 1.0 / RAND_MAX) * G->cumul[ G->N-1 ]; + //printf(" r: %f ", r); + + j = 0; + /* Change with a binary search ???!?!?!?! */ + while (r > G->cumul[j]){ + j ++; + } + return G->arrived[j]; +} + +int already_neighbour(ij_net_t *G, int j, int d, int offset){ + + int i; + + for(i=G-> K + offset; i< G->K + offset + j; i ++){ + if (G->j[i] == d) + return 1; + } + return 0; +} + + +void sample_edges(ij_net_t *G, int n, int m, int offset){ + + int j; + int d; + + //printf("----"); + for(j=0; ji[G->K + offset + j] = n; + d = select_neigh_cumul(G); + while(already_neighbour(G, j, d, offset)){ + d = select_neigh_cumul(G); + } + //printf(" link %d--%d\n", n, d); + G->j[G->K + offset + j] = d; + G->degrees[d] += 1; + } + //printf("\n"); +} + +void create_distr(double *v, double gamma, int x_min, int x_max){ + int n, i; + double sum, new_sum; + + n = x_max-x_min + 1; + + sum = 0; + for(i=0; i v[i]) + i++; + return i; + +} + + +int sample_power_law(distr_t *d){ + + double xi, q, val; + int k; + + while(1){ + xi = rand()* 1.0 / RAND_MAX; + k = find_degree(d->distr, d->N, xi); + val = rand()*1.0/RAND_MAX; + q = d->x_min + xi * d->N; + q = q / (floor(q) + 1); + q = pow(q, d->gamma); + if (val <= q){ + return k; + } + } +} + + + + +int grow_multi_net_delay(ij_net_t *G1, ij_net_t *G2, int N, int m, int m0, coupling_t *matr){ + + int i, j; + int d; + int i2; + + i2 = m0; + + for(i=m0; iarrived[i] = i; + sample_edges(G1, G1->arrived[i], m, 0); + G1->degrees[G1->arrived[i]] += m; + + for (j=0; j < G2->times[i].N; j++){ + G2->arrived[i2] = G2->times[i].val[j]; + //printf("%d\n", G2->arrived[i2]); + sample_edges(G2, G2->arrived[i2], m, m *j); + G2->degrees[G2->arrived[i2]] += m; + i2 += 1; + } + G1->N += 1; + G1->K += m; + G2->N += G2->times[i].N; + G2->K += m * G2->times[i].N; + } + return 0; +} + +void init_structure(ij_net_t *G, int N){ + + int i; + + G->i = malloc(G->size * sizeof(int)); + G->j = malloc(G->size * sizeof(int)); + G->degrees = malloc(N * sizeof(int)); + G->arrived = malloc(N * sizeof(int)); + G->cumul = malloc(N * sizeof(double)); + G->times = malloc(N * sizeof(int_array_t)); + for (i=0; itimes[i].size = 5; + G->times[i].N = 0; + G->times[i].val = malloc(5 * sizeof(int)); + } + memset(G->degrees, 0, N*sizeof(int)); + G->N = 0; + +} + +void add_node_to_time(ij_net_t *G, int node, int t){ + + if (G->times[t].size == G->times[t].N){ + G->times[t].size += 5; + G->times[t].val = realloc(G->times[t].val, G->times[t].size); + } + G->times[t].val[G->times[t].N] = node; + G->times[t].N += 1; +} + + +void init_times_delta(ij_net_t *G, int N){ + + int i; + + for (i=0; itimes[i].N; j++){ + printf("%d %d\n", i,G->times[i].val[j]); + } + //printf("\n"); + } + +} + + +int main(int argc, char *argv[]){ + + ij_net_t G1, G2; + + int N, m, m0, k_max; + coupling_t matr; + double gamma; + distr_t delay_distr; + + char str[256]; + + if (argc < 10){ + printf("Usage: %s \n", argv[0]); + exit(1); + } + + srand(time(NULL)); + + /* Diagonal coupling */ + matr.a = atof(argv[5]); + matr.b = atof(argv[6]); + matr.c = atof(argv[7]); + matr.d = atof(argv[8]); + gamma = atof(argv[9]); + + N = atoi(argv[1]); + m = atoi(argv[2]); + m0 = atoi(argv[3]); + + G1.size = (N+m0) * m; + G2.size = (N+m0) * m; + + init_structure(&G1, N); + init_structure(&G2, N); + + + G1.K = init_network(&G1, m0); + G2.K = init_network(&G2, m0); + + delay_distr.N = N; + delay_distr.gamma = gamma; + delay_distr.x_min = 1; + delay_distr.distr = malloc(N * sizeof(double)); + + create_distr(delay_distr.distr, delay_distr.gamma, delay_distr.x_min, N); + + init_times_delay(&G2, &delay_distr, m0, N); + + dump_times(&G2, N); + + fprintf(stderr, "Init finished!\n"); + + grow_multi_net_delay(&G1, &G2, N, m, m0, &matr); + + //printf("### G1\n"); + sprintf(str, "%s_layer1.txt", argv[4]); + dump_network_to_file(&G1, str); + + //printf("### G2\n"); + sprintf(str, "%s_layer2.txt", argv[4]); + dump_network_to_file(&G2, str); + + /* dump_network_to_file(S, S_num, argv[4]); */ + /* printf("Network dumped!\n"); */ + /* k_max = degree_distr(S, S_num, &distr); */ + /* printf("k_max is: %d\n", k_max); */ + /* dump_distr_to_file(distr, k_max, argv[5]); */ + +} diff --git a/models/growth/nibilab_linear_delay_mix.c b/models/growth/nibilab_linear_delay_mix.c new file mode 100644 index 0000000..e48d16b --- /dev/null +++ b/models/growth/nibilab_linear_delay_mix.c @@ -0,0 +1,457 @@ +/** + * + * NiBiLaB model (Nicosia, Bianconi, Latora, Barthelemy) of multiplex + * linear preferential attachment + * + * At each time step, a new node arrives on one of the two layers + * (chosen uniformly at random), but its replica on the other layer + * arrives after a power-law distributed delay \tau + * + */ + +#include +#include +#include +#include +#include + + +typedef struct{ + int size; + int N; + int *val; +} int_array_t; + + +typedef struct{ + int K; + int N; + int size; + int *i; + int *j; + int *degrees; + int *arrived; + double *cumul; + int_array_t *times; +} ij_net_t; + + + +typedef struct{ + double a; + double b; + double c; + double d; +} coupling_t; + + +typedef struct{ + int N; + double x_min; + double *distr; + double gamma; +} distr_t; + + +int init_network(ij_net_t *G, int m0){ + + int n; + + for(n=0; ni[n] = n; + G->j[n] = (n+1) % m0; + G->degrees[n] = 2; + G->arrived[n] = n; + } + G->K = m0; + G->N = m0; + return n; +} + + + +void dump_network(ij_net_t *G){ + + int i; + for(i=0; i< G->K; i ++){ + printf("%d %d\n",G->i[i], G->j[i]); + } +} + + +void dump_network_to_file(ij_net_t *G, char *fname){ + + + FILE *f; + int i; + + + f = fopen(fname, "w+"); + + for(i=0; i< G->K; i ++){ + fprintf(f, "%d %d\n",G->i[i], G->j[i]); + } + fclose(f); +} + + + +double f1(double v1, double v2, coupling_t *matr){ + return v1 * matr->a + v2 * matr->b; +} + +double f2(double v1, double v2, coupling_t *matr){ + return v1 * matr->c + v2 * matr->d; +} + + +void compute_cumul(ij_net_t *G1, ij_net_t *G2, coupling_t *matr){ + + int i; + double val; + + G1->cumul[0] = f1(G1->degrees[ G1->arrived[0] ], G2->degrees[ G1->arrived[0] ], matr) ; + G2->cumul[0] = f2(G1->degrees[ G2->arrived[0] ], G2->degrees[ G2->arrived[0] ], matr) ; + + for(i=1; iN; i ++){ + val = f1(G1->degrees[ G1->arrived[i] ], G2->degrees[ G1->arrived[i] ],matr) ; + G1->cumul[i] = G1->cumul[i-1] + val; + } + for(i=1; iN; i ++){ + val = f2(G1->degrees[ G2->arrived[i] ], G2->degrees[ G2->arrived[i] ], matr) ; + G2->cumul[i] = G2->cumul[i-1] + val; + } +} + +void dump_cumul(ij_net_t *G){ + + int i; + + for (i=0; iN; i ++){ + printf("%d %2.6f\n", G->times[i], G->cumul[i]); + } + +} + + + +int select_neigh_cumul(ij_net_t *G){ + + double r; + int j; + + r = (rand() * 1.0 / RAND_MAX) * G->cumul[ G->N-1 ]; + //printf(" r: %f ", r); + + j = 0; + /* Change with a binary search ???!?!?!?! */ + while (r > G->cumul[j]){ + j ++; + } + return G->arrived[j]; +} + +int already_neighbour(ij_net_t *G, int j, int d, int offset){ + + int i; + + for(i=G-> K + offset; i< G->K + offset + j; i ++){ + if (G->j[i] == d) + return 1; + } + return 0; +} + + +void sample_edges(ij_net_t *G, int n, int m, int offset){ + + int j; + int d; + + //printf("----"); + for(j=0; ji[G->K + offset + j] = n; + d = select_neigh_cumul(G); + while(already_neighbour(G, j, d, offset)){ + d = select_neigh_cumul(G); + } + //printf(" link %d--%d\n", n, d); + G->j[G->K + offset + j] = d; + G->degrees[d] += 1; + } + //printf("\n"); +} + +void create_distr(double *v, double gamma, int x_min, int x_max){ + int n, i; + double sum, new_sum; + + n = x_max-x_min + 1; + + sum = 0; + for(i=0; i v[i]) + i++; + return i; + +} + + +int sample_power_law(distr_t *d){ + + double xi, q, val; + int k; + + while(1){ + xi = rand()* 1.0 / RAND_MAX; + k = find_degree(d->distr, d->N, xi); + val = rand()*1.0/RAND_MAX; + q = d->x_min + xi * d->N; + q = q / (floor(q) + 1); + q = pow(q, d->gamma); + if (val <= q){ + return k; + } + } +} + + + + +int grow_multi_net_delay_mixed(ij_net_t *G1, ij_net_t *G2, int N, int m, int m0, coupling_t *matr){ + + int i, j; + int d; + int i1, i2; + + i1 = m0; + i2 = m0; + + for(i=m0; itimes[i].N; j++){ + G1->arrived[i1] = G1->times[i].val[j]; + sample_edges(G1, G1->arrived[i1], m, m * j); + G1->degrees[G1->arrived[i1]] += m; + i1 += 1; + } + for (j=0; j < G2->times[i].N; j++){ + G2->arrived[i2] = G2->times[i].val[j]; + //printf("%d\n", G2->arrived[i2]); + sample_edges(G2, G2->arrived[i2], m, m *j); + G2->degrees[G2->arrived[i2]] += m; + i2 += 1; + } + G1->N += G1->times[i].N; + G1->K += m * G1->times[i].N; + G2->N += G2->times[i].N; + G2->K += m * G2->times[i].N; + } + return 0; +} + +void init_structure(ij_net_t *G, int N){ + + int i; + + G->i = malloc(G->size * sizeof(int)); + G->j = malloc(G->size * sizeof(int)); + G->degrees = malloc(N * sizeof(int)); + G->arrived = malloc(N * sizeof(int)); + G->cumul = malloc(N * sizeof(double)); + G->times = malloc(N * sizeof(int_array_t)); + for (i=0; itimes[i].size = 5; + G->times[i].N = 0; + G->times[i].val = malloc(5 * sizeof(int)); + } + memset(G->degrees, 0, N*sizeof(int)); + G->N = 0; +} + +void add_node_to_time(ij_net_t *G, int node, int t){ + + if (G->times[t].size == G->times[t].N){ + G->times[t].size += 5; + G->times[t].val = realloc(G->times[t].val, G->times[t].size); + } + G->times[t].val[G->times[t].N] = node; + G->times[t].N += 1; +} + + +void init_times_delta(ij_net_t *G, int N){ + + int i; + + for (i=0; itimes[i].N; j++){ + printf("%d %d\n", i,G->times[i].val[j]); + } + //printf("\n"); + } + +} + + +int main(int argc, char *argv[]){ + + ij_net_t G1, G2; + + int N, m, m0, k_max; + coupling_t matr; + double gamma; + distr_t delay_distr; + + char str[256]; + + if (argc < 10){ + printf("Usage: %s \n", argv[0]); + exit(1); + } + + srand(time(NULL)); + + /* Diagonal coupling */ + matr.a = atof(argv[5]); + matr.b = atof(argv[6]); + matr.c = atof(argv[7]); + matr.d = atof(argv[8]); + gamma = atof(argv[9]); + + N = atoi(argv[1]); + m = atoi(argv[2]); + m0 = atoi(argv[3]); + + G1.size = (N+m0) * m; + G2.size = (N+m0) * m; + + init_structure(&G1, N); + init_structure(&G2, N); + + + G1.K = init_network(&G1, m0); + G2.K = init_network(&G2, m0); + + delay_distr.N = N; + delay_distr.gamma = gamma; + delay_distr.x_min = 1; + delay_distr.distr = malloc(N * sizeof(double)); + + create_distr(delay_distr.distr, delay_distr.gamma, delay_distr.x_min, N); + + //init_times_delay(&G2, &delay_distr, m0, N); + init_times_delay_mixed(&G1, &G2, &delay_distr, m0, N); + + printf("----- G1 times ----- \n"); + dump_times(&G1, N); + + printf("----- G2 times ----- \n"); + dump_times(&G2, N); + //exit(2); + + fprintf(stderr, "Init finished!\n"); + + grow_multi_net_delay_mixed(&G1, &G2, N, m, m0, &matr); + + //printf("### G1\n"); + sprintf(str, "%s_layer1.txt", argv[4]); + dump_network_to_file(&G1, str); + + //printf("### G2\n"); + sprintf(str, "%s_layer2.txt", argv[4]); + dump_network_to_file(&G2, str); + + /* dump_network_to_file(S, S_num, argv[4]); */ + /* printf("Network dumped!\n"); */ + /* k_max = degree_distr(S, S_num, &distr); */ + /* printf("k_max is: %d\n", k_max); */ + /* dump_distr_to_file(distr, k_max, argv[5]); */ + +} diff --git a/models/growth/nibilab_linear_delta.c b/models/growth/nibilab_linear_delta.c new file mode 100644 index 0000000..b1f7e90 --- /dev/null +++ b/models/growth/nibilab_linear_delta.c @@ -0,0 +1,403 @@ +/** + * + * NiBiLaB model (Nicosia, Bianconi, Latora, Barthelemy) of multiplex + * linear preferential attachment + * + * Node arrive at the same time on both layers. + * + */ + +#include +#include +#include +#include +#include + + +typedef struct{ + int size; + int N; + int *val; +} int_array_t; + + +typedef struct{ + int K; + int N; + int size; + int *i; + int *j; + int *degrees; + int *arrived; + double *cumul; + int_array_t *times; +} ij_net_t; + + + +typedef struct{ + double a; + double b; + double c; + double d; +} coupling_t; + + +typedef struct{ + int N; + double x_min; + double *distr; + double gamma; +} distr_t; + + +int init_network(ij_net_t *G, int m0){ + + int n; + + for(n=0; ni[n] = n; + G->j[n] = n+1 % m0; + G->degrees[n] = 2; + G->arrived[n] = n; + } + G->K = m0; + G->N = m0; + return n; +} + + + +void dump_network(ij_net_t *G){ + + int i; + for(i=0; i< G->K; i ++){ + printf("%d %d\n",G->i[i], G->j[i]); + } +} + + +void dump_network_to_file(ij_net_t *G, char *fname){ + + + FILE *f; + int i; + + + f = fopen(fname, "w+"); + + for(i=0; i< G->K; i ++){ + fprintf(f, "%d %d\n",G->i[i], G->j[i]); + } + fclose(f); +} + + + +double f1(double v1, double v2, coupling_t *matr){ + return v1 * matr->a + v2 * matr->b; +} + +double f2(double v1, double v2, coupling_t *matr){ + return v1 * matr->c + v2 * matr->d; +} + + +void compute_cumul(ij_net_t *G1, ij_net_t *G2, coupling_t *matr){ + + int i; + double val; + + G1->cumul[0] = f1(G1->degrees[ G1->arrived[0] ], G2->degrees[ G1->arrived[0] ], matr) ; + G2->cumul[0] = f2(G1->degrees[ G2->arrived[0] ], G2->degrees[ G2->arrived[0] ], matr) ; + + for(i=1; iN; i ++){ + val = f1(G1->degrees[ G1->arrived[i] ], G2->degrees[ G1->arrived[i] ],matr) ; + G1->cumul[i] = G1->cumul[i-1] + val; + } + for(i=1; iN; i ++){ + val = f2(G1->degrees[ G2->arrived[i] ], G2->degrees[ G2->arrived[i] ], matr) ; + G2->cumul[i] = G2->cumul[i-1] + val; + } +} + +void dump_cumul(ij_net_t *G){ + + int i; + + for (i=0; iN; i ++){ + printf("%d %2.6f\n", G->times[i], G->cumul[i]); + } + +} + + + +int select_neigh_cumul(ij_net_t *G){ + + double r; + int j; + + r = (rand() * 1.0 / RAND_MAX) * G->cumul[ G->N-1 ]; + //printf(" r: %f ", r); + + j = 0; + /* Change with a binary search ???!?!?!?! */ + while (r > G->cumul[j]){ + j ++; + } + return G->arrived[j]; +} + +int already_neighbour(ij_net_t *G, int j, int d, int offset){ + + int i; + + for(i=G-> K + offset; i< G->K + offset + j; i ++){ + if (G->j[i] == d) + return 1; + } + return 0; +} + + +void sample_edges(ij_net_t *G, int n, int m, int offset){ + + int j; + int d; + + //printf("----"); + for(j=0; ji[G->K + offset + j] = n; + d = select_neigh_cumul(G); + while(already_neighbour(G, j, d, offset)){ + d = select_neigh_cumul(G); + } + //printf(" link %d--%d\n", n, d); + G->j[G->K + offset + j] = d; + G->degrees[d] += 1; + } + //printf("\n"); +} + +void create_distr(double *v, double gamma, int x_min, int x_max){ + int n, i; + double sum, new_sum; + + n = x_max-x_min + 1; + + sum = 0; + for(i=0; i v[i]) + i++; + return i; + +} + + +int sample_power_law(distr_t *d){ + + double xi, q, val; + int k; + + while(1){ + xi = rand()* 1.0 / RAND_MAX; + k = find_degree(d->distr, d->N, xi); + val = rand()*1.0/RAND_MAX; + q = d->x_min + xi * d->N; + q = q / (floor(q) + 1); + q = pow(q, d->gamma); + if (val <= q){ + return k; + } + } +} + + + + +int grow_multi_net_delta(ij_net_t *G1, ij_net_t *G2, int N, int m, int m0, coupling_t *matr){ + + int i, j; + int d; + int i2; + + + for(i=m0; iarrived[i] = i; + sample_edges(G1, G1->arrived[i], m, 0); + G1->degrees[G1->arrived[i]] += m; + + G2->arrived[i] = i; + //printf("%d\n", G2->arrived[i2]); + sample_edges(G2, G2->arrived[i], m, 0); + G2->degrees[G2->arrived[i]] += m; + G1->N += 1; + G1->K += m; + G2->N += 1; + G2->K += m; + } + return 0; +} + +void init_structure(ij_net_t *G, int N){ + + int i; + + G->i = malloc(G->size * sizeof(int)); + G->j = malloc(G->size * sizeof(int)); + G->degrees = malloc(N * sizeof(int)); + G->arrived = malloc(N * sizeof(int)); + G->cumul = malloc(N * sizeof(double)); + G->times = malloc(N * sizeof(int_array_t)); + for (i=0; itimes[i].size = 5; + G->times[i].N = 0; + G->times[i].val = malloc(5 * sizeof(int)); + } + memset(G->degrees, 0, N*sizeof(int)); + G->N = 0; + +} + +void add_node_to_time(ij_net_t *G, int node, int t){ + + if (G->times[t].size == G->times[t].N){ + G->times[t].size += 5; + G->times[t].val = realloc(G->times[t].val, G->times[t].size); + } + G->times[t].val[G->times[t].N] = node; + G->times[t].N += 1; +} + + +void init_times_delta(ij_net_t *G, int N){ + + int i; + + for (i=0; itimes[i].N; j++){ + printf(" %d", G->times[i].val[j]); + } + printf("\n"); + } + +} + + +int main(int argc, char *argv[]){ + + ij_net_t G1, G2; + + int N, m, m0, k_max; + coupling_t matr; + double gamma; + distr_t delay_distr; + + char str[256]; + + if (argc < 9){ + printf("Usage: %s \n", argv[0]); + exit(1); + } + + srand(time(NULL)); + + /* Diagonal coupling */ + matr.a = atof(argv[5]); + matr.b = atof(argv[6]); + matr.c = atof(argv[7]); + matr.d = atof(argv[8]); + + N = atoi(argv[1]); + m = atoi(argv[2]); + m0 = atoi(argv[3]); + + G1.size = (N+m0) * m; + G2.size = (N+m0) * m; + + init_structure(&G1, N); + init_structure(&G2, N); + + + G1.K = init_network(&G1, m0); + G2.K = init_network(&G2, m0); + + + init_times_delta(&G2, N); + + //dump_times(&G2, N); + + fprintf(stderr, "Init finished!\n"); + + grow_multi_net_delta(&G1, &G2, N, m, m0, &matr); + + //printf("### G1\n"); + sprintf(str, "%s_layer1.txt", argv[4]); + dump_network_to_file(&G1, str); + + //printf("### G2\n"); + sprintf(str, "%s_layer2.txt", argv[4]); + dump_network_to_file(&G2, str); + + /* dump_network_to_file(S, S_num, argv[4]); */ + /* printf("Network dumped!\n"); */ + /* k_max = degree_distr(S, S_num, &distr); */ + /* printf("k_max is: %d\n", k_max); */ + /* dump_distr_to_file(distr, k_max, argv[5]); */ + +} diff --git a/models/growth/nibilab_linear_random_times.c b/models/growth/nibilab_linear_random_times.c new file mode 100644 index 0000000..48929aa --- /dev/null +++ b/models/growth/nibilab_linear_random_times.c @@ -0,0 +1,417 @@ +/** + * + * NiBiLaB model (Nicosia, Bianconi, Latora, Barthelemy) of multiplex + * linear preferential attachment + * + * Nodes arrive sequentially on the first layer, but their replicas on + * the second layer arrive at uniformly distributed times. + * + */ + +#include +#include +#include +#include +#include + + +typedef struct{ + int size; + int N; + int *val; +} int_array_t; + + +typedef struct{ + int K; + int N; + int size; + int *i; + int *j; + int *degrees; + int *arrived; + double *cumul; + int_array_t *times; +} ij_net_t; + + + +typedef struct{ + double a; + double b; + double c; + double d; +} coupling_t; + + +typedef struct{ + int N; + double x_min; + double *distr; + double gamma; +} distr_t; + + +int init_network(ij_net_t *G, int m0){ + + int n; + + for(n=0; ni[n] = n; + G->j[n] = n+1 % m0; + G->degrees[n] = 2; + G->arrived[n] = n; + } + G->K = m0; + G->N = m0; + return n; +} + + + +void dump_network(ij_net_t *G){ + + int i; + for(i=0; i< G->K; i ++){ + printf("%d %d\n",G->i[i], G->j[i]); + } +} + + +void dump_network_to_file(ij_net_t *G, char *fname){ + + + FILE *f; + int i; + + + f = fopen(fname, "w+"); + + for(i=0; i< G->K; i ++){ + fprintf(f, "%d %d\n",G->i[i], G->j[i]); + } + fclose(f); +} + + + +double f1(double v1, double v2, coupling_t *matr){ + return v1 * matr->a + v2 * matr->b; +} + +double f2(double v1, double v2, coupling_t *matr){ + return v1 * matr->c + v2 * matr->d; +} + + +void compute_cumul(ij_net_t *G1, ij_net_t *G2, coupling_t *matr){ + + int i; + double val; + + G1->cumul[0] = f1(G1->degrees[ G1->arrived[0] ], G2->degrees[ G1->arrived[0] ], matr) ; + G2->cumul[0] = f2(G1->degrees[ G2->arrived[0] ], G2->degrees[ G2->arrived[0] ], matr) ; + + for(i=1; iN; i ++){ + val = f1(G1->degrees[ G1->arrived[i] ], G2->degrees[ G1->arrived[i] ],matr) ; + G1->cumul[i] = G1->cumul[i-1] + val; + } + for(i=1; iN; i ++){ + val = f2(G1->degrees[ G2->arrived[i] ], G2->degrees[ G2->arrived[i] ], matr) ; + G2->cumul[i] = G2->cumul[i-1] + val; + } +} + +void dump_cumul(ij_net_t *G){ + + int i; + + for (i=0; iN; i ++){ + printf("%d %2.6f\n", G->times[i], G->cumul[i]); + } + +} + + + +int select_neigh_cumul(ij_net_t *G){ + + double r; + int j; + + r = (rand() * 1.0 / RAND_MAX) * G->cumul[ G->N-1 ]; + //printf(" r: %f ", r); + + j = 0; + /* Change with a binary search ???!?!?!?! */ + while (r > G->cumul[j]){ + j ++; + } + return G->arrived[j]; +} + +int already_neighbour(ij_net_t *G, int j, int d, int offset){ + + int i; + + for(i=G-> K + offset; i< G->K + offset + j; i ++){ + if (G->j[i] == d) + return 1; + } + return 0; +} + + +void sample_edges(ij_net_t *G, int n, int m, int offset){ + + int j; + int d; + + //printf("----"); + for(j=0; ji[G->K + offset + j] = n; + d = select_neigh_cumul(G); + while(already_neighbour(G, j, d, offset)){ + d = select_neigh_cumul(G); + } + //printf(" link %d--%d\n", n, d); + G->j[G->K + offset + j] = d; + G->degrees[d] += 1; + } + //printf("\n"); +} + +void create_distr(double *v, double gamma, int x_min, int x_max){ + int n, i; + double sum, new_sum; + + n = x_max-x_min + 1; + + sum = 0; + for(i=0; i v[i]) + i++; + return i; + +} + + +int sample_power_law(distr_t *d){ + + double xi, q, val; + int k; + + while(1){ + xi = rand()* 1.0 / RAND_MAX; + k = find_degree(d->distr, d->N, xi); + val = rand()*1.0/RAND_MAX; + q = d->x_min + xi * d->N; + q = q / (floor(q) + 1); + q = pow(q, d->gamma); + if (val <= q){ + return k; + } + } +} + + + + +int grow_multi_net_delay(ij_net_t *G1, ij_net_t *G2, int N, int m, int m0, coupling_t *matr){ + + int i, j; + int d; + int i2; + + i2 = m0; + + for(i=m0; iarrived[i] = i; + sample_edges(G1, G1->arrived[i], m, 0); + G1->degrees[G1->arrived[i]] += m; + + for (j=0; j < G2->times[i].N; j++){ + G2->arrived[i2] = G2->times[i].val[j]; + //printf("%d\n", G2->arrived[i2]); + sample_edges(G2, G2->arrived[i2], m, m *j); + G2->degrees[G2->arrived[i2]] += m; + i2 += 1; + } + G1->N += 1; + G1->K += m; + G2->N += G2->times[i].N; + G2->K += m * G2->times[i].N; + } + return 0; +} + +void init_structure(ij_net_t *G, int N){ + + int i; + + G->i = malloc(G->size * sizeof(int)); + G->j = malloc(G->size * sizeof(int)); + G->degrees = malloc(N * sizeof(int)); + G->arrived = malloc(N * sizeof(int)); + G->cumul = malloc(N * sizeof(double)); + G->times = malloc(N * sizeof(int_array_t)); + for (i=0; itimes[i].size = 5; + G->times[i].N = 0; + G->times[i].val = malloc(5 * sizeof(int)); + } + memset(G->degrees, 0, N*sizeof(int)); + G->N = 0; + +} + +void add_node_to_time(ij_net_t *G, int node, int t){ + + if (G->times[t].size == G->times[t].N){ + G->times[t].size += 5; + G->times[t].val = realloc(G->times[t].val, G->times[t].size); + } + G->times[t].val[G->times[t].N] = node; + G->times[t].N += 1; +} + + +void init_times_delta(ij_net_t *G, int N){ + + int i; + + for (i=0; itimes[i].N; j++){ + printf(" %d", G->times[i].val[j]); + } + printf("\n"); + } + +} + + +int main(int argc, char *argv[]){ + + ij_net_t G1, G2; + + int N, m, m0, k_max; + coupling_t matr; + double gamma; + distr_t delay_distr; + + char str[256]; + + if (argc < 9){ + printf("Usage: %s \n", argv[0]); + exit(1); + } + + srand(time(NULL)); + + /* Diagonal coupling */ + matr.a = atof(argv[5]); + matr.b = atof(argv[6]); + matr.c = atof(argv[7]); + matr.d = atof(argv[8]); + + N = atoi(argv[1]); + m = atoi(argv[2]); + m0 = atoi(argv[3]); + + G1.size = (N+m0) * m; + G2.size = (N+m0) * m; + + init_structure(&G1, N); + init_structure(&G2, N); + + + G1.K = init_network(&G1, m0); + G2.K = init_network(&G2, m0); + + + init_times_random(&G2, N); + + //dump_times(&G2, N); + + fprintf(stderr, "Init finished!\n"); + + grow_multi_net_delay(&G1, &G2, N, m, m0, &matr); + + //printf("### G1\n"); + sprintf(str, "%s_layer1.txt", argv[4]); + dump_network_to_file(&G1, str); + + //printf("### G2\n"); + sprintf(str, "%s_layer2.txt", argv[4]); + dump_network_to_file(&G2, str); + + /* dump_network_to_file(S, S_num, argv[4]); */ + /* printf("Network dumped!\n"); */ + /* k_max = degree_distr(S, S_num, &distr); */ + /* printf("k_max is: %d\n", k_max); */ + /* dump_distr_to_file(distr, k_max, argv[5]); */ + +} diff --git a/models/growth/nibilab_nonlinear.c b/models/growth/nibilab_nonlinear.c new file mode 100644 index 0000000..3ad9ce8 --- /dev/null +++ b/models/growth/nibilab_nonlinear.c @@ -0,0 +1,493 @@ +/** + * + * NiBiLaB model (Nicosia, Bianconi, Latora, Barthelemy) of multiplex + * non-linear preferential attachment. + * + * The probability for a newly arrived node $i$ to create a link to an + * existing node $j$ is + * + * p_{i->j} \propto k\lay{1}^{\alpha}/k\lay{2}^{\beta} + * + * where alpha and beta are two parameters. + * + * Nodes arrive at the same time on both layers. + * + */ + +#include +#include +#include +#include +#include + + +typedef struct{ + int size; + int N; + int *val; +} int_array_t; + + +typedef struct{ + int K; + int N; + int size; + int *i; + int *j; + int *degrees; + int *arrived; + double *cumul; + int_array_t *times; + double *eta; +} ij_net_t; + + + +typedef struct{ + double a; + double b; + double c; + double d; +} coupling_t; + + +typedef struct{ + int N; + double x_min; + double *distr; + double gamma; +} distr_t; + + +int init_network(ij_net_t *G, int m0){ + + int n; + + for(n=0; ni[n] = n; + G->j[n] = n+1 % m0; + G->degrees[n] = 2; + G->arrived[n] = n; + } + G->K = m0; + G->N = m0; + return n; +} + + + +void dump_network(ij_net_t *G){ + + int i; + for(i=0; i< G->K; i ++){ + printf("%d %d\n",G->i[i], G->j[i]); + } +} + + +void dump_network_to_file(ij_net_t *G, char *fname){ + + + FILE *f; + int i; + + + f = fopen(fname, "w+"); + + for(i=0; i< G->K; i ++){ + fprintf(f, "%d %d\n",G->i[i], G->j[i]); + } + fclose(f); +} + + + +double f1(double v1, double v2, coupling_t *matr){ + return v1 * matr->a + v2 * matr->b; +} + +double f2(double v1, double v2, coupling_t *matr){ + return v1 * matr->c + v2 * matr->d; +} + + +void compute_cumul_nlin(ij_net_t *G1, ij_net_t *G2, double alpha){ + + int i; + double val; + + /* The bias at layer 1 is k1/k2^2 */ + if (G1->degrees[G1->arrived[0]] > 0 && G2->degrees[ G1->arrived[0] ]) + G1->cumul[0] = (G1->degrees[G1->arrived[0]]) * 1.0 / pow(G2->degrees[ G1->arrived[0] ],alpha) ; + else + G1->cumul[0] = 0.0; + + if (G2->degrees[G2->arrived[0]] > 0 && G1->degrees[ G2->arrived[0] ] > 0) + G2->cumul[0] = ( G2->degrees[G2->arrived[0]]) * 1.0/ pow(G1->degrees[ G2->arrived[0] ],alpha); + else + G2->cumul[0] = 0.0; + + for(i=1; iN; i ++){ + if (G1->degrees[G1->arrived[i]] > 0 && G2->degrees[ G1->arrived[i] ] > 0) + val = (G1->degrees[G1->arrived[i]]) * 1.0 / pow(G2->degrees[ G1->arrived[i] ],alpha) ; + else + val = 0; + G1->cumul[i] = G1->cumul[i-1] + val; + } + for(i=1; iN; i ++){ + if (G2->degrees[G2->arrived[i]] > 0 && G1->degrees[ G2->arrived[i] ] ) + val = (G2->degrees[G2->arrived[i]]) * 1.0/ pow(G1->degrees[ G2->arrived[i] ], alpha); + else + val = 0.0; + G2->cumul[i] = G2->cumul[i-1] + val; + } +} + + +void compute_cumul_nlin_2(ij_net_t *G1, ij_net_t *G2, double alpha, double beta){ + + int i; + double val; + + /* The bias at layer 1 is k1/k2^2 */ + if (G1->degrees[G1->arrived[0]] > 0 && G2->degrees[ G1->arrived[0] ]) + G1->cumul[0] = pow(G1->degrees[G1->arrived[0]], alpha) / pow(G2->degrees[ G1->arrived[0] ],beta) ; + else + G1->cumul[0] = 0.0; + + if (G2->degrees[G2->arrived[0]] > 0 && G1->degrees[ G2->arrived[0] ] > 0) + G2->cumul[0] = pow(G2->degrees[G2->arrived[0]], alpha)/pow(G1->degrees[ G2->arrived[0] ], beta); + else + G2->cumul[0] = 0.0; + + for(i=1; iN; i ++){ + if (G1->degrees[G1->arrived[i]] > 0 && G2->degrees[ G1->arrived[i] ] > 0) + val = pow(G1->degrees[G1->arrived[i]], alpha)/pow(G2->degrees[ G1->arrived[i] ],beta) ; + else + val = 0; + G1->cumul[i] = G1->cumul[i-1] + val; + } + for(i=1; iN; i ++){ + if (G2->degrees[G2->arrived[i]] > 0 && G1->degrees[ G2->arrived[i] ] ) + val = pow(G2->degrees[G2->arrived[i]],alpha)/pow(G1->degrees[ G2->arrived[i] ], beta); + else + val = 0.0; + G2->cumul[i] = G2->cumul[i-1] + val; + } +} + + +void dump_cumul(ij_net_t *G){ + + int i; + + for (i=0; iN; i ++){ + printf("%d %2.6f\n", G->times[i], G->cumul[i]); + } + +} + + + +int select_neigh_cumul(ij_net_t *G){ + + double r; + int j; + + r = (rand() * 1.0 / RAND_MAX) * G->cumul[ G->N-1 ]; + //printf(" r: %f ", r); + + j = 0; + /* Change with a binary search ???!?!?!?! */ + while (r > G->cumul[j]){ + j ++; + } + return G->arrived[j]; +} + +int already_neighbour(ij_net_t *G, int j, int d, int offset){ + + int i; + + for(i=G-> K + offset; i< G->K + offset + j; i ++){ + if (G->j[i] == d) + return 1; + } + return 0; +} + + +void sample_edges(ij_net_t *G, int n, int m, int offset){ + + int j; + int d; + + //printf("----"); + for(j=0; ji[G->K + offset + j] = n; + d = select_neigh_cumul(G); + while(already_neighbour(G, j, d, offset)){ + d = select_neigh_cumul(G); + } + //printf(" link %d--%d\n", n, d); + G->j[G->K + offset + j] = d; + G->degrees[d] += 1; + } + //printf("\n"); +} + +void create_distr(double *v, double gamma, int x_min, int x_max){ + int n, i; + double sum, new_sum; + + n = x_max-x_min + 1; + + sum = 0; + for(i=0; i v[i]) + i++; + return i; + +} + + +int sample_power_law(distr_t *d){ + + double xi, q, val; + int k; + + while(1){ + xi = rand()* 1.0 / RAND_MAX; + k = find_degree(d->distr, d->N, xi); + val = rand()*1.0/RAND_MAX; + q = d->x_min + xi * d->N; + q = q / (floor(q) + 1); + q = pow(q, d->gamma); + if (val <= q){ + return k; + } + } +} + + + + +int grow_multi_net_nlin_2(ij_net_t *G1, ij_net_t *G2, int N, int m, + int m0, double alpha, double beta){ + + int i, j; + int d; + int i2; + + + for(i=m0; iarrived[i] = i; + sample_edges(G1, G1->arrived[i], m, 0); + G1->degrees[G1->arrived[i]] += m; + + G2->arrived[i] = i; + sample_edges(G2, G2->arrived[i], m, 0); + G2->degrees[G2->arrived[i]] += m; + G1->N += 1; + G1->K += m; + G2->N += 1; + G2->K += m ; + } + return 0; +} + +void init_structure(ij_net_t *G, int N){ + + int i; + + G->i = malloc(G->size * sizeof(int)); + G->j = malloc(G->size * sizeof(int)); + G->degrees = malloc(N * sizeof(int)); + G->arrived = malloc(N * sizeof(int)); + G->cumul = malloc(N * sizeof(double)); + G->eta = malloc(N * sizeof(double)); + G->times = malloc(N * sizeof(int_array_t)); + for (i=0; itimes[i].size = 5; + G->times[i].N = 0; + G->times[i].val = malloc(5 * sizeof(int)); + } + memset(G->degrees, 0, N*sizeof(int)); + G->N = 0; + +} + +void add_node_to_time(ij_net_t *G, int node, int t){ + + if (G->times[t].size == G->times[t].N){ + G->times[t].size += 5; + G->times[t].val = realloc(G->times[t].val, G->times[t].size); + } + G->times[t].val[G->times[t].N] = node; + G->times[t].N += 1; +} + + +void init_times_delta(ij_net_t *G, int N){ + + int i; + + for (i=0; itimes[i].N; j++){ + printf(" %d", G->times[i].val[j]); + } + printf("\n"); + } + +} + + +void init_eta_random(ij_net_t *G, int N){ + + int i; + double val; + + for (i=0; ieta[i] = val; + } +} + +void init_eta_ass(ij_net_t *G2, ij_net_t *G1, int N){ + int i; + + for (i=0; ieta[i] = G1->eta[i]; + } + +} + +void init_eta_dis(ij_net_t *G2, ij_net_t *G1, int N){ + int i; + + for (i=0; ieta[i] = 1 - G1->eta[i]; + } + +} + + +int main(int argc, char *argv[]){ + + ij_net_t G1, G2; + + int N, m, m0, k_max; + coupling_t matr; + double alpha, beta; + distr_t delay_distr; + + char str[256]; + + if (argc < 6){ + printf("Usage: %s \n", argv[0]); + exit(1); + } + + srand(time(NULL)); + + /* Diagonal coupling */ + + N = atoi(argv[1]); + m = atoi(argv[2]); + m0 = atoi(argv[3]); + alpha=atof(argv[5]); + beta = atof(argv[6]); + + G1.size = (N+m0) * m; + G2.size = (N+m0) * m; + + init_structure(&G1, N); + init_structure(&G2, N); + + + G1.K = init_network(&G1, m0); + G2.K = init_network(&G2, m0); + + //init_eta_random(&G1, N); + //init_eta_random(&G2, N); + + + + //init_times_delta(&G1, N); + //init_times_delta(&G2, N); + + //dump_times(&G2, N); + + fprintf(stderr, "Init finished!\n"); + + grow_multi_net_nlin_2(&G1, &G2, N, m, m0, alpha, beta); + + //printf("### G1\n"); + sprintf(str, "%s_layer1.txt", argv[4]); + dump_network_to_file(&G1, str); + + //printf("### G2\n"); + sprintf(str, "%s_layer2.txt", argv[4]); + dump_network_to_file(&G2, str); + + /* dump_network_to_file(S, S_num, argv[4]); */ + /* printf("Network dumped!\n"); */ + /* k_max = degree_distr(S, S_num, &distr); */ + /* printf("k_max is: %d\n", k_max); */ + /* dump_distr_to_file(distr, k_max, argv[5]); */ + +} diff --git a/models/growth/node_deg_over_time.py b/models/growth/node_deg_over_time.py new file mode 100644 index 0000000..a71e86c --- /dev/null +++ b/models/growth/node_deg_over_time.py @@ -0,0 +1,82 @@ +#### +## +## Get an edgelist, a file pof arrival times and a node ID and return +## the degree of that node as a function of time (we suppose that IDs +## are sequential) +## +## + +import sys + + +if len(sys.argv) < 4: + print "Usage: %s [ ...]" % sys.argv[0] + sys.exit(1) + +node_id = int(sys.argv[3]) + +lines = open(sys.argv[2], "r").readlines() + +arrival_time = {} + +#### WARNING!!!! THIS WORKS ONLY FOR M0=3 +arrival_time[0] = 0 +arrival_time[1] = 1 +arrival_time[2] = 2 + + +neigh_by_time = {} + +max_t = -1 + +for l in lines: + if l[0] == "#": + continue + t,node = [int(x) for x in l.strip(" \n").split(" ")] + arrival_time[node] = t + if t > max_t : + max_t = t + + +lines = open(sys.argv[1], "r").readlines() + + +for l in lines: + if l[0] == "#": + continue + n1,n2 = [int(x) for x in l.strip(" \n").split(" ")] + + + if neigh_by_time.has_key(n1): + neigh_by_time[n1].append(arrival_time[n2]) + else: + neigh_by_time[n1] = [arrival_time[n2]] + + if neigh_by_time.has_key(n2): + neigh_by_time[n2].append(arrival_time[n1]) + else: + neigh_by_time[n2] = [arrival_time[n1]] + + + +#print neigh_by_time[node_id] + + +for node_id in sys.argv[3:]: + node_id = int(node_id) + neigh_by_time[node_id].sort() + last_time = neigh_by_time[node_id][0] +#### changed here + k = 1 + print "#### ", node_id + for t in neigh_by_time[node_id][1:]: + if t != last_time: + if last_time < arrival_time[node_id]: + print arrival_time[node_id], k + else: + print last_time, k + last_time = t + k += 1 + print max_t, k-1 + print + print diff --git a/models/nullmodels/model_MDM.py b/models/nullmodels/model_MDM.py new file mode 100644 index 0000000..5b0a969 --- /dev/null +++ b/models/nullmodels/model_MDM.py @@ -0,0 +1,66 @@ +#### +## +## +## This is the vertical participation model. For each node i, we use +## exactly the same value of B_i as in the original network, but we +## choose at random the layers in which node i will be active. This +## breaks down intra-layer correlations. +## +## We get as input a file which reports, for each value of B_i, the +## number of nodes in the original network which have that value, i the format: +## +## B_i N(B_i) +## +## +## +## The output is the obtained distribution of bit-strings. +## +## + +import sys +import random + + +def to_binary(l): + s = 0 + e = 0 + for v in l: + s += v * pow(2,e) + e +=1 + return s + + +if len(sys.argv) < 3: + print "Usage: %s " % sys.argv[0] + sys.exit(1) + +M = int(sys.argv[2]) + +layers = range(M) + +distr = {} + +with open(sys.argv[1], "r") as f: + for l in f: + if l[0] == "#": + continue + val, num = [int(x) for x in l.strip(" \n").split(" ")] + for j in range(num): + node_layers = random.sample(layers, val) + node_bitstring = [0 for x in range(M)] + #print node_bitstring, node_layers + for i in node_layers: + #print i, + node_bitstring[i] = 1 + #print node_bitstring + + bs = to_binary(node_bitstring) + if bs in distr: + distr[bs] += 1 + else: + distr[bs] = 1 + +for k in distr: + bin_list = bin(k) + bin_num = sum([int(x) if x=='1' else 0 for x in bin_list[2:]]) + sys.stderr.write("%d %0175s %d \n" % (bin_num, bin_list[2:], distr[k])) diff --git a/models/nullmodels/model_MSM.py b/models/nullmodels/model_MSM.py new file mode 100644 index 0000000..2c30df5 --- /dev/null +++ b/models/nullmodels/model_MSM.py @@ -0,0 +1,65 @@ +#### +## +## +## Create a synthetic multiplex network in which a node $i$ appears at +## each layer $\alpha$ with a probability equal to $B_i$, which is the +## fraction of layers in which node $i$ participate in the original +## multiplex. +## +## Take a file of node binary participation indices, and sample a +## multiplex compatible with that distribution +## +## +## The input file is in the format: +## +## nodeID_i B_i +## +## The output file is a node-layer participation file, in the format +## +## node_id1 layer_id1 +## node_id2 layer_id2 +## ..... +## + +import sys + +import random + +if len(sys.argv) < 3: + print "Usage: %s " % sys.argv[0] + sys.exit(1) + +M = int(sys.argv[2]) + +bin_index = {} +node_ids = [] + +lines = open(sys.argv[1]).readlines() + + +for l in lines: + if l[0] == "#": + continue + elems = [int(x) for x in l.strip(" \n").split(" ")] + bin_index[elems[0]] = 1.0 * elems[1]/M + node_ids.append(elems[0]) + +N = len(node_ids) + +node_layers = {} + +for alpha in range (M): + for i in node_ids: + val = random.random() + if val < bin_index[i]: + if node_layers.has_key(i): + node_layers[i].append(alpha) + else: + node_layers[i] = [alpha] + + +for i in node_ids: + if node_layers.has_key(i): + for j in range(len(node_layers[i])): + print i, node_layers[i][j] + diff --git a/models/nullmodels/model_hypergeometric.py b/models/nullmodels/model_hypergeometric.py new file mode 100644 index 0000000..0a36237 --- /dev/null +++ b/models/nullmodels/model_hypergeometric.py @@ -0,0 +1,56 @@ +#### +## +## This is the hypergeometric model. Each layer has the same number of +## non-isolated nodes as the initial graph, but the nodes are +## activated at random. The input is a file of number of non-isolated +## nodes in each layer, and the total number of nodes in the multiplex. +## +## The output file is a node-layer participation file, in the format +## +## node_id1 layer_id1 +## node_id2 layer_id2 +## ..... +## + +import sys +import random + +if len(sys.argv) < 3: + print "Usage: %s " % sys.argv[0] + sys.exit(1) + +N = int(sys.argv[2]) + +layer_degs = [] +node_layers = {} + +lines = open(sys.argv[1]).readlines() + +M = 0 + + +for l in lines: + if l[0] == "#": + continue + n = [int(x) for x in l.strip(" \n").split(" ")][0] + layer_degs.append(n) + M += 1 + +for i in range(M): + num = layer_degs[i] + added = [] + n = 0 + while n < num: + j = random.choice(range(N)) + if j not in added: + n += 1 + added.append(j) + if node_layers.has_key(j): + node_layers[j].append(i) + else: + node_layers[j] = [i] + +for n in node_layers.keys(): + for i in node_layers[n]: + print n,i + diff --git a/models/nullmodels/model_layer_growth.py b/models/nullmodels/model_layer_growth.py new file mode 100644 index 0000000..46b4c0f --- /dev/null +++ b/models/nullmodels/model_layer_growth.py @@ -0,0 +1,121 @@ +#### +## +## layer-by-layer multiplex growth +## +## - We start from a multiplex with M_0 layers, with a certain number of +## active nodes each +## +## - Each new layer arrives with a certain number N\lay{\alpha} of nodes +## to be activated (this number is sampled from the observed distribution +## of N\lay{\alpha}, like in the airlines multiplex) +## +## - Each node $i$ is activated with a probability proportional to the +## number of existing layers in which it is already active, added to an +## attractivity A : +## +## P_i(t) \propto A + B_i(t) +## +## - the hope is that A might tune the exponent of the resulting distribution +## of B_i..... +## +## +## This script takes as input a file which contains the degrees of the +## layers, the total number of nodes in the multiplex, the initial +## number M0 of layers in the multiplex and the attractiveness +## parameter A. If "RND" is specified as a third parameter, then the +## sequence of N\lay{\alpha} is shuffled +## +## Gives as output a list of node-layer participation +## + +import sys +import random + +if len(sys.argv) < 5: + print "Usage: %s [RND]" % sys.argv[0] + sys.exit(1) + +N = int(sys.argv[2]) +M0 = int(sys.argv[3]) +A = int(sys.argv[4]) + +layer_degs = [] + + +if len(sys.argv) > 5 and sys.argv[5] == "RND": + randomize = True +else: + randomize = False + +lines = open(sys.argv[1]).readlines() + +M = 0 + + +for l in lines: + if l[0] == "#": + continue + n = [int(x) for x in l.strip(" \n").split(" ")][0] + layer_degs.append(n) + M += 1 + + +if randomize: + random.shuffle(layer_degs) + +## the list node_Bi contains, at each time, the attachment +## probabilities, i.e. it is a list which contains each node $i$ +## exactly $A + B_i$ times + +node_Bi = [] + +# +# initialize the distribution of attachment proibabilities, giving to +# all nodes an attachment probability equal to A +# + +for i in range(N): + for j in range(A): + node_Bi.append(i) + +layers = [] + + +for i in range(M0): + N_alpha = layer_degs.pop() + node_list = [] + num_nodes = 0 + while num_nodes < N_alpha: + val = random.choice(range(N)) + if val not in node_list: + node_list.append(val) + num_nodes += 1 + for n in node_list: + node_Bi.append(n) + layers.append(node_list) + i += 1 + + +#sys.exit(1) + +while i < M: + N_alpha = layer_degs.pop() + node_list = [] + num_nodes = 0 + while num_nodes < N_alpha: + val = random.choice(node_Bi) + if val not in node_list: + node_list.append(val) + num_nodes += 1 + for n in node_list: + node_Bi.append(n) + layers.append(node_list) + i += 1 + +#print layers + +for i in range(M): + node_list = layers[i] + for n in node_list: + print n, i + diff --git a/structure/activity/degs_to_activity_overlap.py b/structure/activity/degs_to_activity_overlap.py new file mode 100644 index 0000000..c96959b --- /dev/null +++ b/structure/activity/degs_to_activity_overlap.py @@ -0,0 +1,36 @@ +#### +## +## Take a file which contains, on the n-th line, the degrees at each +## layer of the n-th node, and print on output the corresponding node +## multi-activity (i.e., the number of layers in which the node is +## active) and the overlapping degree (i.e., the total number of edges +## incident on the node) +## +## + + +import sys + +def to_binary(l): + s = 0 + e = 0 + for v in l: + s += v * pow(2,e) + e +=1 + return s + +if len(sys.argv) < 2: + print "Usage: %s " % sys.argv[0] + sys.exit(1) + +distr = {} + +with open(sys.argv[1]) as f: + for l in f: + elems = [int(x) for x in l.strip(" \n").split(" ")] + ov = sum(elems) + new_list = [1 if x>0 else 0 for x in elems] + multi_act = sum(new_list) + if multi_act and ov: + print ov, multi_act + diff --git a/structure/activity/degs_to_binary.py b/structure/activity/degs_to_binary.py new file mode 100644 index 0000000..cb7aef5 --- /dev/null +++ b/structure/activity/degs_to_binary.py @@ -0,0 +1,45 @@ +#### +## +## Take a file which contains, on the n-th line, the degrees at each +## layer of the n-th node, and print on output the corresponding node +## participation bit-strings, i.e. the string which contains "1" if on +## that layer the node is connected, and zero otherwise +## +## on the stderr, we also dump the distribution of each bit-string +## + + +import sys + +def to_binary(l): + s = 0 + e = 0 + for v in l: + s += v * pow(2,e) + e +=1 + return s + +if len(sys.argv) < 2: + print "Usage: %s " % sys.argv[0] + sys.exit(1) + +distr = {} + +with open(sys.argv[1]) as f: + for l in f: + elems = [int(x) for x in l.strip(" \n").split(" ")] + new_list = [1 if x>0 else 0 for x in elems] + val = to_binary(new_list) + if val in distr: + distr[val] += 1 + else: + distr[val] = 1 + for i in new_list: + print i, + print + +for k in distr: + bin_list = bin(k) + bin_num = sum([int(x) if x=='1' else 0 for x in bin_list[2:]]) + sys.stderr.write("%d %028s %d \n" % (bin_num, bin_list[2:], distr[k])) + diff --git a/structure/activity/hamming_dist.py b/structure/activity/hamming_dist.py new file mode 100644 index 0000000..2a98e64 --- /dev/null +++ b/structure/activity/hamming_dist.py @@ -0,0 +1,41 @@ +#### +## +## Take as input the layers of a multiplex, and provide as output a +## file where the n-th line contains the activity of the n-th +## layer. +## +## + + +import sys + +if len(sys.argv) < 3: + print "Usage: %s [...]" % sys.argv[0] + sys.exit(1) + +max_N = -1 + +layers = [] + + +for layer in sys.argv[1:]: + active = [] + with open(layer, "r") as lines: + for l in lines: + if l[0] == "#": + continue + + s, d = [int(x) for x in l.strip(" \n").split(" ")[:2]] + if s > max_N: + max_N = s + if d > max_N: + max_N = d + active.extend([s,d]) + active = set(active) + layers.append(active) + +for i in range(len(layers)): + for j in range(i+1, len(layers)): + s = layer[i] ^ layer[j] + print i, j, len(s)*1.0 / min(len(layer[i]) + len(layer[j]), max_N+1) + diff --git a/structure/activity/layer_activity.py b/structure/activity/layer_activity.py new file mode 100644 index 0000000..bea0416 --- /dev/null +++ b/structure/activity/layer_activity.py @@ -0,0 +1,27 @@ +#### +## +## Take as input the layers of a multiplex, and provide as output a +## file where the n-th line contains the activity of the n-th +## layer. +## +## + + +import sys + +if len(sys.argv) < 2: + print "Usage: %s [...]" % sys.argv[0] + sys.exit(1) + + +for layer in sys.argv[1:]: + active = [] + with open(layer, "r") as lines: + for l in lines: + if l[0] == "#": + continue + + s, d = [int(x) for x in l.strip(" \n").split(" ")[:2]] + active.extend([s,d]) + active = set(active) + print len(active) diff --git a/structure/activity/layer_activity_vectors.py b/structure/activity/layer_activity_vectors.py new file mode 100644 index 0000000..f32418d --- /dev/null +++ b/structure/activity/layer_activity_vectors.py @@ -0,0 +1,44 @@ +#### +## +## Take as input the layers of a multiplex, and provide as output a +## file where the n-th line contains the activity of the n-th +## layer. +## +## + + +import sys + +if len(sys.argv) < 2: + print "Usage: %s [...]" % sys.argv[0] + sys.exit(1) + +max_N = -1 + +layers = [] + + +for layer in sys.argv[1:]: + active = [] + with open(layer, "r") as lines: + for l in lines: + if l[0] == "#": + continue + + s, d = [int(x) for x in l.strip(" \n").split(" ")[:2]] + if s > max_N: + max_N = s + if d > max_N: + max_N = d + active.extend([s,d]) + active = set(active) + layers.append(active) + +for l in layers: + for n in range(max_N+1): + if n in l: + print 1, + else: + print 0, + print + diff --git a/structure/activity/multiplexity.py b/structure/activity/multiplexity.py new file mode 100644 index 0000000..9e038c9 --- /dev/null +++ b/structure/activity/multiplexity.py @@ -0,0 +1,41 @@ +#### +## +## Take as input the layers of a multiplex, and provide as output a +## file where the n-th line contains the activity of the n-th +## layer. +## +## + + +import sys + +if len(sys.argv) < 3: + print "Usage: %s [...]" % sys.argv[0] + sys.exit(1) + +max_N = -1 + +layers = [] + + +for layer in sys.argv[1:]: + active = [] + with open(layer, "r") as lines: + for l in lines: + if l[0] == "#": + continue + + s, d = [int(x) for x in l.strip(" \n").split(" ")[:2]] + if s > max_N: + max_N = s + if d > max_N: + max_N = d + active.extend([s,d]) + active = set(active) + layers.append(active) + +for i in range(len(layers)): + for j in range(i+1, len(layers)): + s = layer[i] & layer[j] + print i, j, len(s)*1.0 / (max_N+1) + diff --git a/structure/activity/node_activity.py b/structure/activity/node_activity.py new file mode 100644 index 0000000..6410a68 --- /dev/null +++ b/structure/activity/node_activity.py @@ -0,0 +1,51 @@ +#### +## +## Take as input the layers of a multiplex, and provide as output a +## file where the n-th line contains the activity of the n-th node. We +## assume that nodes are numbered sequentially, starting from 0, with +## no gaps (i.e., missing nodes are treated as isolated nodes) +## +## +## + + +import sys + +if len(sys.argv) < 2: + print "Usage: %s [...]" % sys.argv[0] + sys.exit(1) + +node_activity = {} + +max_N = -1 + +for layer in sys.argv[1:]: + active = [] + with open(layer, "r") as lines: + for l in lines: + if l[0] == "#": + continue + + s, d = [int(x) for x in l.strip(" \n").split(" ")[:2]] + active.extend([s,d]) + if s > max_N: + max_N = s + if d > max_N: + max_N = d + active = set(active) + for n in active: + if n in node_activity: + node_activity[n] += 1 + else: + node_activity[n] = 1 + + +for n in range(max_N+1): + if n in node_activity: + print node_activity[n] + else: + print 0 + + + + diff --git a/structure/activity/node_activity_vectors.py b/structure/activity/node_activity_vectors.py new file mode 100644 index 0000000..9839334 --- /dev/null +++ b/structure/activity/node_activity_vectors.py @@ -0,0 +1,68 @@ +#### +## +## Take as input the layers of a multiplex, and provide as output a +## file where the n-th line contains the degrees of the n-th node at +## each layer, separated by a space, in the format: +## +## node1_deglay1 node1_deglay2 .... node1_deglayM +## node2_deglay1 node2_deglay2 .... node2_deglayM +## .............................................. +## nodeN_deglay1 nodeN_deglay2 .... nodeN_deglayM +## +## + +import sys + +if len(sys.argv) < 2: + print "Usage: %s [...]" % sys.argv[0] + sys.exit(1) + +node_degrees = {} + +max_N = -1 + +num_layer = 0 + +for layer in sys.argv[1:]: + with open(layer, "r") as lines: + for l in lines: + if l[0] == "#": + continue + + s, d = [int(x) for x in l.strip(" \n").split(" ")[:2]] + + if s > max_N: + max_N = s + if d > max_N: + max_N = d + + if s in node_degrees: + if num_layer in node_degrees[s]: + node_degrees[s][num_layer] += 1 + else: + node_degrees[s][num_layer] = 1 + else: + node_degrees[s] = {} + node_degrees[s][num_layer] = 1 + + if d in node_degrees: + if num_layer in node_degrees[d]: + node_degrees[d][num_layer] += 1 + else: + node_degrees[d][num_layer] = 1 + else: + node_degrees[d] = {} + node_degrees[d][num_layer] = 1 + num_layer += 1 + + +for n in range(max_N+1): + for i in range(num_layer): + if n in node_degrees: + if i in node_degrees[n]: + print 1, + else: + print 0, + else: + print 0, + print diff --git a/structure/activity/node_degree_vectors.py b/structure/activity/node_degree_vectors.py new file mode 100644 index 0000000..8863daa --- /dev/null +++ b/structure/activity/node_degree_vectors.py @@ -0,0 +1,68 @@ +#### +## +## Take as input the layers of a multiplex, and provide as output a +## file where the n-th line contains the degrees of the n-th node at +## each layer, separated by a space, in the format: +## +## node1_deglay1 node1_deglay2 .... node1_deglayM +## node2_deglay1 node2_deglay2 .... node2_deglayM +## .............................................. +## nodeN_deglay1 nodeN_deglay2 .... nodeN_deglayM +## +## + +import sys + +if len(sys.argv) < 2: + print "Usage: %s [...]" % sys.argv[0] + sys.exit(1) + +node_degrees = {} + +max_N = -1 + +num_layer = 0 + +for layer in sys.argv[1:]: + with open(layer, "r") as lines: + for l in lines: + if l[0] == "#": + continue + + s, d = [int(x) for x in l.strip(" \n").split(" ")[:2]] + + if s > max_N: + max_N = s + if d > max_N: + max_N = d + + if s in node_degrees: + if num_layer in node_degrees[s]: + node_degrees[s][num_layer] += 1 + else: + node_degrees[s][num_layer] = 1 + else: + node_degrees[s] = {} + node_degrees[s][num_layer] = 1 + + if d in node_degrees: + if num_layer in node_degrees[d]: + node_degrees[d][num_layer] += 1 + else: + node_degrees[d][num_layer] = 1 + else: + node_degrees[d] = {} + node_degrees[d][num_layer] = 1 + num_layer += 1 + + +for n in range(max_N+1): + for i in range(num_layer): + if n in node_degrees: + if i in node_degrees[n]: + print node_degrees[n][i], + else: + print 0, + else: + print 0, + print diff --git a/structure/correlations/Makefile b/structure/correlations/Makefile new file mode 100644 index 0000000..58301cb --- /dev/null +++ b/structure/correlations/Makefile @@ -0,0 +1,15 @@ +CFLAGS="-O3" +CC="gcc" +GSL_FLAGS=-lgsl -lgslcblas -lm +MFLAG=-lm + +all: dump_k_q fit_knn + +fit_knn: fit_knn.c fit_utils.c + $(CC) $(CFLAGS) -o fit_knn fit_knn.c fit_utils.c $(GSL_FLAGS) + +dump_k_q: dump_k_q.c rank_utils.c + $(CC) $(CFLAGS) -o dump_k_q dump_k_q.c rank_utils.c $(MFLAG) + +clean: + rm dump_k_q fit_knn diff --git a/structure/correlations/compute_pearson.py b/structure/correlations/compute_pearson.py new file mode 100644 index 0000000..e2c9055 --- /dev/null +++ b/structure/correlations/compute_pearson.py @@ -0,0 +1,33 @@ +#### +## +## Compute the pearson correlation coefficient between the values of +## node properties included in the two files provided as input. +## + +import sys +import numpy +import scipy.stats +import math + +if len(sys.argv) < 3: + print "Usage %s " % sys.argv[0] + sys.exit(1) + + +x1 = [] + +with open(sys.argv[1], "r") as lines: + for l in lines: + elem = [float(x) if "." in x or "e" in x else int(x) for x in l.strip(" \n").split()][0] + x1.append(elem) + +x2 = [] + +with open(sys.argv[2], "r") as lines: + for l in lines: + elem = [float(x) if "." in x or "e" in x else int(x) for x in l.strip(" \n").split()][0] + x2.append(elem) + + +r2 =numpy.corrcoef(x1,x2) +print r2[0][1] diff --git a/structure/correlations/compute_rho.py b/structure/correlations/compute_rho.py new file mode 100644 index 0000000..8fa4174 --- /dev/null +++ b/structure/correlations/compute_rho.py @@ -0,0 +1,118 @@ +#### +## +## Get two rankings and a pairing, and compute the corresponding +## Spearman's rho rank correlation coefficient +## +## +## +## + +import sys +import random +import math +#import scipy.stats + +## +## Compute the constant C of the Spearman's rho correlation coefficient in the draft +## +def compute_C(rank1, rank2): + N = len(rank1) + [mu1, mu2] = [1.0 * sum(x.values()) / len(x.values()) for x in [rank1, rank2]] + [sum1, sum2] = [1.0 * sum(x.values()) for x in [rank1, rank2]] + C = N * mu1 * mu2 - mu2 * sum1 - mu1 * sum2 + + #print mu1, mu2, sum1, sum2, C + + return C + + +## +## Compute the constant D of the Spearman's rho correlation coefficient in the draft +## +def compute_D(rank1, rank2): + [mu1, mu2] = [1.0 * sum(x.values()) / len(x.values()) for x in [rank1, rank2]] + s1 = sum([math.pow((x-mu1), 2) for x in rank1.values()]) + s2 = sum([math.pow((x-mu2), 2) for x in rank2.values()]) + + D = math.sqrt(s1 * s2) + return D + +def compute_rho(rank1, rank2, pairing, C, D): + + rho = 0 + for s,t in pairing: + rho += rank1[s] * rank2[t] + rho = (rho + C) / D + return rho + +if len(sys.argv) < 3: + print "Usage: %s []" % sys.argv[0] + sys.exit(1) + +rank1 = {} +rank2 = {} + +lines = open(sys.argv[1], "r").readlines() + +i = 0 +for l in lines: + if l[0] == "#" or l.strip(" \n").split(" ") == []: ## Strip comments and empty lines + continue + r = [float(x) if "." in x or "e" in x else int(x) for x in l.strip(" \n").split(" ")][0] + rank1[i] = r + i += 1 + + +lines = open(sys.argv[2], "r").readlines() + +i = 0 +for l in lines: + if l[0] == "#" or l.strip(" \n").split(" ") == []: ## Strip comments and empty lines + continue + r = [float(x) if "." in x or "e" in x else int(x) for x in l.strip(" \n").split(" ")][0] + rank2[i] = r + i += 1 + + +N1 = len(rank1) +N2 = len(rank2) + +if (N1 != N2): + print "The two files must have the same number of nodes!!!!!" + sys.exit(2) + + + +C = compute_C(rank1, rank2) +D = compute_D(rank1, rank2) + + +## We start from a random pairing, and compute the corresponding value of rho + +pairing = [] + +if len(sys.argv) > 3: + lines = open(sys.argv[3], "r").readlines() + + + + for l in lines: + if l[0] == "#" or l.strip(" \n").split(" ") == []: + continue + p1, p2 = [int(x) for x in l.strip(" \n").split(" ")][:2] + pairing.append((p1, p2)) + +else: + for i in range (N1): + pairing.append((i,i)) + + +if len(pairing) != N1: + print "ERROR !!! The pairing should be of the same length of the ranking files!!!" + sys.exit(1) + +rho = compute_rho(rank1, rank2, pairing, C, D) + +print rho + + diff --git a/structure/correlations/compute_tau.py b/structure/correlations/compute_tau.py new file mode 100644 index 0000000..3d1f804 --- /dev/null +++ b/structure/correlations/compute_tau.py @@ -0,0 +1,133 @@ +#### +## +## Take as input two files, whose n^th line contains the ranking of +## element n, and compute the Kendall's \tau_b rank correlation +## coefficient +## +## + +import sys +from numpy import * + + +def kendalltau(x,y): + initial_sort_with_lexsort = True # if True, ~30% slower (but faster under profiler!) but with better worst case (O(n log(n)) than (quick)sort (O(n^2)) + n = len(x) + temp = range(n) # support structure used by mergesort + # this closure recursively sorts sections of perm[] by comparing + # elements of y[perm[]] using temp[] as support + # returns the number of swaps required by an equivalent bubble sort + def mergesort(offs, length): + exchcnt = 0 + if length == 1: + return 0 + if length == 2: + if y[perm[offs]] <= y[perm[offs+1]]: + return 0 + t = perm[offs] + perm[offs] = perm[offs+1] + perm[offs+1] = t + return 1 + length0 = length / 2 + length1 = length - length0 + middle = offs + length0 + exchcnt += mergesort(offs, length0) + exchcnt += mergesort(middle, length1) + if y[perm[middle - 1]] < y[perm[middle]]: + return exchcnt + # merging + i = j = k = 0 + while j < length0 or k < length1: + if k >= length1 or (j < length0 and y[perm[offs + j]] <= y[perm[middle + k]]): + temp[i] = perm[offs + j] + d = i - j + j += 1 + else: + temp[i] = perm[middle + k] + d = (offs + i) - (middle + k) + k += 1 + if d > 0: + exchcnt += d; + i += 1 + perm[offs:offs+length] = temp[0:length] + return exchcnt + + # initial sort on values of x and, if tied, on values of y + if initial_sort_with_lexsort: + # sort implemented as mergesort, worst case: O(n log(n)) + perm = lexsort((y, x)) + else: + # sort implemented as quicksort, 30% faster but with worst case: O(n^2) + perm = range(n) + perm.sort(lambda a,b: cmp(x[a],x[b]) or cmp(y[a],y[b])) + + # compute joint ties + first = 0 + t = 0 + for i in xrange(1,n): + if x[perm[first]] != x[perm[i]] or y[perm[first]] != y[perm[i]]: + t += ((i - first) * (i - first - 1)) / 2 + first = i + t += ((n - first) * (n - first - 1)) / 2 + + # compute ties in x + first = 0 + u = 0 + for i in xrange(1,n): + if x[perm[first]] != x[perm[i]]: + u += ((i - first) * (i - first - 1)) / 2 + first = i + u += ((n - first) * (n - first - 1)) / 2 + + # count exchanges + exchanges = mergesort(0, n) + # compute ties in y after mergesort with counting + first = 0 + v = 0 + for i in xrange(1,n): + if y[perm[first]] != y[perm[i]]: + v += ((i - first) * (i - first - 1)) / 2 + first = i + v += ((n - first) * (n - first - 1)) / 2 + + tot = (n * (n - 1)) / 2 + if tot == u and tot == v: + return 1 # Special case for all ties in both ranks + + tau = ((tot-(v+u-t)) - 2.0 * exchanges) / (sqrt(float(( tot - u )) * float( tot - v ))) + + # what follows reproduces ending of Gary Strangman's original stats.kendalltau() in SciPy + svar = (4.0*n+10.0) / (9.0*n*(n-1)) + z = tau / sqrt(svar) + ##prob = erfc(abs(z)/1.4142136) + ##return tau, prob + return tau + +def main(): + + if len(sys.argv) < 3: + print "Usage: %s " % sys.argv[0] + sys.exit(1) + + x1 = [] + x2= [] + + lines = open(sys.argv[1]).readlines() + + for l in lines: + elem = [float(x) if "e" in x or "." in x else int(x) for x in l.strip(" \n").split()][0] + x1.append(elem) + + lines = open(sys.argv[2]).readlines() + + for l in lines: + elem = [float(x) if "e" in x or "." in x else int(x) for x in l.strip(" \n").split()][0] + x2.append(elem) + + + tau = kendalltau(x1,x2) + print tau + + +if __name__ == "__main__": + main() diff --git a/structure/correlations/dump_k_q.c b/structure/correlations/dump_k_q.c new file mode 100644 index 0000000..2b6ba79 --- /dev/null +++ b/structure/correlations/dump_k_q.c @@ -0,0 +1,50 @@ +/** + * + * Get the degree distributions of two layers and a pairing, and dump + * on output the pairs k-q + * + * + */ + +#include +#include + +void dump_k_q(double *R1, double *R2, int N, int *pairing){ + + int i; + + for (i=0; i \n", argv[0]); + exit(1); + } + + load_ranking(argv[1], &N1, &R1); + load_ranking(argv[2], &N2, &R2); + + if (N1 != N2){ + printf("Error!!!! The two files must have the same number of lines!!!! Exiting...\n"); + exit(1); + } + + pairing = malloc(N1 * sizeof(int)); + + load_pairing(&pairing, N1, argv[3]); + + dump_k_q(R1, R2, N1, pairing); + +} diff --git a/structure/correlations/fit_knn.c b/structure/correlations/fit_knn.c new file mode 100644 index 0000000..64fc4c3 --- /dev/null +++ b/structure/correlations/fit_knn.c @@ -0,0 +1,59 @@ +/** + * + * Take a file which contains pairs in the form: + * + * k q + * + * compute qnn(k) and fit this function with a power-law + * + * a*x^{b} + * + * The fit is actually performed as a linear fit on the + * exponential-binned log-log distribution + * + * + */ + + +#include +#include + +#include +#include "fit_utils.h" + + + +int main(int argc, char *argv[]){ + + double *k, *q, *x, *y; + int N, num; + double alpha; + + double c0, c1, cov00, cov01, cov11, sqsum; + + k=q=x=y=NULL; + + if (argc < 3){ + printf("%s \n", argv[0]); + exit(1); + } + + alpha=atof(argv[2]); + + fprintf(stderr,"Alpha: %g\n", alpha); + + load_sequence_col(argv[1], &k, &N, 0); + load_sequence_col(argv[1], &q, &N, 1); + //exit(1); + exp_bin_avg(k, q, N, alpha, &x, &y, &num); + //normalize_distr(x, y, num); + //dump_distr(x, y, num); + compact_distr(x, y, &num); + // dump_distr(x,y,num); + map_vec(x, num, log); + map_vec(y, num, log); + //dump_distr(x,y,num); + + gsl_fit_linear(x, 1, y, 1, num, &c0, &c1, &cov00, &cov01, &cov11, &sqsum); + fprintf(stderr, "a: %g b: %g\n", exp(c0), c1); +} diff --git a/structure/correlations/fit_utils.c b/structure/correlations/fit_utils.c new file mode 100644 index 0000000..e9e3954 --- /dev/null +++ b/structure/correlations/fit_utils.c @@ -0,0 +1,382 @@ +/** + * + * Fit a given sequence with a power-law function + * + * a*x^{b} + * + * The fit is actually performed as a linear fit on the + * exponential-binned log-log distribution + * + * + */ + + +#include +#include +#include + +#include + +/** + * + * Load a sequence from a file, which contains one element on each line + * + */ + +void load_sequence(char *fname, double **v, int *N){ + + int size; + char buff[256]; + + FILE *f; + + f = fopen(fname, "r"); + if (!f){ + fprintf(stderr, "Error opening file %s!!!! Exiting...\n", fname); + exit(1); + } + + *N =0; + size = 10; + if (*v == NULL) + *v = malloc(size * sizeof(double)); + else{ + *v = realloc(*v, size * sizeof(double)); + } + + while (fgets(buff, 255, f)){ + (*v)[*N] = atof(buff); + *N += 1; + if (*N == size){ + size += 10; + *v = realloc(*v, size * sizeof(double)); + } + } + *v = realloc(*v, (*N) * sizeof(double)); + fclose(f); +} + + +/** + * + * Load a sequence, getting the "col"-th column of the input file + * + */ + +void load_sequence_col(char *fname, double **v, int *N, int col){ + + int size, n; + char buff[256]; + char *ptr; + + FILE *f; + + f = fopen(fname, "r"); + if (!f){ + fprintf(stderr, "Error opening file %s!!!! Exiting...\n", fname); + exit(1); + } + + *N =0; + size = 10; + if (*v == NULL) + *v = malloc(size * sizeof(double)); + else{ + *v = realloc(*v, size * sizeof(double)); + } + + while (fgets(buff, 255, f)){ + ptr = strtok(buff, " "); + if (col > 0){ + n = 0; + while (n max_v) + max_v = v[i]; + else if (v[i] > 0 && v[i] < min_v) + min_v = v[i]; + } + + size = 10; + if (*x == NULL){ + *x = malloc(size * sizeof(double)); + } + else{ + *x = realloc(*x, size * sizeof(double)); + } + + val = min_v; + last_size = min_v; + (*x)[0] = min_v; + num_x = 1; + + while(val < max_v){ + new_size = last_size * alpha; + val = last_size + new_size; + last_size = new_size; + last_val = val; + (*x)[num_x] = val; + num_x += 1; + if (num_x == size){ + size += 10; + *x = realloc(*x, size * sizeof(double)); + } + } + + if (*y == NULL){ + *y = malloc(num_x * sizeof(double)); + } + else{ + *y = realloc(*y, num_x * sizeof(double)); + } + for (i=0; i < num_x; i++){ + (*y)[i] = 0; + } + + + + for(i=0; i (*x)[j]){ + j ++; + } + (*y)[j] += 1; + } + *num = num_x; +} + +/** + * + * Make the exponential binning of a distribution, with a giving + * exponent alpha. The value of y[i] is the average of the values in + * the vector "w" whose corresponding v lies between x[i-1] and x[i]... + * + */ + + +void exp_bin_avg(double *v, double *w, int N, double alpha, double **x, double **y, int *num){ + + double min_v, max_v, val, last_val; + int i, j, size, num_x; + double last_size, new_size; + int *cnt; + + + min_v = max_v = v[0]; + + for (i=1; i max_v) + max_v = v[i]; + else if (v[i] > 0 && v[i] < min_v) + min_v = v[i]; + } + + size = 10; + if (*x == NULL){ + *x = malloc(size * sizeof(double)); + } + else{ + *x = realloc(*x, size * sizeof(double)); + } + + val = min_v; + last_size = min_v; + (*x)[0] = min_v; + num_x = 1; + + while(val < max_v){ + new_size = last_size * alpha; + val = last_size + new_size; + last_size = new_size; + last_val = val; + (*x)[num_x] = val; + num_x += 1; + if (num_x == size){ + size += 10; + *x = realloc(*x, size * sizeof(double)); + } + } + + + cnt = malloc(num_x * sizeof(int)); + + if (*y == NULL){ + *y = malloc(num_x * sizeof(double)); + } + else{ + *y = realloc(*y, num_x * sizeof(double)); + } + for (i=0; i < num_x; i++){ + (*y)[i] = 0; + cnt[i] = 0; + } + + for(i=0; i (*x)[j]){ + j ++; + } + if(j == num_x){ + printf("Error!!!!! Trying to assing a non-existing bin!!! -- fit_utils.c:exp_bin_avg!!!\n"); + exit(37); + } + (*y)[j] += w[i]; + cnt[j] += 1; + } + *num = num_x; + + for(i=0; i< num_x; i++){ + if (cnt[i] > 0){ + (*y)[i] = (*y)[i] / cnt[i]; + } + } + free(cnt); +} + + +/** + * + * Print a distribution on stdout + * + */ + +void dump_distr(double *x, double *y, int N){ + int i; + + for(i=0; i 0 + * + */ + +void compact_distr(double *x, double *y, int *num){ + + int i, j; + + i = j = 0; + while(j < *num){ + while(j < *num && y[j] == 0){ + j ++; + } + if (j==*num){ + break; + } + x[i] = x[j]; + y[i] = y[j]; + i ++; + j ++; + } + *num = i; +} + + +/** + * + * Apply the function "f" on all the elemnts of a vector, in-place + * + */ + +void map_vec(double *v, int N, double (*f)(double)){ + int i; + + for (i=0; i" % sys.argv[0] + sys.exit(1) + +qnn_k = {} +knn_q = {} + +with open(sys.argv[1]) as f: + for l in f: + k, q = [int(x) for x in l.strip(" \n").split(" ")] + if qnn_k.has_key(k): + qnn_k[k].append(q) + else: + qnn_k[k] = [q] + if knn_q.has_key(q): + knn_q[q].append(k) + else: + knn_q[q] = [k] + + + + +keys= qnn_k.keys() +keys.sort() +for k in keys: + print k, 1.0 * sum(qnn_k[k])/len(qnn_k[k]) + + + + +keys= knn_q.keys() +keys.sort() +for q in keys: + sys.stderr.write("%d %f\n" % (q, 1.0 * sum(knn_q[q])/len(knn_q[q]))) + + diff --git a/structure/correlations/knn_q_from_layers.py b/structure/correlations/knn_q_from_layers.py new file mode 100644 index 0000000..c108c18 --- /dev/null +++ b/structure/correlations/knn_q_from_layers.py @@ -0,0 +1,98 @@ +#### +## +## +## Compute the degree-degree correlations of a multiplex graph, namely: +## +## (k_2) and (k_1) +## +## Takes as input the two lists of edges corresponding to each layer +## + +import sys +import numpy as np +import networkx as net + + +def knn(G, n): + neigh = G.neighbors(n) + l = G.degree(neigh).values() + return 1.0 * sum(l) / len(l) + + +if len(sys.argv) < 2: + print "Usage: %s " % sys.argv[0] + sys.exit(1) + + +G1 = net.read_edgelist(sys.argv[1]) +G2 = net.read_edgelist(sys.argv[2]) + +k1_k1 = {} ## Intraleyer knn (k1) +k2_k2 = {} ## Intralayer knn (k2) +k1_k2 = {} ## Interlayer average degree at layer 1 of a node having degree k_2 in layer 2 +k2_k1 = {} ## Interlayer average degree at layer 2 of a node having degree k_1 in layer 1 + + +for n in G1.nodes(): + k1 = G1.degree(n) + + + ##print k1,k2 + + knn1 = knn(G1, n) + if n in G2.nodes(): + k2 = G2.degree(n) + knn2 = knn(G2, n) + else: + k2 = 0 + knn2 = 0 + + if k1_k1.has_key(k1): + k1_k1[k1].append(knn1) + else: + k1_k1[k1] = [knn1] + + if k2_k2.has_key(k2): + k2_k2[k2].append(knn2) + else: + k2_k2[k2] = [knn2] + + + if k1_k2.has_key(k2): + k1_k2[k2].append(k1) + else: + k1_k2[k2] = [k1] + + if k2_k1.has_key(k1): + k2_k1[k1].append(k2) + else: + k2_k1[k1] = [k2] + + +k1_keys = k1_k1.keys() +k1_keys.sort() +k2_keys = k2_k2.keys() +k2_keys.sort() + + +f = open("%s_%s_k1" % (sys.argv[1], sys.argv[2]), "w+") + +for n in k1_keys: + avg_knn = np.mean(k1_k1[n]) + std_knn = np.std(k1_k1[n]) + avg_k2 = np.mean(k2_k1[n]) + std_k2 = np.std(k2_k1[n]) + f.write("%d %f %f %f %f\n" % (n, avg_knn, std_knn, avg_k2, std_k2)) + +f.close() + +f = open("%s_%s_k2" % (sys.argv[1], sys.argv[2]), "w+") + +for n in k2_keys: + avg_knn = np.mean(k2_k2[n]) + std_knn = np.std(k2_k2[n]) + avg_k1 = np.mean(k1_k2[n]) + std_k1 = np.std(k1_k2[n]) + f.write("%d %f %f %f %f\n" % (n, avg_knn, std_knn, avg_k1, std_k1)) +f.close() + diff --git a/structure/correlations/rank_nodes.py b/structure/correlations/rank_nodes.py new file mode 100644 index 0000000..6985e88 --- /dev/null +++ b/structure/correlations/rank_nodes.py @@ -0,0 +1,74 @@ +#### +## +## +## Get a file as input, whose n-th line corresponds to the value of a +## certain property of node n, and rank nodes according to their +## properties, taking into account ranking ties properly. +## +## The output is a file whose n-th line is the "ranking" of the n-th +## node according to the given property. (notice that rankings could +## be fractional, due to the tie removal algorithm) +## +## + + +import sys +import math + + +if len(sys.argv) < 2: + print "Usage: %s " % sys.argv[0] + sys.exit(1) + + + +lines = open(sys.argv[1], "r").readlines() + +ranking = [] + +n=0 +for l in lines: + if l[0] == "#" or l.strip(" \n").split(" ") == []: + continue + v = [float(x) if "." in x or "e" in x else int(x) for x in l.strip(" \n").split(" ")][0] + ranking.append((v,n)) + n +=1 + +ranking.sort(reverse=True) +#print ranking +new_ranking = {} + +v0, n0 = ranking[0] + +old_value = v0 +tot_rankings = 1 + +stack = [n0] +l=1.0 +for v,n in ranking[1:]: + l += 1 + ##print stack, tot_rankings + if v != old_value: ### There is a new rank + # We first compute the rank for all the nodes in the stack and then we set it + new_rank_value = 1.0 * tot_rankings / len(stack) + ##print new_rank_value + for j in stack: + new_ranking[j] = new_rank_value + old_value = v + tot_rankings = l + stack = [n] + else: # One more value with the same rank, keep it for the future + stack.append(n) + tot_rankings += l + +new_rank_value = 1.0 * tot_rankings / len(stack) +#print new_rank_value +for j in stack: + new_ranking[j] = new_rank_value + +#print new_ranking + +keys = new_ranking.keys() +keys.sort() +for k in keys: + print new_ranking[k] diff --git a/structure/correlations/rank_nodes_thresh.py b/structure/correlations/rank_nodes_thresh.py new file mode 100644 index 0000000..44b565a --- /dev/null +++ b/structure/correlations/rank_nodes_thresh.py @@ -0,0 +1,87 @@ +#### +## +## +## Get a file as input, whose n-th line corresponds to the value of a +## certain property of node n, and rank nodes according to their +## properties, taking into account ranking ties properly. +## +## The output is a file whose n-th line is the "ranking" of the n-th +## node according to the given property. (notice that rankings could +## be fractional, due to the tie removal algorithm) +## +## The rank of a node is set to "0" (ZERO) if the corresponding +## property is smaller than a value given as second parameter +## + + +import sys +import math + + +if len(sys.argv) < 3: + print "Usage: %s " % sys.argv[0] + sys.exit(1) + + +thresh = float(sys.argv[2]) + +lines = open(sys.argv[1], "r").readlines() + +ranking = [] + +n=0 +for l in lines: + if l[0] == "#" or l.strip(" \n").split(" ") == []: + continue + v = [float(x) if "." in x or "e" in x else int(x) for x in l.strip(" \n").split(" ")][0] + if v >= thresh: + ranking.append((v,n)) + else: + ranking.append((0,n)) + n +=1 + +ranking.sort(reverse=True) +#print ranking +new_ranking = {} + +v0, n0 = ranking[0] + + +old_value = v0 +tot_rankings = 1 + +stack = [n0] +l=1.0 +for v,n in ranking[1:]: + l += 1 + ##print stack, tot_rankings + if v != old_value: ### There is a new rank + # We first compute the rank for all the nodes in the stack and then we set it + if old_value == 0: + new_rank_value = 0 + else: + new_rank_value = 1.0 * tot_rankings / len(stack) + ##print new_rank_value + for j in stack: + new_ranking[j] = new_rank_value + old_value = v + tot_rankings = l + stack = [n] + else: # One more value with the same rank, keep it for the future + stack.append(n) + tot_rankings += l + +if v == 0 : + new_rank_value = 0 +else: + new_rank_value = 1.0 * tot_rankings / len(stack) +#print new_rank_value +for j in stack: + new_ranking[j] = new_rank_value + +#print new_ranking + +keys = new_ranking.keys() +keys.sort() +for k in keys: + print new_ranking[k] diff --git a/structure/correlations/rank_occurrence.py b/structure/correlations/rank_occurrence.py new file mode 100644 index 0000000..6339d5d --- /dev/null +++ b/structure/correlations/rank_occurrence.py @@ -0,0 +1,45 @@ +#### +## +## Get two rankings and compute the size of the k-intersection, +## i.e. the number of elements which are present in the first k +## positions of both rankings, as a function of k +## +## + + +import sys + + +if len(sys.argv)< 4: + print "Usage: %s " % sys.argv[0] + sys.exit(1) + +incr = int(sys.argv[3]) + +rank1 = [] +rank2 = [] + +lines = open(sys.argv[1], "r").readlines() + +for l in lines: + n= l.strip(" \n").split(" ")[0] + rank1.append(n) + +lines = open(sys.argv[2], "r").readlines() + +for l in lines: + n= l.strip(" \n").split(" ")[0] + rank2.append(n) + + +N = len(rank1) + +i = incr + +while i < N+incr: + l = len(set(rank1[:i]) & set(rank2[:i])) + print i, l + i += incr + + + diff --git a/structure/correlations/rank_utils.c b/structure/correlations/rank_utils.c new file mode 100644 index 0000000..4b8ef41 --- /dev/null +++ b/structure/correlations/rank_utils.c @@ -0,0 +1,217 @@ +/** + * + * Some utility functions to be used with tune_rho, compute_rho and + * the like + * + */ + + +#include +#include +#include +#include +#include + +#include "rank_utils.h" + +void load_ranking(char *fname, int *N, double **R){ + + char buff[256]; + int size = 10; + FILE *f; + + if (*R == NULL){ + *R = malloc(size * sizeof (double)); + } + f = fopen(fname, "r"); + if (!f){ + printf("Unable to open file: %s!!! Exiting\n"); + exit(1); + } + + *N = 0; + + while (fgets(buff, 255, f)){ + if (* N == size){ + size += 10; + *R = realloc(*R, size * sizeof(double)); + } + (*R)[*N] = atof(buff); + *N += 1; + } +} + +double avg_array(double *v, int N){ + + double sum = 0.0; + int i; + + for (i = 0; i < N; i ++){ + sum += v[i]; + } + return sum/N; +} + +double compute_C(double *R1, double *R2, int N){ + double mu1, mu2, sum1, sum2; + + mu1 = avg_array(R1, N); + mu2 = avg_array(R2, N); + + sum1 = mu1 * N; + sum2 = mu2 * N; + + return N * mu1 * mu2 - mu2 * sum1 - mu1 * sum2; +} + + +double compute_D(double *R1, double *R2, int N){ + + double mu1, mu2, s1, s2; + int i; + + mu1 = avg_array(R1, N); + mu2 = avg_array(R1, N); + + s1 = s2 = 0.0; + + for (i=0 ; i < N; i ++){ + s1 += pow((R1[i] - mu1), 2); + s2 += pow((R2[i] - mu2), 2); + } + + return sqrt(s1 * s2); +} + + +double compute_rho(double *R1, double *R2, int N, int *pairing){ + + double rho = 0; + int i; + + for (i=0; i < N; i ++){ + rho += R1[i] * R2[ pairing[i] ]; + } + + rho = (rho + compute_C(R1, R2, N))/ compute_D(R1, R2, N); + return rho; +} + +void dump_ranking(double *R, int N){ + int i; + + for (i=0; i < N; i ++){ + printf("%d: %f\n", i, R[i] ); + } +} + + +void init_pairing_natural(int *pairing, int N){ + int i; + + for (i = 0; i< N; i ++){ + pairing[i] = i; + } +} + +void init_pairing_inverse(int *pairing, int N){ + int i; + + for (i = 0; i< N; i ++){ + pairing[i] = N-i-1; + } +} + +void select_pairing(int *pairing, int N, int argc, char *argv[], int pos){ + + if (argc < pos + 1 || !strncasecmp("rnd", argv[pos], 3)){ + init_pairing_random(pairing, N); + } + else if (!strncasecmp("nat", argv[pos], 3)){ + init_pairing_natural(pairing, N); + } + else if (!strncasecmp("inv", argv[pos], 3)){ + init_pairing_inverse(pairing, N); + } + else{ + printf ("Pairing strategy \"%s\" unknown!!! Exiting...\n", argv[pos]); + exit(1); + } + +} + + +void shuffle_sequence(int *s, int N){ + + int i, j, tmp; + + for (i=N-1; i>=0; i--){ + j = rand() % (i+1); + tmp = s[j]; + s[j] = s[i]; + s[i] = tmp; + } +} + + + +void init_pairing_random(int *pairing, int N){ + + init_pairing_natural(pairing, N); + shuffle_sequence(pairing, N); + +} + +/* Loads a pairing from a file, in the format: + * + * rank1 rank2 + * ........... + */ +void load_pairing(int **pairing, int N, char *fname){ + + FILE *f; + int i, j, num; + char buff[256]; + char *ptr; + + f = fopen(fname, "r"); + if (!f){ + printf("Error opening file \"%s\"!!!! Exiting....\n", fname); + exit(2); + } + + if (*pairing == NULL){ + *pairing = malloc(N * sizeof(int)); + init_pairing_natural(*pairing, N); + } + + num = 0; + while(num < N){ + fgets(buff, 255, f); + if (buff[0] == '#') + continue; + ptr = strtok(buff, " "); /* read the first node */ + i = atoi(ptr); + ptr = strtok(NULL, " "); /* read the second node */ + j = atoi(ptr); + (*pairing)[i] = j; + num += 1; + } +} + + +void dump_pairing(int *pairing, int N){ + int i; + + for(i=0; i< N; i ++){ + printf("%d %d\n", i, pairing[i]); + } +} + +void copy_pairing(int *p1, int *p2, int N){ + int i; + + for (i=0 ; i < N; i ++){ + p2[i] = p1[i]; + } +} diff --git a/structure/correlations/rank_utils.h b/structure/correlations/rank_utils.h new file mode 100644 index 0000000..521582a --- /dev/null +++ b/structure/correlations/rank_utils.h @@ -0,0 +1,44 @@ +#ifndef __RANK_UTILS_H__ +#define __RANK_UTILS_H__ + +/* Load a ranking */ +void load_ranking(char *fname, int *N, double **R); + +/* Compute the average of an array */ +double avg_array(double *v, int N); + +/* Compute the term "C" in the rho correlation coefficient */ +double compute_C(double *R1, double *R2, int N); + +/* Compute the term "D" in the rho correlation coefficient */ +double compute_D(double *R1, double *R2, int N); + +/* Compute the Spearman's rank correlation coefficient \rho */ +double compute_rho(double *R1, double *R2, int N, int *pairing); + +void dump_ranking(double *R, int N); + +void init_pairing_natural(int *pairing, int N); + +void init_pairing_inverse(int *pairing, int N); + +void init_pairing_random(int *pairing, int N); + +void select_pairing(int *pairing, int N, int argc, char *argv[], int pos); + +void shuffle_sequence(int *s, int N); + +void dump_pairing(int *pairing, int N); + +void copy_pairing(int *pairing1, int *pairing2, int N); + + +#endif /* __RANK_UTILS_H__ */ + + + + + + + + diff --git a/structure/metrics/aggregate_layers_w.py b/structure/metrics/aggregate_layers_w.py new file mode 100644 index 0000000..cd5ea1d --- /dev/null +++ b/structure/metrics/aggregate_layers_w.py @@ -0,0 +1,37 @@ +#### +## +## Aggregate the layers of a multiplex, weigthing each edge according +## to the number of times it occurs in the different layers +## + +import sys +import networkx as net + + +if len(sys.argv) < 3: + print "Usage: %s [....]" % sys.argv(0) + sys.exit(1) + +G = net.Graph() + +lines = open(sys.argv[1], "r").readlines() + +for l in lines: + s,d = [int(x) for x in l.strip(" \n").split(" ")[:2]] + G.add_edge(s,d) + G[s][d]['weigth'] = 1 + +for f in sys.argv[2:]: + lines = open(f, "r").readlines() + for l in lines: + s,d = [int(x) for x in l.strip(" \n").split(" ")[:2]] + if (G.has_edge(s,d)): + G[s][d]['weigth'] += 1 + else: + G.add_edge(s,d) + G[s][d]['weigth'] = 1 + +for s,d in G.edges(): + print s,d, G[s][d]['weigth'] + + diff --git a/structure/metrics/avg_edge_overlap.py b/structure/metrics/avg_edge_overlap.py new file mode 100644 index 0000000..e68fd8b --- /dev/null +++ b/structure/metrics/avg_edge_overlap.py @@ -0,0 +1,47 @@ +#### +## +## Compute the average edge overlap of a multiplex, i.e. the average +## number of layers in which an edge is present +## +## + +import sys + + +if len(sys.argv) < 2: + print "Usage: %s [...]" % sys.argv[0] + sys.exit(1) + +max_N = -1 + +all_edges = {} + +layer_ID = -1 + +for layer in sys.argv[1:]: + layer_ID += 1 + with open(layer, "r") as lines: + for l in lines: + if l[0] == "#": + continue + s, d = [int(x) for x in l.strip(" \n").split(" ")[:2]] + if s > d: + tmp = s + s = d + d = tmp + if (s,d) in all_edges: + all_edges[(s,d)].append(layer_ID) + else: + all_edges[(s,d)] = [layer_ID] + +K = len(all_edges.keys()) +M = len(sys.argv) - 1 + +numer = 0 + +for k in all_edges.keys(): + numer += len(set(all_edges[(k)])) + + +print 1.0 * numer / K, 1.0 * numer / (K * M) + diff --git a/structure/metrics/cartography_from_columns.py b/structure/metrics/cartography_from_columns.py new file mode 100644 index 0000000..a2343ed --- /dev/null +++ b/structure/metrics/cartography_from_columns.py @@ -0,0 +1,44 @@ +#### +## +## Make a cartography (i.e., sum and participation coefficient) based +## on the values found at the given column numbers of the file given +## as input, e.g.: +## +## cartography_cols.py FILEIN 1 5 8 14 +## +## makes the assumption that the system has 4 layers, and that the +## quantities involved in the cartography are at the 2nd, 6th, 9th and +## 15th column of FILEIN +## +## +## + +import sys + +if len(sys.argv) < 4: + print "Usage: %s [ ...]" % sys.argv[0] + sys.exit(1) + +filein=sys.argv[1] +cols = [int(x) for x in sys.argv[2:]] + +M = len(cols) + +with open(filein,"r") as f: + for l in f: + if l[0] == "#": + continue + elems = [float(x) if "e" in x or "." in x else int(x) for x in l.strip(" \n").split(" ")] + sum_elems = 0 + part = 0 + for c in cols: + val = elems[c] + sum_elems += val + part += val*val + if sum_elems > 0: + part = M * 1.0 / (M -1) * (1 - part * 1.0 / (sum_elems * sum_elems)) + else: + part = 0.0 + print elems[0], sum_elems, part + + diff --git a/structure/metrics/cartography_from_deg_vectors.py b/structure/metrics/cartography_from_deg_vectors.py new file mode 100644 index 0000000..c40d701 --- /dev/null +++ b/structure/metrics/cartography_from_deg_vectors.py @@ -0,0 +1,37 @@ +#### +## +## Take as input a file containing, on each line, the degree vector of +## a node of the multiplex, and compute the multiplex cartography +## diagram +## +## + +import sys + +if len(sys.argv) < 2: + print "Usage: %s " % sys.argv[0] + sys.exit(1) + +filein=sys.argv[1] + +M = -1 + +with open(filein,"r") as lines: + for l in lines: + if l[0] == "#": + continue + elems = [int(x) for x in l.strip(" \n").split(" ")] + if (M == -1): + M = len(elems) + sum_elems = 0 + part = 0 + for val in elems: + sum_elems += val + part += val*val + if sum_elems > 0: + part = M * 1.0 / (M -1) * (1 - part * 1.0 / (sum_elems * sum_elems)) + else: + part = 0.0 + print sum_elems, part + + diff --git a/structure/metrics/cartography_from_layers.py b/structure/metrics/cartography_from_layers.py new file mode 100644 index 0000000..b9c4584 --- /dev/null +++ b/structure/metrics/cartography_from_layers.py @@ -0,0 +1,54 @@ +#### +## +## Compute the participation coefficient of each node of a multiplex +## +## + +import sys +import networkx as net +import collections +from compiler.ast import flatten + + + +if len(sys.argv) < 3: + print "Usage: %s [...]" % sys.argv[0] + sys.exit(1) + + +layers = [] + +for f in sys.argv[1:]: + G = net.Graph(net.read_edgelist(f, nodetype=int)) + layers.append(G) + +nodes = flatten([x for j in layers for x in j.nodes()]) +#nodes.sort() +nodes = set(nodes) + +M = len(layers) + +#print nodes + +for n in nodes: + deg_alpha_square = 0 + deg = 0 + col = 0 + print n, + for l in layers: + val = l.degree([n]) + if not val: + col = 2* col + continue + col *= 2 + col += 1 + val = val[n] + deg += val + deg_alpha_square += val*val + if deg > 0: + print deg, 1.0 * M / (M-1) * (1.0 - 1.0 * deg_alpha_square/(deg * deg)) , col + else: + print 0 , 0, col + + + diff --git a/structure/metrics/edge_overlap.py b/structure/metrics/edge_overlap.py new file mode 100644 index 0000000..1b27f55 --- /dev/null +++ b/structure/metrics/edge_overlap.py @@ -0,0 +1,43 @@ +#### +## +## Compute the edge overlap of each edge of the multiplex, i.e. the +## number of times that each edge appears in the multiplex +## +## + +import sys + + +if len(sys.argv) < 2: + print "Usage: %s [...]" % sys.argv[0] + sys.exit(1) + +max_N = -1 + +all_edges = {} + +layer_ID = -1 + +for layer in sys.argv[1:]: + layer_ID += 1 + with open(layer, "r") as lines: + for l in lines: + if l[0] == "#": + continue + s, d = [int(x) for x in l.strip(" \n").split(" ")[:2]] + if s > d: + tmp = s + s = d + d = tmp + if (s,d) in all_edges: + all_edges[(s,d)].append(layer_ID) + else: + all_edges[(s,d)] = [layer_ID] + +K = len(all_edges.keys()) + +for k in all_edges.keys(): + val = len(set(all_edges[(k)])) + s,d = k + print s, d, val + diff --git a/structure/metrics/intersect_layers.py b/structure/metrics/intersect_layers.py new file mode 100644 index 0000000..a9da00c --- /dev/null +++ b/structure/metrics/intersect_layers.py @@ -0,0 +1,47 @@ +#### +## +## Take a certain number of networks as input and give as output the +## corresponding intersection graph, i.e. the graph in which an edge +## exists between i and j if and only if it exists in ALL the graphs +## given as input +## + + +import sys + + +if len(sys.argv)< 3: + print "Usage: %s [....]" % sys.argv[0] + sys.exit(1) + + +graphs = {} + +num = 0 + +for fname in sys.argv[1:]: + + lines = open(fname).readlines() + graphs[num] = [] + for l in lines: + s,d = [int(x) for x in l.strip(" \n").split(" ")][:2] + if s > d: + graphs[num].append((d,s)) + else: + graphs[num].append((d,s)) + num += 1 + +#print graphs + + +for edge in graphs[0]: + to_print = True + for i in range(1, num): + if edge not in graphs[i]: + to_print = False + break + if to_print: + s,d = edge + print s,d + + diff --git a/structure/metrics/overlap_degree.py b/structure/metrics/overlap_degree.py new file mode 100644 index 0000000..fa69434 --- /dev/null +++ b/structure/metrics/overlap_degree.py @@ -0,0 +1,47 @@ +#### +## +## Compute the overlapping degree for each node and the corresponding +## z-score +## +## + +import sys +import numpy + + +if len(sys.argv) < 2: + print "Usage: %s [...]" % sys.argv[0] + sys.exit(1) + + +nodes = {} + +for f in sys.argv[1:]: + + lines = open(f).readlines() + + for l in lines: + if l[0] == "#": + continue + s,d = [int(x) for x in l.strip(" \n").split(" ")] + if nodes.has_key(s): + nodes[s] +=1 + else: + nodes[s] = 1 + if nodes.has_key(d): + nodes[d] +=1 + else: + nodes[d] = 1 + + +degrees = nodes.values() +avg_deg = numpy.mean(degrees) +std_deg = numpy.std(degrees) + +#print avg_deg, std_deg + +keys = nodes.keys() +keys.sort() + +for n in keys: + print n, nodes[n], (nodes[n] - avg_deg)/std_deg diff --git a/structure/reinforcement/reinforcement.py b/structure/reinforcement/reinforcement.py new file mode 100644 index 0000000..5939e59 --- /dev/null +++ b/structure/reinforcement/reinforcement.py @@ -0,0 +1,61 @@ +import networkx as nx +import sys + + +if __name__ == "__main__": + + + if len(sys.argv) < 6: + print "Usage: %s " % sys.argv[0] + sys.exit(1) + + + filename_a = sys.argv[1] + filename_b = sys.argv[2] + + intervals=int(sys.argv[3]) + minvalue=float(sys.argv[4]) + maxvalue=float(sys.argv[5]) + + + tot_a = [] + pos_a = [] + for t in range (intervals): + tot_a.append(0) + pos_a.append(0) + + + + + fa=open(filename_a, 'r') + Ga=nx.read_adjlist(fa) + + + fb=open(filename_b, 'r') + Gb=nx.read_weighted_edgelist(fb) + + + + + for u,v in Gb.edges(): + Gbw=Gb[u][v]['weight'] + for i in range (intervals): + a=minvalue+float(maxvalue-minvalue)*float(i)/intervals + b=minvalue+float(maxvalue-minvalue)*float(i+1)/intervals + if (Gbw>a and Gbw0): + freq_a.append(float(pos_a[i])/tot_a[i]) + else: + freq_a.append(0) + print "#bin_minvalue bin_maxvalue frequence" + for i in range (intervals): + a=minvalue+float(maxvalue-minvalue)*float(i)/intervals + b=minvalue+float(maxvalue-minvalue)*float(i+1)/intervals + print a, b, freq_a[i] -- cgit v1.2.3