线性代数

    • ：以一维数组的形式返回方阵的对角线（或非对角线）元素，或将一维数组转换为方阵（非对角线元素为0）。
    • dot：矩阵乘法。
    • trace：计算对角线元素的和。
    • det：计算矩阵行列式。
    • eig：计算方阵的特征值和特征向量。
    • inv：计算方阵的逆。 
    1. a: 
    2. [ 0  1  2  3  4  5  6  7  8  9 10 11]
    3. b: 
    4. [[ 0  1  2  3]
    5.  [ 4  5  6  7]
    6.  [ 8  9 10 11]]
    7. c: 
    8. [[ 0  1  2]
    9.  [ 3  4  5]
    10.  [ 6  7  8]
    11.  [ 9 10 11]]
    12. [[ 42  48  54]
    13.  [114 136 158]
    14.  [186 224 262]]
    1. # numpy.linalg  中有一组标准的矩阵分解运算以及诸如求逆和行列式之类的东西
    3. # 或将一维数组转换为方阵（非对角线元素为0）
    4. e = np.diag(d)
    5. f = np.diag(e)
    6. print('d: \n{}'.format(d))
    7. print('e: \n{}'.format(e))
    8. print('f: \n{}'.format(f))
    1. d: 
    2. [[ 42  48  54]
    3.  [114 136 158]
    4.  [186 224 262]]
    5. e: 
    6. [ 42 136 262]
    7. [[ 42   0   0]
    8.  [  0 136   0]
    9.  [  0   0 262]]
    1. 440
    2. h = np.linalg.det(d)
    3. h
    1. 1.3642420526593978e-11
    1. (array([4.36702561e+02, 3.29743887e+00, 3.13152204e-14]),
    2.  array([[ 0.17716392,  0.77712552,  0.40824829],
    3.         [ 0.5095763 ,  0.07620532, -0.81649658],
    4.         [ 0.84198868, -0.62471488,  0.40824829]]))
    1. # inv，计算方阵的逆
    2. tmp = np.random.rand(3, 3)
    3. j = np.linalg.inv(tmp)
    4. j
    1. array([[-0.59449952,  1.39735912, -0.06654123],
    2.        [ 0.10659811, -0.62164179,  1.30437759]])