NumPy - 线性代数

    此函数返回两个数组的点积。 对于二维向量，其等效于矩阵乘法。 对于一维数组，它是向量的内积。 对于 N 维数组，它是a的最后一个轴上的和与b的倒数第二个轴的乘积。

    输出如下：

    1. [[37  40] 
    2.  [85  92]]

    要注意点积计算为：

    1. [[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]]

    numpy.vdot()

    此函数返回两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数id是多维数组，它会被展开。

    例子

    1. import numpy as np 
    2. a = np.array([[1,2],[3,4]]) 
    3. b = np.array([[11,12],[13,14]]) 
    4. print np.vdot(a,b)

    输出如下：

    1. 130

    注意：1*11 + 2*12 + 3*13 + 4*14 = 130。

    此函数返回一维数组的向量内积。 对于更高的维度，它返回最后一个轴上的和的乘积。

    例子

    1. import numpy as np 
    2. print np.inner(np.array([1,2,3]),np.array([0,1,0])) 
    3. # 等价于 1*0+2*1+3*0

    输出如下：

    1. 2

    例子

    1. # 多维数组示例 
    2. import numpy as np 
    3. a = np.array([[1,2], [3,4]]) 
    5. print '数组 a：' 
    6. print a 
    7. b = np.array([[11, 12], [13, 14]]) 
    9. print '数组 b：' 
    10. print b 
    12. print '内积：' 
    13. print np.inner(a,b)

    输出如下：

    1. 数组 a：
    2. [[1 2]
    3. [3 4]]
    5. 数组 b：
    6. [[11 12]
    7. [13 14]]
    9. 内积：
    11. [81 95]]

    上面的例子中，内积计算如下：

    numpy.matmul

    另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。

    例子

    1. # 对于二维数组，它就是矩阵乘法
    2. import numpy.matlib 
    3. import numpy as np 
    4. a = [[1,0],[0,1]] 
    5. b = [[4,1],[2,2]] 
    6. print np.matmul(a,b)

    输出如下：

    1. [[4  1] 
    2.  [2  2]]

    例子

    1. # 二维和一维运算
    2. import numpy.matlib 
    3. import numpy as np 
    5. a = [[1,0],[0,1]] 
    6. b = [1,2] 
    7. print np.matmul(a,b) 
    8. print np.matmul(b,a)

    输出如下：

    1. [1  2] 
    2. [1  2]

    例子

    1. # 维度大于二的数组 
    2. import numpy.matlib 
    3. import numpy as np 
    5. a = np.arange(8).reshape(2,2,2) 
    6. b = np.arange(4).reshape(2,2) 
    7. print np.matmul(a,b)

    输出如下：

    1. [[[2   3] 
    2.    [6   11]] 
    3.   [[10  19] 
    4.    [14  27]]]

    行列式在线性代数中是非常有用的值。 它从方阵的对角元素计算。 对于 2×2 矩阵，它是左上和右下元素的乘积与其他两个的乘积的差。

    换句话说，对于矩阵[[a，b]，[c，d]]，行列式计算为ad-bc。 较大的方阵被认为是 2×2 矩阵的组合。

    numpy.linalg.det()函数计算输入矩阵的行列式。

    例子

    1. import numpy as np
    2. a = np.array([[1,2], [3,4]]) 
    3. print np.linalg.det(a)

    输出如下：

    1. -2.0

    例子

    1. [[ 6 1 1]
    2.  [ 4 -2 5]
    3.  [ 2 8 7]]
    5. -306.0
    7. -306

    numpy.linalg.solve()

    numpy.linalg.solve()函数给出了矩阵形式的线性方程的解。

    考虑以下线性方程：

    1. x + y + z = 6
    3. 2y + 5z = -4
    5. 2x + 5y - z = 27

    可以使用矩阵表示为：

    如果矩阵成为、X和B，方程变为：

    1. AX = B

    或

    1. X = A^(-1)B

    我们使用numpy.linalg.inv()函数来计算矩阵的逆。 矩阵的逆是这样的，如果它乘以原始矩阵，则得到单位矩阵。

    例子

    1. import numpy as np 
    3. y = np.linalg.inv(x) 
    4. print x 
    5. print y 
    6. print np.dot(x,y)

    输出如下：

    1. [[1 2]                                                                        
    2.  [3 4]]                                                                       
    3. [[-2.   1. ]                                                                  
    4.  [ 1.5 -0.5]]                                                                 
    5. [[  1.00000000e+00   1.11022302e-16]                                          
    6.  [  0.00000000e+00   1.00000000e+00]]

    例子

    现在让我们在示例中创建一个矩阵A的逆。

    1. import numpy as np 
    2. a = np.array([[1,1,1],[0,2,5],[2,5,-1]]) 
    4. print '数组 a：'
    5. print a 
    6. ainv = np.linalg.inv(a) 
    8. print 'a 的逆：' 
    9. print ainv  
    11. print '矩阵 b：' 
    12. b = np.array([[6],[-4],[27]]) 
    13. print b 
    15. print '计算：A^(-1)B：' 
    16. x = np.linalg.solve(a,b) 
    17. print x  
    18. # 这就是线性方向 x = 5, y = 3, z = -2 的解

    输出如下：

    1. 数组 a：
    2. [[ 1 1 1]
    3.  [ 0 2 5]
    4.  [ 2 5 -1]]
    6. a 的逆：
    7. [[ 1.28571429 -0.28571429 -0.14285714]
    8.  [-0.47619048 0.14285714 0.23809524]
    9.  [ 0.19047619 0.14285714 -0.0952381 ]]
    11. 矩阵 b：
    12. [[ 6]
    13.  [-4]
    14.  [27]]
    16. 计算：A^(-1)B：
    17. [[ 5.]
    18.  [ 3.]

    结果也可以使用下列函数获取