int main
( int argc
, const char* argv[]
)
{ mclx* mx_score, *mx_start, *mx_end
; mcxIO* xfs, *xfl, *xfr
; dim i, j
; if (argc != 4)
mcxDie(1, me, "need score start end matrices")
; xfs = mcxIOnew(argv[1], "r")
; xfl = mcxIOnew(argv[2], "r")
; xfr = mcxIOnew(argv[3], "r")
; mx_score = mclxRead(xfs, EXIT_ON_FAIL)
; mx_start = mclxRead(xfl, EXIT_ON_FAIL)
; mx_end = mclxRead(xfr, EXIT_ON_FAIL)
; fprintf
( stdout
, "%10s%10s%10s%10s%10s%10s%10s%10s%10s%10s%10s%10s\n"
, "vid1"
, "vid2"
, "diff1"
, "diff2"
, "meet"
, "score"
, "mean"
, "csn"
, "euclid"
, "frac"
, "re1"
, "re2"
)
; for (i=0;i< N_COLS(mx_score);i++)
{ for (j=0;j<N_COLS(mx_score);j++)
{ double s
; s =
get_score
( mx_score->cols+i
, mx_score->cols+j
, mx_start->cols+i
, mx_start->cols+j
, mx_end->cols+i
, mx_end->cols+j
)
; }
}
return 0
; }
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
; }
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 *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 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 *xf_cl = NULL, *xf_mx = NULL
;
mclx *cl = NULL, *elcl = NULL
;
int a = 1
;
dim i
;
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)
;
while(a < argc)
{ if (!strcmp(argv[a], "-icl"))
{ if (a++ + 1 < argc)
xf_cl = mcxIOnew(argv[a], "r")
;
else goto arg_missing
;
}
else if (!strcmp(argv[a], "-h"))
{ help
:
mcxUsage(stdout, me, usagelines)
;
mcxExit(STATUS_FAIL)
;
}
else if (!strcmp(argv[a], "--version"))
{ app_report_version(me)
;
exit(0)
;
}
else if (!strcmp(argv[a], "-imx"))
{ if (a++ + 1 < argc)
xf_mx = mcxIOnew(argv[a], "r")
;
else goto arg_missing
;
}
else if (!strcmp(argv[a], "-h"))
{ goto help
;
}
else if (0)
{ arg_missing:
;
mcxErr
( me
, "flag <%s> needs argument; see help (-h)"
, argv[argc-1]
)
;
mcxExit(1)
;
}
else
{ mcxErr
( me
, "unrecognized flag <%s>; see help (-h)"
, argv[a]
)
;
mcxExit(1)
;
}
a++
;
}
if (!xf_cl)
mcxErr(me, "need cluster file")
, mcxExit(1)
;
cl = mclxRead(xf_cl, EXIT_ON_FAIL)
;
elcl = mclxTranspose(cl)
;
for (i=0; i<N_COLS(elcl); i++)
{ mclv* vec = elcl->cols+i
;
if (vec->n_ivps > 1)
fprintf(stdout, "%ld\n", (long) vec->vid)
;
}
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
; }
static void vary_threshold
( mcxIO* xf
, FILE* fp
, int vary_a
, int vary_z
, int vary_s
, int vary_n
, unsigned mode
)
{ dim cor_i = 0, j
; int step
; mclx* mx
; unsigned long noe
; pval* allvals
; dim n_allvals = 0
; double sum_vals = 0.0
; mx = mclxRead(xf, EXIT_ON_FAIL)
; mcxIOclose(xf)
; if (transform)
mclgTFexec(mx, transform)
; noe = mclxNrofEntries(mx)
; allvals = mcxAlloc(noe * sizeof allvals[0], EXIT_ON_FAIL)
; if (!weight_scale)
{ if (mode == 'c')
weight_scale = 1.0
; else
weight_scale = vary_n
; }
n_allvals = get_n_sort_allvals(mx, allvals, noe, &sum_vals, FALSE)
; if (mode == 'c')
{ double smallest = n_allvals ? allvals[n_allvals-1] : -DBL_MAX
; if (vary_a * 1.0 / vary_n < smallest)
{ while (vary_a * 1.0 / vary_n < smallest)
vary_a++
; vary_a--
; }
mcxTell
( me
, "smallest correlation is %.2f, using starting point %.2f"
, smallest
, vary_a * 1.0 / vary_n
)
; }
if (output_flags & OUTPUT_TABLE)
{
;fprintf(fp, "L\tD\tR\tS\tcce\tEWmean\tEWmed\tEWiqr\tNDmean\tNDmed\tNDiqr\tCCF\t%s\n", mode == 'k' ? "kNN" : mode == 'l' ? "N" : "Cutoff")
;} else
{ if (output_flags & OUTPUT_KEY)
{
;fprintf(fp, "-------------------------------------------------------------------------------\n")
;fprintf(fp, " L Percentage of nodes in the largest component\n")
;fprintf(fp, " D Percentage of nodes in components of size at most %d [-div option]\n", (int) divide_g)
;fprintf(fp, " R Percentage of nodes not in L or D: 100 - L -D\n")
;fprintf(fp, " S Percentage of nodes that are singletons\n")
;fprintf(fp, " cce Expected size of component, nodewise [ sum(sz^2) / sum^2(sz) ]\n")
;fprintf(fp, "*EW Edge weight traits (mean, median and IQR, all scaled!)\n")
;fprintf(fp, " Scaling is used to avoid printing of fractional parts throughout.\n")
;fprintf(fp, " The scaling factor is %.2f [-report-scale option]\n", weight_scale)
;fprintf(fp, " ND Node degree traits [mean, median and IQR]\n")
;fprintf(fp, " CCF Clustering coefficient %s\n", compute_flags & COMPUTE_CLCF ? "(not computed; use --clcf to include this)" : "")
;fprintf(fp, " eff Induced component efficiency %s\n", compute_flags & COMPUTE_EFF ? "(not computed; use --eff to include this)" : "")
;if (mode == 'c')
fprintf(fp, "Cutoff The threshold used.\n")
;else if (mode == 't')
fprintf(fp, "*Cutoff The threshold with scale factor %.2f and fractional parts removed\n", weight_scale)
;else if (mode == 'k')
fprintf(fp, "k-NN The knn parameter\n")
;else if (mode == 'l')
fprintf(fp, "N The knn parameter (merge mode)\n")
;else if (mode == 'n')
fprintf(fp, "ceil The ceil parameter\n")
;fprintf(fp, "Total number of nodes: %lu\n", (ulong) N_COLS(mx))
;}
fprintf(fp, "-------------------------------------------------------------------------------\n")
;fprintf(fp, " L D R S cce *EWmean *EWmed *EWiqr NDmean NDmed NDiqr CCF eff %6s \n", mode == 'k' ? "k-NN" : mode == 'l' ? "N" : mode == 'n' ? "Ceil" : "Cutoff")
;fprintf(fp, "-------------------------------------------------------------------------------\n")
; }
for (step = vary_a; step <= vary_z; step += vary_s)
{ double cutoff = step * 1.0 / vary_n
; double eff = -1.0
; mclv* nnodes = mclvCanonical(NULL, N_COLS(mx), 0.0)
; mclv* degree = mclvCanonical(NULL, N_COLS(mx), 0.0)
; dim i, n_sample = 0
; double cor, y_prev, iqr = 0.0
; mclx* cc = NULL, *res = NULL
; mclv* sz, *ccsz = NULL
; int step2 = vary_z + vary_a - step
; sum_vals = 0.0
; if (mode == 't' || mode == 'c')
mclxSelectValues(mx, &cutoff, NULL, MCLX_EQT_GQ)
, res = mx
; else if (mode == 'k')
{ res = rebase_g ? mclxCopy(mx) : mx
; mclxKNNdispatch(res, step2, n_thread_l, 1)
; }
else if (mode == 'l')
{ res = mx
; mclxKNNdispatch(res, step2, n_thread_l, 0)
; }
else if (mode == 'n')
{ res = rebase_g ? mclxCopy(mx) : mx
; mclv* cv = mclgCeilNB(res, step2, NULL, NULL, NULL)
; mclvFree(&cv)
; }
sz = mclxColSizes(res, MCL_VECTOR_COMPLETE)
; mclvSortDescVal(sz)
; cc = clmUGraphComponents(res, NULL) /* fixme: user has to specify -tf '#max()' if graph is directed */
; if (cc)
{ ccsz = mclxColSizes(cc, MCL_VECTOR_COMPLETE)
; if (compute_flags & COMPUTE_EFF)
{ clmPerformanceTable pftable
; clmPerformance(mx, cc, &pftable)
; eff = pftable.efficiency
; }
}
if (mode == 't' || mode == 'c')
{ for
(
; n_allvals > 0 && allvals[n_allvals-1] < cutoff
; n_allvals--
)
; sum_vals = 0.0
; for (i=0;i<n_allvals;i++)
sum_vals += allvals[i]
; }
else if (mode == 'k' || mode == 'n' || mode == 'l')
{ n_allvals = get_n_sort_allvals(res, allvals, noe, &sum_vals, FALSE)
; }
levels[cor_i].sim_median= mcxMedian(allvals, n_allvals, sizeof allvals[0], pval_get_double, &iqr)
; levels[cor_i].sim_iqr = iqr
; levels[cor_i].sim_mean = n_allvals ? sum_vals / n_allvals : 0.0
; levels[cor_i].nb_median = mcxMedian(sz->ivps, sz->n_ivps, sizeof sz->ivps[0], ivp_get_double, &iqr)
; levels[cor_i].nb_iqr = iqr
; levels[cor_i].nb_mean = mclvSum(sz) / N_COLS(res)
; levels[cor_i].cc_exp = cc ? mclvPowSum(ccsz, 2.0) / N_COLS(res) : 0
; levels[cor_i].nb_sum = mclxNrofEntries(res)
; if (compute_flags & COMPUTE_CLCF)
{ mclv* clcf = mclgCLCFdispatch(res, n_thread_l)
; levels[cor_i].clcf = mclvSum(clcf) / N_COLS(mx)
; mclvFree(&clcf)
; }
else
levels[cor_i].clcf = 0.0
; levels[cor_i].threshold = mode == 'k' || mode == 'l' || mode == 'n' ? step2 : cutoff
; levels[cor_i].bigsize = cc ? cc->cols[0].n_ivps : 0
; levels[cor_i].n_single = 0
; levels[cor_i].n_edge = n_allvals
; levels[cor_i].n_lq = 0
; if (cc)
for (i=0;i<N_COLS(cc);i++)
{ dim n = cc->cols[N_COLS(cc)-1-i].n_ivps
; if (n == 1)
levels[cor_i].n_single++
; if (n <= divide_g)
levels[cor_i].n_lq += n
; else
break
; }
if (levels[cor_i].bigsize <= divide_g)
levels[cor_i].bigsize = 0
; y_prev = sz->ivps[0].val
/* wiki says:
A scale-free network is a network whose degree distribution follows a power
law, at least asymptotically. That is, the fraction P(k) of nodes in the
network having k connections to other nodes goes for large values of k as P(k)
~ k^−g where g is a constant whose value is typically in the range 2<g<3,
although occasionally it may lie outside these bounds.
*/
; for (i=1;i<sz->n_ivps;i++)
{ double y = sz->ivps[i].val
; if (y > y_prev - 0.5)
continue /* same as node degree seen last */
; nnodes->ivps[n_sample].val = log( (i*1.0) / (1.0*N_COLS(res))) /* x = #nodes >= k, as fraction */
; degree->ivps[n_sample].val = log(y_prev ? y_prev : 1) /* y = k = degree of node */
; n_sample++
;if(0)fprintf(stderr, "k=%.0f\tn=%d\t%.3f\t%.3f\n", (double) y_prev, (int) i, (double) nnodes->ivps[n_sample-1].val, (double) degree->ivps[n_sample-1].val)
; y_prev = y
; }
nnodes->ivps[n_sample].val = 0
; nnodes->ivps[n_sample++].val = log(y_prev ? y_prev : 1)
;if(0){fprintf(stderr, "k=%.0f\tn=%d\t%.3f\t%.3f\n", (double) sz->ivps[sz->n_ivps-1].val, (int) N_COLS(res), (double) nnodes->ivps[n_sample-1].val, (double) degree->ivps[n_sample-1].val)
;}
; mclvResize(nnodes, n_sample)
; mclvResize(degree, n_sample)
; cor = pearson(nnodes, degree, n_sample)
; levels[cor_i].degree_cor = cor * cor
;if(0)fprintf(stdout, "cor at cutoff %.2f %.3f\n\n", cutoff, levels[cor_i-1].degree_cor)
; mclvFree(&nnodes)
; mclvFree(°ree)
; mclvFree(&sz)
; mclvFree(&ccsz)
; mclxFree(&cc)
; if(output_flags & OUTPUT_TABLE)
{ fprintf
( fp
, "%lu\t%lu\t%lu\t%lu\t%lu"
"\t%6g\t%6g\t%6g"
"\t%6g\t%lu\t%6g"
, (ulong) levels[cor_i].bigsize
, (ulong) levels[cor_i].n_lq
, (ulong) N_COLS(mx) - levels[cor_i].bigsize - levels[cor_i].n_lq
, (ulong) levels[cor_i].n_single
, (ulong) levels[cor_i].cc_exp
, (double) levels[cor_i].sim_mean
, (double) levels[cor_i].sim_median
, (double) levels[cor_i].sim_iqr
, (double) levels[cor_i].nb_mean
, (ulong) levels[cor_i].nb_median
, (double) levels[cor_i].nb_iqr
)
; if (compute_flags & COMPUTE_CLCF) fprintf(fp, "\t%6g", levels[cor_i].clcf) ; else fputs("\tNA", fp)
; if (eff >= 0.0) fprintf(fp, "\t%4g", eff) ; else fputs("\tNA", fp)
; fprintf(fp, "\t%6g", (double) levels[cor_i].threshold)
; fputc('\n', fp)
; }
else
{ fprintf
( fp
, "%3d %3d %3d %3d %7d "
"%7.0f %7.0f %6.0f"
"%6.1f %6.0f %6.0f"
, 0 ? 1 : (int) (0.5 + (100.0 * levels[cor_i].bigsize) / N_COLS(mx))
, 0 ? 1 : (int) (0.5 + (100.0 * levels[cor_i].n_lq) / N_COLS(mx))
, 0 ? 1 : (int) (0.5 + (100.0 * (N_COLS(mx) - levels[cor_i].bigsize - levels[cor_i].n_lq)) / N_COLS(mx))
, 0 ? 1 : (int) (0.5 + (100.0 * levels[cor_i].n_single) / N_COLS(mx))
, 0 ? 1 : (int) (0.5 + levels[cor_i].cc_exp)
, 0 ? 1.0 : (double) (levels[cor_i].sim_mean * weight_scale)
, 0 ? 1.0 : (double) (levels[cor_i].sim_median * weight_scale)
, 0 ? 1.0 : (double) (levels[cor_i].sim_iqr * weight_scale)
, 0 ? 1.0 : (double) (levels[cor_i].nb_mean )
, 0 ? 1.0 : (double) (levels[cor_i].nb_median + 0.5 )
, 0 ? 1.0 : (double) (levels[cor_i].nb_iqr + 0.5 )
)
; if (compute_flags & COMPUTE_CLCF)
fprintf(fp, " %3d", 0 ? 1 : (int) (0.5 + (100.0 * levels[cor_i].clcf)))
; else
fputs(" -", fp)
; if (eff >= 0.0)
fprintf(fp, " %3d", (int) (0.5 + 1000 * eff))
; else
fputs(" -", fp)
; if (mode == 'c')
fprintf(fp, "%8.2f\n", (double) levels[cor_i].threshold)
; else if (mode == 't')
fprintf(fp, "%8.0f\n", (double) levels[cor_i].threshold * weight_scale)
; else if (mode == 'k' || mode == 'n' || mode == 'l')
fprintf(fp, "%8.0f\n", (double) levels[cor_i].threshold)
; }
; cor_i++
; if (res != mx)
mclxFree(&res)
; }
if (!(output_flags & OUTPUT_TABLE))
{ if (weefreemen)
{
fprintf(fp, "-------------------------------------------------------------------------------\n")
;fprintf(fp, "The graph below plots the R^2 squared value for the fit of a log-log plot of\n")
;fprintf(fp, "<node degree k> versus <#nodes with degree >= k>, for the network resulting\n")
;fprintf(fp, "from applying a particular %s cutoff.\n", mode == 'c' ? "correlation" : "similarity")
;fprintf(fp, "-------------------------------------------------------------------------------\n")
; for (j=0;j<cor_i;j++)
{ dim jj
; for (jj=30;jj<=100;jj++)
{ char c = ' '
; if (jj * 0.01 < levels[j].degree_cor && (jj+1.0) * 0.01 > levels[j].degree_cor)
c = 'X'
; else if (jj % 5 == 0)
c = '|'
; fputc(c, fp)
; }
if (mode == 'c')
fprintf(fp, "%8.2f\n", (double) levels[j].threshold)
; else
fprintf(fp, "%8.0f\n", (double) levels[j].threshold * weight_scale)
; }
fprintf(fp, "|----+----|----+----|----+----|----+----|----+----|----+----|----+----|--------\n")
;fprintf(fp, "| R^2 0.4 0.5 0.6 0.7 0.8 0.9 | 1.0 -o)\n")
;fprintf(fp, "+----+----+----+----+----+---------+----+----+----+----+----+----+----+ /\\\\\n")
;fprintf(fp, "| 2 4 6 8 2 4 6 8 | 2 4 6 8 | 2 4 6 8 | 2 4 6 8 | 2 4 6 8 | 2 4 6 8 | _\\_/\n")
;fprintf(fp, "+----+----|----+----|----+----|----+----|----+----|----+----|----+----+--------\n")
; }
else
fprintf(fp, "-------------------------------------------------------------------------------\n")
; }
mclxFree(&mx)
; mcxFree(allvals)
; }
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
; }
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
; }