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 dim clm_clm_prune
( mclx* mx
, mclx* cl
, dim prune_sz
, mclx** cl_adjustedpp
, dim* n_sink
, dim* n_source
)
{ dim d, n_adjusted = 0
; mclx* cl_adj = mclxCopy(cl)
; mclv* cid_affected = mclvClone(cl->dom_cols)
; const char* me = "clmAssimilate"
; double bar_affected = 1.5
; mclx *el_to_cl = NULL
; mclx *el_on_cl = NULL
; mclx *cl_on_cl = NULL
; mclx *cl_on_el = NULL
; *n_sink = 0
; *n_source = 0
; mclvMakeConstant(cid_affected, 1.0)
; mclxColumnsRealign(cl_adj, mclvSizeCmp)
; *cl_adjustedpp = NULL
; clmCastActors
(&mx, &cl_adj, &el_to_cl, &el_on_cl, &cl_on_cl, &cl_on_el, 0.95)
; mclxFree(&cl_on_el)
; for (d=0;d<N_COLS(cl_on_cl);d++)
{ mclv* clthis = cl_adj->cols+d
; mclv* cllist = cl_on_cl->cols+d
; mclp* pself = mclvGetIvp(cllist, clthis->vid, NULL)
; double self_val = -1.0
; if (pself)
self_val = pself->val
, pself->val *= 1.001 /* to push it up in case of equal weights */
;if(0)fprintf(stderr, "test size %d\n", (int) clthis->n_ivps)
; if (prune_sz && clthis->n_ivps > prune_sz)
continue
; while (1)
{ mclv* clthat
; dim e
; if (cllist->n_ivps < 2)
break
; mclvSort(cllist, mclpValRevCmp)
/* now get biggest mass provided that cluster
* ranks higher (has at least as many entries)
*
* fixme/todo: we probably have a slight order
* dependency for some fringe cases. If provable
* then either solve or document it.
*/
; for (e=0;e<cllist->n_ivps;e++)
if (cllist->ivps[e].idx >= clthis->vid)
break
/* found none or itself */
; if (e == cllist->n_ivps || cllist->ivps[e].idx == clthis->vid)
break
; if /* Should Not Happen */
(!(clthat
= mclxGetVector(cl_adj, cllist->ivps[e].idx, RETURN_ON_FAIL, NULL)
) )
break
/* works for special case prune_sz == 0 */
/* if (clthat->n_ivps + clthis->n_ivps > prune_sz) */
/* ^iced. inconsistent behaviour as k grows. */
; { mcxLog
( MCX_LOG_LIST
, me
, "source %ld|%lu|%.3f absorbed by %ld|%lu|%.3f"
, clthis->vid, (ulong) clthis->n_ivps, self_val
, clthat->vid, (ulong) clthat->n_ivps, cllist->ivps[0].val
)
; n_adjusted += clthis->n_ivps
; (*n_sink)++
/* note: we could from our precomputed cl_on_cl
* obtain that A is absorbed in B, B is absorbed in C.
* below we see that A will be merged with B,
* and the result will then be merged with C.
* This depends on the fact that cl_adj is ordered
* on increasing cluster size.
*/
; mcldMerge(cl_adj->cols+d, clthat, clthat)
; mclvResize(cl_adj->cols+d, 0)
; mclvInsertIdx(cid_affected, clthat->vid, 2.0)
; }
break
; }
mclvSort(cllist, mclpIdxCmp)
; }
mclxFree(&cl_on_cl)
; mclxFree(&el_on_cl)
; mclxFree(&el_to_cl)
; mclxMakeCharacteristic(cl)
; mclvUnary(cid_affected, fltxGT, &bar_affected)
; *n_source = cid_affected->n_ivps
; mclvFree(&cid_affected)
; mclxColumnsRealign(cl_adj, mclvSizeRevCmp)
; if (!n_adjusted)
{ mclxFree(&cl_adj)
; return 0
; }
mclxUnary(cl_adj, fltxCopy, NULL)
; mclxMakeCharacteristic(cl_adj)
; *cl_adjustedpp = cl_adj
; return n_adjusted
; }
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
; }
dim clmAdjust
( mclx* mx
, mclx* cl
, dim cls_size_max
, mclx** cl_adjustedpp
, mclv** ls_adjustedpp /* nodes that moved around */
, dim* sjd_left
, dim* sjd_right
)
{ dim sum_adjusted = 0, n_ite = 0
; dim dist_curr_adj = 0, dist_adj_curr = 0
; mclx* cl_adj = NULL
; mclx* cl_curr = cl
; mclv* ls_adjusted = mclvInit(NULL)
; clmXScore score_curr, score_adj
; const char* me = "clmAdjust"
; *cl_adjustedpp = NULL
; *ls_adjustedpp = NULL
; while (1)
{ dim n_adjusted
; double cov_curr, cov_adj, frac_curr = 0.0, frac_adj = 0.0
; mclv* cid_affected = NULL, *nid_affected = NULL
; dim o, m, e
; if (n_ite++ >= 100)
break
; mclxColumnsRealign(cl_curr, mclvSizeCmp)
; if
( !(n_adjusted
= clm_clm_adjust
(mx, cl_curr, cls_size_max, &cl_adj, &cid_affected, &nid_affected)
)
)
break
; mcxTell
( me
, "assembled %lu nodes with %lu clusters affected"
, (ulong) n_adjusted
, (ulong) cid_affected->n_ivps
)
; clmXScanInit(&score_curr)
; clmXScanInit(&score_adj)
; clmXScanDomainSet(mx, cl_curr,cid_affected, &score_curr)
; clmXScanDomainSet(mx, cl_adj, cid_affected, &score_adj)
; clmXScoreCoverage(&score_curr, &cov_curr, NULL)
; clmXScoreCoverage(&score_adj , &cov_adj , NULL)
; if (score_curr.n_hits && score_adj.n_hits)
frac_curr = score_curr.sum_i / score_curr.n_hits
, frac_adj = score_adj.sum_i / score_adj.n_hits
; mcxLog
( MCX_LOG_LIST
, me
, "consider (%.5f|%.5f|%lu) vs (%.5f|%.5f|%lu)"
, cov_adj, frac_adj, (ulong) score_adj.n_hits
, cov_curr, frac_curr, (ulong) score_curr.n_hits
)
/* experience tells us that mcl's funneling
* worsens frac
*/
; if (frac_adj <= frac_curr)
{ mclvFree(&cid_affected)
; mclvFree(&nid_affected)
; break
; }
clmEnstrict(cl_adj, &o, &m, &e, 0)
; clmSJDistance(cl_curr, cl_adj, NULL, NULL, &dist_curr_adj, &dist_adj_curr)
; mcxLog
( MCX_LOG_AGGR
, me
, "distance %lu|%lu"
, (ulong) dist_curr_adj, (ulong) dist_adj_curr
)
; mclvAdd(ls_adjusted, nid_affected, ls_adjusted)
; if (cl_curr != cl)
mclxFree(&cl_curr)
; cl_curr = cl_adj
; sum_adjusted += n_adjusted
; mclvFree(&cid_affected)
; mclvFree(&nid_affected)
; }
if (cl_curr != cl) /* fixme free logic */
{ mclxColumnsRealign(cl_curr, mclvSizeRevCmp)
; *cl_adjustedpp = cl_curr
; *ls_adjustedpp = ls_adjusted
; clmSJDistance
(cl, cl_curr, NULL, NULL, &dist_curr_adj, &dist_adj_curr)
; if (sjd_left)
*sjd_left = dist_curr_adj
, *sjd_right = dist_adj_curr
; }
else
{ if (sjd_left)
*sjd_left = 0
, *sjd_right = 0
; mclvFree(&ls_adjusted)
; }
mcxLog
( MCX_LOG_AGGR
, me
, "total adjusted %lu, final distance %lu|%lu"
, (ulong) sum_adjusted
, (ulong) dist_curr_adj
, (ulong) dist_adj_curr
)
; mclxColumnsRealign(cl, mclvSizeRevCmp)
; return sum_adjusted
; }
