示例#1
0
 def prune(g):
     numh = bfu.g2num(g)
     cannotprune = True
     for l in gk.edgelist(gk.digonly(g)):
         gk.delanedge(g,l)
         if bfu.forms_loop(g, loop):
             cannotprune = False
             prune(g)
         gk.addanedge(g,l)
     if cannotprune: s.add(bfu.g2num(g))
示例#2
0
 def prune(g):
     numh = bfu.g2num(g)
     cannotprune = True
     for l in sls.simple_loops(gk.digonly(g),0):
         gg = delAloop(g,bfu.g2num(loop2graph(l,n)))
         if bfu.forms_loop(gg, loop):
             cannotprune = False
             prune(gg)
     if cannotprune:
         print 'one'
         s.add(g)
示例#3
0
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 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
示例#5
0
def delAloop(g, loop):
    n = len(g)
    l = []
    l = [bfu.g2num(ur.loop2graph(s,n)) for s in sls.simple_loops(g,0)]
    l = [num for num in l if not num == loop ]
    print loop, ': ',  l
    return bfu.num2CG(reduce(operator.or_, l),n)
示例#6
0
def allsloops(n, asl = alloops):
    if asl: return asl[n]
    s = []
    l = gen_loops(n)
    for e in l:
        s.append(bfu.g2num(loop2graph(e,n)))
    return s
示例#7
0
def simple_loops(g, u):
    """
    iterator over the list of simple loops of graph g at the undersample rate u
    """
    gx = graph2nx(num2CG(g2num(undersample(g, u)), len(g)))
    for l in networkx.simple_cycles(gx):
        yield l
示例#8
0
def iteqclass(H, verbose=True, capsize=100):
    '''
    Find all graphs in the same equivalence class with respect to
    graph H and any undesampling rate.
    '''
    if cmp.isSclique(H):
        print 'not running on superclique'
        return None
    g = {n:{} for n in H}
    s = set()
    Hnum = bfu.ug2num(H)
    if Hnum[1]==0: s.add(Hnum[0])

    cp = confpairs(H)
    ccf = conflictors(H)

    edges = gk.edgelist(gk.complement(g))
    ds = {bfu.g2num(g): edges}

    if verbose: print '%3s'%'i'+'%10s'%' graphs'
    for i in range(len(H)**2):
        ds, ss = add2set_(ds, H, cp, ccf, iter=i,
                            verbose=verbose,
                            capsize=capsize)
        s = s | ss
        if capsize <= len(ss): break
        if not ds: break

    return s
示例#9
0
def simple_loops(g, u):
    """
    iterator over the list of simple loops of graph g at the undersample rate u
    """
    gx = graph2nx(num2CG(g2num(undersample(g,u)), len(g)))
    for l in networkx.simple_cycles(gx):
        yield l
示例#10
0
文件: clingo.py 项目: pliz/gunfolds
def clingo2g(output):
    s = set()
    answers = filterAnswers(output.split('\n'))
    answers = [a2edgetuple(x) for x in answers]
    l = [(c2edgepairs(x[0]),x[1]) for x in answers]
    l = [(bfu.g2num(edgepairs2g(x[0])),int(x[1][2:-1])) for x in l]
    return l
示例#11
0
def clingo2g(output):
    s = set()
    answers = filterAnswers(output.split('\n'))
    answers = [a2edgetuple(x) for x in answers]
    l = [(c2edgepairs(x[0]), x[1]) for x in answers]
    l = [(bfu.g2num(edgepairs2g(x[0])), int(x[1][2:-1])) for x in l]
    return l
示例#12
0
def add2set(gset, elist, H):
    n = len(H)

    s = set()
    ss = set()

    eremove = {e: True for e in elist}

    for gnum in gset:
        g = bfu.num2CG(gnum, n)
        for e in elist:
            if not e[1] in g[e[0]]:
                gk.addanedge(g,e)
                num = bfu.g2num(g)
                if not num in s:
                    au = bfu.call_undersamples(g)
                    if not gk.checkconflict(H, g, au=au):
                        eremove[e] = False
                        s.add(num)
                        if gk.checkequality(H, g, au=au): ss.add(num)
                gk.delanedge(g,e)

    for e in eremove:
        if eremove[e]: elist.remove(e)

    return s, ss, elist
示例#13
0
def iteqclass(H, verbose=True, capsize=100):
    '''
    Find all graphs in the same equivalence class with respect to
    graph H and any undesampling rate.
    '''
    if cmp.isSclique(H):
        print 'not running on superclique'
        return None
    g = {n: {} for n in H}
    s = set()
    Hnum = bfu.ug2num(H)
    if Hnum[1] == 0: s.add(Hnum[0])

    cp = confpairs(H)
    ccf = conflictors(H)

    edges = gk.edgelist(gk.complement(g))
    ds = {bfu.g2num(g): edges}

    if verbose: print '%3s' % 'i' + '%10s' % ' graphs'
    for i in range(len(H)**2):
        ds, ss = add2set_(ds,
                          H,
                          cp,
                          ccf,
                          iter=i,
                          verbose=verbose,
                          capsize=capsize)
        s = s | ss
        if capsize <= len(ss): break
        if not ds: break

    return s
示例#14
0
def add2set(gset, elist, H):
    n = len(H)

    s = set()
    ss = set()

    eremove = {e: True for e in elist}

    for gnum in gset:
        g = bfu.num2CG(gnum, n)
        for e in elist:
            if not e[1] in g[e[0]]:
                gk.addanedge(g, e)
                num = bfu.g2num(g)
                if not num in s:
                    au = bfu.call_undersamples(g)
                    if not gk.checkconflict(H, g, au=au):
                        eremove[e] = False
                        s.add(num)
                        if gk.checkequality(H, g, au=au): ss.add(num)
                gk.delanedge(g, e)

    for e in eremove:
        if eremove[e]: elist.remove(e)

    return s, ss, elist
示例#15
0
    def nodesearch(g, g2, order, inlist, s, cds, pool, pc):
        if order:
            if bfu.undersample(g, rate) == g2:
                s.add(bfu.g2num(g))
                if capsize and len(s) > capsize:
                    raise ValueError('Too many elements')
                s.update(supergraphs_in_eq(g, g2, rate=rate))
                return g

            key = order[0]
            if pc:
                tocheck = [
                    x for x in pc if x in cds[len(inlist) - 1][inlist[0]]
                ]
            else:
                tocheck = cds[len(inlist) - 1][inlist[0]]

            if len(order) > 1:
                kk = order[1]
                pc = predictive_check(g, g2, pool[len(inlist)],
                                      c[edge_function_idx(kk)], kk)
            else:
                pc = set()

            adder, remover, masker = f[edge_function_idx(key)]
            checks_ok = c[edge_function_idx(key)]

            for n in tocheck:
                if not checks_ok(key, n, g, g2, rate=rate): continue
                masked = np.prod(masker(g, key, n))
                if masked:
                    nodesearch(g, g2, order[1:], [n] + inlist, s, cds, pool,
                               pc)
                else:
                    mask = adder(g, key, n)
                    nodesearch(g, g2, order[1:], [n] + inlist, s, cds, pool,
                               pc)
                    remover(g, key, n, mask)

        elif bfu.undersample(g, rate) == g2:
            s.add(bfu.g2num(g))
            if capsize and len(s) > capsize:
                raise ValueError('Too many elements')
            return g
示例#16
0
    def nodesearch0(g, g2, order, inlist, s, cds):

        if order:
            key = order.pop(0)
            tocheck = cds[len(inlist)-1][inlist[0]]

            adder, remover, masker = f[edge_function_idx(key)]
            checks_ok = c[edge_function_idx(key)]

            if len(tocheck) > 1:
                for n in tocheck:
                    if not checks_ok(key,n,g,g2): continue
                    mask = masker(g,key,n)
                    if not np.prod(mask):
                        mask = adder(g,key,n)
                        r = nodesearch0(g,g2,order, [n]+inlist, s, cds)
                        if r and bfu.increment(r)==g2:
                            s.add(bfu.g2num(r))
                            if capsize and len(s)>capsize:
                                raise ValueError('Too many elements')
                        remover(g,key,n,mask)
                    else:
                        r = nodesearch0(g,g2,order, [n]+inlist, s, cds)
                        if r and bfu.increment(r)==g2:
                            s.add(bfu.g2num(r))
                            if capsize and len(s)>capsize:
                                raise ValueError('Too many elements')
            elif tocheck:
                (n,) = tocheck
                mask = adder(g,key,n)
                r = nodesearch0(g,g2, order, [n]+inlist, s, cds)
                if r and bfu.increment(r) == g2:
                    s.add(bfu.g2num(r))
                    if capsize and len(s)>capsize:
                        raise ValueError('Too many elements')
                remover(g,key,n,mask)

            order.insert(0,key)

        else:
            return g
示例#17
0
    def addedges(g,H,edges):
        if edges:
            nedges = prune_conflicts(H, g, edges)
            n = len(nedges)

            if n == 0: return None

            for i in range(n):
                gk.addanedge(g,nedges[i])
                if bfu.call_u_equals(g, H): s.add(bfu.g2num(g))
                addedges(g,H,nedges[:i]+nedges[i+1:])
                gk.delanedge(g,nedges[i])
示例#18
0
    def addedges(g, H, edges):
        if edges:
            nedges = prune_conflicts(H, g, edges)
            n = len(nedges)

            if n == 0: return None

            for i in range(n):
                gk.addanedge(g, nedges[i])
                if bfu.call_u_equals(g, H): s.add(bfu.g2num(g))
                s.add(addedges(g, H, nedges[:i] + nedges[i + 1:]))
                gk.delanedge(g, nedges[i])
示例#19
0
    def nodesearch(g, g2, order, inlist, s, cds, pool, pc):
        if order:
            if bfu.undersample(g,rate) == g2:
                s.add(bfu.g2num(g))
                if capsize and len(s)>capsize:
                    raise ValueError('Too many elements')
                s.update(supergraphs_in_eq(g, g2, rate=rate))
                return g

            key = order[0]
            if pc:
                tocheck = [x for x in pc if x in cds[len(inlist)-1][inlist[0]]]
            else:
                tocheck = cds[len(inlist)-1][inlist[0]]

            if len(order) > 1:
                kk = order[1]
                pc = predictive_check(g,g2,pool[len(inlist)],
                                      c[edge_function_idx(kk)],kk)
            else:
                pc = set()

            adder, remover, masker = f[edge_function_idx(key)]
            checks_ok = c[edge_function_idx(key)]

            for n in tocheck:
                if not checks_ok(key,n,g,g2,rate=rate): continue
                masked = np.prod(masker(g,key,n))
                if masked:
                    nodesearch(g,g2,order[1:], [n]+inlist, s, cds, pool, pc)
                else:
                    mask = adder(g,key,n)
                    nodesearch(g,g2,order[1:], [n]+inlist, s, cds, pool, pc)
                    remover(g,key,n,mask)

        elif bfu.undersample(g,rate)==g2:
            s.add(bfu.g2num(g))
            if capsize and len(s)>capsize:
                raise ValueError('Too many elements')
            return g
示例#20
0
    def nodesearch(g, g2, edges, s):
        if edges:
            if bfu.undersample(g,rate) == g2:
                s.add(bfu.g2num(g))
                if capsize and len(s)>capsize:
                    raise ValueError('Too many elements')
                return g
            e = edges[0]
            for n in ln:

                if (n,e) in single_cache: continue
                if not ok2addaVpath(e, n, g, g2, rate=rate): continue

                mask = addaVpath(g,e,n)
                r = nodesearch(g,g2,edges[1:],s)
                delaVpath(g,e,n,mask)

        elif bfu.undersample(g,rate)==g2:
            s.add(bfu.g2num(g))
            if capsize and len(s)>capsize:
                raise ValueError('Too many elements in eqclass')
            return g
示例#21
0
    def nodesearch(g, g2, edges, s):
        if edges:
            if bfu.increment(g) == g2:
                s.add(bfu.g2num(g))
                if capsize and len(s)>capsize:
                    raise ValueError('Too many elements')
                return g
            e = edges[0]
            for n in g2:

                if (n,e) in single_cache: continue
                if not edge_increment_ok(e[0],n,e[1],g,g2): continue

                mask = add2edges(g,e,n)
                r = nodesearch(g,g2,edges[1:],s)
                del2edges(g,e,n,mask)

        elif bfu.increment(g)==g2:
            s.add(bfu.g2num(g))
            if capsize and len(s)>capsize:
                raise ValueError('Too many elements in eqclass')
            return g
示例#22
0
 def addnodes(g,g2,edges):
     if edges:
         masks  = []
         for e in edges:
             if ok2addanedge(e[0],e[1],g,g2,rate=rate):
                 masks.append(True)
             else:
                 masks.append(False)
         nedges = [edges[i] for i in range(len(edges)) if masks[i]]
         n = len(nedges)
         if n:
             for i in range(n):
                 mask = addanedge(g,nedges[i])
                 s.add(bfu.g2num(g))
                 addnodes(g,g2,nedges[:i]+nedges[i+1:])
                 delanedge(g,nedges[i],mask)
示例#23
0
 def nodesearch(g, g2, edges, s):
     if edges:
         e = edges.pop()
         ln = [n for n in g2]
         for n in ln:
             if (n,e) in single_cache: continue
             mask = add2edges(g,e,n)
             if isedgesubsetD(bfu.increment(g), g2):
                 r = nodesearch(g,g2,edges,s)
                 if r and edgeset(bfu.increment(r))==edgeset(g2):
                     s.add(bfu.g2num(r))
                     if capsize and len(s)>capsize:
                         raise ValueError('Too many elements in eqclass')
             del2edges(g,e,n,mask)
         edges.append(e)
     else:
         return g
示例#24
0
def eqclass_list(H):
    '''
    Find all graphs in the same equivalence class with respect to
    graph H and any undesampling rate.
    '''
    g = {n:{} for n in H}
    s = set()

    edges = gk.edgelist(gk.complement(g))
    #edges = prune_conflicts(H, g, edges)

    gset = set([bfu.g2num(g)])
    for i in range(len(H)**2):
        print i
        gset, ss, edges = add2set(gset, edges, H)
        s = s | ss
        if not edges: break

    return s
示例#25
0
 def nodesearch(g, g2, edges, s):
     if edges:
         #key, checklist = edges.popitem()
         key = random.choice(edges.keys())
         checklist = edges.pop(key)
         adder, remover = f[edge_function_idx(key)]
         checks_ok = c[edge_function_idx(key)]
         for n in checklist:
             mask = adder(g,key,n)
             if isedgesubset(bfu.increment(g), g2):
                 r = nodesearch(g,g2,edges,s)
                 if r and bfu.increment(r)==g2:
                     s.add(bfu.g2num(r))
                     if capsize and len(s)>capsize:
                         raise ValueError('Too many elements')
             remover(g,key,n,mask)
         edges[key] = checklist
     else:
         return g
示例#26
0
def eqclass_list(H):
    '''
    Find all graphs in the same equivalence class with respect to
    graph H and any undesampling rate.
    '''
    g = {n: {} for n in H}
    s = set()

    edges = gk.edgelist(gk.complement(g))
    #edges = prune_conflicts(H, g, edges)

    gset = set([bfu.g2num(g)])
    for i in range(len(H)**2):
        print i
        gset, ss, edges = add2set(gset, edges, H)
        s = s | ss
        if not edges: break

    return s
示例#27
0
def reverse(H, verbose=True, capsize=1000):
    n = len(H)
    s = set()

    g      = gk.superclique(n)
    sloops = set(allsloops(n))

    ds = {bfu.g2num(g): sloops}

    if verbose: print '%3s'%'i'+'%10s'%' graphs'
    i=0
    while ds:
        ds, ss = del_loop(ds, H, iter=i,
                          verbose=verbose,
                          capsize=capsize)
        s = s | ss
        i += 1
        if capsize <= len(s): break

    return s
示例#28
0
def gsig(g):
    '''
    turns input graph g into a hash string using edges
    '''
    return bfu.g2num(g)
示例#29
0
def permuteAset(s, perm):
    n = len(perm)
    ns = set()
    for e in s:
        ns.add(bfu.g2num(permute(bfu.num2CG(e,n),perm)))
    return ns