1
0
mirror of https://github.com/zenorogue/hyperrogue.git synced 2024-12-12 04:10:26 +00:00
hyperrogue/rogueviz/dhrg/betweenness.cpp

407 lines
12 KiB
C++
Raw Normal View History

2022-07-12 09:12:35 +00:00
#include <iostream>
#include <unordered_map>
// pseudo-betweenness
namespace dhrg {
int out(int x, string cmt="") {
println(hlog, "result = ", x, " ", cmt);
return x;
}
ld outNZ(ld x, string cmt="") {
return x;
}
int segmentlen(segment *s) {
auto l = s->left;
auto r = s->right;
int i = 1;
while(l != r) l = l->grightsibling(), i++;
return i;
}
int get0(qtybox& b) { return b.minv == 0 ? b[0] : 0; }
int tallybox_total(qtybox& box) {
int tt = 0;
for(int i=box.minv; i<box.maxv; i++)
tt += box[i];
return tt;
}
string segdesc(segment *s) {
return format("(%s-%s: len=%d, qty=%d/%d)", get_path(s->left).c_str(), get_path(s->right).c_str(), segmentlen(s), get0(s->qty), tallybox_total(s->qty));
}
int quickdist(segment *p1, segment *p2) {
int d = 0;
int d1 = p1->left->lev;
int d2 = p2->left->lev;
while(d1>d2) { p1 = p1->parent; d1--; d++; }
while(d2>d1) { p2 = p2->parent; d2--; d++; }
return segmentdist(p1, p2, d);
}
pair<ll, ll> betweenness3(mycell *c, int setid = 0) {
vector<mycell*> neighbors;
neighbors = allchildren(c);
if(c->lev) {
neighbors.push_back(c->grightsibling());
neighbors.push_back(c->rightparent);
if(c->leftparent != c->rightparent)
neighbors.push_back(c->leftparent);
neighbors.push_back(c->gleftsibling());
}
build_ack(c, setid);
for(auto c1: neighbors) build_ack(c1, setid);
std::unordered_map<segment*, int> info;
for(segment* p: acknowledged) {
int tot = tallybox_total(p->qty);
info[p] += tot;
segment *p2 = p->parent;
while(p2) {
if(p2->seen != -1) {
info[p2] -= tot;
break;
}
p2=p2->parent;
}
}
for(segment* p: acknowledged) {
p->seen = -1;
}
acknowledged.clear();
vector<pair<segment*, int> > info_v;
for(auto p: info) if(p.second) info_v.emplace_back(p);
int NN = isize(neighbors);
int NN2 = 2 * NN;
vector<ll> bydir(NN2, 0);
int bestdist;
vector<int> bestdir;
vector<segment*> neighbor_segs;
for(auto n: neighbors) neighbor_segs.push_back(getsegment(n, n, setid, true));
for(auto p: info_v) {
if(p.first->left == c && p.first->right == c) continue;
bestdist = 1000;
bestdir.clear();
for(int k=0; k<NN; k++) {
int dist = quickdist(neighbor_segs[k], p.first);
if(dist < bestdist) bestdist = dist, bestdir.clear();
if(dist == bestdist) bestdir.push_back(k);
}
if(isize(bestdir) == 1)
bydir[bestdir[0] * 2] += p.second;
else if(isize(bestdir) > 2) {
println(hlog, "many best dirs\n");
throw hr_exception("many best dirs");
}
else if(bestdir[0] + 1 == bestdir[1])
bydir[bestdir[0] + bestdir[1]] += p.second;
else if(bestdir[0] == 0 && bestdir[1] == NN-1)
bydir.back() += p.second;
else {
println(hlog, "non-adjacent best dirs\n");
for(int k=0; k<NN; k++) print(hlog, quickdist(neighbor_segs[k], p.first), " "); printf("\n");
println(hlog, "bestdir = ", bestdir);
throw hr_exception("non-adjacent best dirs");
}
}
ll result = 0;
int here = getsegment(c, c, setid, true)->qty[0];
ll elsewhere = 0;
for(int a=0; a<NN2; a++) elsewhere += bydir[a];
result += (here + elsewhere) * (here + elsewhere);
// for(int a=0; a<NN2; a++) printf("%3d ", bydir[a]); printf("HERE %d EW=%d N=%d\n", here, elsewhere, N);
for(int a=0; a<NN2; a+=2) {
result -= bydir[a] * bydir[a];
result -= 2 * bydir[a] * bydir[(a+1) % NN2];
result -= 2 * bydir[a] * bydir[(a+2) % NN2];
result -= 2 * bydir[a] * bydir[(a+3) % NN2];
result -= 2 * bydir[a] * bydir[(a+NN2-1) % NN2];
result -= 2 * bydir[a] * bydir[(a+NN2-3) % NN2];
result -= bydir[a+1] * bydir[(a+1) % NN2];
result -= 2 * bydir[a+1] * bydir[(a+3) % NN2];
result -= 2 * bydir[a+1] * bydir[(a+5) % NN2];
}
ll result2 = here * here * NN + 2 * here * elsewhere * NN;
for(int a=0; a<NN2; a++) if(bydir[a])
for(int b=0; b<a; b++) if(bydir[b])
result2 += 2 * bydir[a] * bydir[b] * min(a-b, NN2+b-a);
return {result, result2};
}
bool dependent(segment *p1, segment *p2) {
if(is_insegment(p1->left, p2) || is_insegment(p1->right, p2) || is_insegment(p2->left, p1) || is_insegment(p2->right, p1))
return true;
mycell *mright;
mright = p1->right;
for(int u=0; u<=cgi.expansion->sibling_limit; u++) {
mright->build();
if(mright == p2->left) return true;
mright = mright->grightsibling();
}
mright = p2->right;
for(int u=0; u<=cgi.expansion->sibling_limit; u++) {
mright->build();
if(mright == p1->left) return true;
mright = mright->grightsibling();
}
return false;
}
template<class T> void children(segment *s, const T& f) {
s=s->firstchild;
while(s) {
f(s);
s = s->nextchild;
}
}
typedef long double betweenness_type;
betweenness_type ack(int d01, int d02, int d12) {
return pow(cgi.expansion->get_growth(), -(d01 + d02 - d12));
// if(d01 + d02 == d12+2) return 1;
// return 0;
}
int sd(segment *s1, segment *s2) {
/*
for(auto l = s1->left;; l = l->grightsibling()) {
if(is_insegment(l, s2)) return 0;
if(l == s1->right) break;
}
for(auto l = s2->left;; l = l->grightsibling()) {
if(is_insegment(l, s1)) return 0;
if(l == s2->right) break;
}
*/
return quickdist(s1, s2);
}
// di0: distance from Hidden to 0
// di0: distance from Hidden to 1
betweenness_type brec_fix_other(int di0, const vector<segment*>& lst, int pos, int di1, segment *s1) {
// indent_measure im("brec-fo " + its(pos) + " in s1: " + segdesc(s1) + " di0= " + its(di0) + " di1= " + its(di1) );
segment *s0 = lst[pos];
if(!dependent(s0, s1) || pos == 0)
return outNZ(tallybox_total(s1->qty) * ack(di0+pos, sd(s0, s1)+pos, di1));
betweenness_type total = 0;
if(get0(s1->qty))
total += get0(s1->qty) * ack(di0+pos, sd(s0,s1)+pos, di1);
for(segment *c1 = s1->firstchild; c1; c1 = c1->nextchild)
total += brec_fix_other(di0+1, lst, pos-1, di1+1, c1);
return outNZ(total);
}
map<tuple<int, segment*, segment* >, betweenness_type> memo[BOXSIZE];
betweenness_type brec_fix_main(int d1, segment *s1, int d2, segment *s2);
betweenness_type brec_fix_main_actual(int d1, segment *s1, int d2, segment *s2) {
betweenness_type total = 0;
if(get0(s1->qty))
total += get0(s1->qty) * tallybox_total(s2->qty) * ack(d1, d2, sd(s1, s2));
if(get0(s2->qty))
total += get0(s2->qty) * tallybox_total(s1->qty) * ack(d1, d2, sd(s1, s2));
if(get0(s1->qty) && get0(s2->qty))
total -= get0(s1->qty) * get0(s2->qty) * ack(d1, d2, sd(s1, s2));
for(segment *c1 = s1->firstchild; c1; c1 = c1->nextchild)
for(segment *c2 = s2->firstchild; c2; c2 = c2->nextchild)
total += brec_fix_main(d1+1, c1, d2+1, c2);
return total;
}
betweenness_type brec_fix_main(int d1, segment *s1, int d2, segment *s2) {
// indent_measure im("brec-main " + its(d1) + " in s1: " + segdesc(s1) + " " + its(d2) + " in s2: " + segdesc(s2));
if(!dependent(s1, s2))
return outNZ(tallybox_total(s1->qty) * tallybox_total(s2->qty) * ack(d1, d2, sd(s1, s2)));
// if(s1->left->lev >= 10) return brec_fix_main_actual(d1, s1, d2, s2);
auto& mem = memo[s1->left->lev][make_tuple(d1+d2, s1, s2)];
if(mem) return mem-1;
auto total = brec_fix_main_actual(d1, s1, d2, s2);
mem = total + 1;
return total;
}
betweenness_type brec(const vector<segment*>& lst, int pos, segment *s1, segment *s2) {
segment *s0 = lst[pos];
// indent_measure im("brec " + its(pos) + " in s1: " + segdesc(s1) + " in s2: " + segdesc(s2) + " s0 = " + segdesc(s0) );
bool id01 = !dependent(s0, s1);
bool id02 = !dependent(s0, s2);
if(id01 && id02) {
int di01 = sd(s0, s1);
int di02 = sd(s0, s2);
return outNZ(brec_fix_main(di01+pos, s1, di02+pos, s2));
}
else {
bool id12 = (id01 || id02) && !dependent(s1, s2);
if(id12 && id02) {
//01 not
int di12 = sd(s1, s2);
int di02 = sd(s0, s2);
return outNZ(tallybox_total(s2->qty) * brec_fix_other(di02, lst, pos, di12, s1));
}
else if(id12 && id01) {
int di12 = sd(s1, s2);
int di01 = sd(s0, s1);
return outNZ(tallybox_total(s1->qty) * brec_fix_other(di01, lst, pos, di12, s2));
}
else if(pos == 0)
return outNZ(brec_fix_main(sd(s0, s1), s1, sd(s0, s2), s2));
else {
betweenness_type total = 0;
if(get0(s1->qty))
total += get0(s1->qty) * brec_fix_other(sd(s0, s1), lst, pos, sd(s1, s2), s2);
if(get0(s2->qty))
total += get0(s2->qty) * brec_fix_other(sd(s0, s2), lst, pos, sd(s1, s2), s1);
if(get0(s1->qty) && get0(s2->qty))
total -= get0(s1->qty) * get0(s2->qty) * ack(pos + sd(s0, s1), pos + sd(s0, s2), sd(s1, s2));
for(segment *c1 = s1->firstchild; c1; c1 = c1->nextchild)
for(segment *c2 = s2->firstchild; c2; c2 = c2->nextchild)
total += brec(lst, pos-1, c1, c2);
return outNZ(total);
}
}
}
betweenness_type betweenness4(mycell *c, int setid = 0) {
segment *s = getsegment(c, c, setid, true);
vector<segment*> lst;
while(s) { lst.push_back(s); s = s->parent; }
segment *rs = getsegment(mroot, mroot, setid, true);
return brec(lst, isize(lst)-1, rs, rs);
}
bool neq(betweenness_type a, betweenness_type b) {
return abs(a-b) > 1e-6;
}
void compute_betweenness(bool verify) {
progressbar pb(N, "compute_betweenness");
int errorcount = 0, errorcount2 = 0;
for(int i=0; i<N; i++) {
long long total_cache = 0, x_total_cache = 0;
int clean_level = -1;
for(auto& mm: memo) {
ll s = mm.size();
if(!s) continue;
total_cache += s;
if(total_cache >= 8000000000ll / 64) { mm.clear(); }
else { x_total_cache += s; clean_level++; }
}
if(total_cache != x_total_cache) printf("cleanup from %lld to %lld cache items, at level %d\n", total_cache, x_total_cache, clean_level);
// if(i != 1) continue;
mycell *c1 = vertices[i];
// add_to_set(c1, -1, 0);
auto b = betweenness3(c1);
// add_to_set(c1, 1, 0);
auto b4 = betweenness4(c1);
print(hlog, format("B;%10Ld;%10Ld;%20.10Lf;%3d;%-40s", b.first, b.second, b4, vertices[i]->lev, rogueviz::vdata[i].name.c_str()));
if(verify) {
/*
betweenness_type a = b.first;
betweenness_type b = 0;
for(int j=0; j<N; j++)
for(int k=0; k<N; k++)
b += ack(quickdist(vertices[j], c1), quickdist(vertices[k], c1), quickdist(vertices[j], vertices[k]));
if(quickdist(vertices[j], vertices[k]) == quickdist(vertices[j], c1) + quickdist(vertices[k], c1)) {
// iprintf(" %-40s %-40s %d/%d/%d\n", rogueviz::vdata[j].name.c_str(), rogueviz::vdata[k].name.c_str(), quickdist(vertices[j], vertices[k]), quickdist(vertices[j], c1), quickdist(vertices[k], c1));
b++;
}
if(neq(a, b)) iprintf(" ERROR: %f\x1b[K\n", double(b));
else iprintf(" CORRECT %f\x1b[K\n", double(b));
if(b-a>0) errorcount += (b-a);
if(b-a<0) errorcount2 += (a-b);
if(neq(a, b)) exit(1);
*/
}
else printf("\n");
pb++;
}
if(verify) println(hlog, format("errorcount = %d/%d\n", errorcount, errorcount2));
}
void build(mycell *c, int lev, string s) {
int id = 0;
if(lev) for(mycell *c1: allchildren(c)) { build(c1, lev-1, s + std::to_string(id)); id++; }
printf("* %s\n", s.c_str());
vertices.push_back(c);
rogueviz::vdata.emplace_back();
rogueviz::vdata.back().name = s;
/*
vertices.push_back(c);
rogueviz::vdata.emplace_back();
rogueviz::vdata.back().name = s;
*/
}
void build_all(int d) {
build(mroot, d, "");
N = isize(vertices);
counttallies();
}
void load_test() {
string s;
while(getline(std::cin, s)) {
mycell *mc = mroot;
if(s[0] == '#') continue;
for(char c: s) if(c >= '0' && c <= '9') mc = allchildren(mc) [c - '0'];
vertices.push_back(mc);
rogueviz::vdata.emplace_back();
rogueviz::vdata.back().name = "PATH:" + s;
}
// build(mroot, 5, "");
N = isize(vertices);
counttallies();
// add_to_set(vertices[0], -1, 0);
}
}