void mcxDiagnosticsAttractor ( const char* ffn_attr , const mclMatrix* clus2elem , const mcxDumpParam dumpParam ) { int n_nodes = clus2elem->n_range ; int n_written = dumpParam->n_written ; mclMatrix* mtx_Ascore = mclxAllocZero(n_written, n_nodes) ; mcxIO* xfOut = mcxIOnew(ffn_atr, "w") ; dim d = 0 ; if (mcxIOopen(xfOut, RETURN_ON_FAIL) == STATUS_FAIL) { mclxFree(&mtx_Ascore) ; mcxIOfree(&xfOut) ; return ; } ; for(d=0; d<n_written; d++) { mclMatrix* iterand = *(dumpParam->iterands+d) ; mclVector* vec_Ascore = NULL ; if (iterands->n_cols != n_nodes || iterand->n_range != n_nodes) { fprintf(stderr, "mcxDiagnosticsAttractor: dimension error\n") ; mcxExit(1) ; } vec_Ascore = mcxAttractivityScale(iterand) ; mclvRenew((mtx_Ascore->cols+d), vec_Ascore->ivps, vec_Ascore->n_ivps) ; mclvFree(&vec_Ascore) ; } mclxbWrite(mtx_Ascore, xfOut, RETURN_ON_FAIL) ; mclxFree(mtx_Ascore) ; }
static mcxstatus convertMain ( int argc_unused cpl__unused , const char* argv[] ) { mclMatrix* mx ; mclxCat st ; xfin = mcxIOnew(argv[0], "r") ; xfout = mcxIOnew(argv[1], "w") ; mclxCatInit(&st) ; if (main_mode == 'l') { if (mclxCatRead(xfin, &st, catmax, NULL, NULL, 0)) mcxDie(1, me, "failure is, if not an option, the result after all") ; mclxCatWrite(xfout, &st, MCLXIO_VALUE_GETENV, EXIT_ON_FAIL) ; } else if (main_mode == 'f') { int format ; mx = mclxRead(xfin, EXIT_ON_FAIL) ; format = mclxIOformat(xfin) ; if (!test_read) { mcxIOopen(xfout, EXIT_ON_FAIL) ; if (format == 'a') mclxbWrite(mx, xfout, EXIT_ON_FAIL) ; else mclxaWrite(mx, xfout, MCLXIO_VALUE_GETENV, EXIT_ON_FAIL) ; } } else { mcxbits bits = main_mode == 'c' ? MCLX_REQUIRE_DOMTREE | MCLX_CATREAD_CLUSTERSTACK : main_mode == 's' ? MCLX_REQUIRE_DOMSTACK | MCLX_CATREAD_CLUSTERTREE : 0 ; mcxIOopen(xfout, EXIT_ON_FAIL) ; if (mclxCatRead(xfin, &st, catmax, NULL, NULL, bits)) mcxDie(1, me, "failure is, if not an option, the result after all") ; mclxCatWrite(xfout, &st, MCLXIO_VALUE_NONE, EXIT_ON_FAIL) ; } return 0 ; }
int main ( int argc , const char* argv[] ) { mcxIO* xfmx = mcxIOnew("-", "r"), *xfout = mcxIOnew("-", "w") ; mclx* mx = NULL ; mclv* mx_diag = NULL ; mcxstatus parseStatus = STATUS_OK ; mcxOption* opts, *opt ; dim N_edge = 0 ; dim* offsets ; dim template_n_nodes = 0 ; mcxbool plus = FALSE ; double e_min = 1.0 ; double e_max = 0.0 ; double skew = 0.0 ; double radius = 0.0 ; double n_sdev = 0.5 ; double n_range = 2.0 ; double g_radius = 0.0 ; double g_mean = 0.0 ; double g_sdev = 0.0 ; double g_min = 1.0 ; double g_max = 0.0 ; mcxbool do_gaussian = FALSE ; dim i = 0 ; dim N_remove = 0 ; dim N_add = 0 ; dim N_shuffle = 0 ; unsigned long random_ignore = 0 ; srandom(mcxSeed(2308947)) ; mcxOptAnchorSortById(options, sizeof(options)/sizeof(mcxOptAnchor) -1) ; if (!(opts = mcxOptParse(options, (char**) argv, argc, 1, 0, &parseStatus))) exit(0) ; mcxLogLevel = MCX_LOG_AGGR | MCX_LOG_MODULE | MCX_LOG_IO | MCX_LOG_GAUGE | MCX_LOG_WARN ; mclxIOsetQMode("MCLXIOVERBOSITY", MCL_APP_VB_YES) ; mclx_app_init(stderr) ; for (opt=opts;opt->anch;opt++) { mcxOptAnchor* anch = opt->anch ; switch(anch->id) { case MY_OPT_HELP : case MY_OPT_APROPOS : mcxOptApropos(stdout, me, syntax, 20, MCX_OPT_DISPLAY_SKIP, options) ; return 0 ; case MY_OPT_VERSION : app_report_version(me) ; return 0 ; case MY_OPT_SKEW : skew = atof(opt->val) ; break ; case MY_OPT_GEN : template_n_nodes = atoi(opt->val) ; break ; case MY_OPT_IMX : mcxIOrenew(xfmx, opt->val, NULL) ; break ; case MY_OPT_PLUS : case MY_OPT_WB : plus = TRUE ; break ; case MY_OPT_OUT : mcxIOrenew(xfout, opt->val, NULL) ; break ; case MY_OPT_E_MAX : if (!strcmp(opt->val, "copy")) e_max = -DBL_MAX ; else e_max = atof(opt->val) ; break ; case MY_OPT_E_MIN : e_min = atof(opt->val) ; break ; case MY_OPT_G_MIN : g_min = atof(opt->val) ; break ; case MY_OPT_G_MAX : g_max = atof(opt->val) ; break ; case MY_OPT_G_SDEV : g_sdev = atof(opt->val) ; break ; case MY_OPT_G_MEAN : g_mean = atof(opt->val) ; do_gaussian = TRUE ; break ; case MY_OPT_G_RADIUS : g_radius = atof(opt->val) ; break ; case MY_OPT_N_RANGE : n_range = atof(opt->val) ; break ; case MY_OPT_N_SDEV : n_sdev = atof(opt->val) ; break ; case MY_OPT_N_RADIUS : radius = atof(opt->val) ; break ; case MY_OPT_SHUFFLE : N_shuffle = atoi(opt->val) ; break ; case MY_OPT_ADD : N_add = atoi(opt->val) ; break ; case MY_OPT_REMOVE : N_remove = atoi(opt->val) ; break ; } } /* hitting y% in vi tells me the size of this block */ { if (template_n_nodes) mx = mclxAllocZero ( mclvCanonical(NULL, template_n_nodes, 1.0) , mclvCanonical(NULL, template_n_nodes, 1.0) ) ; else mx = mclxReadx ( xfmx , EXIT_ON_FAIL , MCLX_REQUIRE_GRAPH ) ; mx_diag = mclxDiagValues(mx, MCL_VECTOR_COMPLETE) ; if (N_shuffle) mclxAdjustLoops(mx, mclxLoopCBremove, NULL) ; else mclxSelectUpper(mx) /* ^ apparently we always work on single arc representation (docme andsoon) */ ; offsets = mcxAlloc(sizeof offsets[0] * N_COLS(mx), EXIT_ON_FAIL) ; N_edge = 0 ; for (i=0;i<N_COLS(mx);i++) { offsets[i] = N_edge ; N_edge += mx->cols[i].n_ivps ; } if (N_edge < N_remove) { mcxErr ( me , "removal count %ld exceeds edge count %ld" , (long) N_remove , (long) N_edge ) ; N_remove = N_edge ; } random_ignore = RAND_MAX - (N_edge ? RAND_MAX % N_edge : 0) ; if (RAND_MAX / 2 < N_edge) mcxDie(1, me, "graph too large!") ; if (N_shuffle) { do_the_shuffle(mx, N_shuffle, offsets, N_edge, random_ignore) ; mx_readd_diagonal(mx, mx_diag) ; mclxWrite(mx, xfout, MCLXIO_VALUE_GETENV, RETURN_ON_FAIL) ; exit(0) ; } ; if (N_remove) { dim n_remove = do_remove(mx, N_remove, offsets, N_edge, random_ignore) /* Need to recompute N_edge and random_ignore. * NOTE we work with *upper* matrix; this counts graph edges. */ ; N_edge = mclxNrofEntries(mx) - n_remove ; random_ignore = RAND_MAX - (RAND_MAX % N_COLS(mx)) ; } if (g_mean) { if (!g_radius) { if (g_sdev) g_radius = 2 * g_sdev ; mcxWarn(me, "set radius to %.5f\n", g_radius) ; } } ; if (N_add) N_edge += do_add ( mx , N_add , N_edge , do_gaussian ? &g_mean : NULL, g_radius , g_sdev , g_min , g_max , skew , e_min , e_max ) ; if (radius) { for (i=0;i<N_COLS(mx);i++) { mclp* ivp = mx->cols[i].ivps, *ivpmax = ivp + mx->cols[i].n_ivps ;if(DEBUG)fprintf(stderr, "here %d\n", (int) i) ; while (ivp < ivpmax) { double val = ivp->val ; double r = mcxNormalCut(n_range * n_sdev, n_sdev) ; double newval = val + radius * (r / (n_range * n_sdev)) ; if (e_min < e_max && newval >= e_min && newval <= e_max) ; ivp->val = newval ; ivp++ ; } } } mclxUnary(mx, fltxCopy, NULL) /* remove zeroes */ ; mclxAddTranspose(mx, 0.0) ; mx_readd_diagonal(mx, mx_diag) ; if (plus) mclxbWrite(mx, xfout, RETURN_ON_FAIL) ; else mclxWrite(mx, xfout, MCLXIO_VALUE_GETENV, RETURN_ON_FAIL) ; } return 0 ; }
static mcxstatus collectMain ( int argc , const char* argv[] ) { aggr* collect = NULL ; int a ; dim i, collect_n = 0 ; mclTab* tab = NULL ; double avg = 0.0 ; mclx* aggr = NULL, *mx = NULL /* mcxHash* map = NULL */ ; mcxIO* xfout = mcxIOnew(out_g, "w") ; mcxIOopen(xfout, EXIT_ON_FAIL) ; if ( transform_spec && (!(transform = mclgTFparse(NULL, transform_spec))) ) mcxDie(1, me, "input -tf spec does not parse") ; if (xftab_g) tab = mclTabRead(xftab_g, NULL, EXIT_ON_FAIL) /* map not used; perhaps someday we want to map labels to indexes? * in that case, we could also simply reverse the tab when reading .. , map = mclTabHash(tab) */ ; if (!collect_g) mcxDie(1, me, "require one of --paste, --add-column, --add-matrix") ; if (argc) { if (collect_g == 'm') { mcxIO* xf = mcxIOnew(argv[0], "r") ; mcxIOopen(xf, EXIT_ON_FAIL) ; aggr = mclxRead(xf, EXIT_ON_FAIL) ; mcxIOfree(&xf) ; } else collect_n = do_a_file(&collect, argv[0], 0) ; } if (tab && collect_n != N_TAB(tab) + (header_g ? 1 : 0)) mcxErr ( me , "tab has differing size (%lu vs %lu), continuing anyway" , (ulong) N_TAB(tab) , (ulong) (collect_n ? collect_n -1 : 0) ) ; for (a=1;a<argc;a++) { if (collect_g == 'm') { mcxIO* xf = mcxIOnew(argv[a], "r") ; mcxIOopen(xf, EXIT_ON_FAIL) ; mx = mclxRead(xf, EXIT_ON_FAIL) ; mclxAugment(aggr, mx, fltop_g) ; mcxIOfree(&xf) ; mclxFree(&mx) ; } else do_a_file(&collect, argv[a], collect_n) ; } if (collect_g == 'm') { if (transform) mclgTFexec(aggr, transform) ; if (mcx_wb_g) mclxbWrite(aggr, xfout, EXIT_ON_FAIL) ; else mclxWrite(aggr, xfout, MCLXIO_VALUE_GETENV, EXIT_ON_FAIL) ; mcxIOclose(xfout) ; exit(0) ; } /* fimxe: dispatch on binary_g */ for (i=0;i<collect_n;i++) { const char* lb = collect[i].label ; if (!i && collect[i].columns && collect_g != 'p') { fprintf(xfout->fp, "%s\t%s\n", lb, collect[i].columns->str) ; continue ; } if (tab && (!header_g || i > 0)) { unsigned u = atoi(lb) ; lb = mclTabGet(tab, u, NULL) ; if (TAB_IS_NA(tab, lb)) mcxDie(1, me, "no label found for index %ld - abort", (long) u) ; } if (summary_g) avg += collect[i].val ; else { if (collect_g == 'p') fprintf(xfout->fp, "%s%s\n", lb, collect[i].columns->str) ; else fprintf(xfout->fp, "%s\t%.8g\n", lb, collect[i].val) ; } } if (summary_g && collect_n) { dim middle1 = (collect_n-1)/2, middle2 = collect_n/2 ; qsort(collect, collect_n, sizeof collect[0], aggr_cmp_val) ; avg /= collect_n ; fprintf /* --summary option is a bit rubbish interface-wise */ ( xfout->fp , "%g %g %g %g\n" , collect[0].val , (collect[middle1].val + collect[middle2].val) / 2 , collect[collect_n-1].val , avg ) ; } return STATUS_OK ; }