void mclgTFgraph
( mclx* mx
, pnum mode
, pval val
)
{ switch(mode)
{ case MCLG_TF_MAX: mclxMergeTranspose(mx, fltMax, 1.0)
; break ; case MCLG_TF_MIN: mclxMergeTranspose(mx, fltMin, 1.0)
; break ; case MCLG_TF_ADD: mclxMergeTranspose(mx, fltAdd, 1.0)
; break ; case MCLG_TF_SELFRM: mclxAdjustLoops(mx, mclxLoopCBremove, NULL)
; break ; case MCLG_TF_SELFMAX: mclxAdjustLoops(mx, mclxLoopCBmax, NULL)
; break ; case MCLG_TF_NORMSELF: mclxNormSelf(mx)
; break ; case MCLG_TF_MUL: mclxMergeTranspose(mx, fltMultiply, 1.0)
; break ; case MCLG_TF_ARCMAX: mclxMergeTranspose(mx, fltArcMax, 1.0)
; break ; case MCLG_TF_ARCMAXGQ: mclxMergeTranspose3(mx, fltArcMaxGQ, 1.0, val)
; break ; case MCLG_TF_ARCMAXGT: mclxMergeTranspose3(mx, fltArcMaxGT, 1.0, val)
; break ; case MCLG_TF_ARCMAXLQ: mclxMergeTranspose3(mx, fltArcMaxLQ, 1.0, val)
; break ; case MCLG_TF_ARCMAXLT: mclxMergeTranspose3(mx, fltArcMaxLT, 1.0, val)
; break ; case MCLG_TF_ARCMINGQ: mclxMergeTranspose3(mx, fltArcMinGQ, 1.0, val)
; break ; case MCLG_TF_ARCMINGT: mclxMergeTranspose3(mx, fltArcMinGT, 1.0, val)
; break ; case MCLG_TF_ARCMINLQ: mclxMergeTranspose3(mx, fltArcMinLQ, 1.0, val)
; break ; case MCLG_TF_ARCMINLT: mclxMergeTranspose3(mx, fltArcMinLT, 1.0, val)
; break ; case MCLG_TF_ARCDIFFGQ: mclxMergeTranspose3(mx, fltArcDiffGQ, 1.0, val)
; break ; case MCLG_TF_ARCDIFFGT: mclxMergeTranspose3(mx, fltArcDiffGT, 1.0, val)
; break ; case MCLG_TF_ARCDIFFLQ: mclxMergeTranspose3(mx, fltArcDiffLQ, 1.0, val)
; break ; case MCLG_TF_ARCDIFFLT: mclxMergeTranspose3(mx, fltArcDiffLT, 1.0, val)
; break ; case MCLG_TF_ARCSUB: mclxMergeTranspose(mx, fltSubtract, 1.0)
; break ; case MCLG_TF_TUG: mclxPerturb(mx, val, MCLX_PERTURB_SYMMETRIC)
; break ; case MCLG_TF_TRANSPOSE: { mclx* tp = mclxTranspose(mx); mclxTransplant(mx, &tp); }
; break ; case MCLG_TF_SHRUG: mclxPerturb(mx, val, MCLX_PERTURB_SYMMETRIC | MCLX_PERTURB_RAND)
; break ; case MCLG_TF_ILS: mclxILS(mx)
; break ; case MCLG_TF_TOPN: mclxKNNdispatch(mx, val+0.5, mclx_n_thread_g, 0)
; break ; case MCLG_TF_KNN: mclxKNNdispatch(mx, val+0.5, mclx_n_thread_g, 1)
; break ; case MCLG_TF_MCL: tf_do_mcl(mx, val, FALSE)
; break ; case MCLG_TF_ARC_MCL: tf_do_mcl(mx, val, TRUE)
; break ; case MCLG_TF_THREAD: mclx_n_thread_g = val + 0.5
; break ; case MCLG_TF_CEILNB: { mclv* cv = mclgCeilNB(mx, val+0.5, NULL, NULL, NULL); mclvFree(&cv); }
; break ; case MCLG_TF_STEP: mclg_tf_step(mx, val+0.5)
; break ; case MCLG_TF_QT: mclxQuantiles(mx, val)
; break ; case MCLG_TF_SSQ: tf_ssq(mx, val)
; break ; case MCLG_TF_SHUFFLE: mcxErr("mclgTFgraph", "shuffle not yet done (lift from mcxrand)")
; break ; default: mcxErr("mclgTFgraph", "unknown mode")
; break
; }
}
void clmCastActors
( mclx** mxpp /* is made stochastic and has loops added */
, mclx** clpp /* entries are set to self-value */
, mclx** el_to_clpp /* transpose of cl */
, mclx** el_on_clpp /* will be made stochastic */
, mclx** cl_on_clpp /* will be made stochastic */
, mclx** cl_on_elpp /* transpose of stochastic el_on_cl */
, double frac /* consider clusters in el_on_cl until frac
edge weight is covered */
)
{ mclxAdjustLoops(*mxpp, mclxLoopCBmax, NULL)
; mclxMakeStochastic(*mxpp)
; *el_to_clpp = mclxTranspose(*clpp)
/* el_to_cl not stochastic? */
; *el_on_clpp = mclxCompose(*el_to_clpp, *mxpp, 0, 1)
; mclxMakeStochastic(*el_on_clpp)
; *cl_on_clpp = mclxCompose(*el_on_clpp, *clpp, 0, 1)
; mclxMakeStochastic(*cl_on_clpp)
; set_cl_to_projection(*clpp, *el_on_clpp)
; prune_el_on_cl(*el_to_clpp, *el_on_clpp, frac, 10)
; *cl_on_elpp = mclxTranspose(*el_on_clpp)
; }
mclx* handle_query
( mclx* mx
, mcxIO* xfmx
, mcxTing* sa
, mcxTing* sb
)
{ if (!strcmp(sa->str, ":top"))
handle_top(mx, sb)
; else if (!strcmp(sa->str, ":list"))
handle_list(mx, sb)
; else if (!strcmp(sa->str, ":reread"))
{ mclxFree(&mx)
; if (xfabc_g)
{ streamer_g.tab_sym_in = tab_g
;
mx
= mclxIOstreamIn
( xfabc_g
, MCLXIO_STREAM_ABC
| (input_status != 'd' ? MCLXIO_STREAM_MIRROR : 0)
| MCLXIO_STREAM_SYMMETRIC
| MCLXIO_STREAM_GTAB_RESTRICT /* docme/fixme need to check for tab_g ? */
, NULL
, mclpMergeMax
, &streamer_g /* has tab, if present */
, EXIT_ON_FAIL
)
; mcxIOclose(xfabc_g)
; }
else
{ mx
= mclxReadx
(xfmx, EXIT_ON_FAIL, MCLX_REQUIRE_GRAPH | MCLX_REQUIRE_CANONICAL)
; mcxIOclose(xfmx)
; }
mclxAdjustLoops(mx, mclxLoopCBremove, NULL)
; }
else if (!strcmp(sa->str, ":clcf"))
handle_clcf(mx, sb)
; else if (!strcmp(sa->str, ":tf"))
{ handle_tf(mx, sb)
; mcxTell(me, "graph now has %lu arcs", (ulong) mclxNrofEntries(mx))
; }
else
fprintf(stderr, "(error unknown-query (:clcf#1 :list#1 :reread :top#1))\n")
; return mx
; }
static mclx* get_coarse
( const mclx* mxbase
, mclx* clprev
, mcxbool add_transpose
)
{ mclx* blockc = mclxBlocksC(mxbase, clprev)
; mclx* clprevtp = mclxTranspose(clprev)
; mclx *p1 = NULL /* p_roduct */
; mclx* mx_coarse= NULL
; mclxMakeStochastic(clprev)
/****************** <EXPERIMENTAL CRAP> ************************************/
; if (hdp_g)
mclxUnary(clprev, fltxPower, &hdp_g)
/* parameter: use mxbase rather than blockc */
; if (getenv("MCLCM_BLOCK_STOCHASTIC")) /* this works very badly! */
mclxMakeStochastic(blockc)
; else if (getenv("MCLCM_BASE_UNSCALE") && start_col_sums_g)
{ dim i
; for (i=0;i<N_COLS(blockc);i++)
{ double f = start_col_sums_g->ivps[i].val
; mclvUnary(blockc->cols+i, fltxMul, &f)
; }
; }
/****************** </EXPERIMENTAL> *****************************************/
p1 = mclxCompose(blockc, clprev, 0)
;if (0)
{mcxIO* t = mcxIOnew("-", "w")
;mclxWrite(blockc, t, MCLXIO_VALUE_GETENV, EXIT_ON_FAIL)
;
}
; mclxFree(&blockc)
; mx_coarse = mclxCompose(clprevtp, p1, 0)
; if (add_transpose)
mclxAddTranspose(mx_coarse, 0.0)
; mclxAdjustLoops(mx_coarse, mclxLoopCBremove, NULL)
; mclxFree(&p1)
; mclxFree(&clprevtp)
; mclxMakeCharacteristic(clprev)
; return mx_coarse
; }
int main
( int argc
, const char* argv[]
)
{ mcxIO* 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
; }
