void clusterMeasure
( const mclMatrix* clus
, FILE* fp
)
{ int clsize = N_COLS(clus)
;
int clrange = N_ROWS(clus)
;
double ctr = 0.0
;
dim d
;
for (d=0; d<N_COLS(clus); d++)
ctr += pow((clus->cols+d)->n_ivps, 2.0)
;
if (clsize && clrange)
ctr /= clrange
;
fprintf
( fp
, " %-d"
, (int) clsize
)
;
}
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
; }
/* fixme: more robust would be to use distance to meet */
static int annot_cmp_coarse_first
( const void* a1
, const void* a2
)
{ const mclx* mx1 = ((mclxAnnot*) a1)->mx
; const mclx* mx2 = ((mclxAnnot*) a2)->mx
; return
N_COLS(mx1) < N_COLS(mx2)
? -1
: N_COLS(mx1) > N_COLS(mx2)
? 1
: 0
; }
int mclDagTest
( const mclMatrix* dag
)
{ mclv* v_transient = mclvCopy(NULL, dag->dom_cols)
; mclx* m_transient = NULL
; int maxdepth = 0
; dim d
; mclvMakeCharacteristic(v_transient)
; for (d=0;d<N_COLS(dag);d++)
{ mclv* col = dag->cols+d
; if (mclvGetIvp(col, col->vid, NULL)) /* deemed attractor */
mclvInsertIdx(v_transient, col->vid, 0.25)
; }
mclvSelectGqBar(v_transient, 0.5)
; m_transient = mclxSub(dag, v_transient, v_transient)
;if(0)mclxDebug("-", m_transient, 3, "transient")
; maxdepth = calc_depth(m_transient)
; mclxFree(&m_transient)
; mclvFree(&v_transient)
; return maxdepth
; }
void test_cross_ratio
( mclx* mx
)
{ dim i, j, n = 0
; for (i=0;i<N_COLS(mx);i++)
{ mclv* v = mx->cols+i
; double selfv = mclvSelf(v)
; for (j=0;j<v->n_ivps;j++)
{ mclv* w = mclxGetVector(mx, v->ivps[j].idx, EXIT_ON_FAIL, NULL)
; double arc = v->ivps[j].val
; double selfw= mclvSelf(w)
; double cra = mclvIdxVal(w, v->vid, NULL)
; double s = MCX_MIN(selfv, selfw)
; if (s > arc || s > cra)
fprintf
( stdout
, "%u\t%u\t%g\t%g\t%g\t%g\n"
, (unsigned) v->vid
, (unsigned) w->vid
, arc
, cra
, selfv
, selfw
)
; n++
; }
}
fprintf(stderr, "tested %u entries\n", (unsigned) n)
; }
static void prune_el_on_cl
( mclMatrix* el_to_cl /* must be conforming */
, mclMatrix* el_on_cl /* this one will be pruned */
, double pct
, int max
)
{ dim i
; for (i=0;i<N_COLS(el_on_cl);i++)
{ mclv* elclvec = el_on_cl->cols+i
; long clid = el_to_cl->cols[i].ivps[0].idx
; double sum = 0.0
; int n_others = 0
; dim k = 0
; mcxbool selfok = FALSE
; mclvSort(elclvec, mclpValRevCmp)
; while (k++ < elclvec->n_ivps && sum < pct && n_others < max)
{ long y = elclvec->ivps[k-1].idx
; if (y == clid)
selfok = TRUE
; sum += elclvec->ivps[k-1].val
; n_others++
; }
mclvResize(elclvec, k-1) /* careful recentchange */
; mclvSort(elclvec, mclpIdxCmp)
; if (!selfok)
mclvInsertIdx(elclvec, clid, 0.01)
; }
}
dim get_n_sort_allvals
( const mclx* mx
, pval* allvals
, dim noe
, double* sum_vals
, mcxbool asc
)
{ dim n_allvals = 0
; double s = 0.0
; dim j
; for (j=0;j<N_COLS(mx);j++)
{ mclv* vec = mx->cols+j
; dim k
; if (n_allvals + vec->n_ivps > noe)
mcxDie(1, me, "panic/impossible: not enough memory")
; for (k=0;k<vec->n_ivps;k++)
allvals[n_allvals+k] = vec->ivps[k].val
; n_allvals += vec->n_ivps
; s += mclvSum(vec)
; }
if (asc)
qsort(allvals, n_allvals, sizeof(pval), valcmpasc)
; else
qsort(allvals, n_allvals, sizeof(pval), valcmpdesc)
; sum_vals[0] = s
; return n_allvals
; }
mclMatrix* mclDiagOrdering
( const mclMatrix* M
, mclVector** vecp_attr
)
{ int n_cols = N_COLS(M)
; mclMatrix* diago = mclxAllocZero(NULL, NULL)
; long col
; if (*vecp_attr != NULL)
mclvFree(vecp_attr)
; *vecp_attr = mclvResize(NULL, n_cols)
; for (col=0;col<n_cols;col++)
{ ofs offset = -1
; double selfval = mclvIdxVal(M->cols+col, col, &offset)
; double center = mclvPowSum(M->cols+col, 2.0)
/* double maxval = mclvMaxValue(M->cols+col)
*/
; double bar = MCX_MAX(center, selfval) - dpsd_delta
; mclIvp* ivp = (*vecp_attr)->ivps+col
; ivp->idx = col
; ivp->val = center ? selfval / center : 0
; if (offset >= 0) /* take only higher valued entries */
mclvSelectGqBar(diago->cols+col, bar)
; }
; return diago
; }
mclVector* mcxAttractivityScale
( const mclMatrix* M
)
{ dim n_cols = N_COLS(M)
;
dim d
;
mclVector* vec_values = mclvResize(NULL, n_cols)
;
for (d=0; d<n_cols; d++)
{ mclVector* vec = M->cols+d
;
double selfval = mclvIdxVal(vec, d, NULL)
;
double maxval = mclvMaxValue(vec)
;
if (maxval <= 0.0)
{ mcxErr
( "mcxAttractivityScale"
, "encountered nonpositive maximum value"
)
;
maxval = 1.0
;
}
(vec_values->ivps+d)->idx = d
;
(vec_values->ivps+d)->val = selfval / maxval
;
}
return vec_values
;
}
mclMatrix* mclInterpret
( mclMatrix* dag
)
{ mclv* v_attr = mclvCopy(NULL, dag->dom_cols)
; mclx* m_attr = NULL, *m_cls = NULL, *m_clst = NULL
; dim d
; mclvMakeCharacteristic(v_attr)
; for (d=0;d<N_COLS(dag);d++)
{ mclv* col = dag->cols+d
; if (mclvGetIvp(col, col->vid, NULL)) /* deemed attractor */
mclvInsertIdx(v_attr, col->vid, 2.0)
; }
mclvSelectGqBar(v_attr, 1.5)
; m_attr = mclxSub(dag, v_attr, v_attr)
; mclxAddTranspose(m_attr, 1.0)
; m_cls = clmUGraphComponents(m_attr, NULL) /* attractor systems as clusters */
; mclvCopy(m_cls->dom_rows, dag->dom_cols) /* add all nodes to this cluster matrix */
; m_clst = mclxTranspose(m_cls) /* nodes(columns) with zero neighbours need to be classified */
; mclgUnionvReset(dag) /* make mx->dom-rows characteristic */
; mclxFree(&m_cls)
; for (d=0;d<N_COLS(dag);d++)
{ mclv* closure, *clsids
; if (mclvGetIvp(v_attr, dag->cols[d].vid, NULL))
continue /* attractor already classified */
; closure = get_closure(dag, dag->cols+d) /* take all [neighbours of [neighbours of [..]]] */
; clsids = mclgUnionv(m_clst, closure, NULL, SCRATCH_READY, NULL)
; mclvAdd(m_clst->cols+d, clsids, m_clst->cols+d)
; mclvFree(&clsids)
; mclvFree(&closure)
; }
m_cls = mclxTranspose(m_clst)
; mclxFree(&m_attr)
; mclxFree(&m_clst)
; mclvFree(&v_attr)
; return m_cls
; }
void handle_top
( mclx* mx
, mcxTing* sa
)
{ long num = -1
; dim t
; mcxHeap* hp
; if (mcxStrTol(sa->str, &num, NULL) || num < 0)
{ fprintf(stderr, "(error number-no-good)\n")
; return
; }
if (!num || (dim) num > N_COLS(mx))
num = N_COLS(mx)
/* Could use mclxColSizes instead */
; hp = mcxHeapNew
( NULL
, num
, sizeof(mclp)
, mclpValRevCmp
)
; for (t=0;t<N_COLS(mx);t++)
{ mclp ivp
; ivp.idx = mx->cols[t].vid
; ivp.val = mx->cols[t].n_ivps
; mcxHeapInsert(hp, &ivp)
; }
qsort(hp->base, hp->n_inserted, hp->elemSize, hp->cmp)
/* warning this destroys the heap structure */
; for (t=0; t<hp->n_inserted;t++)
{ char* p = (char*) hp->base + (t*hp->elemSize)
; mclp* ivp = (void*) p
; const char* s = tab_g ? mclTabGet(tab_g, (long) ivp->idx, NULL) : NULL
; if (s)
fprintf(stderr, "%20s : %6.0f\n", s, (double) ivp->val)
; else
fprintf(stderr, "%20ld : %6.0f\n", (long) ivp->idx, (double) ivp->val)
; }
mcxHeapFree(&hp)
; }
void mclxInflateBoss
( mclMatrix* mx
, double power
, mclProcParam* mpp
)
{ int workLoad = N_COLS(mx) / mpp->n_ithreads
; int workTail = N_COLS(mx) % mpp->n_ithreads
; int i = 0
; pthread_attr_t pthread_custom_attr
; pthread_t *threads_inflate
= (pthread_t *) mcxAlloc
( mpp->n_ithreads*sizeof(pthread_t)
, EXIT_ON_FAIL
)
; pthread_attr_init(&pthread_custom_attr)
; for (i=0;i<mpp->n_ithreads;i++)
{
mclvInflateLine_arg *a
= (mclvInflateLine_arg *)
malloc(sizeof(mclvInflateLine_arg))
; a->id = i
; a->start = workLoad * i
; a->end = workLoad * (i+1)
; a->mx = mx
; a->power = power
; if (i+1==mpp->n_ithreads)
a->end += workTail
; pthread_create
( &threads_inflate[i]
, &pthread_custom_attr
, (void *(*)(void*)) mclvInflateLine
, (void *) a
)
; }
for (i = 0; i < mpp->n_ithreads; i++)
pthread_join(threads_inflate[i], NULL)
; mcxFree(threads_inflate)
; }
mcxstatus check_bounds
( const mclx* mx
, long idx
)
{ if (idx < 0 || (dim) idx >= N_COLS(mx))
{ fprintf(stderr, "(error argument-out-of-bounds (%ld))\n", idx)
; return STATUS_FAIL
; }
return STATUS_OK
; }
static int calc_depth
( mclx* m_transient
)
{ mclx* m_inverse = mclxTranspose(m_transient)
;
dim c, depth = 0
;
if(0)puts("")
;
for (c=0; c<N_COLS(m_inverse); c++)
{ dim this_depth = 0
;
if (!m_inverse->cols[c].n_ivps) /* no incoming nodes */
{ mclv* next = mclxGetVector(m_transient, m_inverse->cols[c].vid, RETURN_ON_FAIL, NULL)
;
if (!next)
continue
;
mclgUnionvInitList(m_transient, next)
;
do
{ mclv* next2 = mclgUnionv(m_transient, next, NULL, SCRATCH_UPDATE, NULL)
;
if (0 && next->ivps)
fprintf(stdout, "chain %d ->\n", (int) m_inverse->cols[c].vid)
, mclvaDump(next, stdout, -1, " ", 0)
;
if (this_depth) /* otherwise starting vector in matrix */
mclvFree(&next)
;
next = next2
;
this_depth++
;
}
while (next->n_ivps)
;
mclvFree(&next) /* did loop at least once, so not the starting vector */
;
mclgUnionvReset(m_transient)
;
}
if (this_depth > depth)
depth = this_depth
;
}
mclxFree(&m_inverse)
;
return depth
;
}
dim clmAssimilate
( mclx* mx
, mclx* cl
, dim prune_sz
, mclx** cl_prunedpp
, dim* sjd_left
, dim* sjd_right
)
{ dim dist_this_pru = 0, dist_pru_this = 0
; mclx* cl_pru = NULL
; const char* me = "clmAssimilate"
; dim o, m, e, n_source, n_sink
; dim sum_pruned = clm_clm_prune
(mx, cl, prune_sz, &cl_pru, &n_source, &n_sink)
; *cl_prunedpp = NULL
; if (sum_pruned)
{ mcxLog
( MCX_LOG_AGGR
, me
, "funneling %lu nodes from %lu sources into %lu targets"
, (ulong) sum_pruned
, (ulong) n_source
, (ulong) n_sink
)
; clmEnstrict(cl_pru, &o, &m, &e, 0)
; *cl_prunedpp = cl_pru
; clmSJDistance
(cl, cl_pru, NULL, NULL, &dist_this_pru, &dist_pru_this)
; if (sjd_left)
*sjd_left = dist_this_pru
, *sjd_right = dist_pru_this
; }
else if (sjd_left)
*sjd_left = 0
, *sjd_right = 0
; mcxLog
( MCX_LOG_AGGR
, me
, "dim %lu pruned %lu distance %lu|%lu"
, (ulong) N_COLS(mx)
, (ulong) sum_pruned
, (ulong) dist_this_pru
, (ulong) dist_pru_this
)
; return sum_pruned
; }
static void ecc_compute
( dim* tabulator
, const mclx* mx
, dim offset
, dim inc
, mclv* scratch
)
{ dim i
; for (i=offset;i<N_COLS(mx);i+=inc)
{ dim dd = mclgEcc2(mx->cols+i, mx, scratch)
; tabulator[i] = dd
; }
}
mclMatrix* mclDag
( const mclMatrix* A
, const mclInterpretParam* ipp
)
{ dim d
;
double w_selfval= ipp ? ipp->w_selfval: 0.999
;
double w_maxval = ipp ? ipp->w_maxval : 0.001
;
double delta = ipp ? ipp->delta : 0.01
;
mclMatrix* M = mclxAllocZero
( mclvCopy(NULL, A->dom_cols)
, mclvCopy(NULL, A->dom_rows)
)
;
for (d=0; d<N_COLS(A); d++) /* thorough clean-up */
{ mclVector* vec = A->cols+d
;
mclVector* dst = M->cols+d
;
double selfval = mclvIdxVal(vec, vec->vid, NULL)
;
double maxval = mclvMaxValue(vec)
;
double bar = selfval < maxval
? ( (w_selfval * selfval)
+ (w_maxval * maxval)
)
: delta
? selfval / (1 + delta)
: selfval
;
int n_bar = mclvCountGiven(vec, mclpGivenValGQ, &bar)
;
mclvCopyGiven(dst, vec, mclpGivenValGQ, &bar, n_bar)
;
}
if (0)
{ dim ne = mclxNrofEntries(M)
;
fprintf(stderr, "nroff entries %u\n", (unsigned) ne)
;
}
return M
;
}
static void tf_ssq
( mclx* mx
, double val
)
{ dim i
; for (i=0;i<N_COLS(mx);i++)
{ mclv* v = mx->cols+i
; double ssq = mclvPowSum(v, 2.0)
; double sum = mclvSum(v)
; double self = mclvSelf(v)
; if (sum-self)
mclvSelectGtBar(v, val * (ssq - self*self) / (sum - self))
; }
; }
void dump_dag
( mclx* mx
, mclTab* tab
)
{ mclx* mx = mclxTranspose(mx)
; dim i
; for (i=0;i<N_COLS(mx);i++)
{ mclv* v = mx->cols+i
; if (v->val < 1.5)
{ dump_label(tab, v->vid, 0)
; walk_dag(mx, v, 1)
; }
}
}
int main
( int argc
, const char* argv[]
)
{ const char* fn_input = argc > 1 ? argv[1] : ""
; mclAlgParam* mlp = NULL
; const char* me = "mcl"
; mcxstatus status = STATUS_OK
; srandom(mcxSeed(315))
; signal(SIGALRM, mclSigCatch)
; if (signal(SIGUSR1, mcxLogSig) == SIG_ERR)
mcxErr(me, "cannot catch SIGUSR1!")
; mcxLogLevel =
MCX_LOG_AGGR | MCX_LOG_MODULE | MCX_LOG_IO | MCX_LOG_GAUGE | MCX_LOG_WARN
; mclx_app_init(stderr)
; if (argc < 2)
{ mcxTell
( me
, "usage: mcl <-|file name> [options],"
" do 'mcl -h' or 'man mcl' for help"
)
; mcxExit(0)
; }
status
= mclAlgInterface
(&mlp, (char**) (argv+2), argc-2, fn_input, NULL, ALG_DO_IO)
; if (status == ALG_INIT_DONE)
return 0
; else if (status)
mcxDie(STATUS_FAIL, me, "no tango")
; if ((status = mclAlgorithm(mlp)) == STATUS_FAIL)
mcxDie(STATUS_FAIL, me, "failed")
; if (mlp->n_assimilated)
mcxLog(MCX_LOG_MODULE, me, "%lu nodes will assimilate", (ulong) mlp->n_assimilated)
; if (mlp->mx_start)
mcxLog(MCX_LOG_MODULE, me, "cached matrix with %lu columns", (ulong) N_COLS(mlp->mx_start))
; mclAlgParamFree(&mlp, TRUE)
; helpful_reminder()
; return STATUS_OK
; }
static dim do_remove
( mclx* mx
, dim N_remove
, dim* offsets /* size N_COLS(mx) */
, dim N_edge
, dim random_ignore
)
{ dim n_remove = 0
; while (n_remove < N_remove)
{ unsigned long r = (unsigned long) random()
; dim e, *ep
; ofs xo, yo
; long x
; mclv* vecx
; if (r >= random_ignore)
continue
; e = r % N_edge
; if (!(ep = mcxBsearchFloor(&e, offsets, N_COLS(mx), sizeof e, dimCmp)))
mcxDie(1, me, "edge %ld not found (max %ld)", (long) e, (long) N_edge)
; xo = ep - offsets
;if(DEBUG)fprintf(stderr, "have e=%d o=%d\n", (int) e, (int) xo)
; x = mx->dom_cols->ivps[xo].idx
; vecx = mx->cols+xo;
; yo = e - offsets[xo]
; if (yo >= vecx->n_ivps) /* note: mixed sign comparison */
mcxDie
( 1
, me
, "vector %ld has not enough entries: %ld < %ld"
, (long) vecx->vid
, (long) vecx->n_ivps
, (long) yo
)
; if (!vecx->ivps[yo].val)
continue
; vecx->ivps[yo].val = 0.0
;if(DEBUG)fprintf(stderr, "remove [%d] %ld %ld\n", (int) n_remove, (long) x, (long) vecx->ivps[yo].idx)
; n_remove++
; }
return n_remove
; }
void dag_diff_select
( mclx* mx
, mclTab* tab
, mcxIO* xfdiff
, double child_diff_lq
, double parent_diff_gq
)
{ dim i
; mclx* dag = mclxAllocClone(mx)
; for (i=0;i<N_COLS(mx); i++)
{ mclv* v = mx->cols+i
; dim j
; for (j=0;j<v->n_ivps;j++)
{ dim idx = v->ivps[j].idx
; double valv = v->ivps[j].val
; mclv* t = mclxGetVector(mx, idx, EXIT_ON_FAIL, NULL)
; mclp* p = mclvGetIvp(t, v->vid, NULL)
; double valt = p ? p->val : 0.0
; double delta = valv - valt
; double lg = valv, sm = valt
; double child_diff, parent_diff
; int v_is_child = 0
; if (delta < 0)
delta = -delta
, lg=valt, sm=valv
, v_is_child = 1
; child_diff = sm
; parent_diff = lg
;if(0 && i==111)
fprintf(stderr, "nb %d delta %g\n", (int) idx, delta)
; if (child_diff > child_diff_lq || parent_diff < parent_diff_gq)
NOTHING
; else
{ if (v_is_child)
mclvInsertIdx(dag->cols+i, idx, delta)
; else
mclvInsertIdx(dag->cols+(t-mx->cols), v->vid, delta)
; }
}
}
; mclxWrite(dag, xfdiff, MCLXIO_VALUE_GETENV, EXIT_ON_FAIL)
; mclxFree(&dag)
; }
static mclx* get_coarse
( const mclx* mxbase
, mclx* clprev
, mcxbool add_transpose
)
{ mclx* blockc = mclxBlocksC(mxbase, clprev)
; mclx* clprevtp = mclxTranspose(clprev)
; mclx *p1 = NULL /* p_roduct */
; mclx* mx_coarse= NULL
; mclxMakeStochastic(clprev)
/****************** <EXPERIMENTAL CRAP> ************************************/
; if (hdp_g)
mclxUnary(clprev, fltxPower, &hdp_g)
/* parameter: use mxbase rather than blockc */
; if (getenv("MCLCM_BLOCK_STOCHASTIC")) /* this works very badly! */
mclxMakeStochastic(blockc)
; else if (getenv("MCLCM_BASE_UNSCALE") && start_col_sums_g)
{ dim i
; for (i=0;i<N_COLS(blockc);i++)
{ double f = start_col_sums_g->ivps[i].val
; mclvUnary(blockc->cols+i, fltxMul, &f)
; }
; }
/****************** </EXPERIMENTAL> *****************************************/
p1 = mclxCompose(blockc, clprev, 0)
;if (0)
{mcxIO* t = mcxIOnew("-", "w")
;mclxWrite(blockc, t, MCLXIO_VALUE_GETENV, EXIT_ON_FAIL)
;
}
; mclxFree(&blockc)
; mx_coarse = mclxCompose(clprevtp, p1, 0)
; if (add_transpose)
mclxAddTranspose(mx_coarse, 0.0)
; mclxAdjustLoops(mx_coarse, mclxLoopCBremove, NULL)
; mclxFree(&p1)
; mclxFree(&clprevtp)
; mclxMakeCharacteristic(clprev)
; return mx_coarse
; }
static void set_cl_to_projection
( mclMatrix* cl
, mclMatrix* el_on_cl
)
{ dim i, j
; for (i=0;i<N_COLS(cl);i++)
{ mclv* clvec = cl->cols+i
; long clid = clvec->vid
; mclv* elclvec = NULL
; mclp* valivp = NULL
; for (j=0;j<clvec->n_ivps;j++)
{ long elid = clvec->ivps[j].idx
; elclvec = mclxGetVector(el_on_cl, elid, EXIT_ON_FAIL, elclvec)
; valivp = mclvGetIvp(elclvec, clid, NULL)
; if (!valivp && clvec->n_ivps > 1)
mcxErr("clmCastActors", "match error: el %ld cl %ld", elid, clid)
; clvec->ivps[j].val = valivp ? MCX_MAX(0.01, valivp->val) : 0.01
; }
}
}
static void rough_it
( mclx* mx
, dim* tabulator
, dim i
, u8* rough_scratch
, long* rough_priority
, dim* pri
)
{ dim dd = 0, p = i, p1 = 0, p2 = 0, priority = 0, p1p2 = 0, j = 0
; for (j=0;j<N_COLS(mx);j++)
{ if (1)
{ if (rough_priority[j] >= rough_priority[p1])
p2 = p1
, p1 = j
; else if (rough_priority[j] >= rough_priority[p2])
p2 = j
; }
else
{ if (!p1 && rough_priority[j] >= 1)
p1 = j
; }
}
p = p1
; priority = rough_priority[p]
; p1p2 = rough_priority[p1] + rough_priority[p2]
; dd = diameter_rough(mx->cols+p, mx, rough_scratch, rough_priority)
;if (0)
fprintf
( stdout
, "guard %6d--%-6d %6d %6d NODE %6d ECC %6d PRI\n"
, (int) p1p2
, (int) (i * dd)
, (int) i
, (int) p
, (int) dd
, (int) priority
)
; *pri = priority
; tabulator[p] = dd
; }
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
; }
void pairwise_setops
( mclx* mx1
, mclx* mx2
, mcxbits modes
)
{ dim t, u, n_tst = 0
; mclv* cache = mclvInit(NULL)
; mclv* meet = mclvInit(NULL)
; mclv* join = mclvInit(NULL)
; mclv* diff = mclvInit(NULL)
; mcxbool overwrite = modes & MMM_OVERWRITE
; dim n_zero_meet = 0, n_plus_meet = 0
; mclv* (*fn_meet)(const mclv* lft, const mclv* rgt, mclv* dst) = mcldMeet
; mclv* (*fn_minus)(const mclv* lft, const mclv* rgt, mclv* dst) = mcldMinus1
; if (modes & MMM_MEET2)
fn_meet = mcldMeet2
, fn_minus = mcldMinus
/* the point of overwrite is to have
* a lft == dst or rgt == dst pattern.
*/
; for (t=0;t<N_COLS(mx1);t++)
{ for (u=0;u<N_COLS(mx2);u++)
{ mclv* dst = overwrite ? (modes & MMM_RIGHT ? mx1->cols+u : mx2->cols+t) : diff
; if (overwrite)
mclvCopy(cache, dst) /* cache column, reinstate later */
; if (modes & MMM_BINARY)
mclvBinary(mx1->cols+t, mx2->cols+u, dst, fltLaNR)
; else
fn_minus(mx1->cols+t, mx2->cols+u, dst) /* compute t / u */
; if (overwrite)
mclvCopy(diff, dst)
, mclvCopy(dst, cache) /* reinstate column */
/* diff contains t / u */
; dst = overwrite ? dst : meet /* cache column, same as above */
; if (modes & MMM_BINARY)
mclvBinary(mx1->cols+t, mx2->cols+u, dst, fltLaR)
; else
fn_meet(mx1->cols+t, mx2->cols+u, dst)
; if (overwrite)
mclvCopy(meet, dst)
, mclvCopy(dst, cache) /* meet contains t /\ u */
; mcldMerge(diff, meet, join) /* join should be identical to column t */
; if (meet->n_ivps)
n_plus_meet++
; else
n_zero_meet++
; if (modes & MMM_CHECK)
{ mclv* dediff = mclvClone(mx1->cols+t)
; mclv* demeet = mclvClone(mx1->cols+t)
; dim nd = mclvUpdateMeet(dediff, diff, fltSubtract)
; dim nm = mclvUpdateMeet(demeet, meet, fltSubtract)
; if
( diff->n_ivps + meet->n_ivps != mx1->cols[t].n_ivps
|| !mcldEquate(join, mx1->cols+t, MCLD_EQT_EQUAL)
|| diff->n_ivps != nd
|| meet->n_ivps != nm
)
{ mclvaDump(mx1->cols+t, stdout, -1, " ", MCLVA_DUMP_HEADER_ON)
; mclvaDump(mx2->cols+u, stdout, -1, " ", MCLVA_DUMP_HEADER_ON)
; mclvaDump(meet, stdout, -1, " ", MCLVA_DUMP_HEADER_ON)
; mclvaDump(diff, stdout, -1, " ", MCLVA_DUMP_HEADER_ON)
; mcxDie(1, me, "rats")
; }
mclvFree(&dediff)
; mclvFree(&demeet)
; }
n_tst++
; }
}
fprintf
( stdout
, "meet was nonempty %.2f\n"
, (double) (n_plus_meet * 1.0f / n_tst)
)
; fprintf
( stdout
, "%d successful tests in %s%s %s mode (checked: %s)\n"
, (int) n_tst
, overwrite ? "overwrite" : "create"
, overwrite ? ( modes & MMM_RIGHT ? "-right" : "-left" ) : ""
, modes & MMM_BINARY
? "generic"
: "update"
, (modes & MMM_CHECK ? "yes" : "no")
)
; fprintf
( stdout
, "meet-can: %10lu\n"
"meet-zip: %10lu\n"
"meet-s/l: %10lu\n"
"diff-can: %10lu\n"
"diff-zip: %10lu\n"
"diff-s/l: %10lu\n"
, (ulong) nu_meet_can
, (ulong) nu_meet_zip
, (ulong) nu_meet_sl
, (ulong) nu_diff_can
, (ulong) nu_diff_zip
, (ulong) nu_diff_sl
)
; mclvFree(&cache)
; mclvFree(&meet)
; mclvFree(&join)
; mclvFree(&diff)
; }
int main
( int argc
, const char* argv[]
)
{ mcxIO* xfmx = mcxIOnew("-", "r"), *xfout = mcxIOnew("-", "w")
; mclx* mx = NULL
; mclv* mx_diag = NULL
; mcxstatus parseStatus = STATUS_OK
; mcxOption* opts, *opt
; dim N_edge = 0
; dim* offsets
; dim template_n_nodes = 0
; mcxbool plus = FALSE
; double e_min = 1.0
; double e_max = 0.0
; double skew = 0.0
; double radius = 0.0
; double n_sdev = 0.5
; double n_range = 2.0
; double g_radius = 0.0
; double g_mean = 0.0
; double g_sdev = 0.0
; double g_min = 1.0
; double g_max = 0.0
; mcxbool do_gaussian = FALSE
; dim i = 0
; dim N_remove = 0
; dim N_add = 0
; dim N_shuffle = 0
; unsigned long random_ignore = 0
; srandom(mcxSeed(2308947))
; mcxOptAnchorSortById(options, sizeof(options)/sizeof(mcxOptAnchor) -1)
; if
(!(opts = mcxOptParse(options, (char**) argv, argc, 1, 0, &parseStatus)))
exit(0)
; mcxLogLevel =
MCX_LOG_AGGR | MCX_LOG_MODULE | MCX_LOG_IO | MCX_LOG_GAUGE | MCX_LOG_WARN
; mclxIOsetQMode("MCLXIOVERBOSITY", MCL_APP_VB_YES)
; mclx_app_init(stderr)
; for (opt=opts;opt->anch;opt++)
{ mcxOptAnchor* anch = opt->anch
; switch(anch->id)
{ case MY_OPT_HELP
: case MY_OPT_APROPOS
: mcxOptApropos(stdout, me, syntax, 20, MCX_OPT_DISPLAY_SKIP, options)
; return 0
;
case MY_OPT_VERSION
: app_report_version(me)
; return 0
;
case MY_OPT_SKEW
: skew = atof(opt->val)
; break
;
case MY_OPT_GEN
: template_n_nodes = atoi(opt->val)
; break
;
case MY_OPT_IMX
: mcxIOrenew(xfmx, opt->val, NULL)
; break
;
case MY_OPT_PLUS
: case MY_OPT_WB
: plus = TRUE
; break
;
case MY_OPT_OUT
: mcxIOrenew(xfout, opt->val, NULL)
; break
;
case MY_OPT_E_MAX
: if (!strcmp(opt->val, "copy"))
e_max = -DBL_MAX
; else
e_max = atof(opt->val)
; break
;
case MY_OPT_E_MIN
: e_min = atof(opt->val)
; break
;
case MY_OPT_G_MIN
: g_min = atof(opt->val)
; break
;
case MY_OPT_G_MAX
: g_max = atof(opt->val)
; break
;
case MY_OPT_G_SDEV
: g_sdev = atof(opt->val)
; break
;
case MY_OPT_G_MEAN
: g_mean = atof(opt->val)
; do_gaussian = TRUE
; break
;
case MY_OPT_G_RADIUS
: g_radius = atof(opt->val)
; break
;
case MY_OPT_N_RANGE
: n_range = atof(opt->val)
; break
;
case MY_OPT_N_SDEV
: n_sdev = atof(opt->val)
; break
;
case MY_OPT_N_RADIUS
: radius = atof(opt->val)
; break
;
case MY_OPT_SHUFFLE
: N_shuffle = atoi(opt->val)
; break
;
case MY_OPT_ADD
: N_add = atoi(opt->val)
; break
;
case MY_OPT_REMOVE
: N_remove = atoi(opt->val)
; break
; }
}
/* hitting y% in vi tells me the size of this block */
{ if (template_n_nodes)
mx = mclxAllocZero
( mclvCanonical(NULL, template_n_nodes, 1.0)
, mclvCanonical(NULL, template_n_nodes, 1.0)
)
; else
mx = mclxReadx
( xfmx
, EXIT_ON_FAIL
, MCLX_REQUIRE_GRAPH
)
; mx_diag = mclxDiagValues(mx, MCL_VECTOR_COMPLETE)
; if (N_shuffle)
mclxAdjustLoops(mx, mclxLoopCBremove, NULL)
; else
mclxSelectUpper(mx)
/* ^ apparently we always work on single arc representation (docme andsoon) */
; offsets = mcxAlloc(sizeof offsets[0] * N_COLS(mx), EXIT_ON_FAIL)
; N_edge = 0
; for (i=0;i<N_COLS(mx);i++)
{ offsets[i] = N_edge
; N_edge += mx->cols[i].n_ivps
; }
if (N_edge < N_remove)
{ mcxErr
( me
, "removal count %ld exceeds edge count %ld"
, (long) N_remove
, (long) N_edge
)
; N_remove = N_edge
; }
random_ignore = RAND_MAX - (N_edge ? RAND_MAX % N_edge : 0)
; if (RAND_MAX / 2 < N_edge)
mcxDie(1, me, "graph too large!")
; if (N_shuffle)
{ do_the_shuffle(mx, N_shuffle, offsets, N_edge, random_ignore)
; mx_readd_diagonal(mx, mx_diag)
; mclxWrite(mx, xfout, MCLXIO_VALUE_GETENV, RETURN_ON_FAIL)
; exit(0)
; }
; if (N_remove)
{ dim n_remove = do_remove(mx, N_remove, offsets, N_edge, random_ignore)
/* Need to recompute N_edge and random_ignore.
* NOTE we work with *upper* matrix; this counts graph edges.
*/
; N_edge = mclxNrofEntries(mx) - n_remove
; random_ignore = RAND_MAX - (RAND_MAX % N_COLS(mx))
; }
if (g_mean)
{ if (!g_radius)
{ if (g_sdev)
g_radius = 2 * g_sdev
; mcxWarn(me, "set radius to %.5f\n", g_radius)
; }
}
; if (N_add)
N_edge += do_add
( mx
, N_add , N_edge
, do_gaussian ? &g_mean : NULL, g_radius , g_sdev , g_min , g_max
, skew
, e_min , e_max
)
; if (radius)
{ for (i=0;i<N_COLS(mx);i++)
{ mclp* ivp = mx->cols[i].ivps, *ivpmax = ivp + mx->cols[i].n_ivps
;if(DEBUG)fprintf(stderr, "here %d\n", (int) i)
; while (ivp < ivpmax)
{ double val = ivp->val
; double r = mcxNormalCut(n_range * n_sdev, n_sdev)
; double newval = val + radius * (r / (n_range * n_sdev))
; if (e_min < e_max && newval >= e_min && newval <= e_max)
; ivp->val = newval
; ivp++
; }
}
}
mclxUnary(mx, fltxCopy, NULL) /* remove zeroes */
; mclxAddTranspose(mx, 0.0)
; mx_readd_diagonal(mx, mx_diag)
; if (plus)
mclxbWrite(mx, xfout, RETURN_ON_FAIL)
; else
mclxWrite(mx, xfout, MCLXIO_VALUE_GETENV, RETURN_ON_FAIL)
; }
return 0
; }
static 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 *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
;
}
