static int test_cycle
( const mclx* mx
, dim n_limit
)
{ mclv* starts = run_through(mx), *starts2
; if (starts->n_ivps)
{ dim i
; if (n_limit)
{ mclx* mxt = mclxTranspose(mx)
; starts2 = run_through(mxt)
; mclxFree(&mxt)
; mclvBinary(starts, starts2, starts, fltMultiply)
; mcxErr
(me, "cycles detected (%u nodes)", (unsigned) starts->n_ivps)
; if (starts->n_ivps)
{ fprintf(stdout, "%lu", (ulong) starts->ivps[0].idx)
; for (i=1; i<MCX_MIN(starts->n_ivps, n_limit); i++)
fprintf(stdout, " %lu", (ulong) starts->ivps[i].idx)
; fputc('\n', stdout)
; }
else
mcxErr(me, "strange, no nodes selected")
; }
else
mcxErr(me, "cycles detected")
; return 1
; }
mcxTell(me, "no cycles detected")
; return 0
; }
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)
; }
int mclvLexCmp
( const void* p1
, const void* p2
)
{ mclIvp* ivp1 = ((mclVector*)p1)->ivps
; mclIvp* ivp2 = ((mclVector*)p2)->ivps
; long diff
; dim n_ivps = MCX_MIN
( ((mclVector*)p1)->n_ivps
, ((mclVector*)p2)->n_ivps
)
/*
* Vectors with low numbers first
*/
; while (n_ivps-- > 0) /* careful with unsignedness */
if ((diff = (ivp1++)->idx - (ivp2++)->idx))
return MCX_SIGN(diff)
; diff = ((mclVector*)p1)->n_ivps - ((mclVector*)p2)->n_ivps
; return MCX_SIGN(diff)
; }
double get_score
( const mclv* c
, const mclv* d
, const mclv* c_start
, const mclv* d_start
, const mclv* c_end
, const mclv* d_end
)
{ mclv* vecc = mclvClone(c)
; mclv* vecd = mclvClone(d)
; mclv* meet_c = mcldMeet(vecc, vecd, NULL)
; mclv* meet_d = mcldMeet(vecd, meet_c, NULL)
; mclv* cwid = mclvBinary(c_end, c_start, NULL, fltSubtract)
; mclv* dwid = mclvBinary(d_end, d_start, NULL, fltSubtract)
; mclv* rmin = mclvBinary(c_end, d_end, NULL, fltMin)
; mclv* lmax = mclvBinary(c_start, d_start, NULL, fltMax)
; mclv* delta = mclvBinary(rmin, lmax, NULL, fltSubtract)
; mclv* weightc, *weightd
; double ip, cd, csn, meanc, meand, mean, euclid, meet_fraction, score, sum_meet_c, sum_meet_d, reduction_c, reduction_d
; int nmeet = meet_c->n_ivps
; int nldif = vecc->n_ivps - nmeet
; int nrdif = vecd->n_ivps - nmeet
; mclvSelectGqBar(delta, 0.0)
; weightc= mclvBinary(delta, cwid, NULL, mydiv)
; weightd= mclvBinary(delta, dwid, NULL, mydiv)
#if 0
;if (c != d)mclvaDump
( cwid
, stdout
, 5
, "\n"
, 0)
,mclvaDump
( dwid
, stdout
, 5
, "\n"
, 0)
#endif
; sum_meet_c = 0.01 + mclvSum(meet_c)
; sum_meet_d = 0.01 + mclvSum(meet_d)
; mclvBinary(meet_c, weightc, meet_c, fltMultiply)
; mclvBinary(meet_d, weightd, meet_d, fltMultiply)
; reduction_c = mclvSum(meet_c) / sum_meet_c
; reduction_d = mclvSum(meet_d) / sum_meet_d
; ip = mclvIn(meet_c, meet_d)
; cd = sqrt(mclvPowSum(meet_c, 2.0) * mclvPowSum(meet_d, 2.0))
; csn = cd ? ip / cd : 0.0
; meanc = meet_c->n_ivps ? mclvSum(meet_c) / meet_c->n_ivps : 0.0
; meand = meet_d->n_ivps ? mclvSum(meet_d) / meet_d->n_ivps : 0.0
; mean = MCX_MIN(meanc, meand)
; euclid = 0
? 1.0
: ( mean
? sqrt(mclvPowSum(meet_c, 2.0) / mclvPowSum(vecc, 2.0))
: 0.0
)
; meet_fraction = pow((meet_c->n_ivps * 1.0 / vecc->n_ivps), 1.0)
; score = mean * csn * euclid * meet_fraction * 1.0
; mclvFree(&meet_c)
; mclvFree(&meet_d)
; fprintf
( stdout
, "%10d%10d%10d%10d%10d%10g%10g%10g%10g%10g%10g%10g\n"
, (int) c->vid
, (int) d->vid
, (int) nldif
, (int) nrdif
, (int) nmeet
, score
, mean
, csn
, euclid
, meet_fraction
, reduction_c
, reduction_d
)
; return score
; }
void mclpMergeMin
( void* i1
, const void* i2
)
{ ((mclIvp*)i1)->val = MCX_MIN(((mclIvp*)i1)->val,((mclIvp*)i2)->val)
; }
