Algebra lineare NumPy

　 　 esempio di algebra lineare NumPy

numpy.dot()

numpy.dot() calcola la somma dei prodotti dei corrispondenti elementi degli array unidimensionali; per gli array bidimensionali, calcola il prodotto matriciale; per gli array multidimensionali, la formula di calcolo universale è la seguente, ossia ogni elemento dell'array di risultato è: la somma dei prodotti di tutti gli elementi dell'ultima dimensione dell'array a con tutti gli elementi della seconda dimensione inversa dell'array b: dot(a, b)[i,j,k,m] = somma(a[i,j,:]*b[k,:,m]).

　　　numpy.dot(a, b, out=None)

Spiegazione dei parametri:

a : ndarray, array b : ndarray, array out : ndarray, opzionale, utilizzato per salvare il risultato del calcolo di dot()

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

Risultato di output:

　[[37 40]　
　[85 92]]

计算式为：

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

numpy.vdot()

numpy.vdot() 函数是两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数是多维数组，它会被展开。

　import numpy.matlib
　import numpy as np
　a = np.array([[1,2],[3,4]])　
　b = np.array([[11,12],[13,14]])　
　　
　# vdot 将数组展开计算内积
　print(np.vdot(a,b))

Risultato di output:

　130

计算式为：

1*11 + 2*12 + 3*13 + 4*14 = 130

numpy.inner()

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

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

Risultato di output:

　　　2

　import numpy as np　
　a　=　np.array([[1,2],　[3,4]])　
　　
　print('Array a:')
　print(a)
　b = np.array([[11, 12], [13, 14]])　
　　
　print('数组 b：')
　print(b)
　　
　print('内积：')
　print(np.inner(a,b))

Risultato di output:

　Array a:
　[[1　2]
　　[3　4]
　数组 b：
　[[11 12]
　　[13 14]]
　内积：
　[[35 41]
　　[81 95]]
　Array a:
　[[1　2]
　　[3　4]
　数组 b：
　[[11 12]
　　[13 14]]
　内积：
　[[35 41]
　　[81 95]]

内积计算式为：

　1*11+2*12, 1*13+2*14　
　3*11+4*12, 3*13+4*14

numpy.matmul

numpy.matmul 函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。

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

对于二维数组，它就是矩阵乘法：

　import numpy.matlib　
　import numpy as np　
　　
　a = [[1,0],[0,1]]　
　b = [[4,1],[2,2]]　
　print　(np.matmul(a,b))

Risultato di output:

　　　[[4 1]　
　　[2 2]]

二维和一维运算：

　import numpy.matlib　
　import numpy as np　
　　
　a = [[1,0],[0,1]]　
　b = [1,2]　
　print　(np.matmul(a,b))
　print(np.matmul(b,a))

Risultato di output:

　[1 2]　
　[1 2]

维度大于二的数组 ：

　import numpy.matlib　
　import numpy as np　
　　
　a = np.arange(8).reshape(2,2,2)　
　b = np.arange(4).reshape(2,2)　
　print　(np.matmul(a,b))

Risultato di output:

　　　[[[　2　3]
　　　[　6　11]]
　　[[10　19]
　　　[14　27]]]

numpy.linalg.det()

La funzione numpy.linalg.det() calcola il determinante della matrice in input.

Il determinante è un valore molto utile nell'algebra lineare. È calcolato dagli elementi diagonali della matrice. Per una matrice 2x2, è il prodotto del elemento superiore sinistro e inferiore destro meno il prodotto degli altri due.

In altre parole, per la matrice [[a，b]，[c，d]]，il calcolo del determinante è ad-bc. La matrice quadrata più grande è considerata una combinazione di matrici 2x2.

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

Risultato di output:

-2.0

　import numpy as np
　　
　b　=　np.array([[6,1,1],　[4,　-2,　5],　[2,8,7]])　
　print(b)
　print　(np.linalg.det(b))
　print　(6*(-2*7　-　5*8)　-　1*(4*7　-　5*2)　+　1*(4*8　-　-2*2))

Risultato di output:

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

numpy.linalg.solve()

La funzione numpy.linalg.solve() fornisce la soluzione dell'equazione lineare in forma matriciale.

Consideriamo l'equazione lineare seguente:

　x　+　y　+　z　=　6
　2y　+　5z　=　-4
　2x　+　5y　-　z　=　27

Può essere rappresentato come una matrice:

Se la matrice diventa A, X e B, l'equazione diventa:

　AX　=　B
　o
　X　=　A^(-1)B

numpy.linalg.inv()

La funzione numpy.linalg.inv() calcola la matrice inversa del prodotto di matrici.

Matrice inversa (inverse matrix)：Definiamo A come una matrice n di ordine su un anello, se esiste un'altra matrice n di ordine B nello stesso anello tale che: AB=BA=E, allora B è la matrice inversa di A e A è detta matrice invertibile. Nota: E è la matrice unitaria.

　import numpy as np　
　　
　x　=　np.array([[1,2],[3,4]])　
　y　=　np.linalg.inv(x)　
　print(x)
　print　(y)
　print　(np.dot(x,y))

Risultato di output:

　[[1　2]
　　[3　4]
　[[-2.　1.　]]
　　[　1.5　-0.5]
　[[1.0000000e+00　0.0000000e+00]]
　　[8.8817842e-16　1.0000000e+00]

Ora crea la matrice inversa della matrice A:

　import numpy as np　
　　
　a = np.array([[1,1,1],[0,2,5],[2,5,-1]])　
　　
　print('Array a:')
　print(a)
　ainv = np.linalg.inv(a)　
　　
　print('Inverso di a:')
　print(ainv)
　　
　print('Matrice b:')
　b = np.array([[6],[-4],[27]])　
　print(b)
　　
　print('Calcolo: A^(-1)B:')
　x = np.linalg.solve(a, b)　
　print(x)
　# Questo è la soluzione della direzione lineare x = 5, y = 3, z = -2

Risultato di output:

　Array a:
　[[ 1 1 1]
　　[ 0 2 5]
　　[ 2 5 -1]
　Inverso di a:
　[[ 1.28571429 -0.28571429 -0.14285714]
　　[-0.47619048 0.14285714 0.23809524]
　　[ 0.19047619 0.14285714 -0.0952381 ]
　Matrice b:
　[[ 6]
　　[-4]
　　[27]]
　Calcolo: A^(-1)B:
　[[ 5.]
　　[ 3.]
　　[-2.]]

　　　x = np.dot(ainv, b)