Processing math: 100%

Стек 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=¯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−1Av=D, D=diag(l1,l2)

In [169]:
# 2 проверка
inv(vec)@A@vec
Out[169]:
array([[ 0.+1.j,  0.+0.j],
       [ 0.+0.j,  0.-1.j]])
In [ ]: