mesh-rb 0.0.1 → 0.0.2

data/ext/mesh/mesh/theory/compute_exp_Y.py

@@ -1,134 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Wed Apr 27 22:18:12 2016
-
-@author: devd
-"""
-from __future__ import division
-from choose import compute_q, nCr, compute_p3
-import cPickle as pickle
-
-def prob(a,b,c, numStrings, numOnes, p1, p2, p3):
-    p4 = 1-p1-p2-p3
-    d = numStrings-2-a-b-c
-    return (nCr(numStrings-2,a)*(p1**a)*nCr(numStrings-2-a, b)*(p2**b)*nCr(numStrings-2-a-b, c)*(p3**c)*(p4**d))
-
-def lookup(bound_id, length, numOnes, numStrings):
-    path = "bounds/{}".format(bound_id)
-    with open(path, "rb") as file:
-        bound_dict = pickle.load(file)
-    try:
-        bound = bound_dict[(length, numOnes, numStrings)]
-    except KeyError:
-        return None, bound_dict
-    return bound, None
-
-def store(bound_id, bound_dict):
-    path = "bounds/{}".format(bound_id)
-    with open(path, "wb") as file:
-        pickle.dump(bound_dict, file)
-    
-
-def compute_exp_Y(length, numOnes, numStrings):
-    q = compute_q(length, numOnes)
-    p3 = compute_p3(length, numOnes)
-    p1 = q-p3
-    p2 = p1
-    
-    p4 = 1-p1-p2-p3
-    
-    sum = 0
-    for a in range(numStrings-2+1):
-        for b in range(numStrings-2-a+1):
-            for c in range(numStrings-2-a-b+1):
-                add = min(1/(a+c+1), 1/(b+c+1))*prob(a,b,c,numStrings, numOnes,p1,p2,p3)
-#                add = min(1/(a+c), 1/(b+c))*prob(a,b,c,numStrings, numOnes,p1,p2,p3)
-                sum += add
-#                sum += min(1/(a+c+1), 1/(b+c+1))*prob(a,b,c,numStrings,p1,p2,p3)
-    sum *= q
-    return sum*nCr(numStrings,2)
-    
-def compute_degree_bound(length, numOnes, numStrings):
-    print length
-    print numOnes
-    q = compute_q(length, numOnes)
-    exp_degree = (numStrings-1)*q
-    a = exp_degree
-    b = exp_degree
-    return numStrings/2*(a/(b+1))
-    
-def compute_isolated_edge_bound(length, numOnes, numStrings):
-    q = compute_q(length, numOnes)
-    p3 = compute_p3(length, numOnes)
-    m = numStrings
-    bound1 = (m-1)*q*(1-(2*q)+p3)**(m-2)
-    bound2 = 2- 2*(1-q)**(m-1) - (m-1)*q
-    return (m/2)*max(bound1,bound2)
-#    return (m/2)*bound2
-    
-def compute_degreeplusone_bound(length, numOnes, numStrings):
-    q = compute_q(length, numOnes)
-    p3 = compute_p3(length, numOnes)
-    p1 = q-p3
-    p2 = p1
-    
-    p4 = 1-p1-p2-p3
-    
-    sum = 0
-    for a in range(numStrings-2+1):
-        for b in range(numStrings-2-a+1):
-            for c in range(numStrings-2-a-b+1):
-                add = min(1/(a+c+2), 1/(b+c+2))*prob(a,b,c,numStrings, numOnes,p1,p2,p3)
-#                add = .5*(1/(a+c+2) + 1/(b+c+2))*prob(a,b,c,numStrings, numOnes,p1,p2,p3)
-                sum += add
-    sum *= q
-    return sum*nCr(numStrings,2)
-    
-def compute_improved_degreeplusone_bound(length, numOnes, numStrings):
-    bound, bound_dict = lookup("impdeg+1", length, numOnes, numStrings)
-    if bound:
-        print 'value already exists, retrieving from database'
-        return bound
-    q = compute_q(length, numOnes)
-    p3 = compute_p3(length, numOnes)
-    p1 = q-p3
-    p2 = p1
-    
-    p4 = 1-p1-p2-p3
-    
-    sum = 0
-    for a in range(numStrings-2+1):
-        for b in range(numStrings-2-a+1):
-            for c in range(numStrings-2-a-b+1):
-                if a+c+1==1 and b+c+1==1:
-                    add = 1*prob(a,b,c,numStrings, numOnes,p1,p2,p3)
-                elif a+c+1==1:
-                    add = (1/(b+c+1))*prob(a,b,c,numStrings, numOnes,p1,p2,p3)
-                elif b+c+1==1:
-                    add = (1/(a+c+1))*prob(a,b,c,numStrings, numOnes,p1,p2,p3)
-#                elif a+c+1==2 and b+c+1==2:
-##                    add = .5*prob(a,b,c,numStrings, numOnes,p1,p2,p3)
-                elif (a+c+1==2 and b+c+1==3) or (a+c+1==3 and b+c+1==2): 
-                    add = prob(a,b,c,numStrings, numOnes,p1,p2,p3)/3.0
-#                elif a+c+1 != b+c+1:
-#                    add = min(1/(a+c+1), 1/(b+c+1))*prob(a,b,c,numStrings, numOnes,p1,p2,p3)
-                else:
-                    add = min(1/(a+c+2), 1/(b+c+2))*prob(a,b,c,numStrings, numOnes,p1,p2,p3)
-#                add = .5*(1/(a+c+2) + 1/(b+c+2))*prob(a,b,c,numStrings, numOnes,p1,p2,p3)
-                sum += add
-    sum *= q
-    result = sum*nCr(numStrings,2)
-    bound_dict[(length, numOnes, numStrings)] = result
-    store("impdeg+1", bound_dict)
-    print 'value did not already exist, writing to database'
-    return result
-
-def boundRetrieve(identifier):
-    fetcher = { "impdeg+1": (compute_improved_degreeplusone_bound)   
-    }
-    return fetcher[identifier]
-
-if __name__ == '__main__':
-#print prob(18,2,12,80,0.03125,0.03125,0.9375)/31
-#    print compute_exp_Y(32, 13, 80)
-    print compute_improved_degreeplusone_bound(16, 4, 100)

data/ext/mesh/mesh/theory/createRandomString.py

@@ -1,69 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Sat Feb 27 21:20:37 2016
-
-@author: David Tench
-"""
-import random
-import math
-
-def createRandomString(length, numOnes):
-    """Returns a random binary string with specified number of randomly located
-    ones."""
-    counter = numOnes
-    string = ''
-    for i in range(length):
-        string += '0'
-    while counter !=0:
-        loc = random.randrange(length)
-        while string[loc] == '1':
-            loc = random.randrange(length)
-        string = string[:loc] + '1' + string[loc+1:]
-        counter -= 1
-    return string
-
-def createConstRandomStrings(length, numStrings, numOnes):
-    """Returns a list of random binary strings, each with exactly numOnes ones."""
-    strings = []
-    for i in range(numStrings):
-        strings.append(createRandomString(length, numOnes))
-    return strings
-    
-def createIndependentRandomStrings(length, numStrings, q = -1, numOnes = -1):
-    """Returns a set (size numStrings) of binary strings where each bit is
-    randomly 0 or 1 with probability s.t. the probability of 2 strings meshing
-    is q."""
-    if q >= 0:
-#        print 'q = (1-p^2)^b'
-        p = math.sqrt(1 - (q**(1.0/length)))
-    elif numOnes > 0:
-#        print 'p = n/b'
-        p = float(numOnes)/length
-#        print "q = {}".format(((1 - (p)**2)**length))
-    elif numOnes == 0:
-        raise Exception("numOnes should not be 0.")
-    else: 
-         raise Exception('must specify q or numOnes')   
-#    print "q = {}".format(q)
-#    print "p = {}".format(p)
-#    print "occupancy mean is {} variance is {}".format(length*p,length*p*(1-p))
-    all_strings = []
-    for i in range(numStrings):
-        string = ''
-        for i in range(length):
-            if random.random() < p:
-                string += '1'
-            else:
-                string += '0'
-        all_strings.append(string)
-        string = ''            
-        
-    return all_strings
-
-def providedStrings(filename):
-    """not yet implemented.  will return the list of strings from some location."""
-    return None
-    
-
-#print createRandomString(32, 16)
-#print createIndependentRandomStrings(32,.5,1)

data/ext/mesh/mesh/theory/deg_bound_check.py

@@ -1,100 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Fri Apr 15 15:25:44 2016
-
-@author: devd
-"""
-
-from __future__ import division
-from createRandomString import *
-from makeGraph import *
-import matplotlib.pyplot as plt
-import matplotlib.patches as mpatches
-import networkx as nx
-import numpy as np
-import time
-from compute_exp_Y import compute_exp_Y, compute_degree_bound, compute_isolated_edge_bound, compute_degreeplusone_bound, compute_improved_degreeplusone_bound
-from choose import compute_q
-import logging
-
-logging.getLogger('').handlers = []
-logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
-
-def compute_actual_improved_deg_bound(graph):
-    edgeList = graph.edges()
-    lower_bound = 0
-    for edge in edgeList:
-        deg1 = graph.degree(edge[0])
-        deg2 = graph.degree(edge[1])
-#        if deg1 == deg2 == 1:
-#            lower_bound += 1
-#        elif deg1 == 1 and deg2 == 2:
-#            lower_bound+=.5
-#        elif deg1 == 1:
-#            lower_bound += (1.0/deg2)
-#        elif deg2 ==1:
-#            lower_bound += (1.0/deg1)
-#        elif deg1 == 2 and deg2 == 3:
-#            lower_bound += 1.0/3.0
-        if deg1 == 2 and deg2 == 2:
-            lower_bound += 1/3.0
-        else:
-#            lower_bound += min((1.0/(deg1+1)),(1.0/(deg2+1)))
-            lower_bound += min((1.0/(deg1)),(1.0/(deg2)))
-    return lower_bound
-
-def experiment(length, ones_range_min, ones_range_max, reps, numStrings):
-    strings = []
-
-
-    for numOnes in range(ones_range_min, ones_range_max+1):
-        for iterations in range (reps):
-#            for i in range(numStrings):
-#               strings.append(createRandomString(length, numOnes))
-            strings = createIndependentRandomStrings(length = length, numStrings = numStrings, numOnes = numOnes)
-               
-            graph = makeGraph(strings)
-            max_matching = len(nx.max_weight_matching(graph))/2
-            lower_bound = compute_actual_improved_deg_bound(graph)
-            if max_matching+.0001 < lower_bound:
-                print 'Max matching {} but lower bound {} for length {} strings, occupancy {}, {} total strings'.format(max_matching, lower_bound, length, numOnes, numStrings)
-                print nx.triangles(graph)
-                print graph.degree()                
-#                nx.draw(graph)
-            strings = []
-    
-def experiment2(numNodes):
-    graph = nx.complete_graph(numNodes)
-    max_matching = len(nx.max_weight_matching(graph))/2
-    lower_bound = compute_actual_improved_deg_bound(graph)
-    if max_matching+.0001 < lower_bound:
-        print 'Max matching {} but lower bound {} for complete graph on {} nodes'.format(max_matching, lower_bound, numNodes)
-    
-    
-def plot_it(length, ones_range_min, ones_range_max, reps, numStrings):
-    experiment(length, ones_range_min, ones_range_max, reps, numStrings)
-
-
-
-if __name__ == '__main__': 
-#    experiment2(101)
-    
-    length = [32]
-    ones_range_min = 1
-#    ones_range_min = 8
-    ones_range_max = 32
-    reps = 100
-    numStrings= [20]
-    
-    start = time.time()
-    t = time.localtime()
-    logging.info('deg bound experiment with lengths {}, num strings {} started'.format(length, numStrings))
-    for l in length:
-        for n in numStrings:
-            plot_it(l, ones_range_min, int(l/2), reps, n)
-            logging.info('completed length {} num strings {}'.format(l, n))
-    end = time.time()
-    print 'done in {} seconds'.format(end-start)
-#    graph = makeGraph(['0101','1100','0011','1010'])
-#    nx.draw(graph)
-#    print compute_actual_improved_deg_bound(graph)

data/ext/mesh/mesh/theory/degcheck.py

@@ -1,47 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Mon Jun 13 11:46:53 2016
-
-@author: devd
-"""
-
-from createRandomString import *
-from makeGraph import *
-import networkx as nx
-import matplotlib.pyplot as plt
-
-def experiment(numOnes, numStrings, length, reps):
-    maxdeg = []
-    mindeg = []
-    for i in range(reps):
-        strings = []
-        for i in range(numStrings):
-               strings.append(createRandomString(length, numOnes))
-        graph = makeGraph(strings)
-#        nx.draw(graph)
-        max = min = graph.degree(0)
-#        print 'initial max/min is {}'.format(max)
-        for j in range(1, numStrings):
-            deg = graph.degree(j)
-#            print 'this one has degree {}'.format(deg)
-            if deg>max:
-                max = deg
-            if deg<min:
-                min = deg
-        maxdeg.append(max)
-        mindeg.append(min)
-    
-    return maxdeg, mindeg
-
-
-def plot_it(numOnes, numStrings, length, reps):
-    maxdeg, mindeg = experiment(numOnes, numStrings, length, reps)
-    x = range(reps)
-    print maxdeg
-    print mindeg
-    plt.plot(x, maxdeg)
-    plt.plot(x, mindeg)
-#    plt.show()
-    
-
-plot_it(5, 80, 32, 10)

data/ext/mesh/mesh/theory/dumps/32,1,80,dumb.txt

@@ -1,81 +0,0 @@
-00000000000000000000000000000000
-01001000000000000000000000000000
-00000000000000000000000000000000
-00000000001000000000000000000000
-00000000000000000000000000000000
-00000000000010000000001000000000
-00000000000000000000000000000000
-00010000000000000100100000000010
-00000000000000000000000000000000
-10000000000000000000000000001000
-00000000000010000000100000000000
-00000000000000000000000000000000
-00000000000000000000000000000000
-00000000100000100000000000000000
-00000000000010000000000000000000
-00000000100000000000000000000000
-00000000001010000000000000000000
-00000000000000000000000000000000
-00000000000000000000000000000000
-00000000000000010000001000000000
-00000000000000100000000000000000
-00000000001000010000000000000000
-00000000000000000000000000000000
-00000000000000000000000000000000
-00000001000000000000000000000000
-00000000000000000000000000000000
-00000100100000000000000000000000
-00000000000000000000000000000000
-00000000000000001000000000000000
-00000000000000000000000100000000
-00000000000000000000000000000000
-00100000010000000000000000000000
-00000000000000000000000000000000
-00000000000000000000000000000000
-00000000000000100000000000000001
-00000000000000000000001000000000
-00000000000000000000000000000000
-00010000000000000000000000000000
-00000000000000100000000000000000
-00100000000000000000000000000000
-01000000000000000100000000000000
-00000000000000100000000000000100
-00000000000000000000000000000000
-00000000000000000000000000000000
-00000000000000010000000000000000
-00100000000000100000000000000000
-00000000000000000000000000000000
-00000000000000000000000000000010
-00000000000000000000000000100000
-00000001000001000000000000100000
-00000000000000000000000000000000
-00000001000000000000000000000000
-00000000000100000000000000000000
-00000000000000000000000000000000
-00000000000000000000000000000000
-00000000000000000000000000000000
-00000000000000101000000000100000
-00000000000000000000000000000000
-00000000000100000000000100000000
-00000000000000010000000000000000
-00000000000000000000000000000000
-00000000000000000000000000000000
-00000000000000001000000000000001
-00000000000000000000000000000100
-00000010000000000000000000000000
-00000000101000000010000000000000
-00000000000000001000000000000000
-00000000000000000000000000000000
-00000000000000000000000010000000
-00000100000000000000000000000000
-00000000000000000000000000000000
-00000000000000000001000000000000
-00000000000000000000100000000000
-00000010000010000000000000000101
-00000000000000000010000000000000
-00000000000000000000000000000000
-00000000000000000000000000000100
-00000000000000010000000000000000
-00001100100000000000000000000000
-00000000001000000000000000000000
--39

data/ext/mesh/mesh/theory/dumps/32,2,80,dumb.txt

@@ -1,81 +0,0 @@
-00010100000000000000100000000000
-00000100000000000000000000000000
-00000000000000000000000000000000
-00000000000000000010110010000000
-00100000010000000000001000000000
-00000000000000000000001000000001
-00000000000000000000000000001000
-00000000001000100000000000000000
-01000000000000000000000000000010
-00000000000000000000000000010000
-00000000001000000000000000000000
-00000000000000000000001000000000
-00010000000000000000000000000000
-00000100000001000000000000000000
-10000100000000000000000100000000
-00000000000000010000000000100000
-00000001000010000100000000000100
-10000000000000000000000000000000
-00000000000000000000000001000000
-00010000000000000010000000100001
-00000100000000000000000000000000
-00000000100000010010000000000000
-00000000000000000000000000000000
-00000100000000000000000000000000
-00000000010000000000000000000000
-00000100000000000000000100000000
-00000000000001000001000000000000
-00000000000000000000000000000000
-00000000000100001010100000000000
-10000000000011000000000000101000
-00000000000000000001000011000000
-00101001000000000001100100000000
-00000000001000000000000000000000
-00000000000000000100101000000000
-00000000000000000000000000000000
-00000000000000000001000000000000
-10001000000000000000000000000000
-00000000000000001000000000000000
-00000000000000000000000100000000
-00000100000000010000000001000000
-00000000100000000000000000000000
-00000001010000000000001000000000
-10000000000000000100000000000001
-00001000000000000000000000000000
-00000000000000000000000000000000
-00000000000100000000010100000000
-00001000001000000000010000000000
-00100000000000000000010000000000
-01000000000000000000000001000000
-00000000000000000000000000000000
-00000000000100001000000000000000
-00000000000000000000000000000000
-00000001000010000000000000101000
-00000000001000010000000000000000
-00000000000000000000100000100100
-00000000010110000000000000000000
-00000000000000000000010010000010
-00000000000000000000000000000000
-00000000000000000000000000001000
-00001000000000000000000000000000
-00000000000010000000000000000000
-00100001000100000000000000011010
-00100000010000000000000000000000
-00000000000010000000010000001000
-00010000000000000100000000000000
-00000010000000000000001000000000
-00000000000000010000010000000000
-00000000000000000000000000001000
-00000000000100001000000000000100
-00000010000000000000000000000000
-10000000000000000000001000001010
-00000010000000000001000000000000
-00000000000000000000000101000010
-00000000000000000000000000010000
-00000000000000000000000000000000
-10000000000000100001000000000000
-00010000001000001000000000100000
-00000000000000000000000000000000
-00000000000000000000000010000000
-00001000100000000101000010001100
--35