def ledgemask(gl,H, cds):
"""given a list of encoded graphs and observed undersampled graph
H returns a matrix with -1 on diagonal, 0 at the conflicting graph
combination and encoded graph at non-conflicted
positions. Furthermore, returns a set of graphs that are in the
equivalence class of H
Arguments:
- `gl`: list of integer encoded graphs
- `H`: the observed undersampled graph
"""
n = len(H)
nl= len(gl)
s = set()
mask = np.zeros((nl,nl),'int')
np.fill_diagonal(mask,-1)
for i in xrange(nl):
for j in xrange(i+1,nl):
if gl[i] & gl[j]: continue
gnum = gl[i] | gl[j]
if skip_conflictors(gnum, cds): continue
g = bfu.num2CG(gnum,n)
if not bfu.call_u_conflicts(g, H):
if bfu.call_u_equals(g, H): s.add(gnum)
mask[i,j] = gnum
mask[j,i] = gnum
return mask, s
def edgemask(gl, H, cds):
nl = len(gl)
ss = set()
mask = np.zeros((nl, nl), 'int')
np.fill_diagonal(mask, -1)
idx = np.triu_indices(nl, 1)
for i, j in zip(idx[0], idx[1]):
if gl[i] & gl[j]:
mask[i, j] = -1
mask[j, i] = -1
continue
if skip_conflict(gl[i], gl[j], cds):
gnum = gl[i] | gl[j]
cache[gnum] = False
continue
gnum = gl[i] | gl[j]
if gnum in cache:
if cache[gnum]:
mask[i, j] = gnum
mask[j, i] = gnum
else:
cache[gnum] = False
g = bfu.num2CG(gnum, n)
if not bfu.call_u_conflicts(g, H):
if bfu.call_u_equals(g, H): ss.add(gnum)
mask[i, j] = gnum
mask[j, i] = gnum
cache[gnum] = True
return mask, ss
def edgemask(gl, H, cds):
"""given a list of encoded graphs and observed undersampled graph
H returns a matrix with -1 on diagonal, 0 at the conflicting graph
combination and encoded graph at non-conflicted
positions. Furthermore, returns a set of graphs that are in the
equivalence class of H
Arguments:
- `gl`: list of integer encoded graphs
- `H`: the observed undersampled graph
"""
n = len(H)
nl = len(gl)
s = set()
mask = np.zeros((nl, nl), 'int')
np.fill_diagonal(mask, -1)
for i in xrange(nl):
for j in xrange(i + 1, nl):
if gl[i] & gl[j]: continue
if skip_conflict(gl[i], gl[j], cds): continue
gnum = gl[i] | gl[j]
g = bfu.num2CG(gnum, n)
if not bfu.call_u_conflicts(g, H):
if bfu.call_u_equals(g, H): s.add(gnum)
mask[i, j] = gnum
mask[j, i] = gnum
return mask, s
def edgemask(gl, H, cds):
nl= len(gl)
ss = set()
mask = np.zeros((nl,nl),'int')
np.fill_diagonal(mask,-1)
idx = np.triu_indices(nl,1)
for i,j in zip(idx[0], idx[1]):
if gl[i] & gl[j]:
mask[i,j] = -1
mask[j,i] = -1
continue
if skip_conflict(gl[i], gl[j], cds):
gnum = gl[i] | gl[j]
cache[gnum] = False
continue
gnum = gl[i] | gl[j]
if gnum in cache:
if cache[gnum]:
mask[i,j] = gnum
mask[j,i] = gnum
else:
cache[gnum] = False
g = bfu.num2CG(gnum,n)
if not bfu.call_u_conflicts(g, H):
if bfu.call_u_equals(g, H): ss.add(gnum)
mask[i,j] = gnum
mask[j,i] = gnum
cache[gnum] = True
return mask, ss
def lconfpairs(H, cap=10, sloops=None):
n = len(H)
d = {}
if not sloops: sloops = prune_loops(allsloops(len(H)),H)
c = 0
for p in combinations(sloops,2):
g = bfu.num2CG(p[0]|p[1], n)
if bfu.call_u_conflicts(g, H):
d.setdefault(p[0],set()).add(p[1])
d.setdefault(p[1],set()).add(p[0])
if c >= cap: break
c +=1
return d
def prune(gl, H):
l = []
ss = set()
for gnum in gl:
if gnum in cache:
if cache[gnum]: l.append(gnum)
else:
cache[gnum] = False
g = bfu.num2CG(gnum, n)
if not bfu.call_u_conflicts(g, H):
if bfu.call_u_equals(g, H): ss.add(gnum)
l.append(gnum)
cache[gnum] = True
return l
def prune(gl, H):
l = []
ss = set()
for gnum in gl:
if gnum in cache:
if cache[gnum]: l.append(gnum)
else:
cache[gnum] = False
g = bfu.num2CG(gnum,n)
if not bfu.call_u_conflicts(g, H):
if bfu.call_u_equals(g, H): ss.add(gnum)
l.append(gnum)
cache[gnum] = True
return l
def add2set_(ds, H, cp, ccf, iter=1, verbose=True, capsize=100):
n = len(H)
n2 = n*n +n
dsr = {}
s = set()
ss = set()
pbar = start_progress_bar(iter, len(ds), verbose = verbose)
c = 0
for gnum in ds:
g = bfu.num2CG(gnum, n)
c += 1
pbar.update(c)
glist = []
elist = []
eset = set()
for e in ds[gnum]:
if not e[1] in g[e[0]]:
gk.addanedge(g,e)
num = bfu.g2num(g)
ekey = (1<<(n2 - int(e[0],10)*n - int(e[1],10)))
if ekey in ccf and skip_conflictors(num,ccf[ekey]):
gk.delanedge(g,e)
continue
if not num in s:
s.add(num)
if not bfu.call_u_conflicts(g, H):
#cf, gl2 = bfu.call_u_conflicts2(g, H)
#if not cf:
glist.append((num,ekey))
elist.append(e)
eset.add(ekey)
if bfu.call_u_equals(g, H):
ss.add(num)
#if bfu.call_u_equals2(g, gl2, H): ss.add(num)
if capsize <= len(ss): break
gk.delanedge(g,e)
for gn,e in glist:
if e in cp:
dsr[gn] = [ekey2e(k,n) for k in eset - cp[e]]
else:
dsr[gn] = elist
if capsize <= len(ss): return dsr, ss
pbar.finish()
return dsr, ss
def add2set_(ds, H, cp, ccf, iter=1, verbose=True, capsize=100):
n = len(H)
n2 = n * n + n
dsr = {}
s = set()
ss = set()
pbar = start_progress_bar(iter, len(ds), verbose=verbose)
c = 0
for gnum in ds:
g = bfu.num2CG(gnum, n)
gnum = bfu.g2num(g)
c += 1
pbar.update(c)
glist = []
elist = []
eset = set()
for e in ds[gnum]:
if not e[1] in g[e[0]]:
gk.addanedge(g, e)
num = bfu.g2num(g)
ekey = (1 << (n2 - int(e[0], 10) * n - int(e[1], 10)))
if ekey in ccf and skip_conflictors(num, ccf[ekey]):
gk.delanedge(g, e)
continue
if not num in s:
if not bfu.call_u_conflicts(g, H):
#cf, gl2 = bfu.call_u_conflicts2(g, H)
#if not cf:
glist.append((num, ekey))
elist.append(e)
eset.add(ekey)
s.add(num)
if bfu.call_u_equals(g, H): ss.add(num)
if capsize <= len(ss): break
#if bfu.call_u_equals2(g, gl2, H): ss.add(num)
gk.delanedge(g, e)
for gn, e in glist:
if e in cp:
dsr[gn] = [ekey2e(k, n) for k in eset - cp[e]]
else:
dsr[gn] = elist
if capsize <= len(ss): return dsr, ss
pbar.finish()
return dsr, ss
def prune_conflicts(H, g, elist):
"""checks if adding an edge from the list to graph g causes a
conflict with respect to H and if it does removes the edge
from the list
Arguments:
- `H`: the undersampled graph
- `g`: a graph under construction
- `elist`: list of edges to check
"""
l = []
for e in elist:
gk.addanedge(g, e)
if not bfu.call_u_conflicts(g, H): l.append(e)
gk.delanedge(g, e)
return l
def prune_conflicts(H, g, elist):
"""checks if adding an edge from the list to graph g causes a
conflict with respect to H and if it does removes the edge
from the list
Arguments:
- `H`: the undersampled graph
- `g`: a graph under construction
- `elist`: list of edges to check
"""
l = []
for e in elist:
gk.addanedge(g,e)
if not bfu.call_u_conflicts(g, H): l.append(e)
gk.delanedge(g,e)
return l
def patchmerge(ds, H, cds):
n = len(H)
l = set()
s = set()
o = set()
for gkey in ds:
for num in ds[gkey]:
if gkey & num: continue
gnum = gkey | num
if gnum is s: continue
if skip_conflictors(gnum, cds): continue
g = bfu.num2CG(gnum, n)
if not bfu.call_u_conflicts(g, H):
l.add(gnum)
if bfu.call_u_equals(g, H): s.add(gnum)
elif not gnum in o and bfu.overshoot(g, H): o.add(gnum)
return l, s, o
def patchmerge(ds, H, cds):
n = len(H)
l = set()
s = set()
o = set()
for gkey in ds:
for num in ds[gkey]:
if gkey & num: continue
gnum = gkey | num
if gnum is s: continue
if skip_conflictors(gnum, cds): continue
g = bfu.num2CG(gnum,n)
if not bfu.call_u_conflicts(g, H):
l.add(gnum)
if bfu.call_u_equals(g, H): s.add(gnum)
elif not gnum in o and bfu.overshoot(g, H): o.add(gnum)
return l, s, o
def confpairs(H):
n = len(H)
g = {n: {} for n in H}
d = {}
edges = gk.edgelist(gk.complement(g))
edges = prune_conflicts(H, g, edges)
for p in combinations(edges, 2):
gk.addedges(g, p)
if bfu.call_u_conflicts(g, H):
n1 = e2num(p[0], n)
n2 = e2num(p[1], n)
d.setdefault(n1, set()).add(n2)
d.setdefault(n2, set()).add(n1)
gk.deledges(g, p)
return d
def confpairs(H):
n = len(H)
g = {n:{} for n in H}
d = {}
edges = gk.edgelist(gk.complement(g))
edges = prune_conflicts(H, g, edges)
for p in combinations(edges,2):
gk.addedges(g,p)
if bfu.call_u_conflicts(g, H):
n1 = e2num(p[0],n)
n2 = e2num(p[1],n)
d.setdefault(n1,set()).add(n2)
d.setdefault(n2,set()).add(n1)
gk.deledges(g,p)
return d
def edgemask2(gl,H, cds):
n = len(H)
nl= len(gl)
s = set()
o = set()
mask = np.zeros((nl,nl),'int')
np.fill_diagonal(mask,-1)
for i in xrange(nl):
for j in xrange(i+1,nl):
if gl[i] & gl[j]: continue
gnum = gl[i] | gl[j]
if skip_conflictors(gnum, cds): continue
g = bfu.num2CG(gnum,n)
if not bfu.call_u_conflicts(g, H):
if bfu.call_u_equals(g, H): s.add(gnum)
mask[i,j] = gnum
mask[j,i] = gnum
elif bfu.overshoot(g, H): o.add(gnum)
return mask, s, o # mask, found eqc members, overshoots
def edgemask2(gl, H, cds):
n = len(H)
nl = len(gl)
s = set()
o = set()
mask = np.zeros((nl, nl), 'int')
np.fill_diagonal(mask, -1)
for i in xrange(nl):
for j in xrange(i + 1, nl):
if gl[i] & gl[j]: continue
gnum = gl[i] | gl[j]
if skip_conflictors(gnum, cds): continue
g = bfu.num2CG(gnum, n)
if not bfu.call_u_conflicts(g, H):
if bfu.call_u_equals(g, H): s.add(gnum)
mask[i, j] = gnum
mask[j, i] = gnum
elif bfu.overshoot(g, H):
o.add(gnum)
return mask, s, o # mask, found eqc members, overshoots
def quadmerge_(glist, H, ds):
n = len(H)
gl = set()
ss = set()
conflicts = set()
for gi in combinations(glist, 2):
if gi[0] & gi[1]: continue
#if skip_conflict(gi[0], gi[1], ds): continue
gnum = gi[0] | gi[1]
if gnum in conflicts: continue
if skip_conflictors(gnum, ds):
conflicts.add(gnum)
continue
if gnum in gl: continue
g = bfu.num2CG(gnum, n)
if not bfu.call_u_conflicts(g, H):
gl.add(gnum)
if bfu.call_u_equals(g, H): ss.add(gnum)
else:
conflicts.add(gnum)
return gl, ss
def quadmerge_(glist, H, ds):
n = len(H)
gl = set()
ss = set()
conflicts = set()
for gi in combinations(glist, 2):
if gi[0] & gi[1]: continue
#if skip_conflict(gi[0], gi[1], ds): continue
gnum = gi[0] | gi[1]
if gnum in conflicts: continue
if skip_conflictors(gnum, ds):
conflicts.add(gnum)
continue
if gnum in gl: continue
g = bfu.num2CG(gnum,n)
if not bfu.call_u_conflicts(g, H):
gl.add(gnum)
if bfu.call_u_equals(g, H): ss.add(gnum)
else:
conflicts.add(gnum)
return gl, ss
def add2set_loop(ds, H, cp, ccf, iter=1, verbose=True,
capsize=100, currsize=0):
n = len(H)
n2 = n*n +n
dsr = {}
s = set()
ss = set()
pbar = start_progress_bar(iter, len(ds), verbose = verbose)
c = 0
for gnum in ds:
c += 1
pbar.update(c)
gset = set()
eset = set()
for sloop in ds[gnum]:
if sloop & gnum == sloop: continue
num = sloop | gnum
if sloop in ccf and skip_conflictors(num,ccf[sloop]):continue
if not num in s:
g = bfu.num2CG(num, n)
if not bfu.call_u_conflicts(g, H):
s.add(num)
gset.add((num,sloop))
eset.add(sloop)
if bfu.call_u_equals(g, H):
ss.add(num)
if capsize <= len(ss)+currsize: return dsr, ss
#for gn,e in gset:
# if e in cp:
# dsr[gn] = eset - cp[e] - set([e])
# else:
# dsr[gn] = eset - set([e])
for gn in gset: dsr[gn[0]] = eset - set([gn[1]])
pbar.finish()
return dsr, ss
def lquadmerge(gl, H, cds):
n = len(H)
l = set()
s = set()
mask, ss = ledgemask(gl, H, cds)
s = s | ss
ds = edgeds(mask)
#pp = pprint.PrettyPrinter(indent=1)
#pp.pprint(ds)
for idx in ds:
for gn in ds[idx]:
if mask[idx]&gn: continue
if skip_conflictors(mask[idx], gn, cds): continue
gnum = mask[idx] | gn
if gnum in l or gnum in ss: continue
g = bfu.num2CG(gnum,n)
if not bfu.call_u_conflicts(g, H):
l.add(gnum)
if bfu.call_u_equals(g, H): s.add(gnum)
return list(l), s
def quadmerge(gl, H, cds):
n = len(H)
l = set()
s = set()
mask, ss = edgemask(gl, H, cds)
s = s | ss
ds = edgeds(mask)
#pp = pprint.PrettyPrinter(indent=1)
#pp.pprint(ds)
for idx in ds:
for gn in ds[idx]:
if mask[idx] & gn: continue
if skip_conflict(mask[idx], gn, cds): continue
gnum = mask[idx] | gn
if gnum in l or gnum in ss: continue
g = bfu.num2CG(gnum, n)
if not bfu.call_u_conflicts(g, H):
l.add(gnum)
if bfu.call_u_equals(g, H): s.add(gnum)
return list(l), s
