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 ; }