void dag_diff_select ( mclx* mx , mclTab* tab , mcxIO* xfdiff , double child_diff_lq , double parent_diff_gq ) { dim i ; mclx* dag = mclxAllocClone(mx) ; for (i=0;i<N_COLS(mx); i++) { mclv* v = mx->cols+i ; dim j ; for (j=0;j<v->n_ivps;j++) { dim idx = v->ivps[j].idx ; double valv = v->ivps[j].val ; mclv* t = mclxGetVector(mx, idx, EXIT_ON_FAIL, NULL) ; mclp* p = mclvGetIvp(t, v->vid, NULL) ; double valt = p ? p->val : 0.0 ; double delta = valv - valt ; double lg = valv, sm = valt ; double child_diff, parent_diff ; int v_is_child = 0 ; if (delta < 0) delta = -delta , lg=valt, sm=valv , v_is_child = 1 ; child_diff = sm ; parent_diff = lg ;if(0 && i==111) fprintf(stderr, "nb %d delta %g\n", (int) idx, delta) ; if (child_diff > child_diff_lq || parent_diff < parent_diff_gq) NOTHING ; else { if (v_is_child) mclvInsertIdx(dag->cols+i, idx, delta) ; else mclvInsertIdx(dag->cols+(t-mx->cols), v->vid, delta) ; } } } ; mclxWrite(dag, xfdiff, MCLXIO_VALUE_GETENV, EXIT_ON_FAIL) ; mclxFree(&dag) ; }
static mclx* get_coarse ( const mclx* mxbase , mclx* clprev , mcxbool add_transpose ) { mclx* blockc = mclxBlocksC(mxbase, clprev) ; mclx* clprevtp = mclxTranspose(clprev) ; mclx *p1 = NULL /* p_roduct */ ; mclx* mx_coarse= NULL ; mclxMakeStochastic(clprev) /****************** <EXPERIMENTAL CRAP> ************************************/ ; if (hdp_g) mclxUnary(clprev, fltxPower, &hdp_g) /* parameter: use mxbase rather than blockc */ ; if (getenv("MCLCM_BLOCK_STOCHASTIC")) /* this works very badly! */ mclxMakeStochastic(blockc) ; else if (getenv("MCLCM_BASE_UNSCALE") && start_col_sums_g) { dim i ; for (i=0;i<N_COLS(blockc);i++) { double f = start_col_sums_g->ivps[i].val ; mclvUnary(blockc->cols+i, fltxMul, &f) ; } ; } /****************** </EXPERIMENTAL> *****************************************/ p1 = mclxCompose(blockc, clprev, 0) ;if (0) {mcxIO* t = mcxIOnew("-", "w") ;mclxWrite(blockc, t, MCLXIO_VALUE_GETENV, EXIT_ON_FAIL) ; } ; mclxFree(&blockc) ; mx_coarse = mclxCompose(clprevtp, p1, 0) ; if (add_transpose) mclxAddTranspose(mx_coarse, 0.0) ; mclxAdjustLoops(mx_coarse, mclxLoopCBremove, NULL) ; mclxFree(&p1) ; mclxFree(&clprevtp) ; mclxMakeCharacteristic(clprev) ; return mx_coarse ; }
int main ( int argc , const char* argv[] ) { mcxIO* xf1, *xf2 ; mclx* mx1, *mx2 ; mcxbits modes = 0 ; mcxLogLevel = MCX_LOG_AGGR | MCX_LOG_MODULE | MCX_LOG_IO | MCX_LOG_GAUGE | MCX_LOG_WARN ; mclx_app_init(stdout) ; if (argc < 4) mcxUsage(stdout, me, usagelines) , mcxExit(0) ; modes = atoi(argv[1]) ; xf1 = mcxIOnew(argv[2], "r") ; xf2 = mcxIOnew(argv[3], "r") ; mx1 = mclxRead(xf1, EXIT_ON_FAIL) ; mx2 = mclxRead(xf2, EXIT_ON_FAIL) ; pairwise_setops(mx1, mx2, modes) ; if (modes & MMM_DUMPMX) { mcxIO* xo = mcxIOnew("out.mmm", "w") ; mclxWrite(mx1, xo, MCLXIO_VALUE_GETENV, RETURN_ON_FAIL) ; } mclxFree(&mx1) ; mclxFree(&mx2) ; mcxIOfree(&xf1) ; mcxIOfree(&xf2) ; return 0 ; }
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 ; }
static mcxstatus meetMain ( int argc , const char* argv[] ) { mcxIO **xfmcs = NULL ; mclMatrix *lft = NULL ; mclMatrix *rgt = NULL ; mclMatrix *dst = NULL ; int a = 0 ; int n_mx = 0 ; int j ; dim o, m, e ; mclxIOsetQMode("MCLXIOVERBOSITY", MCL_APP_VB_YES) ; mclx_app_init(stderr) ; xfmcs = (mcxIO**) mcxAlloc ( (argc)*sizeof(mcxIO*) , EXIT_ON_FAIL ) ; mcxIOopen(xfout, EXIT_ON_FAIL) ; for(j=a;j<argc;j++) { xfmcs[n_mx] = mcxIOnew(argv[j], "r") ; n_mx++ ; } if (!n_mx) mcxDie(1, me, "at least one clustering matrix required") /* Fixme: do a decent initialization with lft = clmTop() *before* * this loop (removing the need for ugly tmp assignment), but that requires * we know the correct domain to pass to it. For that, we need to peak into * the first matrix. */ ; for (j=0;j<n_mx;j++) { mclMatrix* tmp = mclxRead (xfmcs[j], EXIT_ON_FAIL) ; if (clmEnstrict(tmp, &o, &m, &e, ENSTRICT_SPLIT_OVERLAP)) report_partition("clmmeet", tmp, xfmcs[j]->fn, o, m, e) , mcxExit(1) ; if (!lft) { lft = tmp ; continue ; } else rgt = tmp ; if (!MCLD_EQUAL(lft->dom_rows, rgt->dom_rows)) mcxDie ( 1 , me , "domains not equal (files %s/%s)" , xfmcs[j-1]->fn->str , xfmcs[j]->fn->str ) ; mcxIOclose(xfmcs[j]) ; dst = clmMeet(lft, rgt) ; lft = dst ; mclxFree(&rgt) ; } mclxColumnsRealign(lft, mclvSizeRevCmp) ; mclxWrite(lft, xfout, MCLXIO_VALUE_NONE, EXIT_ON_FAIL) ; mclxFree(&lft) ; mcxIOfree(&xfout) ; free(xfmcs) ; return STATUS_OK ; }
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 mclx* process_queries ( mcxIO* xq , mclx* mx , mclx* mxtp , mcxIO* xfmx , mclTab* tab , mcxIO* xfout , mcxIO* xfpath , mcxIO* xfstep ) { mcxTing* line = mcxTingEmpty(NULL, 100) ; mcxTing* sa = mcxTingEmpty(NULL, 100) ; mcxTing* sb = mcxTingEmpty(NULL, 100) ; SSPxy* sspo = mclgSSPxyNew(mx, mxtp) ; mcxIOopen(xq, EXIT_ON_FAIL) ; while (1) { long a = -1, b = -2, ns = 0 ; mcxbool query = FALSE ; if (isatty(fileno(xq->fp))) fprintf ( stdout , "\n(ready (expect two %s or : directive))\n" , tab ? "labels" : "graph indices" ) ; if ( STATUS_OK != mcxIOreadLine(xq, line, MCX_READLINE_CHOMP) || !strcmp(line->str, ".") ) break ; query = (u8) line->str[0] == ':' ; if (query && (line->len == 1 || isspace((unsigned char) line->str[1]))) { fprintf(xfout->fp, "-->\n") ; fprintf(xfout->fp, ":tf <tf-spec>\n") ; fprintf(xfout->fp, ":top <num>\n") ; fprintf(xfout->fp, ":list <node>\n") ; fprintf(xfout->fp, ":clcf <node>\n") ; fprintf(xfout->fp, ":reread>\n") ; fprintf(xfout->fp, "<--\n") ; continue ; } mcxTingEnsure(sa, line->len) ; mcxTingEnsure(sb, line->len) ; ns = sscanf(line->str, "%s %s", sa->str, sb->str) ; if (ns == 2) sa->len = strlen(sa->str) , sb->len = strlen(sb->str) ; else sa->len = strlen(sa->str) , sb->len = 0 , sb->str[0] = '\0' ; if (!query && ns != 2) { if (line->len) fprintf(stderr, "(error expect two nodes or : directive)\n") ; continue ; } if (query) { mx = handle_query(mx, xfmx, sa, sb) ; sspo->mx = mx /* fixme improve ownership handling */ ; sspo->mxtp = mx ; fprintf(xfout->fp, "%s\n\n", line->str) ; continue /* fixme improve flow */ ; } else if (tab) { mcxKV* kv ; if ((kv = mcxHashSearch(sa, hsh_g, MCX_DATUM_FIND))) a = VOID_TO_ULONG kv->val /* fixme (> 2G labels) */ ; else { label_not_found(sa) ; continue ; } if ((kv = mcxHashSearch(sb, hsh_g, MCX_DATUM_FIND))) b = VOID_TO_ULONG kv->val /* fixme (> 2G labels) */ ; else { label_not_found(sb) ; continue ; } } else if (mcxStrTol(sa->str, &a, NULL) || mcxStrTol(sb->str, &b, NULL)) { fprintf(stderr, "(error failed-reading-number)\n") ; continue ; } if (check_bounds(mx, a)) continue ; if (check_bounds(mx, b)) continue ; fprintf ( xfout->fp , "\n(lattice\n" " (anchors %s %s)\n" , sa->str , sb->str ) ; if (0 && a == b) { fprintf ( xfout->fp , " (path-length 0)\n" "(data\n" ) ; } else { mcxstatus thestat = mclgSSPxyQuery(sspo, a, b) ; dim t ; if (thestat) fprintf(xfout->fp, " (path-length -2)\n(data\n") ; else if (sspo->length < 0) /* not in same component */ fprintf(xfout->fp, " (path-length -1)\n(data\n") ; else { fprintf ( xfout->fp , " (path-length %d)\n" "(data\n" , (int) sspo->length ) ; if (sspo->length == 1) { if (tab) fprintf(xfout->fp, "((%s %s))\n", sa->str, sb->str) ; else fprintf(xfout->fp, "((%ld %ld))\n", (long) a, (long) b) ; } else for (t=0; t< N_COLS(sspo->pathmx)-1; t++) erdos_link_together(xfout, mx, sspo->pathmx->cols+t, sspo->pathmx->cols+t+1) ; fputs(")\n", xfout->fp) ; fprintf(xfout->fp, " (anchors %s %s)\n", sa->str, sb->str) ; fprintf(xfout->fp, " (considered %d)\n", (int) sspo->n_considered) ; fprintf(xfout->fp, " (participants %d)\n", (int) sspo->n_involved) ; fprintf(xfout->fp, " (path-length %d)\n", (int) sspo->length) ; } } fprintf(xfout->fp, ")\n\n") ; if (xfpath) mclxWrite(sspo->pathmx, xfpath, MCLXIO_VALUE_NONE, RETURN_ON_FAIL) ; if (xfstep) mclxWrite(sspo->stepmx, xfstep, MCLXIO_VALUE_GETENV, RETURN_ON_FAIL) ; mclgSSPxyReset(sspo) ; } mcxTingFree(&sa) ; mcxTingFree(&sb) ; mcxTingFree(&line) ; mclgSSPxyFree(&sspo) ; return mx ; }
int main ( int argc , const char* argv[] ) { mcxIO* xfdagreduce = NULL, *xfattr = NULL, *xfdiff = NULL ; double child_diff_lq = 0.2 ; double parent_diff_gq = 0.4 ; mcxIO* xfimx = mcxIOnew("-", "r"), *xfdag = NULL, *xftab = NULL ; mclTab* tab = NULL ; int q = -1 ; mclx* mx ; unsigned char test_mode = 0 ; mcxstatus parseStatus = STATUS_OK ; mcxOption* opts, *opt ; 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 : mcxOptApropos(stdout, me, syntax, 0, 0, options) ; return 0 ; case MY_OPT_VERSION : app_report_version(me) ; return 0 ; case MY_OPT_TEST_CYCLE : test_mode = 'c' ; break ; case MY_OPT_TEST_CROSS : test_mode = 'x' ; break ; case MY_OPT_DAG_ATTR : xfattr = mcxIOnew(opt->val, "w") ; mcxIOopen(xfattr, EXIT_ON_FAIL) ; break ; case MY_OPT_DAG_DIFF : xfdiff = mcxIOnew(opt->val, "w") ; break ; case MY_OPT_DAG_REDUCE : xfdagreduce = mcxIOnew(opt->val, "w") ; break ; case MY_OPT_CHILD_DIFF_LQ : child_diff_lq = atof(opt->val) ; break ; case MY_OPT_PARENT_DIFF_GQ : parent_diff_gq = atof(opt->val) ; break ; case MY_OPT_QUERY : q = atoi(opt->val) ; break ; case MY_OPT_TAB : xftab = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_IMX : mcxIOnewName(xfimx, opt->val) ; break ; } } ; if (xfimx) mx = mclxRead(xfimx, EXIT_ON_FAIL) ; else mcxDie(1, me, "need -imx") ; if (xftab) tab = mclTabRead(xftab, mx->dom_cols, EXIT_ON_FAIL) ; if (test_mode == 'c') test_for_cycles(mx) ; else if (test_mode == 'x') test_cross_ratio(mx) ; else if (xfattr) get_attr(mx, tab, xfattr) ; else if (xfdagreduce) { mclxComposeHelper* ch = mclxComposePrepare(mx, mx) ; dim i ; for (i=0;i<N_COLS(mx);i++) { mclv* in = mx->cols+i ; mclv* out = mclxVectorCompose(mx, in, NULL, ch) ; mcldMinus(in, out, in) ; mclvFree(&out) ; } mclxWrite(mx, xfdagreduce, MCLXIO_VALUE_GETENV, EXIT_ON_FAIL) ; mclxComposeRelease(&ch) ; } else if (xfdiff) dag_diff_select(mx, tab, xfdiff, child_diff_lq, parent_diff_gq) ; mclxFree(&mx) ; mcxIOfree(&xfimx) ; mcxIOfree(&xfdag) ; mcxIOfree(&xfattr) ; mcxIOfree(&xfdagreduce) ; 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 ; }