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

Question

So i am trying to check if on one of all possible permutations I will get a form where the matrix is diagonally dominant but when trying to check for it i get an error

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

this here is the error

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

You define A as a list of lists. You get this error when you pass it to 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

But if you first make A an array, it runs fine:

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

I won't dig into why dominance has problems, but it looks like dominance was written with numpy arrays in mind, not lists of lists. sumC=numpy.sum(numpy.absolute(A),axis=0) treats A like an array (it works with list A because internally absolute converts it to an array).

The 2nd call to dominance must also get an array:

dominance(np.array(i))

Answer 2

You are approaching this very inefficiently!

---

If you are seeking strict diagonal dominance:

• each row of the matrix can only have 0 or 1 strictly dominant values

• each column of the matrix can only have 0 or 1 strictly dominant values

• if any row or column has 0 strictly dominant values, there are no strictly diagonally dominant permutations of the matrix

• if every row and every column has exactly 1 strictly dominant value, then there is exactly 1 strictly diagonally dominant permuted matrix: for each row of the original matrix, the column index of the dominant item specifies the index of the row in the permuted result matrix

This results in an O(n^2) algorithm instead of O(n^2 * n!) - for a 10*10 matrix, it should be something like 3 million times faster.

---

If you are seeking non-strict diagonal dominance:

• each row of the matrix can only have 0, 1 or 2 dominant values

• each column of the matrix can only have 0, 1 or 2 dominant values

• if any row or column has 0 dominant values, there are no diagonally dominant permutations of the matrix

• (reduction:) if a row has exactly 1 dominant value, and that value's column contains 2 dominant values, the other dominant value in that column can be trivially disregarded (and vice-versa)

• if every row and every column has exactly 1 dominant value, then there is exactly 1 diagonally dominant permuted matrix: for each row of the original matrix, the column index of the dominant item specifies the index of the row in the permuted result matrix

• sets of rows having 2 dominant values can combine to form circuits, where each circuit has 0, 1, or 2 diagonally dominant solutions (and selecting a dominant value for one row forces the selection for all other rows in the circuit). A branch-and-prune approach can very quickly find all valid solutions.

For a matrix having t rows with 2 dominant values, this results in an O(n^2 * 2^t) algorithm instead of O(n^2 * n!) - for a 10*10 matrix, it should be between 3 thousand and 3 million times faster (depending on the number of rows having 2 dominant values).