mesh-rb 0.0.1 → 0.0.2

data/ext/mesh/mesh/theory/maxmatch_vs_greedymatch.py

@@ -1,96 +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 *
-from greedyMesher import *
-import matplotlib.pyplot as plt
-import matplotlib.patches as mpatches
-import networkx as nx
-import numpy as np
-import time
-
-def experiment(length, ones_range_min, ones_range_max, reps, numStrings):
-    strings = []
-    ones = []
-    maxmatch_avg = []
-    maxmatch_std_dev = []
-    greedymatch_avg = []
-    greedymatch_std_dev = []
-
-    for numOnes in range(ones_range_min, ones_range_max+1):
-        ones.append(numOnes)
-        freed_pages_maxmatching = []
-        freed_pages_greedymatching = []
-        for iterations in range (reps):
-            for i in range(numStrings):
-               strings.append(createRandomString(length, numOnes))
-               
-            graph = makeGraph(strings)
-            frdpgs_maxmatching = len(nx.max_weight_matching(graph))/2
-            perc = (frdpgs_maxmatching/numStrings)*100
-            freed_pages_maxmatching.append(perc)
-            
-#            graph_c = nx.complement(graph)
-#            frdpgs_greedymatching = numStrings - color_counter(graph_c)
-#            perc = (frdpgs_greedymatching/numStrings)*100
-#            freed_pages_greedymatching.append(perc)
-            
-            b, unmatched = greedyMesher(strings)        
-            frdpgs_greedymatching = (numStrings - len(unmatched))/2
-            perc = (frdpgs_greedymatching/numStrings)*100
-            freed_pages_greedymatching.append(perc)
-            
-            strings = []
-        m = np.asarray(freed_pages_maxmatching)
-        m_a = np.mean(m)
-        maxmatch_avg.append(m_a)
-        m_s = np.std(m)
-        maxmatch_std_dev.append(m_s)
-        
-        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, greedymatch_avg, greedymatch_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,60])
-    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 = 'greedy matching')
-    plt.legend(handles=[blue_patch, green_patch])
-    plt.title('MAX MATCHING VS GREEDY MATCHING MESHING RESULTS \n{}-object pages, {} pages'.format(length, numStrings))
-    #plt.show()
-    plt.savefig('maxvgreedy{},{}'.format(length, numStrings) + '.png', dpi = 1000)
-    plt.close()
-    
-#length = [32,64]
-length = [128]
-ones_range_min = 1
-ones_range_max = 32
-reps = 10
-#numStrings = [80,100,150,200]
-numStrings= [150,200]
-
-
-start = time.time()
-for l in length:
-    for n in numStrings:
-        plot_it(l, ones_range_min, int(l/2), reps, n)
-        print 'max match vs greedy match plot {},{} done'.format(l,n)
-end = time.time()
-print('making this took {} seconds'.format(end-start) )

data/ext/mesh/mesh/theory/mesh_util.py

@@ -1,322 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Mon Jun 19 15:32:02 2017
-
-@author: devd
-"""
-import math
-import operator
-from itertools import izip, imap
-import random
-from scipy.misc import comb as fast_nCr
-from scipy.special import gamma
-
-
-def formatStrings(strings):
-    """Adds extra data to a list of strings for ease of meshing.  Replaces each
-    string in the list with a tuple (A,B,C,D). A = original string. B = binary 
-    representation for fast arithmetic.  C = occupancy.  D = flag that indicates
-    whether the string has been meshed(initially set to False)."""
-    new_strings = []
-    for string in strings:
-        #new_strings.append((string, long(string, base=2)))
-        new_strings.append(
-            (string, long(string, base=2), string.count("1"), False))
-    return new_strings
-
-
-def hamming(str1, str2):
-    """Calculates the Hamming distance between two strings of equal length."""
-#    if type(str1) == long:
-#        str1 = bin(str1)[2:].rjust(len(str2),"0")
-    assert len(str1) == len(str2)
-    ne = operator.ne
-    return sum(imap(ne, str1, str2))
-
-
-def fast_q(length, occ1, occ2):
-    """computes the probability that two strings with given occupancies will
-    mesh."""
-    result = float((fast_nCr(length - occ2, occ1))) / (fast_nCr(length, occ1))
-    return result
-
-
-def faster_q(length, occ1, occ2):
-    numerator = 1
-    for i in range(length - occ1, length - occ1 - occ2, -1):
-        print(i)
-        numerator *= i
-    denominator = 1
-    for i in range(length, length - occ2, -1):
-        denominator *= i
-    return float(numerator) / float(denominator)
-
-
-def generate_cutoffs(bkt1, length, cutoff):
-    """returns a dict indexed by string occupancy, value is the cutoff occupancy
-    for potential meshes (if you encounter a higher occupancy during a greedy
-    search for a mesh, stop)."""
-    cutoffs = {}
-    for s in bkt1:
-        occ1 = s[2]
-        if occ1 not in cutoffs.keys():
-            cutoffs[occ1] = float('inf')
-            # only calculate cutoffs for every 5th occupancy, to save time
-            for occ2 in range(0, int(length / 2), 5):
-                if faster_q(length, occ1, occ2) < cutoff:
-                    cutoffs[occ1] = occ2
-                    break
-    return cutoffs
-
-
-class Splitter(object):
-    """
-    Encapsulates splitting behavior for a trial.
-
-    Keeps track of multiple different splitting strings and can
-    automatically cycle through them if required.
-    """
-
-    def __init__(self, length):
-        self.length = length
-        self.splitting_strings = []
-        self.num_splitters = int(math.log(length, 2))
-        # print self.num_splitters
-        for i in range(1, self.num_splitters + 1):
-            split_string = ""
-            for j in range(2**(i - 1)):
-                split_string = split_string + \
-                    (("1" * int((length / (2**i)))) +
-                     ("0" * (int(length / (2**i)))))
-            self.splitting_strings.append(split_string)
-        # print self.splitting_strings
-        print 'Splitter(%d): %d splitters with strings: %s' % \
-            (length, self.num_splitters, self.splitting_strings)
-
-        self.current_method = 0
-
-    def _splitter(self, strings, advance):
-        """splits the given string set based on the current splitting string.  
-        optionally advances to the next splitting string for future splittings."""
-        split = self.splitting_strings[self.current_method]
-        if advance:
-            self.current_method = self.current_method + 1
-        bucket1 = []
-        bucket2 = []
-        for s in strings:
-            diff = hamming(s[0], split)
-            if diff < int(self.length * 0.5):
-                bucket1.append(s)
-            elif diff == int(self.length * 0.5):
-                if random.randint(0, 1):
-                    bucket1.append(s)
-                else:
-                    bucket2.append(s)
-            else:
-                bucket2.append(s)
-        return bucket1, bucket2
-
-    def split(self, strings=[], bucket1=[], bucket2=[], advance=True):
-        """the outward-facing method for splitting.  gracefully handles both
-        a single string set and a """
-#        print 'trying to split. current method is {}'.format(self.current_method)
-        if strings == [] and bucket1 == [] and bucket2 == []:
-            raise Exception('must provide split method with nonempty input')
-        if strings != []:
-            return self._splitter(strings, advance)
-        else:
-            if self.current_method >= self.num_splitters:
-                return bucket1, bucket2
-            else:
-                return self._splitter(bucket1 + bucket2, advance)
-
-    def advance(self):
-        self.current_method = self.current_method + 1
-
-
-def occupancySort(strings):
-    """Modifies given list of strings in place, sorting them in order of 
-    increasing occupancy."""
-#    strings.sort(key = lambda x: x[0].count("1"))
-    strings.sort(key=lambda x: x[2])
-
-
-def simple_traverse(meshes, strings, dim=0):
-    """probes a list of strings for meshable pairs. the first string is checked
-    against the second, third/fourth, etc. mesh and unmeshed string lists are 
-    modified in place. returns True if all strings have been meshed; else returns
-    False."""
-#    print 'here are the strings passed to simple_traverse', strings
-#    print 'and dim is', dim
-    matched = []
-    for i in range(len(strings) - 2, -1 + dim, -2):
-        num1 = strings[i][1]
-        num2 = strings[i + 1][1]
-#        print num1, num2
-        if num1 & num2 == 0:
-            matched.append(i)
-            meshes.append((strings[i], strings[i + 1]))
-#            meshes.append(strings[i+1])
-#            print "adding mesh {}, {}".format(strings[i], strings[i+1])
-    for x in matched:
-        del strings[x + 1]
-        del strings[x]
-    if len(strings) == 0:
-        return True
-    return False
-
-
-def traverse(meshes, bucket1=None, bucket2=None, strings=None, extra=False):
-    """looks for meshable pairs between the buckets. modifies the buckets and
-    the list of found meshes in place.  returns whether or not meshing is done.
-    throws an assertion error if only one bucket has anything in it, so the
-    caller can resplit the buckets or whatever."""
-    if strings != None:
-        #        print 'found strings'
-        return simple_traverse(strings, meshes)
-    if bucket1 == None or bucket2 == None:
-        raise Exception(
-            'must pass either buckets or string set to traverse function')
-
-    dim = min(len(bucket1), len(bucket2))
-    if len(bucket1) == len(bucket2) == 0:
-        return True
-    assert dim != 0
-    matched = []
-    if dim == 1:
-        num1 = bucket1[0][1]
-        num2 = bucket2[0][1]
-        if num1 & num2 == 0:
-            matched.append(0)
-    for i in range(dim - 1, 0, -1):
-        num1 = bucket1[i][1]
-        num2 = bucket2[i][1]
-        if num1 & num2 == 0:
-            matched.append(i)
-    for x in matched:
-        meshes.append((bucket1[x], bucket2[x]))
-    # if one bucket is larger than the other, mesh remaining strings among themselves
-    if extra:
-        #        print 'extra'
-        if len(bucket1) != len(bucket2):
-            #            print bucket1, bucket2
-            #            print 'chosing one'
-            bucket = max([bucket1, bucket2], key=lambda x: len(x))
-#            print '{} chosen'.format(bucket)
-            simple_traverse(meshes, bucket, dim)
-#            print bucket
-
-    for x in matched:
-        del bucket1[x]
-        del bucket2[x]
-    return False
-
-
-def simpleGreedyTraverse(meshes, strings, cutoff=None):
-    """given a list of strings, exhaustively checks the first string for meshes,
-    then the second, etc.  found meshes are removed from the list.  ends when all
-    pairs of remaining strings have been checked. returns whether or not all
-    strings have been meshed."""
-
-    length = len(strings)
-    strlength = len(strings[0][0])
-#    matched = []
-    if cutoff:
-        cutoffs = generate_cutoffs(strings, strlength, cutoff)
-    for i in range(length):
-        # if the current string has already been meshed, skip it
-        if strings[i][3]:
-            continue
-
-        if cutoff:
-            current_cutoff = cutoffs[strings[i][2]]
-        for j in range(i + 1, length):
-            # if current string has already been meshed, skip it
-            if strings[j][3]:
-                continue
-
-            if cutoff and strings[j][2] >= current_cutoff:
-                break
-
-#            if i not in matched and j not in matched: (should be unnecessary now, test soon)
-            if not strings[i][3] and not strings[j][3]:
-                num1 = strings[i][1]
-                num2 = strings[j][1]
-                if num1 & num2 == 0:
-                    #                    matched.append(i)
-                    #                    matched.append(j)
-                    strings[i] = (strings[i][0], strings[i]
-                                  [1], strings[i][2], True)
-                    strings[j] = (strings[j][0], strings[j]
-                                  [1], strings[j][2], True)
-                    meshes.append((strings[i], strings[j]))
-                    break
-    for string1, string2 in meshes:
-        strings.remove(string1)
-        strings.remove(string2)
-    if len(strings) == 0:
-        return True
-    return False
-
-
-def greedyTraverse(meshes, bucket1=None, bucket2=None, strings=None, cutoff=None):
-    """
-    Looks for meshable pairs between the buckets greedily (looks
-    first at all potential meshes with the first string in bucket1 and
-    anything in bucket 2, then the second string in bucket 2 with
-    everything in bucket 2, etc.  adds found pairs to meshes in
-    place. returns whether or not all strings have been meshed.
-    """
-
-    # if only one string list is supplied, search it exhaustively for
-    # pairs using a simpler function
-    if strings != None:
-        return simpleGreedyTraverse(meshes, strings, cutoff)
-
-    if bucket1 == None or bucket2 == None:
-        raise Exception(
-            'must pass either buckets or string set to traverse function')
-
-    strlength = len(bucket1[0][0])
-    len1, len2 = len(bucket1), len(bucket2)
-    assert len1 != 0 and len2 != 0
-    if cutoff:
-        cutoffs = generate_cutoffs(bucket1, strlength, cutoff)
-    for i in range(len1):
-        if cutoff:
-            bkt1cutoff = cutoffs[bucket1[i][2]]
-
-        for j in range(len2):
-            # notice when (due to occupancy ordering) there is little hope of finding more meshes
-            # for the ith string in bucket 1
-            if cutoff and bucket2[j][2] >= bkt1cutoff:
-                #                print "doing a break!"
-                break
-            if not bucket1[i][3] and not bucket2[j][3]:
-                num1 = bucket1[i][1]
-                num2 = bucket2[j][1]
-                if num1 & num2 == 0:
-                    bucket1[i] = (bucket1[i][0], bucket1[i]
-                                  [1], bucket1[i][2], True)
-                    bucket2[j] = (bucket2[j][0], bucket2[j]
-                                  [1], bucket2[j][2], True)
-                    meshes.append((bucket1[i], bucket2[j]))
-    for string1, string2 in meshes:
-        #        print "removing {} from bucket1 and {} from bucket2".format(string1, string2)
-        bucket1.remove(string1)
-        bucket2.remove(string2)
-    if len(bucket1) == len(bucket2) == 0:
-        return True
-    return False
-
-
-if __name__ == '__main__':
-    bkt1 = formatStrings([("11100000"), ("11111000")])
-    bkt2 = formatStrings([("00011111"), ("00000111")])
-    meshes = []
-    greedyTraverse(meshes, bucket1=bkt1, bucket2=bkt2, cutoff=None)
-#    occupancySort(bkt1)
-    print bkt1, bkt2, meshes
-#    print fast_q(64, 25,13)
-#    print generate_cutoffs(bkt1, 8)
-#    print generate_cutoffs(bkt2, 8)

data/ext/mesh/mesh/theory/meshers.py

@@ -1,452 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Fri Feb 03 10:23:57 2017
-
-@author: devd
-"""
-
-import random
-import numpy as np
-from makeGraph import makeGraph
-import networkx as nx
-from mesh_util import Splitter, hamming, traverse, occupancySort, formatStrings, simpleGreedyTraverse, greedyTraverse
-import time
-
-
-def simpleMesher(strings, stdOutput=False):
-    """
-    Attempts to mesh the first string in the list with the second, etc.
-    Returns number of successful meshes.
-    """
-    meshes = 0
-    # try to mesh each string
-    for i in range(0, len(strings), 2):
-        str1 = strings[i]
-        str2 = strings[i + 1]
-        num = [int(x) for x in list(str1)]
-        num2 = [int(x) for x in list(str2)]
-        if np.dot(num, num2) == 0:
-            meshes += 1
-    if stdOutput:
-        return 100 * float(meshes) / len(strings)
-    return meshes
-
-
-# def randomMesher(strings, attempts):
-#    """DEPRECATED"""
-#    s = [x for x in strings]
-#    matched_strings = []
-#    for i in range(attempts):
-#        pair = random.sample(s,2)
-#        str1 = pair[0]
-#        str2 = pair[1]
-#        num = [int(x) for x in list(str1)]
-#        num2 = [int(x) for x in list(str2)]
-#        if np.dot(num, num2) == 0:
-#            #print('removing {} and {}'.format(str1, str2))
-#            matched_strings.append(str1)
-#            matched_strings.append(str2)
-#            s.remove(str1)
-#            s.remove(str2)
-#            if len(s) < 2:
-#                return matched_strings
-#    return matched_strings
-
-def randomMesher(strings, attempts, display=False, stdOutput=False):
-    length = len(strings[0])
-    totalStrings = len(strings)
-    strings = [long(string, base=2) for string in strings]
-    meshes = []
-    for k in range(attempts):
-        matched = []
-        random.shuffle(strings)
-        dim = len(strings)
-        for i in range(dim - 2, -2, -2):
-            num1 = strings[i]
-            num2 = strings[i + 1]
-            if num1 & num2 == 0:
-                matched.append(i)
-        for x in matched:
-            meshes.append((strings[x], strings[x + 1]))
-        for x in matched:
-            del strings[x + 1]
-            del strings[x]
-
-    formatstring = "{0:0" + str(length) + "b}"
-    meshes = [(formatstring.format(num), formatstring.format(num2))
-              for (num, num2) in meshes]
-    if display:
-        print "meshes:"
-        print meshes
-    if stdOutput:
-        return 100 * float(len(meshes)) / totalStrings
-    return len(meshes)
-
-
-def _greedyMesher(strings, stdOutput=False):
-    """DEPRECATED
-    Meshes a list of strings using a greedy first-match technique.  Returns 
-    the number of matched pairs after available matches are exhausted."""
-    s = strings
-    matched_strings = []
-    unmatched_strings = []
-    matched = []
-    for i in range(len(s)):
-        for j in range(i + 1, len(s)):
-            if i not in matched and j not in matched:
-                num = [int(x) for x in list(s[i])]
-                num2 = [int(x) for x in list(s[j])]
-                if np.dot(num, num2) == 0:
-                    matched.append(i)
-                    matched.append(j)
-    matched_strings += [s[x] for x in matched]
-    unmatched_strings += [s[x] for x in range(len(s)) if x not in matched]
-
-    if stdOutput == True:
-        return 100 * len(matched_strings) / (2 * len(strings))
-    else:
-        return matched_strings, unmatched_strings
-
-
-def greedyMesher(strings, stdOutput=False, cutoff=None):
-    length = len(strings)
-    new_strings = formatStrings(strings)
-    meshes = []
-    occupancySort(new_strings)
-    simpleGreedyTraverse(meshes, new_strings, cutoff)
-    if stdOutput:
-        return 100 * len(meshes) / length
-    else:
-        return meshes
-
-# def splitter(strings, length, splitting_string = 0):
-#    splitting_strings = []
-#    num_splitters = int(math.log(length,2))+1
-#    for i in range(1,num_splitters):
-#        split_string = ""
-#        for j in range(2**(i-1)):
-#            split_string = split_string + (("1" * int((length/(2**i)))) + ("0" * (int(length/(2**i)))))
-#        splitting_strings.append(split_string)
-# if splitting_string >= num_splitters-1:
-# return bucket1, bucket2
-#    split = splitting_strings[splitting_string]
-#    bucket1 = []
-#    bucket2 = []
-#    for s in strings:
-#        diff = hamming(s[0], split)
-#        if diff < int(length * 0.5):
-#            bucket1.append(s)
-#        elif diff  == int(length * 0.5):
-#            if random.randint(0,1):
-#                bucket1.append(s)
-#            else:
-#                bucket2.append(s)
-#        else:
-#            bucket2.append(s)
-#    return bucket1, bucket2
-#
-# def splitAgain(bucket1, bucket2, length, method):
-#    try:
-#        new_bucket1, new_bucket2 = splitter(bucket1+bucket2, length, method)
-#    except IndexError:
-#        return bucket1, bucket2
-#    return new_bucket1, new_bucket2
-
-
-def splittingMesher(strings, attempts, splittingMethod=0, display=False, stdOutput=False, extra=True):
-    if display:
-        print "using Splitting Mesher"
-    length = len(strings[0])
-    new_strings = formatStrings(strings)
-    splt = Splitter(length)
-    bucket1, bucket2 = splt.split(strings=new_strings)
-
-    meshes = []
-    for k in range(attempts):
-        #        if k == attempts/2:
-        #            print "rebucketing at halfway point"
-        #            print bucket1, bucket2
-        #            bucket1, bucket2 = splt.split(bucket1 = bucket1, bucket2 = bucket2)
-        random.shuffle(bucket1)
-        random.shuffle(bucket2)
-        try:
-            #            print bucket1, bucket2, meshes
-            done = traverse(meshes, bucket1=bucket1,
-                            bucket2=bucket2, extra=extra)
-#            print bucket1, bucket2, meshes
-#            print 'that was round {}'.format(k)
-        except AssertionError:
-            #            print "rebucketing because one bucket is empty"
-            bucket1, bucket2 = splt.split(bucket1=bucket1, bucket2=bucket2)
-            continue
-        if done:
-            #            print "all done, ending early at attempt {}".format(k)
-            break
-    if display:
-        print "meshes:"
-        print meshes
-    if stdOutput:
-        return 100 * float(len(meshes)) / len(strings)
-    return len(meshes)
-
-
-def randomSplittingMesher(strings, attempts, display=False, stdOutput=False):
-    """randomly splits string list into two lists, and then tries to mesh pairs
-    between the lists.  for comparison purposes only, not an actual useful meshing
-    method."""
-    if display:
-        print "using random Splitting Mesher"
-    bucket1, bucket2 = [], []
-    length = len(strings[0])
-#    if splittingMethod == "left":
-#        splittingString = ("1" * (length/2)) + ("0" * (length/2))
-#    elif splittingMethod == "checkers":
-#        splittingString = ("10" * (length/2))
-    for string in strings:
-        s = long(string, base=2)
-        if random.randint(0, 1):
-            bucket1.append(s)
-        else:
-            bucket2.append(s)
-    formatstring = "{0:0" + str(length) + "b}"
-#    print "bucket1:"
-#    print [formatstring.format(item) for item in bucket1]
-#    print "bucket2:"
-#    print [formatstring.format(item) for item in bucket2]
-#    print "\n"
-#    print "bucket2: {0:08b}\n".format(bucket2)
-
-    meshes = []
-    for k in range(attempts):
-        random.shuffle(bucket1)
-        random.shuffle(bucket2)
-#        print "shuffles: {},\n{}".format(bucket1, bucket2)
-        dim = min(len(bucket1), len(bucket2))
-        if dim == 0:
-            break
-        matched = []
-        if dim == 1:
-            #            print "checking {} and {}".format(bucket1[0], bucket2[0])
-            num1 = bucket1[0]
-            num2 = bucket2[0]
-            if num1 & num2 == 0:
-                matched.append(0)
-        for i in range(dim - 1, 0, -1):
-            #            print "checking {} and {}".format(bucket1[i], bucket2[i])
-            num1 = bucket1[i]
-            num2 = bucket2[i]
-            if num1 & num2 == 0:
-                matched.append(i)
-        for x in matched:
-            meshes.append((bucket1[x], bucket2[x]))
-        for x in matched:
-            del bucket1[x]
-            del bucket2[x]
-#    meshes = [(num.toBinaryString(), num2.toBinaryString()) for (num, num2) in meshes]
-    meshes = [(formatstring.format(num), formatstring.format(num2))
-              for (num, num2) in meshes]
-    if display:
-        print "meshes:"
-        print meshes
-    if stdOutput:
-        return 100 * float(len(meshes)) / len(strings)
-    return len(meshes)
-
-
-def greedySplittingMesher(strings, display=False, std_output=True, cutoff=None):
-    """
-    Given a list of strings, splits that list into two lists based off
-    of a distance measure and then exhaustively checks pairs between
-    the two lists for meshes, greedily taking any it finds.  Sorts the
-    lists in increasing order of occupancy so sparse/sparse meshes are
-    likely to be discovered.  Can specify a cutoff probability below
-    which potential meshes will not be considered - this saves a lot
-    of time without affecting performance too much.
-    """
-    if display:
-        print "using greedy splitting mesher"
-
-    length = len(strings[0]) # length of each string, e.g. 4 for '0100'
-    start = time.time()
-    new_strings = formatStrings(strings)
-    splt = Splitter(length)
-    bucket1, bucket2 = splt.split(strings=new_strings)
-    # print "preliminaries took {}".format(time.time()-start)
-
-    start = time.time()
-    meshes = []
-    # sorts buckets into low -> high occupancy
-    occupancySort(bucket1)
-    occupancySort(bucket2)
-    # print "sorting took {}".format(time.time()-start)
-
-    start = time.time()
-    done = greedyTraverse(meshes, bucket1=bucket1,
-                          bucket2=bucket2, cutoff=cutoff)
-    # print "traversal took {}".format(time.time()-start)
-
-    if display:
-        print "meshes:"
-        print meshes
-    if std_output:
-        return 100 * float(len(meshes)) / len(strings)
-    else:
-        return len(meshes)
-
-
-def doubleSplittingMesher(strings, attempts, display=False, stdOutput=False):
-    """This function is temporary.  I will soon merge it with splittingMesher to allow for arbitrary levels of splitting
-    in the same function."""
-    if display:
-        print "using double Splitting Mesher"
-    buckets = [[], []], [[], []]
-    length = len(strings[0])
-    numStrings = len(strings)
-    splittingString1 = ("1" * (length / 2)) + ("0" * (length / 2))
-    splittingString2 = ("10" * (length / 2))
-    for string in strings:
-        s = long(string, base=2)
-        diff = hamming(string, splittingString1)
-        diff2 = hamming(string, splittingString2)
-
-        if diff < int(length * 0.5):
-            id1 = 0
-        elif diff == int(length * 0.5):
-            if random.randint(0, 1):
-                id1 = 0
-            else:
-                id1 = 1
-        else:
-            id1 = 1
-
-        if diff2 < int(length * 0.5):
-            id2 = 0
-        elif diff == int(length * 0.5):
-            if random.randint(0, 1):
-                id2 = 0
-            else:
-                id2 = 1
-        else:
-            id2 = 1
-
-        buckets[id1][id2].append(s)
-    formatstring = "{0:0" + str(length) + "b}"
-    for layer in buckets:
-        for thing in layer:
-            print len(thing)
-#    print buckets
-
-    meshes = []
-
-    check1 = True
-    check2 = True
-    for k in range(attempts):
-        dim1 = min(len(buckets[0][0]), len(buckets[1][1]))
-        dim2 = min(len(buckets[0][1]), len(buckets[1][0]))
-#        print dim1, dim2
-        if dim1 == 0:
-            if check1:
-                print 'found meshes for everything in set 1, so stopped after {} attempts'.format(k)
-                check1 = False
-        else:
-            matched1 = []
-            if dim1 == 1:
-                num1 = buckets[0][0][0]
-                num2 = buckets[1][1][0]
-                if num1 & num2 == 0:
-                    matched1.append(0)
-            for i in range(dim1 - 1, 0, -1):
-                num1 = buckets[0][0][i]
-                num2 = buckets[1][1][i]
-                if num1 & num2 == 0:
-                    matched1.append(i)
-            for x in matched1:
-                meshes.append((buckets[0][0][x], buckets[1][1][x]))
-            for x in matched1:
-                del buckets[0][0][x]
-                del buckets[1][1][x]
-        if dim2 == 0:
-            if check2:
-                print 'found meshes for everything in set 2, so stopped after {} attempts'.format(k)
-                check2 = False
-        else:
-            matched2 = []
-            if dim2 == 1:
-                num1 = buckets[0][1][0]
-                num2 = buckets[1][0][0]
-                if num1 & num2 == 0:
-                    matched2.append(0)
-            for i in range(dim2 - 1, 0, -1):
-                num1 = buckets[0][1][i]
-                num2 = buckets[1][0][i]
-                if num1 & num2 == 0:
-                    matched2.append(i)
-            for x in matched2:
-                meshes.append((buckets[0][1][x], buckets[1][0][x]))
-            for x in matched2:
-                del buckets[0][1][x]
-                del buckets[1][0][x]
-
-    meshes = [(formatstring.format(num), formatstring.format(num2))
-              for (num, num2) in meshes]
-    if display:
-        print "meshes:"
-        print meshes
-    if stdOutput:
-        return 100 * float(len(meshes)) / len(strings)
-    return len(meshes)
-
-
-def maxMatchingMesher(strings, stdOutput=False):
-    """Converts the string set into a meshing graph and finds the maximum matching on said graph."""
-    graph = makeGraph(strings)
-    meshes = len(nx.max_weight_matching(graph)) / 2
-    if stdOutput:
-        return 100 * float(meshes) / len(strings)
-    return meshes
-
-
-def color_counter(graph):
-    """interprets a coloring on a graph as a meshing."""
-    color = nx.greedy_color(graph)
-    i = 0
-    for key, value in color.iteritems():
-        i = max(i, value)
-    return i + 1
-
-
-def optimalMesher(strings, stdOutput=False):
-    """Converts the string set into a meshing graph and finds a greedy coloring on the complement of said graph."""
-    graph = makeGraph(strings)
-    graph_c = nx.complement(graph)
-    meshes = len(strings) - color_counter(graph_c)
-    if stdOutput:
-        return 100 * float(meshes) / len(strings)
-    return meshes
-
-
-def mesherRetrieve(identifier):
-    fetcher = {"simple": (simpleMesher),
-               "dumb": (randomMesher),
-               "greedy": (greedyMesher),
-               "split": (splittingMesher),
-               "greedysplit": (greedySplittingMesher),
-               "doubsplit": (doubleSplittingMesher),
-               "randsplit": (randomSplittingMesher),
-               "maxmatch": (maxMatchingMesher),
-               "color": (optimalMesher)
-               }
-    return fetcher[identifier]
-
-
-if __name__ == '__main__':
-    #    print splittingMesher(["00000001", "11111110", "11100000", "00000111"], 10, display = True)
-    #    print splitter([(("1" * 16),0)], 16)
-    #    print greedySplittingMesher(["00000001", "11111110", "11100000", "00000111"], display = True, stdOutput = False)
-
-    #    meshes = []
-    #    strings = formatStrings(["00000001", "11111110", "11100000", "00000111"])
-    #    simpleGreedyTraverse(meshes, strings)
-    #    print meshes, strings
-
-    print greedyMesher(["00000001", "11111110", "11100000", "00000111"])