Question

描述（这是一个鹰派问题）：

我不知道从哪里开始。我打算使用Laplace的扩展，但我不确定如何为nxn矩阵实现它。任何帮助，将不胜感激。

注意：我已经有了为nxn矩阵生成随机矩阵的函数。计算的时间也不是问题。我唯一的问题是如何计算行列式。

必须删除我的课程政策的问题描述b / c。

Answer 1

好的，这是一个提示。

编写一个函数来计算次要矩阵。（提示，使用切片）
编写一个函数来计算辅助因子（这应该调用第一个函数和确定函数）
确定函数在第二步中调用函数并将结果一起添加。（提示：使用sum）

另外，不要忘记，由于我们在python中编写列表的方式，索引会被反转。那就是

M = [[1, 2, 3],
     [4, 5, 6],
     [7, 8, 9]]

然后m _0,1是2而不是4，因为它将是正常的表示法。您可以将其视为转置或使用zip

Answer 2

这是用于查找矩阵的行列式的adjucate方法的递归python代码。

def getMatrixMinor(m,i,j):
    return [row[:j] + row[j+1:] for row in (m[:i]+m[i+1:])]

def getMatrixDeternminant(m):
    #base case for 2x2 matrix
    if len(m) == 2:
        return m[0][0]*m[1][1]-m[0][1]*m[1][0]

    determinant = 0
    for c in range(len(m)):
        determinant += ((-1)**c)*m[0][c]*getMatrixDeternminant(getMatrixMinor(m,0,c))
    return determinant

请注意，输入是一个表示nxn矩阵的数组数组

Answer 3

def minor(array,i,j):
    c = array
    c = c[:i] + c[i+1:]
    for k in range(0,len(c)):
        c[k] = c[k][:j]+c[k][j+1:]
    return c
def det(array,n):
    if n == 1 :return array[0][0]
    if n == 2 :return array[0][0]*array[1][1] - array[0][1]*array[1][0]
    sum = 0
    for i in range(0,n):
        m = minor(array,0,i)
        sum =sum + ((-1)**i)*array[0][i] * det(m,n-1)
    return sum

Answer 4

对于大型矩阵，不建议使用Laplace方法进行行列式计算，因为这在计算上比较昂贵（递归函数）。相反，更好的方法是使用高斯消除法将原始矩阵转换为上三角矩阵。下三角矩阵或上三角矩阵的行列式只是对角线元素的乘积。

我们在此显示一个示例。

import numpy as np
from scipy import linalg

def determinant(a):
    assert len(a.shape) == 2 # check if a is a two diamentional matrix
    assert a.shape[0] == a.shape[1] # check if matrix is square
    n = a.shape[0]
   
    for k in range(0, n-1):
       
        for i in range(k+1, n):
            if a[i,k] != 0.0:
                lam = a [i,k]/a[k,k]
                a[i,k:n] = a[i,k:n] - lam*a[k,k:n]

               
    # the matrix (a) is now in the upper triangular form
                
    return np.prod(np.diag(a))

matrix = np.random.rand(50, 50)


print(linalg.det(matrix))
print(determinant(matrix))

结果类似于从Scipy行列式获得的结果！

-3032.573716363944

-3032.573716915967

但是，该功能仍可以表述为包括旋转。此外，通过使用numba库，它可以达到与scipy相似的效率。

Answer 5

我已将 Peyman Naseri 用作基本思想，并希望与我的实现分享，

import numpy as np
import time

def minor(arr,i,j):
    c = arr[:]
    c = np.delete(c, (i),axis=0)
    return [np.delete(row, (j),axis=0) for row in (c)]
    

def det(arr):
    n = len(arr)
    if n == 1 :return arr[0][0]
    if n == 2 :return arr[0][0]*arr[1][1] - arr[0][1]*arr[1][0]
    sum = 0
    for i in range(0,n):
        m = minor(arr,0,i)
        sum =sum + ((-1)**i)*arr[0][i] * det(m)
    return sum

matrix = np.random.randint(-5, 5, size=(10, 10)) # martix nxn with integer values in interval [-5, 5)

print(matrix)
start_time = time.time()
print("started:", start_time)
det(matrix)
end_time = time.time()
print("finished:", end_time)
print("--- %s seconds ---" % (end_time - start_time))

因为我的笔记本电脑上矩阵 10*10 的结果行列式计算需要大约 1 分钟，我知道我的代码不是最佳的，但是这个实现的主要原因（也许我丢失了一些东西）我只需要获得基于 {{ 3}} 看起来非常漂亮的解决方案。

使用Python解决行列式而不使用scipy.linalg.det的代码

5 个答案: