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 ; }
int main ( int argc , const char* argv[] ) { mcxIO *xfin = mcxIOnew("-", "r") ; mcxIO *xfout = mcxIOnew("-", "w") ; mclMatrix *mx = NULL ; mclx* cmapx = NULL, *rmapx = NULL ; const char* me = "mcxmap" ; long cshift = 0 ; long rshift = 0 ; long cmul = 1 ; long rmul = 1 ; mcxIO* xf_cannc = NULL ; mcxIO* xf_cannr = NULL ; mcxstatus status = STATUS_OK ; mcxbool invert = FALSE ; mcxbool invertr = FALSE ; mcxbool invertc = FALSE ; mcxIO* xf_map_c = NULL, *xf_map_r = NULL, *xf_map = NULL, *xf_tab = NULL ; mcxOption* opts, *opt ; mcxstatus parseStatus = STATUS_OK ; mcxLogLevel = MCX_LOG_AGGR | MCX_LOG_MODULE | MCX_LOG_IO | MCX_LOG_GAUGE | MCX_LOG_WARN ; mclxIOsetQMode("MCLXIOVERBOSITY", MCL_APP_VB_NO) ; mclx_app_init(stderr) ; mcxOptAnchorSortById(options, sizeof(options)/sizeof(mcxOptAnchor) -1) ; opts = mcxOptParse(options, (char**) argv, argc, 1, 0, &parseStatus) ; if (!opts) exit(0) ; 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, 0, 0, options) ; return 0 ; case MY_OPT_VERSION : app_report_version(me) ; return 0 ; case MY_OPT_IMX : mcxIOnewName(xfin, opt->val) ; break ; case MY_OPT_OUT : mcxIOnewName(xfout, opt->val) ; break ; case MY_OPT_MUL : cmul = atol(opt->val) ; rmul = cmul ; break ; case MY_OPT_CMUL : cmul = atol(opt->val) ; break ; case MY_OPT_RMUL : rmul = atol(opt->val) ; break ; case MY_OPT_SHIFT : cshift = atol(opt->val) ; rshift = atol(opt->val) ; break ; case MY_OPT_CSHIFT : cshift = atol(opt->val) ; break ; case MY_OPT_RSHIFT : rshift = atol(opt->val) ; break ; case MY_OPT_MAP : xf_map = mcxIOnew(opt->val, "r") ; invert = FALSE ; break ; case MY_OPT_CMAP : invertc = FALSE ; xf_map_c = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_RMAP : invertr = FALSE ; xf_map_r = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_MAPI : invert = TRUE ; xf_map = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_CMAPI : invertc = TRUE ; xf_map_c = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_RMAPI : invertr = TRUE ; xf_map_r = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_MAKE_MAP : xf_cannc = mcxIOnew(opt->val, "w") ; xf_cannr = xf_cannc ; break ; case MY_OPT_MAKE_MAPC : xf_cannc = mcxIOnew(opt->val, "w") ; break ; case MY_OPT_MAKE_MAPR : xf_cannr = mcxIOnew(opt->val, "w") ; break ; case MY_OPT_TAB : xf_tab = mcxIOnew(opt->val, "r") ; break ; } } /* little special case. restructure when it grows */ if (xf_tab) { mclTab* tab1, *tab2 ; if (xf_map) { mcxIOopen(xf_map, EXIT_ON_FAIL) ; cmapx = mclxRead(xf_map, EXIT_ON_FAIL) ; } else mcxDie(1, me, "-tab option requires -map option") ; tab1 = mclTabRead(xf_tab, NULL, EXIT_ON_FAIL) ; if ((tab2 = mclTabMap(tab1, cmapx))) mclTabWrite(tab2, xfout, NULL, EXIT_ON_FAIL) ; else mcxDie(1, me, "map file error (subsumption/bijection)") ; return 0 ; } mx = mclxRead(xfin, EXIT_ON_FAIL) ; if (xf_map) { mcxIOopen(xf_map, EXIT_ON_FAIL) ; cmapx = mclxRead(xf_map, EXIT_ON_FAIL) ; rmapx = cmapx ; } else { if (xf_map_c) { mcxIOopen(xf_map_c, EXIT_ON_FAIL) ; cmapx = mclxRead(xf_map_c, EXIT_ON_FAIL) ; } else if (cshift || cmul > 1) cmapx = mclxMakeMap ( mclvCopy(NULL, mx->dom_cols) , mclvMap(NULL, cmul, cshift, mx->dom_cols) ) ; else if (xf_cannc) /* fixme slightly flaky interface */ { cmapx = mclxMakeMap ( mclvCopy(NULL, mx->dom_cols) , mclvCanonical(NULL, mx->dom_cols->n_ivps, 1.0) ) ; mclxWrite(cmapx, xf_cannc, MCLXIO_VALUE_GETENV, RETURN_ON_FAIL) ; } if (xf_map_r) { mcxIOopen(xf_map_r, EXIT_ON_FAIL) ; rmapx = mclxRead(xf_map_r, EXIT_ON_FAIL) ; } else if (rshift || rmul > 1) rmapx = mclxMakeMap ( mclvCopy(NULL, mx->dom_rows) , mclvMap(NULL, rmul, rshift, mx->dom_rows) ) ; else if (xf_cannr) { rmapx = mclxMakeMap ( mclvCopy(NULL, mx->dom_rows) , mclvCanonical(NULL, mx->dom_rows->n_ivps, 1.0) ) ; if (xf_cannr != xf_cannc) mclxWrite(rmapx, xf_cannr, MCLXIO_VALUE_GETENV, RETURN_ON_FAIL) ; else if (!mclxIsGraph(mx)) mcxErr(me, "row map not written but matrix is not a graph") ; } } if (invert && cmapx && cmapx == rmapx) { mclx* cmapxi = mclxTranspose(cmapx) ; mclxFree(&cmapx) ; cmapx = rmapx = cmapxi ; } else { if ((invert || invertr) && rmapx) { mclx* rmapxi = mclxTranspose(rmapx) ; mclxFree(&rmapx) ; rmapx = rmapxi ; } if ((invert || invertc) && cmapx) { mclx* cmapxi = mclxTranspose(cmapx) ; mclxFree(&cmapx) ; cmapx = cmapxi ; } } ; status = STATUS_FAIL ; do { if (cmapx && mclxMapCols(mx, cmapx)) break ; if (rmapx && mclxMapRows(mx, rmapx)) break ; status = STATUS_OK ; } while (0) ; if (status) { mcxErr(me, "error, nothing written") ; return 1 ; } mclxWrite(mx, xfout, MCLXIO_VALUE_GETENV, EXIT_ON_FAIL) ; return 0 ; }