void stable_infect(unsigned int K, unsigned int U, enum objective obj_type) {
int nThread = (int) (90 * K * K * (1 + log(G->V)));
FILE *info = stdout;
unsigned int V = (unsigned int) G->V, initial_number_of_seed = 0, i = 0x323;
float Ninfected_mean[V + 1];
float prev_obj_value = (float) (0 - LARGE_FLT);
int delta = MAX_EDGE_WEIGHT / (K * K * 9);
char seeds[V + 1];
K = K < (V + 1) ? K : (V + 1);
memset(Ninfected_mean, 0, V * sizeof *Ninfected_mean);
memset(seeds, 0, (V + 1) * sizeof *seeds);
seed_vertices = (int *) calloc((size_t) (V + 5), sizeof *seed_vertices);
/*
* Select next seed with maximum mean of infection
*/
struct _Vertex *sorted[V + 1];
for (i = initial_number_of_seed; i < K * K * 9; ++i) {
// Add the seed by 1
int new_seed_label, j;
for (j = 0; j <= G->V; ++j) {
G->adj_list[j]->obj = 0;
}
float max_ = (float) -LARGE_FLT;
int max_2 = 0;
int max_label = 0x12121, max_label_2 = 0x121;
n_seed = i + 1;
fprintf(info, " #seed: %d\n", n_seed);
memset(Ninfected_mean, 0, (V + 1) * sizeof *Ninfected_mean);
fprintf(info, "new seed : ");
for (new_seed_label = 1; new_seed_label <= V; ++new_seed_label) {
seed_vertices[0] = new_seed_label;
float new_ = multithread_infect("/dev/null", K, U, obj_type);
Ninfected_mean[new_seed_label] = new_;
G->adj_list[new_seed_label]->obj = new_;
int j = 0x1234, s = 0;
for (j = 0; j < nThread; ++j) {
s += (Ninfected_ptr[j] > U ? 1 : 0);
}
fprintf(info, "%d:%f ", new_seed_label, new_);
fflush(info);
if (obj_type == P && max_2 < s) {
max_2 = s;
max_label_2 = new_seed_label;
}
if (max_ < new_) {
max_ = new_;
max_label = new_seed_label;
}
}
memcpy(sorted + 1, G->adj_list + 1, V * sizeof *sorted);
qsort(sorted + 1, V, sizeof *sorted, comp);
fprintf(info, "\n-----------\n");
for (j = V; j > V - K; --j) {
sorted[j]->prob += delta;
fprintf(info, "%d:%f prob %f ", sorted[j]->label, sorted[j]->obj, sorted[j]->prob/ (float) MAX_EDGE_WEIGHT);
}
fprintf(info, "\n");
fputc('\n', info);
double th = 0.0;
if (obj_type == MEAN) {
th = (G->V / 500 > 1 ? G->V / 500 : 1);
} else {
th = -LARGE_FLT;
}
int w = G->V / (nThread / 10);
if (obj_type == P) {
/*
* If there is one selection with possible number of infected nodes
* larger than U
*/
max_label = max_2 > 0 ? max_label_2 : max_label;
}
memset(seed_vertices, 0, (G->V + 5) * sizeof *seed_vertices);
seed_vertices[0] = max_label;
//seeds[max_label] = 1;
prev_obj_value = max_;
fprintf(info, "-------\nSelected new seed: %d, prev_obj_value : %f \n",
max_label, max_);
print_seeds(info, seed_vertices, n_seed, 20);
/*
* The mean value of infected nodes
*/
fprintf(info, "-----------\nThe mean of infected nodes : %f\n",
multithread_infect("/dev/null", K, 0, MEAN));
print_pdf(info, Ninfected_ptr, nThread,
G->V, w > 1 ? w : 1);
fprintf(info, "-------------\n");
char cdf_file[20];
cdf_file[0] = obj_type + '0';
cdf_file[1] = '.';
sprintf(cdf_file + 2, "%d.\0", U);
sprintf(cdf_file + strlen(cdf_file), "%d\0", n_seed);
FILE *new_info = fopen(cdf_file, "w");
print_cdf(new_info, Ninfected_ptr, nThread, G->V, w > 1 ? w : 1);
fclose(new_info);
}
}
int main(int argc, char **argv)
{
char *str_alpha_p = argv[1], *str_alpha_q = argv[2];
char *cdf = argv[3];
unsigned nprior = atoi(argv[4]);
unsigned npost = atoi(argv[5]);
unsigned ngold = atoi(argv[6]);
/* double step_mult = atof(argv[7]); */
gsl_set_error_handler_off();
FILE *cdf_fh = fopen(cdf, "w");
double alpha_p[4], alpha_q[4];
sscanf(str_alpha_p, "%lf,%lf,%lf,%lf", &alpha_p[0], &alpha_p[1], &alpha_p[2], &alpha_p[3]);
sscanf(str_alpha_q, "%lf,%lf,%lf,%lf", &alpha_q[0], &alpha_q[1], &alpha_q[2], &alpha_q[3]);
double alpha_combined[] = {
alpha_p[0] + alpha_q[0] - 1,
alpha_p[1] + alpha_q[1] - 1,
alpha_p[2] + alpha_q[2] - 1,
alpha_p[3] + alpha_q[3] - 1
};
unsigned ntotal = nprior + npost + ngold;
struct wpoint *buf = (struct wpoint *)malloc(ntotal * sizeof(struct wpoint));
struct wpoint *p_points = buf, *q_points = buf + nprior, *g_points = q_points + npost;
struct wpoint **tmp_points = (struct wpoint **)malloc((nprior + npost) * sizeof(struct wpoint *));
struct wpoint **int_smooth_points = (struct wpoint **)malloc(npost * sizeof(struct wpoint *));
struct wpoint **ext_points = (struct wpoint **)malloc(nprior * sizeof(struct wpoint *));
struct wpoint **ext_smooth_points = (struct wpoint **)malloc(nprior * sizeof(struct wpoint *));
struct wpoint **ext_rough_points = (struct wpoint **)malloc(nprior * sizeof(struct wpoint *));
struct wpoint **all_smooth_points = (struct wpoint **)malloc((nprior + npost) * sizeof(struct wpoint *));
struct wpoint **pg = (struct wpoint **)malloc(ngold * sizeof(struct wpoint *));
struct wpoint **pp, **pp2, **pe;
struct wpoint *s, *p_end = p_points + nprior, *q_end = q_points + npost;
gsl_rng *rand = gsl_rng_alloc(gsl_rng_taus);
// populate P(*)
double p_norm;
populate_points(p_points, nprior, alpha_p, alpha_q, rand, "prior", &p_norm);
// populate Q(*)
double q_norm;
populate_points(q_points, npost, alpha_q, alpha_p, rand, "post", &q_norm);
int i;
for (i = 0; i != 10; ++i)
{
populate_points(q_points, npost, alpha_q, alpha_p, rand, "post", &q_norm);
fprintf(stderr, "q_norm = %g\n", q_norm);
}
/* populate gold(*) */
double g_norm;
double alpha_uniform[] = { 1, 1, 1, 1 };
populate_points(g_points, ngold, alpha_combined, alpha_uniform, rand, "gold", &g_norm);
/* normalize */
normalize_points(p_points, nprior, p_norm, q_norm);
normalize_points(q_points, npost, q_norm, p_norm);
normalize_points(g_points, ngold, g_norm, g_norm);
unsigned n;
/* gather all Q(*) points (use int_smooth_points temporarily) */
for (s = q_points, pp = int_smooth_points; s != q_end; ++s)
*pp++ = s;
n = pp - int_smooth_points;
/* collect Q(*) smooth (interior) points */
// double ln_p_bound = smooth_threshold(int_smooth_points, step_mult, &n);
/* for (s = q_points, pp = int_smooth_points; s != q_end; ++s) */
/* if (s->ln_o <= ln_p_bound) */
/* *pp++ = s; */
for (s = q_points, pp = int_smooth_points; s != q_end; ++s)
if (s->ln_d > s->ln_o)
*pp++ = s;
unsigned n_int_smooth_q = pp - int_smooth_points;
/* double ma_ratio = max_to_avg_ratio(int_smooth_points,); */
double int_mass_on_q = sum_of_weights(int_smooth_points, n_int_smooth_q);
/* collect exterior P(*) points */
/* for (s = p_points, pp = ext_points; s != p_end; ++s) */
/* if (s->ln_d > ln_p_bound) */
/* *pp++ = s; */
for (s = p_points, pp = ext_smooth_points; s != p_end; ++s)
if (s->ln_d > s->ln_o)
*pp++ = s;
/* unsigned n_ext_p = n = pp - ext_points; */
/* double ln_q_bound = smooth_threshold(ext_points, step_mult, &n); */
/* collect exterior P(*) smooth points */
/* for (s = p_points, pp = ext_smooth_points; s != p_end; ++s) */
/* if (s->ln_d > ln_p_bound && s->ln_o < ln_q_bound) */
/* *pp++ = s; */
unsigned n_ext_smooth_p = pp - ext_smooth_points;
/* double ma2_ratio = max_to_avg_ratio(ext_smooth_points, n_ext_smooth_p); */
double ext_mass_on_p = sum_of_weights(ext_smooth_points, n_ext_smooth_p);
double total_mixed_mass = int_mass_on_q + ext_mass_on_p;
/* fprintf(stderr, "Number of points unaccounted for: %u\n", n_ext_p - n_ext_smooth_p); */
// print out numerical CDFs
char hdr[] = "Dist\tBase\tComp\tPointIndex\tCDF\tln_d\tln_o\tBaseDist\n";
fprintf(cdf_fh, hdr);
print_cdf(int_smooth_points, n_int_smooth_q, total_mixed_mass, buf, "int_smooth_q", cdf_fh);
print_cdf(ext_smooth_points, n_ext_smooth_p, total_mixed_mass, buf, "ext_smooth_p", cdf_fh);
pe = int_smooth_points + n_int_smooth_q;
for (pp = int_smooth_points, pp2 = all_smooth_points; pp != pe; ++pp, ++pp2)
*pp2 = *pp;
pe = ext_smooth_points + n_ext_smooth_p;
for (pp = ext_smooth_points; pp != pe; ++pp, ++pp2)
*pp2 = *pp;
unsigned n_smooth = n_int_smooth_q + n_ext_smooth_p;
print_cdf(all_smooth_points, n_smooth, total_mixed_mass, p_points, "smooth_combined", cdf_fh);
/* all points in the P(*) sampling */
for (s = p_points, pp = tmp_points; s != p_end; ++s)
*pp++ = s;
print_cdf(tmp_points, nprior, total_mixed_mass, p_points, "all_p", cdf_fh);
/* all points in the Q(*) sampling */
for (s = q_points, pp = tmp_points; s != q_end; ++s)
*pp++ = s;
print_cdf(tmp_points, npost, total_mixed_mass, q_points, "all_q", cdf_fh);
/* print out the gold standard */
struct wpoint *gold_end = g_points + ngold;
for (s = g_points, pp = pg; s != gold_end; ++s)
*pp++ = s;
double gold_mass = sum_of_weights(pg, ngold);
print_cdf(pg, ngold, gold_mass, g_points, "dgold", cdf_fh);
/* compute component-wise marginal estimates. */
/* double q[] = { 0.0001, 0.001, 0.01, 0.1, 0.5, 0.9, 0.99, 0.999, 0.9999 }; */
/* double qv[NUCS][sizeof(q) / sizeof(double)]; */
// print out marginal estimates
/* unsigned iq; */
/* for (dim = 0; dim != NUCS; ++dim) */
/* { */
/* for (iq = 0; iq != sizeof(qv[dim]) / sizeof(double); ++iq) */
/* printf(iq ? "\t%f" : "%f", qv[dim][iq]); */
/* printf("\n"); */
/* } */
free(buf);
free(tmp_points);
free(int_smooth_points);
free(ext_points);
free(ext_smooth_points);
free(ext_rough_points);
free(all_smooth_points);
free(pg);
gsl_rng_free(rand);
fclose(cdf_fh);
return 0;
}
