Question

所以我编写了下面的代码，以产生一对产生对我有用的特性的分区，并且我正在尝试并行化一个源于这些特性输出的程序。

注意：r和n几乎是任意的，但它们往往在2到16之间。

from itertools import combinations_with_replacement

def conjugate(p1):
    p = list(p1)
    if p == []:
        return p1
    else:
        l = len(p)
        conj =  [l]*p[-1]
        for i in xrange(l-1,0,-1):
            conj.extend([i]*(p[i-1] - p[i]))
        return conj

def dominates(p1,p2):
    sum1 = 0
    sum2 = 0
    min_length = min(len(p1), len(p2))
    if min_length == 0:
        return len(p1) >= len(p2)

    for i in range(min_length):
        sum1 += p1[i]
        sum2 += p2[i]
        if sum2 > sum1:
            return False
    return bool(sum(p1) >= sum(p2))


def partition_lists(r,n):
    half = n*r/2
    combDict = {}
    for a in range(half,n*r+1):
        combDict[a] = []
    for a in combinations_with_replacement(range(0,n+1),r):
        if sum(a) >= half:
            combDict[sum(a)].append(list(reversed(a)))
    for key,item in combDict.iteritems():
        for i in range(len(item)):
            for j in range(len(item)):
                rp = [2*n - 2*a for a in item[i]]
                cp = [2*n - 2*a for a in item[j]]
                rpN = filter(lambda a: a != 0, reversed(rp))
                cpN = filter(lambda a: a != 0, reversed(cp))
                if dominates(conjugate(rpN),cpN):
                    yield item[i],item[j]

前两个函数是实数，但在最后一个函数中使用。最后一个函数生成我称之为“重”矩阵的行和列总和，并根据这些值，我计算“轻”矩阵（rp，cp）的行和列总和，然后测试优势以查看是否光矩阵是可行的，其中光矩阵仅为重基质重量的一半的0和1。问题在于，当我开始使用支配和共轭函数时，我会生成大量数据并通过大约一半的数据。有没有办法以某种方式更快地完成这项工作，或者更快地删除不必要的数据？还有一种方法可以并行化另一个函数，该函数将在partition_lists的输出上运行更多进程吗？

试图加快我写的一些代码：python

0 个答案: