Стек SciPy https://scipy.org/stackspec.html

Научные вычисления в Python основываются на небольшом ядре пакетов:

NumPy - основной ΠΏΠ°ΠΊΠ΅Ρ‚ для числСнного вычислСния. Он опрСдСляСт числСнныС Ρ‚ΠΈΠΏΡ‹ массивов ΠΈ ΠΌΠ°Ρ‚Ρ€ΠΈΡ† ΠΈ основныС ΠΎΠΏΠ΅Ρ€Π°Ρ†ΠΈΠΈ Π½Π°Π΄ Π½ΠΈΠΌΠΈ.

SciPy - Π½Π°Π±ΠΎΡ€ числовых Π°Π»Π³ΠΎΡ€ΠΈΡ‚ΠΌΠΎΠ² ΠΈ Π½Π°Π±ΠΎΡ€ΠΎΠ² инструмСнтов, спСцифичных для Π΄ΠΎΠΌΠ΅Π½Π°, Π²ΠΊΠ»ΡŽΡ‡Π°Ρ ΠΎΠ±Ρ€Π°Π±ΠΎΡ‚ΠΊΡƒ сигналов, ΠΎΠΏΡ‚ΠΈΠΌΠΈΠ·Π°Ρ†ΠΈΡŽ, статистику ΠΈ ΠΌΠ½ΠΎΠ³ΠΎΠ΅ Π΄Ρ€ΡƒΠ³ΠΎΠ΅.

Matplotlib - обСспСчиваСт Π²ΠΎΠ·ΠΌΠΎΠΆΠ½ΠΎΡΡ‚ΡŒ рисования Π³Ρ€Π°Ρ„ΠΈΠΊΠΎΠ².

pandas - обСспСчивая Π²Ρ‹ΡΠΎΠΊΠΎΠΏΡ€ΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΡ‚Π΅Π»ΡŒΠ½Ρ‹Π΅ ΠΈ простыС Π² использовании структуры Π΄Π°Π½Π½Ρ‹Ρ….

SymPy - для символьной ΠΌΠ°Ρ‚Π΅ΠΌΠ°Ρ‚ΠΈΠΊΠΈ ΠΈ ΠΊΠΎΠΌΠΏΡŒΡŽΡ‚Π΅Ρ€Π½ΠΎΠΉ Π°Π»Π³Π΅Π±Ρ€Ρ‹.

In [95]:
% matplotlib inline
import  sympy  as  sympy 
import  numpy  as  np 
import  matplotlib.pyplot  as  plt 
from  scipy  import  *
In [ ]:

Матрицы в numpy

Набор Ρ„ΡƒΠ½ΠΊΡ†ΠΈΠΉ ΠΈ ΠΌΠ΅Ρ‚ΠΎΠ΄ΠΎΠ² для Ρ€Π°Π±ΠΎΡ‚Ρ‹ с массивами Π² numpy https://docs.scipy.org/doc/numpy/reference/routines.html

ΠœΠ°Π½ΠΈΠΏΡƒΠ»ΡΡ†ΠΈΠΈ с массивами https://docs.scipy.org/doc/numpy/reference/routines.array-manipulation.html

N-dimensional array (ndarray) https://docs.scipy.org/doc/numpy/reference/arrays.ndarray.html

2-мерные массивы

In [96]:
# созданиС массива из списка
A = np.array([[1, 2, 3], [4, 5, 6]], np.int32)
In [97]:
A
Out[97]:
array([[1, 2, 3],
       [4, 5, 6]])
In [98]:
len(set(dir(A))- set(dir(object)))
Out[98]:
137
In [99]:
#help(A)
In [100]:
# Π°Ρ‚Ρ€ΠΈΠ±ΡƒΡ‚Ρ‹
A.ndim
Out[100]:
2
In [101]:
A.shape
# A.shape=1,6
Out[101]:
(2, 3)
In [102]:
len(A)
Out[102]:
2
In [103]:
A.size
Out[103]:
6
In [104]:
# ΠΎΠ±Ρ€Π°Ρ‰Π΅Π½ΠΈΠ΅ ΠΊ элСмСнту (см. lecture_2)
A[0,1]
Out[104]:
2

Класс numpy.matrix

https://docs.scipy.org/doc/numpy/reference/generated/numpy.matrix.html#numpy.matrix

ΠžΠ±ΡŠΠ΅ΠΊΡ‚ matrix ΠΈΠΌΠ΅Π΅Ρ‚ ΡΠΏΠ΅Ρ†ΠΈΠ°Π»ΡŒΠ½Ρ‹Π΅ ΠΎΠΏΠ΅Ρ€Π°Ρ‚ΠΎΡ€Ρ‹ * (ΠΌΠ°Ρ‚Ρ€ΠΈΡ‡Π½ΠΎΠ΅ ΡƒΠΌΠ½ΠΎΠΆΠ΅Π½ΠΈΠ΅) ΠΈ **(ΠΌΠΎΡ‰Π½ΠΎΡΡ‚ΡŒ ΠΌΠ°Ρ‚Ρ€ΠΈΡ†Ρ‹)

Π‘ΠΌ. сравнСниС numpy.matrix vs 2D numpy.ndarray https://docs.scipy.org/doc/scipy/reference/tutorial/linalg.html#numpy-matrix-vs-2d-numpy-ndarray

In [105]:
B=np.matrix([[1, 2], [3, 4]])
In [106]:
type(B)
Out[106]:
numpy.matrixlib.defmatrix.matrix
In [107]:
B
Out[107]:
matrix([[1, 2],
        [3, 4]])
In [108]:
B.A
Out[108]:
array([[1, 2],
       [3, 4]])
In [109]:
B.A1
Out[109]:
array([1, 2, 3, 4])

Сложение и вычитание матриц

In [110]:
# слоТСниС (Π²Ρ‹Ρ‡ΠΈΡ‚Π°Π½ΠΈΠ΅) ΠΌΠ°Ρ‚Ρ€ΠΈΡ†Ρ‹ ΠΈ скаляра (поэлСмСнтноС)
A+1
Out[110]:
array([[2, 3, 4],
       [5, 6, 7]])
In [111]:
B+2
Out[111]:
matrix([[3, 4],
        [5, 6]])
In [112]:
# слоТСниС (Π²Ρ‹Ρ‡ΠΈΡ‚Π°Π½ΠΈΠ΅) ΠΌΠ°Ρ‚Ρ€ΠΈΡ†
In [113]:
A+B

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-113-0e75ae3cf3e2> in <module>()
----> 1 A+B

ValueError: operands could not be broadcast together with shapes (2,3) (2,2)
In [114]:
A[0:2, 0:2]+B
Out[114]:
matrix([[2, 4],
        [7, 9]])

Транспонирование матриц

In [115]:
# ΠΌΠ°Ρ‚Ρ€ΠΈΡ†Ρ‹
A.T
Out[115]:
array([[1, 4],
       [2, 5],
       [3, 6]])
In [116]:
# Π²Π΅ΠΊΡ‚ΠΎΡ€Π°
C=np.array([1,1,1])
C.T
Out[116]:
array([1, 1, 1])
In [117]:
C.reshape(3,1)
Out[117]:
array([[1],
       [1],
       [1]])
In [118]:
D=np.matrix([1,1])
D.T
Out[118]:
matrix([[1],
        [1]])

Матричное умножение

In [119]:
A
Out[119]:
array([[1, 2, 3],
       [4, 5, 6]])
In [120]:
# поэлСмСнтноС ΡƒΠΌΠ½ΠΎΠΆΠ΅Π½ΠΈΠ΅ ΠΌΠ°Ρ‚Ρ€ΠΈΡ†
A*A
Out[120]:
array([[ 1,  4,  9],
       [16, 25, 36]])
In [121]:
# ΡƒΠΌΠ½ΠΎΠΆΠ΅Π½ΠΈΠ΅ Π½Π° скаляр (поэлСмСнтноС)
A*3
Out[121]:
array([[ 3,  6,  9],
       [12, 15, 18]])
In [122]:
# ΡƒΠΌΠ½ΠΎΠΆΠ΅Π½ΠΈΠ΅ ΠΌΠ°Ρ‚Ρ€ΠΈΡ†Ρ‹ A Π½Π° ΠΌΠ°Ρ‚Ρ€ΠΈΡ†Ρƒ C
# 1
A.dot(C)
Out[122]:
array([ 6, 15])
In [123]:
# 2
np.dot(A, C)
Out[123]:
array([ 6, 15])
In [124]:
# 3
A@C
Out[124]:
array([ 6, 15])
In [125]:
D
Out[125]:
matrix([[1, 1]])
In [126]:
B*D

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-126-b0239c03fafd> in <module>()
----> 1 B*D

D:\Anaconda\lib\site-packages\numpy\matrixlib\defmatrix.py in __mul__(self, other)
    341         if isinstance(other, (N.ndarray, list, tuple)) :
    342             # This promotes 1-D vectors to row vectors
--> 343             return N.dot(self, asmatrix(other))
    344         if isscalar(other) or not hasattr(other, '__rmul__') :
    345             return N.dot(self, other)

ValueError: shapes (2,2) and (1,2) not aligned: 2 (dim 1) != 1 (dim 0)
In [127]:
# транспонированиС Π²Π΅ΠΊΡ‚ΠΎΡ€Π° D
B*np.reshape(D, (2,1))
Out[127]:
matrix([[3],
        [7]])
In [128]:
# транспонированиС Π²Π΅ΠΊΡ‚ΠΎΡ€Π° D
B*D.T
Out[128]:
matrix([[3],
        [7]])
In [129]:
E=np.eye(2)
In [130]:
E
Out[130]:
array([[ 1.,  0.],
       [ 0.,  1.]])
In [131]:
# matrix * array (Π½Π΅ поэлСмСнтно)
B*E
Out[131]:
matrix([[ 1.,  2.],
        [ 3.,  4.]])

Операции со строками и столбцами (подробнее см. Lecture_2.ipynb)

In [132]:
A[1]
Out[132]:
array([4, 5, 6])
In [133]:
B[1]
Out[133]:
matrix([[3, 4]])
In [134]:
# Ρ†ΠΈΠΊΠ» ΠΏΠΎ строкС
for row in A:
    print(row)

[1 2 3]
[4 5 6]
In [135]:
# столбСц 
A[:,2]
Out[135]:
array([3, 6])
In [136]:
B[:,1]
Out[136]:
matrix([[2],
        [4]])
In [137]:
# cΡƒΠΌΠΌΠ° всСх элСмСнтов; суммы столбцов; суммы строк.
print(A.sum())
print(A.sum(0))
print(A.sum(1))

21
[5 7 9]
[ 6 15]
In [138]:
A
Out[138]:
array([[1, 2, 3],
       [4, 5, 6]])
In [139]:
# ΠΏΡ€ΠΎΠΈΠ·Π²Π΅Π΄Π΅Π½ΠΈΠ΅ элСмСнтов, 
print(A.prod())
print(A.max(0))
print(A.min(1))

720
[4 5 6]
[1 4]
In [140]:
# слСд ΠΌΠ°Ρ‚Ρ€ΠΈΡ†Ρ‹ - сумма Π΄ΠΈΠ°Π³ΠΎΠ½Π°Π»ΡŒΠ½Ρ‹Ρ… элСмСнтов
trace(E)
Out[140]:
2.0

Линейная алгебра scipy и numpy

https://docs.scipy.org/doc/scipy/reference/tutorial/linalg.html

scipy.linalg содСрТит всС Ρ„ΡƒΠ½ΠΊΡ†ΠΈΠΈ Π² numpy.linalg. плюс Π½Π΅ΠΊΠΎΡ‚ΠΎΡ€Ρ‹Π΅ Π΄Ρ€ΡƒΠ³ΠΈΠ΅ Π±ΠΎΠ»Π΅Π΅ ΠΏΡ€ΠΎΠ΄Π²ΠΈΠ½ΡƒΡ‚Ρ‹Π΅, Π½Π΅ содСрТащиСся Π² numpy.linalg

from scipy import linalg

Определитель матрицы

In [141]:
np.linalg.det(E)
Out[141]:
1.0

Обращение (инверсия) матриц

In [142]:
B
Out[142]:
matrix([[1, 2],
        [3, 4]])
In [143]:
B_inverse=np.linalg.inv(B)
In [144]:
B_inverse
Out[144]:
matrix([[-2. ,  1. ],
        [ 1.5, -0.5]])
In [145]:
# ΠΏΡ€ΠΎΠ²Π΅Ρ€ΠΊΠ°
B_inverse.dot(B)
Out[145]:
matrix([[  1.00000000e+00,   4.44089210e-16],
        [  0.00000000e+00,   1.00000000e+00]])
In [146]:
B.dot(B_inverse)
Out[146]:
matrix([[  1.00000000e+00,   1.11022302e-16],
        [  0.00000000e+00,   1.00000000e+00]])

Решение СЛАУ Ax=v

In [147]:
A=np.array([[0.0,1.0],[-1.0,0.0]])
A
Out[147]:
array([[ 0.,  1.],
       [-1.,  0.]])
In [148]:
v=np.array([2,2])
v
Out[148]:
array([2, 2])
In [149]:
np.linalg.inv(A)@v
Out[149]:
array([-2.,  2.])
In [150]:
x=solve(A,v)
x
Out[150]:
array([-2.,  2.])
In [151]:
# ΠΏΡ€ΠΎΠ²Π΅Ρ€ΠΊΠ°
A@x-v
Out[151]:
array([ 0.,  0.])

Собственные числа и собственные векторы

https://docs.scipy.org/doc/scipy/reference/tutorial/linalg.html#eigenvalues-and-eigenvectors

Набор ΠΌΠ΅Ρ‚ΠΎΠ΄ΠΎΠ² numpy.linalg https://docs.scipy.org/doc/numpy/reference/routines.linalg.html

In [152]:
A
Out[152]:
array([[ 0.,  1.],
       [-1.,  0.]])
In [153]:
vals=np.linalg.eigvals(A)
In [154]:
vals
Out[154]:
array([ 0.+1.j,  0.-1.j])
In [155]:
vals,vectors=np.linalg.eig(A)
In [156]:
vals
Out[156]:
array([ 0.+1.j,  0.-1.j])
In [157]:
vectors
Out[157]:
array([[ 0.70710678+0.j        ,  0.70710678-0.j        ],
       [ 0.00000000+0.70710678j,  0.00000000-0.70710678j]])
In [158]:
from numpy.linalg import *
In [159]:
l,vec=eig(A)
In [160]:
l
Out[160]:
array([ 0.+1.j,  0.-1.j])
In [161]:
vec
Out[161]:
array([[ 0.70710678+0.j        ,  0.70710678-0.j        ],
       [ 0.00000000+0.70710678j,  0.00000000-0.70710678j]])
In [162]:
# собствСнный Π²Π΅ΠΊΡ‚ΠΎΡ€ v_1 - Π½ΡƒΠ»Π΅Π²ΠΎΠΉ столбСц ΠΌΠ°Ρ‚Ρ€ΠΈΡ†Ρ‹ vec
vec[:,0]
Out[162]:
array([ 0.70710678+0.j        ,  0.00000000+0.70710678j])
In [163]:
# собствСнный Π²Π΅ΠΊΡ‚ΠΎΡ€ v_2 - ΠΏΠ΅Ρ€Π²Ρ‹ΠΉ столбСц ΠΌΠ°Ρ‚Ρ€ΠΈΡ†Ρ‹ vec
vec[:,1]
Out[163]:
array([ 0.70710678-0.j        ,  0.00000000-0.70710678j])
In [164]:
# ΠΏΡ€ΠΎΠ²Π΅Ρ€ΠΊΠ° для v_1
A.dot(vec[:,0])-l[0]*vec[:,0]
Out[164]:
array([ 0.+0.j,  0.+0.j])
In [165]:
# ΠΏΡ€ΠΎΠ²Π΅Ρ€ΠΊΠ° для v_2
A.dot(vec[:,1])-l[1]*vec[:,1]
Out[165]:
array([ 0.+0.j,  0.+0.j])
In [166]:
# ΠΏΡ€ΠΎΠ²Π΅Ρ€ΠΊΠ° с ΠΏΠΎΠΌΠΎΡ‰ΡŒΡŽ диагональной ΠΌΠ°Ρ‚Ρ€ΠΈΡ†Ρ‹ (собствСнныС числа ΠΏΠΎ Π³Π». Π΄ΠΈΠ°Π³ΠΎΠ½Π°Π»ΠΈ)
# Av=vD, D=diag(l_1, l_2)
In [167]:
D=diag(l)
D
Out[167]:
array([[ 0.+1.j,  0.+0.j],
       [ 0.+0.j,  0.-1.j]])

1. проверка $Av-vD=\overline{0}$

In [168]:
# 1. ΠΏΡ€ΠΎΠ²Π΅Ρ€ΠΊΠ° 
A.dot(vec)-vec.dot(D)
Out[168]:
array([[ 0.+0.j,  0.+0.j],
       [ 0.+0.j,  0.+0.j]])

2. проверка $v^{-1}Av=D$, $D=diag(l_1, l_2)$

In [169]:
# 2 ΠΏΡ€ΠΎΠ²Π΅Ρ€ΠΊΠ°
inv(vec)@A@vec
Out[169]:
array([[ 0.+1.j,  0.+0.j],
       [ 0.+0.j,  0.-1.j]])
In [ ]: