SEXP binarizeBASCB(SEXP vect, SEXP tau, SEXP numberofSamples, SEXP sigma)
{
int value_count, sigma_count;
mgs_result mgs_res;
quant_result q_res;
dbl_array *vector, *vect_sorted, *s;
dbl_matrix *H_Mat;
calc_V_result v_res;
final_result f_res;
SEXP result, binarized_vector, threshold, p_value, other_results, names;
SEXP smoothed, zerocrossing, deriv, steps, H, index, v_vec, meanlist, smoothedX;
value_count = length(vect);
sigma_count = length(sigma);
PROTECT(result = allocVector(VECSXP, 4));
PROTECT(names = allocVector(VECSXP, 4));
SET_VECTOR_ELT(names,0, mkChar("binarized_vector"));
SET_VECTOR_ELT(names,1, mkChar("threshold"));
SET_VECTOR_ELT(names,2, mkChar("p_value"));
SET_VECTOR_ELT(names,3, mkChar("other_results"));
setAttrib(result, R_NamesSymbol, names);
UNPROTECT(1);
PROTECT(other_results = allocVector(VECSXP, 9));
PROTECT(names = allocVector(VECSXP, 9));
SET_VECTOR_ELT(names,0, mkChar("smoothed"));
SET_VECTOR_ELT(names,1, mkChar("zerocrossing"));
SET_VECTOR_ELT(names,2, mkChar("deriv"));
SET_VECTOR_ELT(names,3, mkChar("steps"));
SET_VECTOR_ELT(names,4, mkChar("H_Mat"));
SET_VECTOR_ELT(names,5, mkChar("index"));
SET_VECTOR_ELT(names,6, mkChar("v_vec"));
SET_VECTOR_ELT(names,7, mkChar("smoothedX"));
SET_VECTOR_ELT(names,8, mkChar("meanlist"));
setAttrib(other_results, R_NamesSymbol, names);
UNPROTECT(1);
PROTECT(smoothed = allocMatrix(REALSXP, value_count - 1, sigma_count));
PROTECT(zerocrossing = allocMatrix(INTSXP, (int)ceil((double)value_count / 2.0), sigma_count));
PROTECT(deriv = allocVector(REALSXP, value_count - 1));
mgs_res.smoothed = init_dbl_matrix(REAL(smoothed), sigma_count, value_count - 1, 0);
mgs_res.zerocrossing = init_int_matrix(INTEGER(zerocrossing), sigma_count, (int)ceil((double)value_count / 2.0), 0);
mgs_res.deriv = init_dbl_array(REAL(deriv), value_count - 1, 0);
vector = init_dbl_array(REAL(vect), value_count, 1);
vect_sorted = init_dbl_array(0, value_count, 0);
s = init_dbl_array(REAL(sigma), sigma_count, 1);
b = init_dbl_matrix(0, sigma_count, mgs_res.deriv->length, 0);
b_returned = init_int_matrix(0, sigma_count, mgs_res.deriv->length, 0);
memcpy(vect_sorted->values, REAL(vect), vect_sorted->length * sizeof(double));
qsort(vect_sorted->values, vect_sorted->length, sizeof(double), comp);
mgs(&mgs_res, vect_sorted, s);
q_res.steps = init_int_matrix(0, sigma_count, (int)ceil((double)value_count / 2.0), 0);
q_res.index = init_int_array(0, sigma_count, 0);
q_res.greatest_index_ind = 0;
q_res.greatest_steps_col = 0;
q_res.greatest_steps_row = 0;
getQuantizations(&q_res, &mgs_res);
PROTECT(steps = allocMatrix(INTSXP, q_res.greatest_steps_col, q_res.greatest_steps_row));
PROTECT(H = allocMatrix(REALSXP, q_res.greatest_steps_col, q_res.greatest_steps_row));
PROTECT(index = allocVector(INTSXP, q_res.greatest_index_ind));
cut_int_matrix(q_res.steps, INTEGER(steps), 0, q_res.greatest_steps_row - 1, 0, q_res.greatest_steps_col - 1);
cut_int_array(q_res.index, INTEGER(index), 0, q_res.greatest_index_ind - 1);
H_Mat = init_dbl_matrix(REAL(H), q_res.greatest_steps_row, q_res.greatest_steps_col, 0);
PROTECT(v_vec = allocVector(INTSXP, q_res.index->length));
PROTECT(smoothedX = allocMatrix(REALSXP, mgs_res.smoothed->cols + 1, q_res.index->length));
PROTECT(meanlist = allocMatrix(REALSXP, vect_sorted->length, q_res.index->length + 1));
v_res.v = init_int_array(INTEGER(v_vec), q_res.index->length, 0);
v_res.meanlist = init_dbl_matrix(REAL(meanlist), q_res.index->length + 1, vect_sorted->length, 0);
v_res.smoothedX = init_dbl_matrix(REAL(smoothedX), q_res.index->length, mgs_res.smoothed->cols + 1, 0);
calc_V_Scalespace(&v_res, &mgs_res, &q_res, H_Mat, vect_sorted);
PROTECT(binarized_vector = allocVector(INTSXP, value_count));
PROTECT(threshold = allocVector(REALSXP, 1));
PROTECT(p_value = allocVector(REALSXP, 1));
f_res.binarized_vector = init_int_array(INTEGER(binarized_vector), value_count, 0);
f_res.p = REAL(p_value);
f_res.threshold = REAL(threshold);
calc_final_results(&f_res, v_res.v, vector, vect_sorted, *REAL(tau), *INTEGER(numberofSamples));
SET_VECTOR_ELT(other_results, 0, smoothed);
SET_VECTOR_ELT(other_results, 1, zerocrossing);
SET_VECTOR_ELT(other_results, 2, deriv);
SET_VECTOR_ELT(other_results, 3, steps);
SET_VECTOR_ELT(other_results, 4, H);
SET_VECTOR_ELT(other_results, 5, index);
SET_VECTOR_ELT(other_results, 6, v_vec);
SET_VECTOR_ELT(other_results, 7, smoothedX);
SET_VECTOR_ELT(other_results, 8, meanlist);
SET_VECTOR_ELT(result, 0, binarized_vector);
SET_VECTOR_ELT(result, 1, threshold);
SET_VECTOR_ELT(result, 2, p_value);
SET_VECTOR_ELT(result, 3, other_results);
destroy_dbl_matrix(mgs_res.smoothed);
destroy_int_matrix(mgs_res.zerocrossing);
destroy_dbl_array(mgs_res.deriv);
destroy_dbl_array(vector);
destroy_dbl_array(vect_sorted);
destroy_dbl_array(s);
destroy_dbl_matrix(b);
destroy_int_matrix(b_returned);
b = 0;
b_returned = 0;
destroy_dbl_matrix(H_Mat);
destroy_int_matrix(q_res.steps);
destroy_int_array(q_res.index);
destroy_int_array(v_res.v);
destroy_dbl_matrix(v_res.meanlist);
destroy_dbl_matrix(v_res.smoothedX);
destroy_int_array(f_res.binarized_vector);
UNPROTECT(14);
return result;
}
int
main(int argc, char *argv[]) {
int rc = 0;
Network *N = NULL;
time_measure_start(&GNRL_ST.total_time);
//process input arguments and init global structure
rc |= process_input_args(argc, argv);
if (GNRL_ST.quiet_mode == FALSE)
printf("mfinder Version %.2f\n\n", VERSION);
if (rc == RC_ERR)
at_exit(-1);
//general initialization
rc |= gnrl_init();
if (rc == RC_ERR)
at_exit(-1);
// load network from input file
if (GNRL_ST.quiet_mode == FALSE)
printf("Loading Network\n");
load_network(&G_N, input_network_fname);
duplicate_network(G_N, &N, "real_network");
init_random_seed();
if (rc == RC_ERR)
at_exit(-1);
if (GNRL_ST.quiet_mode == FALSE)
printf("Searching motifs size %d\nProcessing Real network...\n", GNRL_ST.mtf_sz);
//search motifs size n in Real network
if (GNRL_ST.dont_search_real != TRUE)
rc |= motifs_search_real(N);
if (rc == RC_ERR)
at_exit(-1);
/*
printf("RES TBL real\n");
for (l_id = list64_get_next(RES_TBL.real, NULL); l_id != NULL;
l_id = list64_get_next(RES_TBL.real, l_id))
{
printf("id: %d\ncount: %.0f\n", (int)((Motif*)l_id->p)->id,
((Motif*)l_id->p)->count);
}
*/
if (GNRL_ST.quiet_mode == FALSE)
printf("Processing Random networks\n");
if (GNRL_ST.rnd_net_num > 0) {
// create random networks with same single node statisticfs as the input network
if (GNRL_ST.r_grassberger == FALSE) {
//use switches or stubs
rc |= process_rand_networks(&RES_TBL, GNRL_ST.mtf_sz);
} else {
//use grassberger alg
weights_arr = (double*) calloc(GNRL_ST.rnd_net_num + 1, sizeof (double));
rc |= process_rand_networks_grassberger(&RES_TBL, GNRL_ST.mtf_sz, weights_arr);
}
if (rc == RC_ERR)
at_exit(-1);
}
if (GNRL_ST.quiet_mode == FALSE)
printf("Calculating Results...\n");
if (GNRL_ST.rnd_net_num >= 0) {
//calculate final results and dump them to the results file
if (!GNRL_ST.r_grassberger) {
calc_final_results(&RES_TBL, &final_res, &final_res_all, GNRL_ST.rnd_net_num);
} else {
//Nadav change for GRASS NEW
calc_final_results_grassberger(&RES_TBL, FALSE, res_sub_motif, &final_res, &final_res_all, GNRL_ST.rnd_net_num, weights_arr);
}
}
//calculate final results
time_measure_stop(&GNRL_ST.total_time);
//output results
rc |= output_results(final_res, final_res_all);
free_network_mem(G_N);
free(G_N);
final_res_free(final_res);
final_res_free(final_res_all);
if (GNRL_ST.r_grassberger)
free(weights_arr);
res_tbl_mem_free(&RES_TBL);
if (GNRL_ST.calc_roles == TRUE) {
free_mem_role_hash();
free_roles_res_tbl(GNRL_ST.rnd_net_num);
free_role_members();
}
if (rc == RC_ERR)
at_exit(-1);
exit(at_exit(rc));
}
