20190524-矩陣算法，矩陣相加，矩陣相乘，矩陣轉置等

1.二維矩陣的轉置

arrA = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
def turn(arr):
    if not arr:
        return []
    result = []
    for i in range(len(arr[0])):#原來的列變成行
        temp =[]
        for j in range(len(arr)):#原來的行變成列
            temp.append(arr[j][i])
        result.append(temp)
    return result
print(turn(arrA))

2.矩陣相加，A，B矩陣均需要為一個N*M的矩陣，即相加矩陣的行和列必須相等

def matrix_add(arrA,arrB):
    if not arrA and not arrB:
        return []
    if len(arrA)!=len(arrB)or len(arrA[0])!=len(arrA[0]):
        return 'Error'
    arrC = [[None]*len(arrA[0]) for row in range(len(arrA))]#首先定義結果矩陣
    for i in range(len(arrA)):
        for j in range(len(arrA[i])):
            arrC[i][j] = arrA[i][j] + arrB[i][j]
    return arrC
A = [[1,3,5,4],[7,9,1,3],[13,15,17,42]]
B = [[9,8,7,1],[6,5,4,2],[3,2,1,3]]
print(matrix_add(A,B))

3.矩陣相乘，A,B矩陣需要滿足條件為A為m*n的矩陣，B為n*p的矩陣，結果C為m*p的矩陣

C11 = A11*B11+A12*B21+....+A1n*Bn1
C1P = A11*B1p+A12*B2p+...+A1n*Bnp
CMP = Am1*B1p+Am2*B2p+...+Amn*Bnp
arrA的第一個index等於C的第一個index，arrA的第二個index每次逐漸增加
arrB的第一個index每次逐漸增加，同時arrB的第二個index等於C的第二個index。因此，因為C是一個m*p的矩陣
arrA的第一個index= i
arrA的第二個index= k
arrB的第一個index= k
arrB的第二個index= j

A = [[1,3,5],[7,9,11],[13,15,17]]
B = [[9,8],[6,5],[3,2]]

def MatrixMultiply(arrA,arrB):
    if len(arrA[0])!=len(arrB):
        return False
    M = len(A)
    N = len(A[0])
    P = len(B[0])
    arrC = [[None] * P for row in range(M)]
    for i in range(len(arrA)):
        for j in range(len(arrB[0])):
            temp = 0
            for k in range(len(arrB)):
                #print(arrA[i][k],arrB[k][j],end =' ')
                temp = temp+int(arrA[i][k])*int(arrB[k][j])#實現C1P = A11*B1p+A12*B2p+...+A1n*Bnp
            arrC[i][j] = temp
    return arrC

print(MatrixMultiply(A,B))

4.編寫函數利用三項式壓縮稀疏矩陣
稀疏矩陣：一個矩陣的大部分元素為0,則是稀疏矩陣
三項式：非零項用（i，j，item-value）來表示，假定一個稀疏矩陣有n個非零項，則可以用一個A(0:N,1:3)的二維數組來存儲這些非零項
A(0,1)存儲稀疏矩陣的行數
A(0,2)存儲稀疏矩陣的列數
A(0,3)存儲稀疏矩陣的非零項
每個非零項用（i,j,item-value）來表示

def Sparse_Transfer2_Trinomial(sparse):
    trinomial = []
    print(trinomial)
    if not sparse:
        return trinomial
    non_zero = 0
    for i in range(len(sparse)):
        for j in range(len(sparse[i])):
            #print(sparse[i][j])
            if sparse[i][j]:#sparse[i][j]非0
                non_zero+=1
                trinomial.append([i,j,sparse[i][j]])
    trinomial.insert(0,[len(sparse),len(sparse[0]),non_zero])
    return trinomial
Sparse = [[15,0,0,22,0,-15],[0,11,3,0,0,0],[0,0,0,-6,0,0],[0,0,0,0,0,0,0],[91,0,0,0,0,0],[0,0,28,0,0,0]]
print(Sparse_Transfer2_Trinomial(Sparse))

 5.利用三項式轉置稀疏矩陣

 先定義稀疏矩陣，將行列交換，其他的位置填充0

def Turn_Sparse(trinomial):
    sparse = [[0]*trinomial[0][1] for i in range(trinomial[0][0])]
    for each in trinomial[1:]:
        sparse[each[1]][each[0]] = each[2]
    return sparse
print(Turn_Sparse(Sparse_Transfer2_Trinomial(Sparse)))