1

因此，我编写了以下代码，以产生对我有用的特征的分区对，并且我正在尝试并行化源自这些输出的程序。

注意：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 的输出上运行更多进程？

4

0 回答 0