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[] ) { int a = 0 ; mcxTing* argtxt = mcxTingEmpty(NULL, 10) ; if (0) mclxIOsetQMode("MCLXIOVERBOSITY", MCL_APP_VB_NO) ; opInitialize() /* symtable etc */ ; globInitialize() /* hdltable etc */ ; if (argc == 1) { mcxTing* ops = mcxTingEmpty(NULL, 20) ; mcxIO *xfin = mcxIOnew("-", "r") ; mcxIOopen(xfin, EXIT_ON_FAIL) ; fprintf ( stdout , "At your service: " "'[/<op>] help', '[/<str>] grep', 'ops', 'info', and 'quit'.\n" ) ; while (1) { int ok ; mcxTing* line = mcxTingEmpty(NULL, 30) ; fprintf(stdout, "> ") ; fflush(stdout) ; if (STATUS_OK != mcxIOreadLine(xfin, line, MCX_READLINE_BSC)) { fprintf(stdout, "curtains!\n") ; mcxTingFree(&line) ; break ; } mcxTingAppend(ops, line->str) ; mcxTingFree(&line) ; ok = zsDoSequence(ops->str) ; if (ok && (v_g & V_STACK)) zsList(0) ; mcxTingEmpty(ops, 20) ; } } else { for (a=1;a<argc;a++) { mcxTingWrite(argtxt, argv[a]) ; if (!zgUser(argtxt->str)) mcxExit(1) ; } } mcxTingFree(&argtxt) ; return 0 ; }
mcxstatus mcxIOtestOpen ( mcxIO* xf , mcxOnFail ON_FAIL ) { if (!xf->fp && mcxIOopen(xf, ON_FAIL) != STATUS_OK) { mcxErr ("mcxIO", "cannot open file <%s> in mode %s", xf->fn->str, xf->mode) ; return STATUS_FAIL ; } return STATUS_OK ; }
void write_clustering ( mclx* cl , const mclx* clprev , mcxIO* xfcone , mcxIO* xfstack , const char* plexprefix , int multiplex_idx , const mclAlgParam* mlp ) { /* this branch is also taken for dispatch mode */ if (plexprefix) { mcxTing* clname = mcxTingPrint(NULL, "%s.%03d", plexprefix, multiplex_idx) ; mcxIO* xfout = mcxIOnew(clname->str, "w") ; if (dispatch_g && mlp && !mcxIOopen(xfout, RETURN_ON_FAIL)) fprintf(xfout->fp, "# %s\n", mlp->cline->str) ; mclxaWrite(cl, xfout, MCLXIO_VALUE_NONE, RETURN_ON_FAIL) ; mcxTingFree(&clname) ; mcxIOfree(&xfout) ; } if (subcluster_g || dispatch_g) return ; if (xfstack) mclxaWrite(cl, xfstack, MCLXIO_VALUE_NONE, RETURN_ON_FAIL) ; if (xfcone && !clprev) mclxaWrite(cl, xfcone, MCLXIO_VALUE_NONE, RETURN_ON_FAIL) ; else if (xfcone) { mclx* clprevt = mclxTranspose(clprev) ; mclx* contracted = mclxCompose(clprevt, cl, 0) ; mclxMakeCharacteristic(contracted) ; mclxaWrite(contracted, xfcone, MCLXIO_VALUE_NONE, RETURN_ON_FAIL) ; mclxFree(&clprevt) ; mclxFree(&contracted) ; } }
mcxstatus mcxIOreadFile ( mcxIO *xf , mcxTing *filetxt ) { struct stat mystat ; size_t sz = 4096 ; ssize_t r ; const char* me = "mcxIOreadFile" ; mcxTingEmpty(filetxt, 0) ; if (inbuffer(xf)) buffer_spout(xf, me) ; if (!xf->stdio) { if (stat(xf->fn->str, &mystat)) mcxIOerr(xf, me, "cannae stat file") ; else sz = mystat.st_size ; } if (!xf->fp && mcxIOopen(xf, RETURN_ON_FAIL)) { mcxIOerr(xf, me, "cannae open file") ; return STATUS_FAIL ; } if (xf->ateof) return STATUS_OK /* fixme; ting count overflow */ ; if (!(filetxt = mcxTingEmpty(filetxt, sz))) return STATUS_NOMEM ; while ((r = mcxIOappendChunk(xf, filetxt, sz, 0)) > 0 && !xf->ateof) ; if (r <0) return STATUS_FAIL /* fixme; look closer at error */ ; return STATUS_OK ; }
mcxstatus mcxIOreadLine ( mcxIO *xf , mcxTing *dst , mcxbits flags ) { int a ; dim ll ; mcxbool chomp = flags & MCX_READLINE_CHOMP ? TRUE : FALSE ; mcxbool skip = flags & MCX_READLINE_SKIP_EMPTY ? TRUE : FALSE ; mcxbool par = flags & MCX_READLINE_PAR ? TRUE : FALSE ; mcxbool dot = flags & MCX_READLINE_DOT ? TRUE : FALSE ; mcxbool bsc = flags & MCX_READLINE_BSC ? TRUE : FALSE ; mcxbool repeat = dot || par || bsc ? TRUE : FALSE ; mcxbool continuation = FALSE ; mcxTing* line ; mcxstatus stat = STATUS_OK ; if (!xf->fp && mcxIOopen(xf, RETURN_ON_FAIL)) { mcxIOerr(xf, "mcxIOreadLine", "is not open") ; return STATUS_FAIL ; } if (xf->ateof) return STATUS_DONE ; if (!dst || !mcxTingEmpty(dst, 1)) return STATUS_NOMEM ; if (skip || par) { while((a = mcxIOstep(xf)) == '\n') NOTHING ; if (xf->ateof) return STATUS_DONE ; else mcxIOstepback(a, xf) ; } if (!(line = repeat ? mcxTingEmpty(NULL, 1) : dst)) return STATUS_NOMEM ; while (1) { ofs d = mcxIO__rl_rl__(xf, line) ; if (IO_MEM_ERROR == d) { stat = STATUS_NOMEM /* fixme grainify error/status */ ; break ; } ll = line->len ; if (!repeat) break ; else /* must append line to dst */ { if ( dot && !continuation && line->str[0] == '.' && ( ll == 2 || (ll == 3 && line->str[1] == '\r') ) /* fixme still not fully covering */ ) break /* do not attach the single-dot-line */ ; if (par && !continuation && ll == 1) break /* do not attach the second newline */ ; if (!mcxTingNAppend(dst, line->str, line->len)) { stat = STATUS_NOMEM ; break ; } continuation = bsc && (ll > 1 && *(line->str+ll-2) == '\\') ; if (continuation) mcxTingShrink(dst, -2) ; if (!par && !dot && (bsc && !continuation)) break ; if (xf->ateof) break ; } } if (repeat) mcxTingFree(&line) ; if (stat) return stat /* fixme; should we not check chomp first ? */ /* fixme _: \n\r ? */ ; if (chomp && dst->len && *(dst->str+dst->len-1) == '\n') mcxTingShrink(dst, -1) ; if (xf->ateof && !dst->len) return STATUS_DONE ; return STATUS_OK ; }
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 *xfcl = NULL , *xfctrl = NULL , *xfcoarse= NULL , *xfbase = NULL , *xfcone = NULL , *xfstack = NULL ; mclx* mxbase, *cl, *cl_coarse, *clprev, *clctrl = NULL ; mcxTing* shared = mcxTingNew("-I 4 -overlap split") ; mcxbool root = TRUE ; mcxbool have_bootstrap = FALSE ; const char* plexprefix = NULL ; const char* stem = "mcl" ; mcxbool same = FALSE ; mcxbool plex = TRUE ; mcxbool add_transpose = FALSE ; const char* b2opts = NULL ; const char* b1opts = NULL ; mcxbits write_modes = 0 ; mclAlgParam* mlp = NULL ; mcxstatus status = STATUS_OK ; mcxstatus parse_status = STATUS_OK ; int multiplex_idx = 1 ; int N = 0 ; int n_ite = 0 ; dim n_components = 0, n_cls = 0 ; int a = 1, i= 0 ; int n_arg_read = 0 ; int delta = 0 ; mcxOption* opts, *opt ; mcxTing* cline = mcxOptArgLine(argv+1, argc-1, '\'') ; mclgTF* transform = NULL ; mcxTing* transform_spec = NULL ; double iaf = 0.84 ; mclx_app_init(stderr) ; if (0) mcxLogLevel = MCX_LOG_AGGR | MCX_LOG_MODULE | MCX_LOG_IO | MCX_LOG_GAUGE | MCX_LOG_WARN ; else mcxLogLevelSetByString("xf4g1") ; mcxOptAnchorSortById(options, sizeof(options)/sizeof(mcxOptAnchor) -1) ; if (argc == 2 && argv[1][0] == '-' && mcxOptIsInfo(argv[1], options)) delta = 1 ; else if (argc < 2) { help(options, shared) ; exit(0) ; } opts = mcxOptExhaust (options, (char**) argv, argc, 2-delta, &n_arg_read, &parse_status) ; if (parse_status != STATUS_OK) { mcxErr(me, "initialization failed") ; exit(1) ; } ; for (opt=opts;opt->anch;opt++) { mcxOptAnchor* anch = opt->anch ; switch(anch->id) { case MY_OPT_HELP : help(options, shared) ; exit(0) ; case MY_OPT_APROPOS : help(options, shared) ; exit(0) ; break ; case MY_OPT_NMAX : N = atoi(opt->val) ; break ; case MY_OPT_Z : help(NULL, shared) ; exit(0) ; break ; case MY_OPT_SHARED : mcxTingPrintAfter(shared, " %s", opt->val) ; break ; case MY_OPT_TRANSFORM : transform_spec = mcxTingNew(opt->val) ; break ; case MY_OPT_B1 : b1opts = opt->val ; break ; case MY_OPT_B2 : b2opts = opt->val ; break ; case ALG_OPT_SETENV : mcxSetenv(opt->val) ; break ; case ALG_OPT_QUIET : mcxLogLevelSetByString(opt->val) ; break ; case MY_OPT_HDP : hdp_g = atof(opt->val) ; break ; case MY_OPT_ADDTP : add_transpose = TRUE ; break ; case MY_OPT_ANNOT /* only used in command-line copying */ : break ; case MY_OPT_IAF : iaf = atof(opt->val) / 100 ; break ; case MY_OPT_WRITE : if (strstr(opt->val, "stack")) write_modes |= OUTPUT_STACK ; if (strstr(opt->val, "cone")) write_modes |= OUTPUT_CONE ; if (strstr(opt->val, "levels")) write_modes |= OUTPUT_STEPS ; if (strstr(opt->val, "coarse")) write_modes |= OUTPUT_COARSE ; if (strstr(opt->val, "base")) write_modes |= OUTPUT_BASE ; break ; case MY_OPT_BASENAME : xfbase = mcxIOnew(opt->val, "w") ; break ; case MY_OPT_COARSE : xfcoarse = mcxIOnew(opt->val, "w") ; break ; case MY_OPT_CONE : xfcone = mcxIOnew(opt->val, "w") ; break ; case MY_OPT_ROOT : root = strchr("1yY", (u8) opt->val[0]) ? TRUE : FALSE ; break ; case MY_OPT_STACK : xfstack = mcxIOnew(opt->val, "w") ; break ; case MY_OPT_STEM : stem = opt->val ; break ; case MY_OPT_MULTIPLEX : plex = strchr("yY1", (unsigned char) opt->val[0]) ? TRUE : FALSE ; break ; case MY_OPT_DISPATCH : dispatch_g = TRUE ; break ; case MY_OPT_INTEGRATE : integrate_g = TRUE ; break ; case MY_OPT_CONTRACT : break ; case MY_OPT_SUBCLUSTERX : subclusterx_g = TRUE, subcluster_g = TRUE ; break ; case MY_OPT_SUBCLUSTER : subcluster_g = TRUE ; break ; case MY_OPT_CONTROL : xfctrl = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_CL : xfcl = mcxIOnew(opt->val, "r") ; have_bootstrap = TRUE ; break ; case MY_OPT_VERSION : app_report_version(me) ; exit(0) ; default : mcxExit(1) ; } } mcxOptFree(&opts) ; a = 2 + n_arg_read ; if (a < argc) { if (strcmp(argv[a], "--")) mcxDie ( 1 , me , "trailing %s options require standalone '--' separator (found %s)" , integrate_g ? "integrate" : "mcl" , argv[a] ) ; a++ ; } if (subcluster_g + dispatch_g + integrate_g > 1) mcxDie(1, me, "too many modes!") ; if (N && N < argc-a) mcxErr(me, "-n argument leaves spurious option specifications") ; srandom(mcxSeed(89315)) ; signal(SIGALRM, mclSigCatch) ; if (dispatch_g) plexprefix = "dis" ; else if (!write_modes || (write_modes & OUTPUT_STEPS)) plexprefix = stem ; { mcxTing* tg = mcxTingEmpty(NULL, 30) ; if ((write_modes & OUTPUT_COARSE) && !xfcoarse) mcxTingPrint(tg, "%s.%s", stem, "coarse") , xfcoarse = mcxIOnew(tg->str, "w") ; if ((write_modes & OUTPUT_BASE) && !xfbase) mcxTingPrint(tg, "%s.%s", stem, "base") , xfbase = mcxIOnew(tg->str, "w") ; if ( (!write_modes || (write_modes & OUTPUT_CONE)) && !xfcone ) { mcxTingPrint(tg, "%s.%s", stem, "cone") ; xfcone = mcxIOnew(tg->str, "w") ; mcxIOopen(xfcone, EXIT_ON_FAIL) ; fprintf(xfcone->fp, "# %s %s\n", argv[0], cline->str) ; } if ((write_modes & OUTPUT_STACK) && !xfstack) { mcxTingPrint(tg, "%s.%s", stem, "stack") ; xfstack = mcxIOnew(tg->str, "w") ; mcxIOopen(xfstack, EXIT_ON_FAIL) ; fprintf(xfstack->fp, "# %s %s\n", argv[0], cline->str) ; } mcxTingFree(&tg) ; } if (integrate_g) { for (i=a;i<argc;i++) { mcxIO* xf = mcxIOnew(argv[i], "r") ; mclx* cl = mclxRead(xf, EXIT_ON_FAIL) ; mclxCatPush(&stck_g, cl, NULL, NULL, mclxCBdomStack, NULL, "dummy-integrate", n_cls++) ; } integrate_results(&stck_g) ; if (xfstack) mclxCatWrite(xfstack, &stck_g, MCLXIO_VALUE_NONE, RETURN_ON_FAIL) ; if (xfcone) mclxCatConify(&stck_g) , mclxCatWrite(xfcone, &stck_g, MCLXIO_VALUE_NONE, RETURN_ON_FAIL) ; return 0 ; } for (i=a;i<argc;i++) { if (get_interface(NULL, argv[1], shared->str, argv[i], NULL, 0, RETURN_ON_FAIL)) mcxDie(1, me, "error while testing mcl options viability (%s)", argv[i]) ; } mcxLog(MCX_LOG_APP, me, "pid %ld", (long) getpid()) /* make sure clusters align with this cluster * status: does not seem promising. */ ; if (xfctrl) clctrl = mclxRead(xfctrl, EXIT_ON_FAIL) ; /* * Below: compute cl and mxbase. */ ; if (xfcl) { cl = mclxRead(xfcl, EXIT_ON_FAIL) ; write_clustering (cl, NULL, xfcone, xfstack, plexprefix, multiplex_idx++, NULL) ; if (subcluster_g || dispatch_g) mclxCatPush(&stck_g, cl, NULL, NULL, mclxCBdomStack, NULL, "dummy-mclcm", n_cls++) ; mcxIOfree(&xfcl) ; if (!b1opts && !b2opts) b1opts = "" ; mxbase = get_base(argv[1], NULL, b1opts, b2opts) ; } else { mcxbits CACHE = b1opts || b2opts ? ALG_CACHE_INPUT /* cache, transform later */ : ALG_CACHE_START ; get_interface ( &mlp , argv[1] , shared->str , a < argc ? argv[a] : NULL , NULL , CACHE , EXIT_ON_FAIL ) ; if (a < argc) a++ ; if ((status = mclAlgorithm(mlp)) == STATUS_FAIL) { mcxErr(me, "failed at initial run") ; exit(1) ; } cl_coarse = mclAlgParamRelease(mlp, mlp->cl_result) ; cl_coarse = control_test(cl_coarse, clctrl) ; write_clustering (cl_coarse, NULL, xfcone, xfstack, plexprefix, multiplex_idx++, mlp) ; if (subcluster_g || dispatch_g) mclxCatPush(&stck_g, cl_coarse, NULL, NULL, mclxCBdomStack, NULL, "dummy-mclcm", n_cls++) ; cl = cl_coarse ; n_ite++ ; if (b1opts || b2opts) { mclx* mx_input = mclAlgParamRelease(mlp, mlp->mx_input) ; mxbase = get_base(NULL, mx_input, b1opts, b2opts) /* ^ get_base frees mx_input */ ; } else mxbase = mclAlgParamRelease(mlp, mlp->mx_start) ; } clprev = cl ; mclAlgParamFree(&mlp, TRUE) ; if (xfbase) { dim nre = mclxNrofEntries(mxbase) ; mcxLog(MCX_LOG_APP, me, "base has %lu entries", (ulong) nre) ; mclxaWrite(mxbase, xfbase, MCLXIO_VALUE_GETENV, EXIT_ON_FAIL) ; mcxIOclose(xfbase) ; } if (subcluster_g || dispatch_g) iaf = iaf ? 1/iaf : 1.414 ; while ( (!dispatch_g && (!N || n_ite < N)) || (dispatch_g && a < argc) ) { mclx* mx_coarse = NULL, *clnext = NULL ; dim dist_new_prev = 0, dist_prev_new = 0 ; mclx* clnew = NULL ; mcxbool faith = FALSE ; double inflation = -1.0 ; if (subcluster_g) mx_coarse = subclusterx_g ? mclxBlockPartition(mxbase, clprev, 50) : mclxBlockUnion(mxbase, clprev) /* have to copy mxbase as mx_coarse is freed. * Even if it were not freed, it is probably transformed. */ ; else if (dispatch_g) mx_coarse = mclxCopy(mxbase) ; else { mx_coarse = get_coarse(mxbase, clprev, add_transpose) ; if (n_ite == 1) { mclx* cc = clmUGraphComponents(mx_coarse, NULL) /* fixme; mx_coarse garantueed UD ? */ ; n_components = N_COLS(cc) ; mclxFree(&cc) ; } } if (xfcoarse) write_coarse(xfcoarse, mx_coarse) ; get_interface ( &mlp , NULL , shared->str , a < argc ? argv[a] : NULL , mx_coarse , ALG_CACHE_START , EXIT_ON_FAIL ) ; inflation = mlp->mpp->mainInflation ; BIT_OFF(mlp->modes, ALG_DO_SHOW_PID | ALG_DO_SHOW_JURY) ; if ((status = mclAlgorithm(mlp)) == STATUS_FAIL) { mcxErr(me, "failed") ; mcxExit(1) ; } cl_coarse = mclAlgParamRelease(mlp, mlp->cl_result) ; if (xfcoarse) mclxaWrite(cl_coarse, xfcoarse, MCLXIO_VALUE_NONE, RETURN_ON_FAIL) ; if (dispatch_g || subcluster_g) clnext = cl_coarse ; else clnext = mclxCompose(clprev, cl_coarse, 0) , clnext = control_test(clnext, clctrl) , mclxFree(&cl_coarse) ; clmSJDistance (clprev, clnext, NULL, NULL, &dist_prev_new, &dist_new_prev) ; if (dist_prev_new + dist_new_prev) { write_clustering (clnext, clprev, xfcone, xfstack, plexprefix, multiplex_idx++, mlp) ; clnew = clnext ; if (subcluster_g || dispatch_g) mclxCatPush(&stck_g, clnext, NULL, NULL, mclxCBdomStack, NULL, "dummy-mclcm", n_cls++) ; else mclxFree(&clprev) ; clprev = clnew ; } else if ( N_COLS(clnext) > n_components && inflation * iaf > 1.2 && inflation * iaf < 10 ) { mclxFree(&clnext) ; inflation *= iaf ; mcxTingPrintAfter(shared, " -I %.2f", inflation) ; mcxLog(MCX_LOG_APP, me, "setting inflation to %.2f", inflation) ; faith = TRUE ; } /* i.e. vanilla mode, contraction */ else if (!subcluster_g && !dispatch_g) { mclx* cc ; mclxFree(&clnext) ; mclxAddTranspose(mx_coarse, 1.0) ; cc = clmUGraphComponents(mx_coarse, NULL) ; if (N_COLS(cc) < N_COLS(clprev)) { mclx* ccback = mclxCompose(clprev, cc, 0) ; write_clustering (ccback, clprev, xfcone, xfstack, plexprefix, multiplex_idx++, NULL) ; mclxFree(&clprev) ; clprev = ccback ; mcxTell(me, "connected components added as root clustering") ; } if (root && N_COLS(cc) > 1) { mclx* root = mclxCartesian ( mclvCanonical(NULL, 1, 0) , mclvCopy(NULL, mxbase->dom_cols) , 1.0 ) ; write_clustering (root, clprev, xfcone, xfstack, plexprefix, multiplex_idx++, NULL) ; mclxFree(&clprev) ; mcxTell(me, "universe added as root clustering") ; clprev = root ; clnew = NULL ; } mclxFree(&cc) ; } else if (subcluster_g || dispatch_g) mclxFree(&clnext) ; mclAlgParamFree(&mlp, TRUE) /* frees mx_coarse */ ; if (!clnew && !faith) { same = TRUE ; break ; } a++ ; if (dispatch_g && a == argc) break ; n_ite++ ; } if (same) mcxLog(MCX_LOG_MODULE, me, "no further contraction: halting") ; if (dispatch_g) integrate_results(&stck_g) ; else if (subcluster_g) mclxCatReverse(&stck_g) ; if (dispatch_g || subcluster_g) { dim j ; if (xfstack) mclxCatWrite(xfstack, &stck_g, MCLXIO_VALUE_NONE, RETURN_ON_FAIL) ; if (xfcone && ! mclxCatConify(&stck_g)) mclxCatWrite(xfcone, &stck_g, MCLXIO_VALUE_NONE, RETURN_ON_FAIL) ; for (j=0;j<stck_g.n_level;j++) { mclxAnnot* an = stck_g.level+j ; mclxFree(&an->mx) ; } mcxFree(stck_g.level) ; } mcxIOfree(&xfcoarse) ; mcxIOfree(&xfbase) ; mcxIOfree(&xfcone) ; mcxIOfree(&xfstack) ; mcxTingFree(&shared) ; if (!dispatch_g && !subcluster_g) /* fixme fixme fixme */ mclxFree(&clprev) ; mclxFree(&mxbase) ; mclvFree(&start_col_sums_g) ; mcxTingFree(&cline) ; helpful_reminder() ; return STATUS_OK ; }
mclx* mclxIOstreamIn ( mcxIO* xf , mcxbits bits , mclpAR* transform , void (*ivpmerge)(void* ivp1, const void* ivp2) , mclxIOstreamer* streamer , mcxOnFail ON_FAIL ) { mcxstatus status = STATUS_FAIL ; const char* me = module ; mcxbool symmetric = bits & MCLXIO_STREAM_SYMMETRIC ; mcxbool mirror = bits & MCLXIO_STREAM_MIRROR ; mcxbool abc = bits & MCLXIO_STREAM_ABC ? TRUE : FALSE ; mcxbool one23 = bits & MCLXIO_STREAM_123 ? TRUE : FALSE ; mcxbool etc = bits & (MCLXIO_STREAM_ETC | MCLXIO_STREAM_ETC_AI) ? TRUE : FALSE ; mcxbool longlist = bits & (MCLXIO_STREAM_ETCANY | MCLXIO_STREAM_235ANY) ? TRUE : FALSE ; mcxTing* linebuf = mcxTingEmpty(NULL, 100) ; map_state map_c = { NULL, NULL, -1 , 0} ; map_state map_r = { NULL, NULL, -1 , 0} ; stream_state iface ; etc_state etcstate ; unsigned long n_ite = 0 ; mclx* mx = NULL ; if (!ivpmerge) ivpmerge = mclpMergeMax ; if (symmetric) iface.map_c = &map_c /* this bit of hidgery-pokery */ , iface.map_r = &map_c /* is a crucial interfacummathingy */ ; else iface.map_c = &map_c , iface.map_r = &map_r ;if(DEBUG2)fprintf(stderr, "%s abc\n", abc ? "yes" : "no") ; etcstate.etcbuf = NULL ; etcstate.etcbuf_ofs = 0 ; etcstate.etcbuf_check = 0 ; etcstate.x_prev = ULONG_MAX /* note we depend on ULONG_MAX + 1 == 0 */ ; etcstate.n_y = 0 /* fixme incomplete and distributed initialization of iface */ ; iface.pars = NULL ; iface.pars_n_alloc = 0 ; iface.pars_n_used = 0 ;if(DEBUG3)fprintf(stderr, "1 + max c %lu\n", (ulong) (iface.map_c->max_seen+1)) /* fixme: put the block below in a subroutine */ ; while (1) { if (abc + one23 + longlist > TRUE) /* OUCH */ { mcxErr(module, "multiple stream formats specified") ; break ; } if (!symmetric && streamer->tab_sym_in) { mcxErr(module, "for now disallowed, single tab, different domains") ; break ; } if ((!one23 && !abc && !longlist)) { mcxErr(module, "not enough to get going") ; break ; } /* These have maps associated with them. * Note that bitsp may be changed (by filling in * somewhat underspecified settings). * todo hierverder: etc case supported below ? */ if (abc || etc) stream_state_set_map(symmetric, &iface, streamer, &bits) ; if (xf->fp == NULL && (mcxIOopen(xf, ON_FAIL) != STATUS_OK)) { mcxErr(me, "cannot open stream <%s>", xf->fn->str) ; break ; } status = STATUS_OK ; break ; } iface.bits = bits ; if (!status) while (1) { unsigned long x = 876543210, y = 876543210 ; double value = 0 ; n_ite++ ; iface.x = 0 ; iface.y = 0 ; if (n_ite % 20000 == 0) fputc('.', stderr) /* fixme conditional to sth */ ; if (n_ite % 1000000 == 0) fprintf(stderr, " %ldM\n", (long) (n_ite / 1000000)) /* * - the read routines largely manage iface, including * map_c->max_seen and map_r->max_seen. It would be * nice to encapsulate that management in a single * place. Note the read_abc requirement that sometimes * a label may need to be deleted from a hash. The fact * that handle_label (called by read_etc and read_abc) * also manages max_seen complicate encapsulation though. * * - read_etc manages its line buffer. */ ; status = one23 ? read_123(xf, linebuf, &iface, streamer, &value, bits) : abc ? read_abc(xf, linebuf, &iface, &value) : longlist ? read_etc(xf, &iface, &etcstate, &value) : STATUS_FAIL ; x = iface.x ; y = iface.y /* considerme: etc status ignore could still expand column range. * do we change the status and deal with not incorporating the row, * or do we keep status, and change realloc/ignore logic below? */ ;if(0)fprintf(stderr, "#x now %lu status %s\n", (ulong) (iface.map_c->max_seen+1), MCXSTATUS(status)) /* etc/235 are special in that with NEW x and IGNORE y * we respect x * fixme: should not do that for auto-increment */ ; if (status == STATUS_IGNORE) /* maybe restrict mode */ { if ( longlist && iface.statusx == STATUS_NEW && iface.map_c->max_seen+1 > iface.pars_n_used /* note mixed-sign comparison */ ) { if ((status = pars_realloc(&iface, iface.map_c->max_seen+1))) break ; } continue ; } else if (status) /* FAIL or DONE */ break ; if ( iface.map_c->max_seen >= iface.pars_n_used /* note mixed-sign comparison */ && (status = pars_realloc(&iface, iface.map_c->max_seen+1)) ) break ; status = STATUS_FAIL /* fixme restructure logic, mid-re-initialization is ugly */ ; if ( bits & (MCLXIO_STREAM_LOGTRANSFORM | MCLXIO_STREAM_NEGLOGTRANSFORM) ) { if (bits & MCLXIO_STREAM_LOGTRANSFORM) value = value > 0 ? log(value) : -PVAL_MAX ; else if (bits & MCLXIO_STREAM_NEGLOGTRANSFORM) value = value > 0 ? -log(value) : PVAL_MAX ; if (bits & MCLXIO_STREAM_LOG10) value /= log(10) ; } if (transform) { mclp bufivp ; bufivp.idx = 0 ; bufivp.val = value ; value = mclpUnary(&bufivp, transform) ; } /* fixme: below we have canonical dependence, index as offset */ if (value) { if(DEBUG3)fprintf(stderr, "attempt to extend %d\n", (int) x) ; if (mclpARextend(iface.pars+x, y, value)) { mcxErr(me, "x-extend fails") ; break ; } if (mirror && mclpARextend(iface.pars+y, x, value)) { mcxErr(me, "y-extend fails") ; break ; } } status = STATUS_OK ; } if (n_ite >= 1000000 && n_ite % 5000000) fputc('\n', stderr) ; mcxTingFree(&(etcstate.etcbuf)) ; if (status == STATUS_FAIL || ferror(xf->fp)) mcxErr(me, "error occurred (status %d lc %d)", (int) status, (int) xf->lc) ; else { mx = make_mx_from_pars(streamer, &iface, ivpmerge, bits) ; status = mx ? STATUS_OK : STATUS_FAIL ; } mcxTingFree(&linebuf) ; free_pars(&iface) ; if (status == STATUS_FAIL) { if (ON_FAIL == EXIT_ON_FAIL) mcxDie(1, me, "fini") ; } /* with 123, etcai there is simply no column tab * todo: perhaps create a dummy one (integers). */ if ( !status && (abc || (bits & (MCLXIO_STREAM_ETC | MCLXIO_STREAM_ETC_AI))) ) { if (symmetric) streamer->tab_sym_out = make_tab(iface.map_c) ; else { if (!(bits & MCLXIO_STREAM_ETC_AI)) streamer->tab_col_out = make_tab(iface.map_c) ;if(0)fprintf(stderr, "%p x %p\n", (void*) iface.map_c->map, (void*) iface.map_c->tab) ;if(0)mcxHashStats(stdout, iface.map_c->map) ; streamer->tab_row_out = make_tab(iface.map_r) ; } } mcxHashFree(&(iface.map_c->map), mcxTingRelease, NULL) ; if (!symmetric) mcxHashFree(&(iface.map_r->map), mcxTingRelease, NULL) ; return mx ; }
int main ( int argc , const char* argv[] ) { mcxIO* xf_tab = NULL ; mcxIO* xf_tabr = NULL ; mcxIO* xf_tabc = NULL ; mcxIO* xf_restrict_tab = NULL ; mcxIO* xf_restrict_tabr = NULL ; mcxIO* xf_restrict_tabc = NULL ; mcxIO* xf_mx = mcxIOnew("-", "r") ; mcxIO* xfout = NULL ; const char* fndump = "-" ; mclTab* tabr = NULL ; mclTab* tabc = NULL ; mclTab* restrict_tabr = NULL ; mclTab* restrict_tabc = NULL ; mcxbool transpose = FALSE ; mcxbool lazy_tab = FALSE ; mcxbool write_tabc = FALSE ; mcxbool write_tabr = FALSE ; mcxbool cat = FALSE ; mcxbool tree = FALSE ; mcxbool skel = FALSE ; mcxbool newick = FALSE ; mcxbits newick_bits = 0 ; mcxbits cat_bits = 0 ; dim catmax = 1 ; dim n_max = 0 ; dim table_nlines = 0 ; dim table_nfields = 0 ; int split_idx = 1 ; int split_inc = 1 ; const char* split_stem = NULL ; const char* sort_mode = NULL ; mcxTing* line = mcxTingEmpty(NULL, 10) ; mcxbits modes = MCLX_DUMP_VALUES ; mcxbits mode_dump = MCLX_DUMP_PAIRS ; mcxbits mode_part = 0 ; mcxbits mode_loop = MCLX_DUMP_LOOP_ASIS ; mcxbits mode_matrix = 0 ; int digits = MCLXIO_VALUE_GETENV ; 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_YES) ; 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_TAB : xf_tab = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_TABC : xf_tabc = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_TABR : xf_tabr = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_OUTPUT : fndump = opt->val ; break ; case MY_OPT_SEP_LEAD : sep_lead_g = opt->val ; break ; case MY_OPT_SEP_FIELD : sep_row_g = opt->val ; break ; case MY_OPT_SEP_CAT : sep_cat_g = opt->val ; break ; case MY_OPT_SEP_VAL : sep_val_g = opt->val ; break ; case MY_OPT_PREFIXC : prefixc_g = opt->val ; break ; case MY_OPT_RESTRICT_TAB : xf_restrict_tab = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_RESTRICT_TABC : xf_restrict_tabc = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_RESTRICT_TABR : xf_restrict_tabr = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_LAZY_TAB : lazy_tab = TRUE ; break ; case MY_OPT_NO_VALUES : BIT_OFF(modes, MCLX_DUMP_VALUES) ; break ; case MY_OPT_DUMP_RLINES : mode_dump = MCLX_DUMP_LINES ; BIT_ON(modes, MCLX_DUMP_NOLEAD) ; break ; case MY_OPT_DUMP_VLINES : mode_dump = MCLX_DUMP_LINES ; BIT_ON(modes, MCLX_DUMP_LEAD_VALUE) ; break ; case MY_OPT_DUMP_LINES : mode_dump = MCLX_DUMP_LINES ; break ; case MY_OPT_OMIT_EMPTY : BIT_ON(modes, MCLX_DUMP_OMIT_EMPTY) ; break ; case MY_OPT_SORT : sort_mode = opt->val ; break ; case MY_OPT_NO_LOOPS : mode_loop = MCLX_DUMP_LOOP_NONE ; break ; case MY_OPT_CAT_LIMIT : n_max = atoi(opt->val) ; break ; case MY_OPT_SPLIT_STEM : split_stem = opt->val ; sep_cat_g = NULL ; break ; case MY_OPT_FORCE_LOOPS : mode_loop = MCLX_DUMP_LOOP_FORCE ; break ; case MY_OPT_SKEL : skel = TRUE ; break ; case MY_OPT_WRITE_TABC : write_tabc = TRUE ; break ; case MY_OPT_DIGITS : digits = strtol(opt->val, NULL, 10) ; break ; case MY_OPT_WRITE_TABR : write_tabr = TRUE ; break ; case MY_OPT_DUMP_RDOM : transpose = TRUE ; skel = TRUE ; mode_dump = MCLX_DUMP_LINES ; break ; case MY_OPT_DUMP_CDOM : skel = TRUE ; mode_dump = MCLX_DUMP_LINES ; break ; case MY_OPT_IMX : mcxIOnewName(xf_mx, opt->val) ; break ; case MY_OPT_ICL : mcxIOnewName(xf_mx, opt->val) ; mode_dump = MCLX_DUMP_LINES ; BIT_ON(modes, MCLX_DUMP_NOLEAD) ; BIT_OFF(modes, MCLX_DUMP_VALUES) ; break ; case MY_OPT_TREECAT : mcxIOnewName(xf_mx, opt->val) ; tree = TRUE ; cat_bits |= MCLX_PRODUCE_DOMSTACK ; break ; case MY_OPT_CAT : mcxIOnewName(xf_mx, opt->val) ; cat = TRUE ; break ; case MY_OPT_DUMP_MATRIX : mode_matrix |= MCLX_DUMP_MATRIX ; break ; case MY_OPT_TRANSPOSE : transpose = TRUE ; break ; case MY_OPT_DUMP_UPPER : mode_part = MCLX_DUMP_PART_UPPER ; break ; case MY_OPT_DUMP_UPPERI : mode_part = MCLX_DUMP_PART_UPPERI ; break ; case MY_OPT_DUMP_LOWER : mode_part = MCLX_DUMP_PART_LOWER ; break ; case MY_OPT_DUMP_LOWERI : mode_part = MCLX_DUMP_PART_LOWERI ; break ; case MY_OPT_DUMP_NOLEAD : BIT_ON(modes, MCLX_DUMP_NOLEAD) ; break ; case MY_OPT_NEWICK_MODE : if (strchr(opt->val, 'N')) newick_bits |= (MCLX_NEWICK_NONL | MCLX_NEWICK_NOINDENT) ; if (strchr(opt->val, 'I')) newick_bits |= MCLX_NEWICK_NOINDENT ; if (strchr(opt->val, 'B')) newick_bits |= MCLX_NEWICK_NONUM ; if (strchr(opt->val, 'S')) newick_bits |= MCLX_NEWICK_NOPTHS ; newick = TRUE ; break ; case MY_OPT_DUMP_NEWICK : newick = TRUE ; break ; case MY_OPT_DUMP_TABLE : mode_dump = MCLX_DUMP_TABLE ; break ; case MY_OPT_TABLE_NFIELDS : table_nfields = atoi(opt->val) ; break ; case MY_OPT_TABLE_NLINES : table_nlines = atoi(opt->val) ; break ; case MY_OPT_DUMP_PAIRS : mode_dump = MCLX_DUMP_PAIRS ; break ; } } ; if (skel) cat_bits |= MCLX_READ_SKELETON ; modes |= mode_loop | mode_dump | mode_part | mode_matrix ; xfout = mcxIOnew(fndump, "w") ; mcxIOopen(xfout, EXIT_ON_FAIL) ; mcxIOopen(xf_mx, EXIT_ON_FAIL) ; if (cat || tree) catmax = n_max ? n_max : 0 ; if ((write_tabc || write_tabr) && !xf_tab) mcxDie(1, me, "need a single tab file (-tab option) with --write-tabc or --write-tabr") ; if (xf_tab && mcxIOopen(xf_tab, RETURN_ON_FAIL)) mcxDie(1, me, "no tab") ; else { if (xf_tabr && mcxIOopen(xf_tabr, RETURN_ON_FAIL)) mcxDie(1, me, "no tabr") ; if (xf_tabc && mcxIOopen(xf_tabc, RETURN_ON_FAIL)) mcxDie(1, me, "no tabc") ; } { if (xf_restrict_tab && mcxIOopen(xf_restrict_tab, RETURN_ON_FAIL)) mcxDie(1, me, "no restriction tab") ; else { if (xf_restrict_tabr && mcxIOopen(xf_restrict_tabr, RETURN_ON_FAIL)) mcxDie(1, me, "no restriction tabr") ; if (xf_restrict_tabc && mcxIOopen(xf_restrict_tabc, RETURN_ON_FAIL)) mcxDie(1, me, "no restriction tabc") ; } /* fixme: below is pretty boilerplate, happens in other places as well */ if (xf_restrict_tab) { if (!(restrict_tabr = mclTabRead (xf_restrict_tab, NULL, RETURN_ON_FAIL))) mcxDie(1, me, "error reading restriction tab") ; restrict_tabc = restrict_tabr ; mcxIOclose(xf_restrict_tab) ; } else { if (xf_restrict_tabr) { if (!(restrict_tabr = mclTabRead(xf_restrict_tabr, NULL, RETURN_ON_FAIL))) mcxDie(1, me, "error reading restriction tabr") ; mcxIOclose(xf_restrict_tabr) ; } if (xf_restrict_tabc) { if (!(restrict_tabc = mclTabRead(xf_restrict_tabc, NULL, RETURN_ON_FAIL))) mcxDie(1, me, "error reading restriction tabc") ; mcxIOclose(xf_restrict_tabc) ; } } } /* fixme: restructure code to include bit below */ if (write_tabc || write_tabr) { mclv* dom_cols = mclvInit(NULL) ; mclv* dom_rows = mclvInit(NULL) ; mclv* dom = write_tabc ? dom_cols : dom_rows ; if (!(tabc = mclTabRead(xf_tab, NULL, RETURN_ON_FAIL))) mcxDie(1, me, "error reading tab file") ; if (mclxReadDomains(xf_mx, dom_cols, dom_rows)) mcxDie(1, me, "error reading matrix file") ; mcxIOclose(xf_mx) /* fixme check status */ ; mclTabWrite(tabc, xfout, dom, RETURN_ON_FAIL) ; mcxIOclose(xfout) ; return 0 ; } if (newick) { mcxTing* thetree ; mclxCat cat ; if (xf_tab && !(tabr = mclTabRead(xf_tab, NULL, RETURN_ON_FAIL))) mcxDie(1, me, "error reading tab file") ; mclxCatInit(&cat) ; if ( mclxCatRead ( xf_mx , &cat , 0 , NULL , tabr ? tabr->domain : NULL , MCLX_CATREAD_CLUSTERTREE | MCLX_ENSURE_ROOT ) ) mcxDie(1, me, "failure reading file") ; thetree = mclxCatNewick(&cat, tabr, newick_bits) ; fwrite(thetree->str, 1, thetree->len, xfout->fp) ; fputc('\n', xfout->fp) ; mcxIOclose(xfout) ; return 0 ; } while (1) { mclxIOdumper dumper ; mclxCat cat ; dim i ; if (xf_tab && !lazy_tab) cat_bits |= MCLX_REQUIRE_GRAPH ; mclxCatInit(&cat) ; if (mclxCatRead(xf_mx, &cat, catmax, NULL, NULL, cat_bits)) break ; for (i=0;i<cat.n_level;i++) { mclx* mx = cat.level[i].mx ; if (restrict_tabr || restrict_tabc) { mclx* sub ; sub = mclxSub ( mx , restrict_tabc ? restrict_tabc->domain : mx->dom_cols , restrict_tabr ? restrict_tabr->domain : mx->dom_rows ) ; mx = sub ; } /* noteme fixme dangersign mx now may violate some 'cat' invariant */ if (sort_mode) { if (!strcmp(sort_mode, "size-ascending")) mclxColumnsRealign(mx, mclvSizeCmp) ; else if (!strcmp(sort_mode, "size-descending")) mclxColumnsRealign(mx, mclvSizeRevCmp) ; else mcxErr(me, "unknown sort mode <%s>", sort_mode) ; if (catmax != 1) mcxErr(me, "-sort option and cat mode may fail or corrupt") ; } if (xf_tab && !tabr) { if (!( tabr = mclTabRead (xf_tab, lazy_tab ? NULL : mx->dom_rows, RETURN_ON_FAIL) ) ) mcxDie(1, me, "consider using --lazy-tab option") ; tabc = tabr ; mcxIOclose(xf_tab) ; } else { if (!tabr && xf_tabr) { if (!(tabr = mclTabRead (xf_tabr, lazy_tab ? NULL : mx->dom_rows, RETURN_ON_FAIL) ) ) mcxDie(1, me, "consider using --lazy-tab option") ; mcxIOclose(xf_tabr) ; } if (!tabc && xf_tabc) { if (!( tabc = mclTabRead (xf_tabc, lazy_tab ? NULL : mx->dom_cols, RETURN_ON_FAIL) ) ) mcxDie(1, me, "consider using --lazy-tab option") ; mcxIOclose(xf_tabc) ; } } ; if (transpose) { mclx* tp = mclxTranspose(mx) ; mclxFree(&mx) ; mx = tp ; if (tabc || tabr) { mclTab* tabt = tabc ; tabc = tabr ; tabr = tabt ; } } if (mode_dump == MCLX_DUMP_TABLE) BIT_ON(modes, MCLX_DUMP_TABLE_HEADER) ; mclxIOdumpSet(&dumper, modes, sep_lead_g, sep_row_g, sep_val_g) ; dumper.table_nlines = table_nlines ; dumper.table_nfields = table_nfields ; dumper.prefixc = prefixc_g ; if (split_stem) { mcxTing* ting = mcxTingPrint(NULL, "%s.%03d", split_stem, split_idx) ; mcxIOclose(xfout) ; mcxIOrenew(xfout, ting->str, "w") ; split_idx += split_inc ; } if ( mclxIOdump ( mx , xfout , &dumper , tabc , tabr , digits , RETURN_ON_FAIL ) ) mcxDie(1, me, "something suboptimal") ; mclxFree(&mx) ; if (sep_cat_g && i+1 < cat.n_level) fprintf(xfout->fp, "%s\n", sep_cat_g) ; } break ; } mcxIOfree(&xf_mx) ; mcxIOfree(&xfout) ; mcxIOfree(&xf_tab) ; mcxIOfree(&xf_tabr) ; mcxIOfree(&xf_tabc) ; mcxTingFree(&line) ; return 0 ; }
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 ; }
static dim do_a_file ( aggr** collectpp , const char* fname , dim collect_n ) { mcxIO* xf = mcxIOnew(fname, "r") ; mcxTing* buf = mcxTingEmpty(NULL, 100) ; mcxTing* lbl = mcxTingEmpty(NULL, 100) ; mcxstatus status = STATUS_OK ; aggr* collect = *collectpp ; dim ct = 0, collect_alloc = 0 ; if (!collect_n) collect_alloc = 100 , collect = mcxNAlloc(collect_alloc, sizeof collect[0], NULL, EXIT_ON_FAIL) ; mcxIOopen(xf, EXIT_ON_FAIL) ; while (STATUS_OK == (status = mcxIOreadLine(xf, buf, MCX_READLINE_CHOMP))) { double val ; const char* tabchar = NULL ; mcxbool get_header = collect_g != 'p' && !ct ? TRUE : FALSE ; mcxTingEnsure(lbl, buf->len) /* if header_g && !ct && !paste create/check label */ /* body of this while loop does too many things, refactor */ ; if (collect_g == 'p' || get_header) { if (!(tabchar = strchr(buf->str, '\t'))) mcxDie(1, me, "paste error at line %d file %s (no tab)", (int) xf->lc, fname) ; mcxTingNWrite(lbl, buf->str, tabchar - buf->str) ; } else { if (2 != sscanf(buf->str, "%s%lg", lbl->str, &val)) mcxDie(1, me, "parse error at line %d file %s", (int) xf->lc, fname) ; lbl->len = strlen(lbl->str) ; } if (!collect_n) { if (ct >= collect_alloc) { dim collect_realloc = collect_alloc * 1.44 ; collect = mcxNRealloc(collect, collect_realloc, collect_alloc, sizeof collect[0], NULL, EXIT_ON_FAIL) ; collect_alloc = collect_realloc ; } collect[ct].label = mcxTingStr(lbl) ; collect[ct].val = collect_g == 'p' || get_header ? 0.0 : val ; collect[ct].columns = collect_g == 'p' || get_header ? mcxTingNew(tabchar + (get_header ? 1 : 0)) : NULL ; } else { if (ct >= collect_n) mcxDie(1, me, "additional lines in file %s", fname) ; if (strcmp(collect[ct].label, lbl->str)) mcxDie ( 1 , me , "label conflict %s/%s at line %d in file %s" , collect[ct].label , lbl->str , (int) xf->lc, fname ) ; if (get_header) /* only need to check identity */ { if (strcmp(tabchar+1, collect[ct].columns->str)) mcxDie(1, me, "different columns <%s> and <%s>", collect[ct].columns->str, tabchar+1) ; } else if (collect_g == 'p') /* tack it on */ mcxTingNAppend(collect[ct].columns, tabchar, buf->len - lbl->len) ; else collect[ct].val += val ; } ct++ ; } if (collect_n) { if (ct != collect_n) mcxDie(1, me, "not enough lines in file %s", fname) ; } else { if (!ct) mcxDie(1, me, "empty file(s)") ; *collectpp = collect ; } mcxIOfree(&xf) ; return ct ; }
static mcxstatus mateMain ( int argc_unused cpl__unused , const char* argv[] ) { mcxIO* xfx, *xfy ; mclx* mx, *my, *meet, *teem, *myt ; dim x, y ; mcxIOopen(xfout, EXIT_ON_FAIL) ; xfx = mcxIOnew(argv[0], "r") ; mx = mclxRead(xfx, EXIT_ON_FAIL) ; mcxIOclose(xfx) ; xfy = mcxIOnew(argv[1], "r") ; my = mclxRead(xfy, EXIT_ON_FAIL) ; myt = mclxTranspose(my) ; if (!MCLD_EQUAL(mx->dom_rows, my->dom_rows)) mcxDie(1, me, "domains are not equal") ; meet= mclxCompose(myt, mx, 0, 0) /* fixme thread interface */ ; teem= mclxTranspose(meet) ; if (legend) fprintf ( xfout->fp , "%-10s %6s %6s %6s %6s %6s %6s %6s\n" , "overlap" , "x-idx" , "y-idx" , "meet" , "xdiff" , "ydiff" , "x-size" , "y-size" ) ; for (x=0;x<N_COLS(meet);x++) { mclv* xvec = meet->cols+x ; long X = xvec->vid ; long xsize = mx->cols[x].n_ivps ; if (one2many && xvec->n_ivps < 2) continue ; for (y=0;y<N_COLS(teem);y++) { mclv* yvec = teem->cols+y ; long Y = yvec->vid ; long ysize = my->cols[y].n_ivps ; double twinfac ; long meetsize ; mclp* ivp = mclvGetIvp(yvec, X, NULL) ; if (!ivp) continue /* * meet size, left diff, right diff, right size. */ ; meetsize = ivp->val ; if (!xsize && !ysize) /* paranoia */ continue ; twinfac = 2 * meetsize / ( (double) (xsize + ysize) ) ; if (xfout) fprintf ( xfout->fp , "%-10.3f %6ld %6ld %6ld %6ld %6ld %6ld %6ld\n" , twinfac , X , Y , meetsize , xsize - meetsize , ysize - meetsize , xsize , ysize ) ; } } 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 ; }
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 ; }