mclVector* mclvAdd
( const mclVector* lft
, const mclVector* rgt
, mclVector* dst
)
{ return mclvBinary(lft, rgt, dst, fltAdd)
; }
mclVector* mcldMeet
( const mclVector* lft
, const mclVector* rgt
, mclVector* dst
)
{ return mclvBinary(lft, rgt, dst, fltLaR)
; }
mclv* mcldMinus1
( const mclv* lft
, const mclv* rgt
, mclv* dst
)
{ return mclvBinary(lft, rgt, dst, fltLaNR)
; }
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
; }
mclVector* mcldMinus
( const mclVector* lft
, const mclVector* rgt
, mclVector* dst
)
{ if (rgt == dst) /* interesting src/dst pattern */
return mclvBinary(lft, rgt, dst, fltLaNR)
; else
{ if (lft != dst)
dst = mclvCopy(dst, lft)
/* if lft is large and rgt as well then copying may introduce
* unnecessary work. But we don't really have a way of knowing in
* advance, and the solution would probably involve headaches
* similar to the ones in mcldMeet.
*/
; if (mclvUpdateMeet(dst, rgt, flt0p0))
mclvUnary(dst, fltxCopy, NULL)
; }
return dst
; }
/* current dst content is thrown away if fltbinary not used */
mclv* mclvFromPAR
( mclv* dst
, mclpAR* par
, mcxbits warnbits
, void (*ivpmerge)(void* ivp1, const void* ivp2)
, double (*fltbinary)(pval val1, pval val2)
)
{ mcxbool warn_re = warnbits & MCLV_WARN_REPEAT_ENTRIES
; mcxbool warn_rv = warnbits & MCLV_WARN_REPEAT_VECTORS
; mclp* ivps = par->ivps
; dim n_ivps = par->n_ivps
; mcxbits sortbits = par->sorted
; dim n_old = dst ? dst->n_ivps : 0
; const char* me = "mclvFromPAR"
; dim n_re = 0, n_rv = 0
; if (!dst)
dst = mclvInit(NULL)
; if (n_ivps)
{ if (dst->n_ivps && fltbinary)
{ mclVector* tmpvec = mclvNew(ivps, n_ivps)
; if (!(sortbits & MCLPAR_SORTED))
mclvSort(tmpvec, NULL)
; if (!(sortbits & MCLPAR_UNIQUE))
n_re = mclvUniqIdx(tmpvec, ivpmerge)
; n_rv += tmpvec->n_ivps
; n_rv += dst->n_ivps
; mclvBinary(dst, tmpvec, dst, fltbinary)
; n_rv -= dst->n_ivps
; mclvFree(&tmpvec)
; }
else
{ if (dst->ivps == ivps)
mcxErr(me, "DANGER dst->ivps == ivps (dst vid %d)", (int) dst->vid)
; mclvRenew(dst, ivps, n_ivps)
; if (!(sortbits & MCLPAR_SORTED))
mclvSort(dst, NULL)
; if (!(sortbits & MCLPAR_UNIQUE))
n_re += mclvUniqIdx(dst, ivpmerge)
; }
}
if (warn_re && n_re)
mcxErr
( me
, "<%ld> found <%ld> repeated entries within %svector"
, (long) dst->vid
, (long) n_re
, n_rv ? "repeated " : ""
)
; if (warn_rv && n_rv)
mcxErr
( me
, "<%ld> new vector has <%ld> overlap with previous amalgam"
, (long) dst->vid
, (long) n_rv
)
; if (warnbits && n_re + n_rv)
mcxErr
( me
, "<%ld> vector went from <%ld> to <%ld> entries"
, (long) dst->vid
, (long) n_old
, (long) dst->n_ivps
)
; return dst
; }
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)
; }
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
; }
