void chapeau_savestate ( chapeau * ch, int timestep, char * filename ) {
int N=ch->N;
int m=ch->m;
FILE *ofs;
ofs=fopen(filename,"w");
fwrite(×tep,sizeof(int),1,ofs);
fwrite(ch, sizeof(*ch), 1, ofs);
fwrite(ch->hits,sizeof(*(ch->hits)),m,ofs);
fwrite(ch->mask,sizeof(*(ch->mask)),N,ofs);
//fwrite(ch->s,sizeof(***(ch->s)),m*N*3,ofs);
gsl_matrix_fwrite(ofs,ch->A);
gsl_vector_fwrite(ofs,ch->b);
gsl_matrix_fwrite(ofs,ch->Afull);
gsl_vector_fwrite(ofs,ch->bfull);
gsl_vector_fwrite(ofs,ch->lam);
fclose(ofs);
}
int
pca_write_vector(const char *filename, const gsl_vector * v)
{
int s;
FILE *fp;
fp = fopen(filename, "w");
if (!fp)
{
fprintf(stderr, "pca_write_vector: unable to open %s: %s\n",
filename, strerror(errno));
return -1;
}
fwrite(&(v->size), sizeof(size_t), 1, fp);
s = gsl_vector_fwrite(fp, v);
fclose(fp);
return s;
}
int
lls_save(const char *filename, lls_workspace *w)
{
int s = 0;
FILE *fp;
fp = fopen(filename, "w");
if (!fp)
{
fprintf(stderr, "lls_save: unable to open %s: %s\n",
filename, strerror(errno));
return GSL_FAILURE;
}
fwrite(&(w->bTb), sizeof(double), 1, fp);
s += gsl_matrix_fwrite(fp, w->ATA);
s += gsl_vector_fwrite(fp, w->ATb);
fclose(fp);
return s;
} /* lls_save() */
void crypt_vector(int *a, int n, int factor, int seed) {
/*
Opening the coresponding files as streams
*/
int i = 0;
FILE *fp_s;
FILE *fp_m1;
FILE *fp_m2;
if(factor == 0) {
fp_s = fopen("s.key", "r");
fp_m1 = fopen("m1_t.key", "r");
fp_m2 = fopen("m2_t.key", "r");
}
else {
fp_s = fopen("s_i.key", "r");
fp_m1 = fopen("m1_i.key", "r");
fp_m2 = fopen("m2_i.key", "r");
}
/*
Allocating memories for the datastructures
*/
gsl_vector *org_vector = gsl_vector_alloc(n);
gsl_vector *s = gsl_vector_alloc(n);
gsl_matrix *m1 = gsl_matrix_alloc(n,n);
gsl_matrix *m2 = gsl_matrix_alloc(n,n);
/*
Getting them into memory
*/
gsl_vector_fread(fp_s, s);
gsl_matrix_fread(fp_m1, m1);
gsl_matrix_fread(fp_m2, m2);
for(i = 0; i<n; i++)
gsl_vector_set(org_vector, i, a[i]);
init_rng(seed);
if(factor == 1) {
int scale = gsl_rng_uniform_int(r, 100);
gsl_vector_scale(org_vector, scale);
}
gsl_vector *splt_vec_1 = gsl_vector_alloc(n);
gsl_vector *splt_vec_2 = gsl_vector_alloc(n);
split(org_vector, splt_vec_1, splt_vec_2, s, n);
/*{
int j = 0;
for(j = 0; j<n; j++)
printf("%d", (int) gsl_vector_get(org_vector, j));
printf("\n\n\n");
//int i = 0, j = 0;
for(j = 0; j<n; j++)
printf("%d", (int) gsl_vector_get(splt_vec_1, j));
printf("\n\n\n");
for(j = 0; j<n; j++)
printf("%d", (int) gsl_vector_get(splt_vec_2, j));
printf("\n\n");
}*/
gsl_vector *crp_vector_1 = gsl_vector_alloc(n);
gsl_vector *crp_vector_2 = gsl_vector_alloc(n);
compute_crp_vector(splt_vec_1, m1, crp_vector_1, n);
compute_crp_vector(splt_vec_2, m2, crp_vector_2, n);
FILE *f_crpt_1 = fopen("crypt_1.key", "w");
FILE *f_crpt_2 = fopen("crypt_2.key", "w");
gsl_vector_fwrite(f_crpt_1, crp_vector_1);
gsl_vector_fwrite(f_crpt_2, crp_vector_2);
gsl_vector_free(org_vector);
gsl_vector_free(s);
gsl_vector_free(splt_vec_1);
gsl_vector_free(splt_vec_2);
gsl_vector_free(crp_vector_1);
gsl_vector_free(crp_vector_2);
gsl_matrix_free(m1);
gsl_matrix_free(m2);
gsl_rng_free(r);
fclose(fp_s);
fclose(fp_m1);
fclose(fp_m2);
fclose(f_crpt_1);
fclose(f_crpt_2);
}
gsl_matrix * bootstrap_and_calc_adj_matrix(
gsl_matrix * A,
size_t num_steps,
decimal threshold,
CoexpressionMeasure filter,
void (* interaction_matrix_generator_fnc)(gsl_matrix *, gsl_matrix *, CoexpressionMeasure),
bool use_tmp_file = false
)
{
size_t num_elems = A->size1;
//num_obs = A->size2;
gsl_matrix * interaction = gsl_matrix_calloc(num_elems, num_elems);
interaction_matrix_generator_fnc(A, interaction, filter);
// Bootstrapping
std::list<gsl_matrix *> boot_matrix;
{
detail::write_matrix_3d write_boot_matrix;
if (use_tmp_file)
write_boot_matrix.set_filename("tmp_file.out");
boost::mt19937 rng(time(NULL) - num_steps - int(threshold * 100));
for (size_t i = 0; i < num_steps; ++i)
{
std::cout << "step = " << i << std::endl; // DEBUG
bootstrap_and_calc_adj_matrix_helper(A, boot_matrix, write_boot_matrix, filter, rng, interaction_matrix_generator_fnc, use_tmp_file);
}
}
// Compute adjacency matrix
detail::read_matrix_3d read_boot_matrix(num_elems, num_elems, num_steps);
if (use_tmp_file)
read_boot_matrix.set_filename("tmp_file.out");
gsl_matrix * adj_matrix = gsl_matrix_alloc(num_elems, num_elems);
for (size_t r = 0; r < num_elems; ++r)
{
for (size_t c = 0; c < num_elems; ++c)
{
double value = gsl_matrix_get(interaction, r, c);
gsl_vector * boot_z_vec = gsl_vector_calloc(num_steps);
if (use_tmp_file)
{
read_boot_matrix.read(r, c, boot_z_vec);
}
else
{
size_t i = 0;
for (std::list<gsl_matrix *>::iterator li = boot_matrix.begin(); li != boot_matrix.end(); ++li, ++i)
gsl_vector_set(boot_z_vec, i, gsl_matrix_get(*li, r, c));
}
double mean = gsl_stats_mean(boot_z_vec->data, boot_z_vec->stride, num_steps),
sd = gsl_stats_sd(boot_z_vec->data, boot_z_vec->stride, num_steps);
// DEBUG
std::string filename = "boot_" + to_string(r) + "_" + to_string(c) + ".out";
FILE * outfile = fopen(filename.c_str(), "wb");
gsl_vector_fwrite(outfile, boot_z_vec);
fclose(outfile);
// END DEBUG
if (value < (mean - threshold * sd) || value > (mean + threshold * sd))
gsl_matrix_set(adj_matrix, r, c, value);
else
gsl_matrix_set(adj_matrix, r, c, 0.0);
gsl_vector_free(boot_z_vec);
}
}
// Free interaction matrices
gsl_matrix_free(interaction);
if (!use_tmp_file)
for (std::list<gsl_matrix *>::iterator li = boot_matrix.begin(); li != boot_matrix.end(); ++li)
gsl_matrix_free(*li);
return adj_matrix;
}
