如何在 python 中将元组转换为整数

Question

所以我试图检查在所有可能的排列之一上我是否会得到矩阵对角占优的形式但是在尝试检查它时我得到一个错误

import numpy
from itertools import product
A = numpy.array([[10., -1., 2., 0.],
    [2., -1., 10., -1.],
    [-1., 11., -1., 3.],
    [0.0, 3., -1., 8.]])

def dominance(A):
    dominance=True
    n=4
    sumC=numpy.sum(numpy.absolute(A),axis=0)
    sumR=numpy.sum(numpy.absolute(A),axis=1)
    resC = [0 for i in range(n)]
    resR= [0 for i in range(n)]
    for i in range(n):
        resC[i]=sumC[i]-A[i,i]
        resR[i]=sumR[i]-A[i,i]
        if A[i,i]<resC[i] or A[i,i]<resR[i]:
            dominance=False
            break

    return dominance

def permutate(iterable, r=None):
    pool = tuple(iterable)
    n = len(pool)
    r = n if r is None else r
    for indices in product(range(n), repeat=r):
        if len(set(indices)) == r:
            yield tuple(pool[i] for i in indices)


if dominance(A):
    print "Es dominante"
else:
    for i in permutate(A):
        if dominance(list(i)):
            print "this way is dominant"
            print i
            break

这是错误

Traceback (most recent call last):
    File "Prueba.py", line 37, in <module>
        if dominance(list(i)):
    File "Prueba.py", line 16, in dominance
        resC[i]=sumC[i]-A[i,i]
TypeError: list indices must be integers, not tuple

Answer 1

您将 A 定义为列表的列表。将它传递给 dominance:

时会出现此错误

In [87]: dominance(A)
---------------------------------------------------------------------------
...
      8         for i in range(n):
----> 9                 resC[i]=sumC[i]-A[i,i]
     10                 resR[i]=sumR[i]-A[i,i]
     11                 if A[i,i]<resC[i] or A[i,i]<resR[i]:

TypeError: list indices must be integers, not tuple

但是如果你先把 A 做成一个数组，它运行得很好：

In [94]: dominance(np.array(A))
Out[94]: False

我不会深入研究为什么 dominance 有问题，但看起来 dominance 是用 numpy 数组编写的，而不是列表的列表。 sumC=numpy.sum(numpy.absolute(A),axis=0) 将 A 视为数组（它与列表 A 一起使用，因为在内部 absolute 将其转换为数组）。

第二次调用 dominance 也必须得到一个数组：

dominance(np.array(i))

Answer 2

您的处理效率很低！

如果您正在寻求严格的对角线优势：

矩阵的每一行只能有0个或1个严格显性值
矩阵的每一列只能有0个或1个严格显性值
如果任何行或列的严格显性值为 0，则矩阵不存在严格对角显性排列
如果每行每列恰好有1个严格占优值，则恰好有1个严格对角占优置换矩阵：对于原矩阵的每一行，占优项的列索引指定置换结果矩阵中行的索引

这导致 O(n^2) 算法而不是 O(n^2 * n!) - 对于 10*10 矩阵，它应该快 300 万倍。

如果您正在寻求非严格的对角优势：

矩阵的每一行只能有0、1或2个显性值
矩阵的每一列只能有0、1或2个显性值
如果任何行或列的显性值为 0，则矩阵不存在对角显性排列
(reduction:) 如果一行恰好有 1 个主导值，并且该值的列包含 2 个主导值，则可以忽略该列中的另一个主导值（反之亦然）
如果每行每列恰好有1个主值，则恰好有1个对角占优置换矩阵：对于原矩阵的每一行，主项的列索引指定索引置换结果矩阵中的行
具有 2 个显性值的行集可以组合形成电路，其中每个电路具有 0、1 或 2 个对角线显性解决方案（并且为一行选择一个显性值会强制选择所有电路中的其他行）。分支和修剪方法可以非常快速地找到所有有效的解决方案。

对于具有 t 行和 2 个主值的矩阵，这会导致 O(n^2 * 2^t) 算法而不是 O(n^2 * n!) - 对于 10*10 矩阵，它应该快 3000 到 300 万倍（取决于具有 2 个显性值的行数）。

如何在 python 中将元组转换为整数

How do I convert a tuple to an Integer in python

python

arrays

numpy

tuples

iterable