mesh-rb 0.0.1

data/ext/mesh/mesh/theory/greedy_experiment_copy.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Feb 27 21:32:33 2016
+
+@author: devd
+"""
+from __future__ import division
+from createRandomString import *
+from meshers import *
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_pdf import PdfPages
+
+
+length = 32
+ones_range_min = 4
+ones_range_max = 16
+reps = 10
+numStrings = 100
+
+strings = []
+ones = []
+numUnmatched = []
+perc = []
+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))
+        b, unmatched = greedyMesher(strings)
+        ones.append(numOnes)
+        percentage = (len(unmatched)/numStrings)*100
+        numUnmatched.append(len(unmatched))
+        perc.append(percentage)
+        strings = []
+plt.plot(ones, numUnmatched,'ro')
+plt.ylabel('Number of unmatched strings')
+plt.xlabel('Number of ones per string')
+plt.title('GREEDY FIRST-MATCH MESHING RESULTS \n{}-bit strings, {} trials per x value'.format(length, reps))
+#plt.show()
+
+
+plt.plot(ones, perc,'ro')
+plt.ylabel('Percentage of unmatched strings')
+plt.xlabel('Number of ones per string')
+plt.title('GREEDY FIRST-MATCH MESHING RESULTS \n{}-bit strings, {} trials per x value, {} strings per trial'.format(length, reps, numStrings))
+plt.show()
+#plt.savefig('test.png', dpi = 1000)

data/ext/mesh/mesh/theory/greedy_experiment_q.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Feb 27 21:32:33 2016
+
+@author: devd
+"""
+from __future__ import division
+from createRandomString import *
+from greedyMesher import *
+import matplotlib.pyplot as plt
+import numpy as np
+import math
+from choose import compute_q
+
+#def nCr(n,r):
+#    f = math.factorial
+#    return f(n) / f(r) / f(n-r)
+#
+#def compute_q(length, numOnes):
+#    result = float((nCr(length-numOnes, numOnes)))/(nCr(length, numOnes))
+#    return result
+    
+
+def experiment(length, ones_range_min, ones_range_max, reps, numStrings):
+    
+    strings = []
+    ones = []
+    avg = []
+    stddev = []
+    
+    for numOnes in range(ones_range_min, ones_range_max+1):
+        ones.append(numOnes)
+        vals = []
+        for iterations in range (reps):
+            for i in range(numStrings):
+                strings.append(createRandomString(length, numOnes))
+            b, unmatched = greedyMesher(strings)        
+            pages_freed = (numStrings - len(unmatched))/2
+            percentage = (pages_freed/numStrings)*100
+            vals.append(percentage)
+            strings = []
+        v = np.asarray(vals)
+        a = np.mean(v)
+        avg.append(a)
+        s = np.std(v)
+        stddev.append(s)
+    return ones, avg, stddev
+
+def plot_it(length, ones_range_min, ones_range_max, reps, numStrings):
+
+    ones, avg, stddev = experiment(length, ones_range_min, ones_range_max, reps, numStrings)
+        
+    q = [compute_q(length, x) for x in ones]
+    
+    plt.errorbar(np.asarray(q), np.asarray(avg), np.asarray(stddev), markersize=3, lw=1, fmt='-o')
+    plt.ylim([0,60])
+    plt.ylabel('Percentage of pages freed')
+    plt.xlabel('q (probability of 2 pages meshing)')
+    plt.title('GREEDY FIRST-MATCH MESHING RESULTS \n{}-object pages, {} pages'.format(length, numStrings))
+    plt.show()
+    #plt.savefig('{}p{}'.format(length, numStrings) + '.png', dpi = 1000)
+    #plt.close()
+
+#length = [32,64]
+length = [32]
+ones_range_min = 1
+ones_range_max = 16
+reps = 10
+#numStrings = [80,100,150,200]
+numStrings = [80,100]
+
+for l in length:
+    for n in numStrings:
+        plot_it(l, 1, int(l/2), reps, n)
+        print 'greedy plot {},{} done'.format(l,n)

data/ext/mesh/mesh/theory/makeGraph.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Feb 27 23:07:03 2016
+
+@author: devd
+"""
+import numpy as np
+from scipy.sparse import csr_matrix
+import networkx as nx
+
+def makeAdjacencyMatrix(strings, sparse):
+    nums = [long(s, base=2) for s in strings]
+    dim = len(strings)
+    graph = np.zeros((dim,dim))
+    for i in range(dim):
+        for j in range(dim):
+            if i == j:
+                continue
+            num = nums[i]
+            num2 = nums[j]
+            if num & num2 == 0:
+                graph[i,j] = 1
+    if sparse:
+        graph = csr_matrix(graph)
+    return graph
+
+
+
+
+def makeGraph(strings):
+    nums = [long(s, base=2) for s in strings]
+    dim = len(strings)
+    g = np.zeros((dim,dim))
+    for i in range(dim):
+        for j in range(dim):
+            if i == j:
+                continue
+            num = nums[i]
+            num2 = nums[j]
+            if num & num2 == 0:
+                g[i,j] = 1
+    graph = nx.Graph(g)
+    return graph
+    
+    
+#g = makeGraph(['000','001','111','101', '110', '010'])
+#nx.draw(g)
+#degrees = g.degree(g.nodes())
+#print max(degrees.values())
+#print min(degrees.values())
+#print degrees
+    
+    
+    
+    
+    
+    
+#g_c = nx.complement(g)
+#color = nx.greedy_color(g_c)
+#print color
+#i = 0
+#for key, value in color.iteritems():
+#    i = max(i, value)
+#print i + 1

data/ext/mesh/mesh/theory/match_vs_color_experiment.py

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Feb 28 22:44:37 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
+
+
+def color_counter(graph):
+    color = nx.greedy_color(graph)
+    i = 0
+    for key, value in color.iteritems():
+        i = max(i, value)
+    return i+1
+
+def experiment(length, ones_range_min, ones_range_max, reps, numStrings):
+    strings = []
+    ones = []
+    match_avg = []
+    match_std_dev = []
+    color_avg = []
+    color_std_dev = []
+
+    for numOnes in range(ones_range_min, ones_range_max+1):
+        ones.append(numOnes)
+        freed_pages_matching = []
+        freed_pages_coloring = []
+        for iterations in range (reps):
+            for i in range(numStrings):
+               strings.append(createRandomString(length, numOnes))
+#            strings = createIndependentRandomStrings(length, numStrings, numOnes = numOnes)
+               
+            graph = makeGraph(strings)
+            frdpgs_matching = len(nx.max_weight_matching(graph))/2
+            perc = (frdpgs_matching/numStrings)*100
+            freed_pages_matching.append(perc)
+            
+            graph_c = nx.complement(graph)
+            frdpgs_coloring = numStrings - color_counter(graph_c)
+            perc = (frdpgs_coloring/numStrings)*100
+            freed_pages_coloring.append(perc)
+            
+            strings = []
+        m = np.asarray(freed_pages_matching)
+        m_a = np.mean(m)
+        match_avg.append(m_a)
+        m_s = np.std(m)
+        match_std_dev.append(m_s)
+        
+        c = np.asarray(freed_pages_coloring)
+        c_a = np.mean(c)
+        color_avg.append(c_a)
+        c_s = np.std(c)
+        color_std_dev.append(c_s)
+        
+    return ones, match_avg, match_std_dev, color_avg, color_std_dev
+
+
+def plot_it(length, ones_range_min, ones_range_max, reps, numStrings):
+    ones, match_avg, match_std_dev, color_avg, color_std_dev = experiment(length, ones_range_min, ones_range_max, reps, numStrings)
+    
+    plt.errorbar(np.asarray(ones), np.asarray(match_avg), np.asarray(match_std_dev), markersize=3, lw=1, fmt='-o')
+    plt.errorbar(np.asarray(ones), np.asarray(color_avg), np.asarray(color_std_dev), markersize=3, lw=1, fmt='-o')
+    plt.ylim([0,100])
+    plt.ylabel('Percentage of pages freed')
+    plt.xlabel('Number of objects per page')
+    blue_patch = mpatches.Patch(color='blue', label='matching')
+    green_patch = mpatches.Patch(color = 'green', label = 'clique')
+    plt.legend(handles=[blue_patch, green_patch])
+    plt.title('MAX MATCHING VS MIN CLIQUE COVER MESHING RESULTS \n{}-object pages, {} pages'.format(length, numStrings))
+#    plt.show()
+    plt.savefig('{}m{}ind'.format(length, numStrings) + '.png', dpi = 1000)
+#    plt.close()
+
+length = [64]
+ones_range_min = 1
+ones_range_max = 32
+reps = 10
+#numStrings = [80,100,150,200]
+numStrings = [80]
+
+for l in length:
+    for n in numStrings:
+        plot_it(l, ones_range_min, int(l/2), reps, n)
+        print 'match vs color plot {},{} done'.format(l,n)
+

data/ext/mesh/mesh/theory/maxmatch_vs_E[Y].py

@@ -0,0 +1,162 @@
+# -*- 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
+
+def experiment(length, ones_range_min, ones_range_max, reps, numStrings):
+    strings = []
+    ones = []
+    maxmatch_avg = []
+    maxmatch_std_dev = []
+#    greedymatch_avg = []
+#    greedymatch_std_dev = []
+    y_estimate = []
+    justy = []
+    raw = []
+    qs = []
+
+
+    for numOnes in range(ones_range_min, ones_range_max+1):
+        ones.append(numOnes)
+        q = compute_q(length, numOnes)
+        qs.append(q*100)
+#        qs.append(compute_q(length, numOnes)*100)
+        freed_pages_maxmatching = []
+        freed_pages_greedymatching = []
+        for iterations in range (reps):
+            for i in range(numStrings):
+               strings.append(createRandomString(length, numOnes))
+#            strings = createIndependentRandomStrings(length = length, numStrings = numStrings, q = q)
+               
+            graph = makeGraph(strings)
+            frdpgs_maxmatching = len(nx.max_weight_matching(graph))/2
+            perc = (frdpgs_maxmatching/numStrings)*100
+            freed_pages_maxmatching.append(perc)
+            
+            strings = []
+            
+                    
+            
+        m = np.asarray(freed_pages_maxmatching)
+        raw.append(freed_pages_maxmatching)
+        m_a = np.mean(m)
+        maxmatch_avg.append(m_a)
+        m_s = np.std(m)
+        maxmatch_std_dev.append(m_s)
+        
+#        y = compute_exp_Y(length, numOnes, numStrings)
+#        y = compute_degreeplusone_bound(length, numOnes, numStrings)
+        y = compute_improved_degreeplusone_bound(length, numOnes, numStrings)
+        
+#        y_est_raw = max(y,compute_degree_bound(length, numOnes, numStrings),compute_isolated_edge_bound(length, numOnes, numStrings))
+#        y_est_raw = compute_isolated_edge_bound(length, numOnes, numStrings)
+#        y_est_raw = compute_degree_bound(length, numOnes, numStrings)
+#        y_est_raw = y
+        yperc = (math.floor(y)/numStrings)*100
+        y_estimate.append(yperc)
+
+        
+#    mistakes = {}
+#    for i in range(len(raw)):
+#        oops = []
+#        for entry in raw[i]:
+#            if entry < y_estimate[i]:
+#                oops.append(entry)
+#        mistakes[i+1] = oops
+#    print 'mistakes:'
+#    print mistakes
+    
+    
+    
+    
+    
+#    use this version of mistakes
+    mistakes = {}
+    for i in range(len(raw)):
+        oops = 0
+        for entry in raw[i]:
+            if entry < y_estimate[i]:
+                oops += 1
+        mistakes[i+1] = oops
+    print 'mistakes:'
+    print mistakes    
+    
+    print 'E[Y]:'
+    ey = {}
+    for i in range(len(y_estimate)):
+        ey[i+1] = y_estimate[i]
+    print ey
+#                
+        
+#        yperc = (y/numStrings)*100
+#        justy.append(yperc)
+        
+#        c = np.asarray(freed_pages_greedymatching)
+#        c_a = np.mean(c)
+#        greedymatch_avg.append(c_a)
+#        c_s = np.std(c)
+#        greedymatch_std_dev.append(c_s)
+    
+    
+        
+    return ones, maxmatch_avg, maxmatch_std_dev, y_estimate, justy, qs
+    
+    
+def plot_it(length, ones_range_min, ones_range_max, reps, numStrings):
+    ones, match_avg, match_std_dev, y_estimate, justy, qs = experiment(length, ones_range_min, ones_range_max, reps, numStrings)
+    
+#    print y_estimate
+    plt.errorbar(np.asarray(ones), np.asarray(match_avg), np.asarray(match_std_dev), markersize=3, lw=1, fmt='-o')
+#    plt.errorbar(np.asarray(ones), np.asarray(color_avg), np.asarray(color_std_dev), markersize=3, lw=1, fmt='-o')
+    plt.errorbar(np.asarray(ones), np.asarray(y_estimate), np.zeros(len(ones)), markersize=3, lw=1, fmt='-o')
+#    plt.errorbar(np.asarray(ones), np.asarray(justy), np.zeros(len(ones)), markersize=3, lw=1, fmt='-o')
+#    plt.plot(np.asarray(ones), y_estimate, markersize = 3, lw=1, fmt='o')
+#    plt.errorbar(np.asarray(ones), np.asarray(qs), np.zeros(len(ones)), markersize=3, lw=1, fmt='-o')
+    plt.ylim([0,60])
+#    plt.xlim([10, 14])
+    plt.ylabel('Percentage of pages freed')
+    plt.xlabel('Number of objects per page')
+    blue_patch = mpatches.Patch(color='blue', label='max matching')
+    green_patch = mpatches.Patch(color = 'green', label = 'lower bound')
+    red_patch = mpatches.Patch(color = 'red', label = 'q')
+    plt.legend(handles=[blue_patch, green_patch])
+#    plt.legend(handles=[blue_patch, green_patch, red_patch])
+    plt.title('MAX MATCHING VS LOWER BOUND \n{}-object pages, {} pages'.format(length, numStrings))
+#    plt.show()
+#    plt.savefig('maxvE[Y]{},{}'.format(length, numStrings) + '.png', dpi = 1000)
+    plt.savefig('maxvdeg+1imp++{},{}'.format(length, numStrings) + '.png', dpi = 1000)
+#    plt.savefig('manystrings.png', dpi = 1000)
+    plt.close()
+
+
+if __name__ == '__main__':    
+    #length = [32,64]
+    length = [32]
+    ones_range_min = 1
+    ones_range_max = 32
+    reps = 10
+#    numStrings = [80,100,150,200]
+    numStrings= [80]
+    
+    
+    start = time.time()
+    for l in length:
+        for n in numStrings:
+            plot_it(l, ones_range_min, int(l/2), reps, n)
+    #        plot_it(l, 10, 13, 10, n)
+            print 'max match vs E[Y] plot {},{} done'.format(l,n)
+    end = time.time()
+    print('making this took {} seconds'.format(end-start) )