要知道的數學名詞

線性代數
行列式
行列式的計算
矩陣的乘法

矩陣的轉置
矩陣的逆
矩陣*矩陣的逆=單位陣
矩陣QR分解

隨機漫步

隨機生成1或者-1，每次生成進行疊加，存入陣列，檢視關係

# -*- coding: utf-8 -*-
import numpy as np
'''
將陣列以二進位制方式存入磁碟
'''
arr=np.arange(10)
print(arr)#[0 1 2 3 4 5 6 7 8 9]
#npy結尾的檔案
np.save('some_array',arr)

#讀取檔案
read_arr=np.load('some_array.npy')
print(read_arr)#[0 1 2 3 4 5 6 7 8 9]

#儲存到壓縮格式,npz結尾的檔案
np.savez('zip_arr',a=arr,b=arr)

#載入npz的檔案
arch=np.load('zip_arr.npz')
print(arch['b'])#[0 1 2 3 4 5 6 7 8 9]

#載入cvs格式的txt檔案
arr=np.loadtxt('a.txt',delimiter=',')
print(arr)
# [[  1.  23.   4. 532.  52.  23.]
#  [  1. 123. 321.   3.   1.   3.]
#  [123.  32.  32.   1.  23.   1.]]

#存入檔案
np.savetxt('b.txt',arr)



'''
線性代數

行列式

行列式的計算

矩陣的乘法

矩陣的轉置

矩陣的逆

矩陣*矩陣的逆=單位陣

矩陣QR分解

隨機漫步
'''
x=np.array([[1,2,3,],[4,5,6]])
y=np.array([[6,23],[-1,7],[8,9]])
print(x)
print(y)
# [[1 2 3]
#  [4 5 6]]
# [[ 6 23]
#  [-1  7]
#  [ 8  9]]
# xy
#矩陣的乘法，y的行數要等x的列數

print(x.dot(y))
#[[ 28  64]
 # [ 67 181]]

#如果yx，
# 就是x的行數要等與y的列數
print(y.dot(x))
# [[ 98 127 156]
#  [ 27  33  39]
#  [ 44  61  78]]

z=np.array([[1,2],[3,4]])
print(z)
# [[1 2]
#  [3 4]]


#print(z.dot(y))#ValueError: shapes (2,2) and (3,2) not aligned: 2 (dim 1) != 3 (dim 0)
print(y.dot(z))#y的列數=z的行數   生成的型別y的行數z的列數的矩陣
# [[ 75 104]
#  [ 20  26]
#  [ 35  52]]

w=np.ones(3)
print(w)
# w
# [1. 1. 1.]

#x
# [[1 2 3]
#  [4 5 6]]

print(x.dot(w))#[ 6. 15.]

from numpy.linalg import inv,qr,det

X=np.random.randn(5,5)
print(X)
#X的轉置 * X矩陣的本身
mat=X.T.dot(X)
print(mat)
#再去矩陣的逆
mat_=inv(mat)
#在將矩陣 * 矩陣的逆=單位陣
print(mat.dot(inv(mat)))

# [[ 1.00000000e+00 -1.38777878e-17  9.71445147e-17  1.11022302e-16
#   -4.16333634e-17]
#  [-1.11022302e-16  1.00000000e+00 -4.44089210e-16  0.00000000e+00
#    0.00000000e+00]
#  [ 0.00000000e+00  1.11022302e-16  1.00000000e+00  0.00000000e+00
#   -3.33066907e-16]
#  [-2.42861287e-17  8.15320034e-17 -1.40512602e-16  1.00000000e+00
#    6.59194921e-17]
#  [ 5.55111512e-17  0.00000000e+00  0.00000000e+00 -1.66533454e-16
#    1.00000000e+00]]

x_=inv(X)
a=X.dot(x_)
print(a)


'''
qr分解
'''

print(mat)
# [[ 5.94700575  1.67794721  5.05492158 -2.95012009 -6.74457499]
#  [ 1.67794721  5.98947553  2.05150894 -0.09196568 -1.65633165]
#  [ 5.05492158  2.05150894  7.10432233 -3.14996849 -5.51766286]
#  [-2.95012009 -0.09196568 -3.14996849  2.06381474  2.80042822]
#  [-6.74457499 -1.65633165 -5.51766286  2.80042822 11.17434671]]
q,r=qr(mat)
print(q)
# [[-0.54763541  0.07785414  0.29677708  0.43010504  0.64881987]
#  [-0.15451529 -0.97188837  0.0945459   0.09265504 -0.1184658 ]
#  [-0.46548703 -0.04648143 -0.8442281  -0.2185828   0.14374207]
#  [ 0.27166448 -0.17202467  0.14554887 -0.68493222  0.63740827]
#  [ 0.62108029 -0.13273556 -0.41119203  0.53806515  0.37154751]]

print(r)
# [[-10.85942525  -3.85301838 -10.67485961   5.39602571  14.21884047]
#  [  0.          -5.55014905  -0.65624782  -0.72062709  -0.62383063]
#  [  0.           0.          -2.49317729   0.92394106  -1.68727171]
#  [  0.           0.           0.          -0.49561403   2.24614612]
#  [  0.           0.           0.           0.           0.96390096]]



#以矩陣的形式，返回對角線矩陣
import matlab as mb
a=np.array([[1,0,0],[0,1,0],[0,0,1]])

print(a)
a=mb.diag(a)

print(a)
# [1 1 1]


'''
計算矩陣的行列式
'''
a=det(mat)
print(a)#1.2810727850030796


'''
隨機數的生成

'''
#生成有一個標準的正態分佈的4*4的樣本
sample=np.random.normal(size=(4,4))
print(sample)
# [[-0.46801467  1.14814752 -0.06250482 -0.81041506]
#  [ 0.7279229  -0.73639369  0.252881   -0.25403524]
#  [ 0.80712111  1.51751028 -1.02781585 -1.75518633]
#  [-0.45332071  0.0496177  -0.86698178  0.64285792]]


from random import normalvariate
samples=[normalvariate(0,1) for _ in range(100)]
#print(samples)


'''
隨機漫步

模擬隨機漫步，說明如何運用陣列運算
'''
import random
position=0
walk=[position]
steps=1000
for i in range(steps):
    step=1 if random.randint(0,1) else -1#隨機生成0是step=1，生成1時step=-1
    position+=step
    walk.append(position)

#print(walk)



#另一種方式
nsteps=1000
draws=np.random.randint(0,2,size=nsteps)#隨機產生0或者1，生成陣列

steps=np.where(draws>0,1,-1)#遍歷draws大於0的為1，等於零的為-1

walk=steps.cumsum()#陣列累加

print(walk)

#計算最大值
print(walk.max())

#計算最小值
print(walk.min())

'''
首次穿越時間--隨機漫步，過程中第一次到達某一特定值得時間
'''
#到達10或者時所用的時間

#返回一個布林型別的陣列
bulr=np.abs(walk)>10
#print(bulr)

#找到第一個出現True的索引
index=(np.abs(walk)>=10).argmax()
print(index)


arr=np.array([[1,2,3,4,5],[1,2,3,4,5]])
arr=arr.cumsum(1)
print(arr)
# [[ 1  3  6 10 15]
#  [ 1  3  6 10 15]]

'''
模擬多個隨機漫步
'''
nwalks=5000
nsteps=1000
draws=np.random.randint(0,2,size=(nwalks,nsteps))#生成二維陣列，大陣列內包含五千小陣列，每個小陣列中有一千個數
steps=np.where(draws>0,1,-1)
walks=steps.cumsum(1)#二維陣列的疊加
print(walks)

#計算五千個數組中，隨機漫步的最大值
print(walks.max())
#最小值
print(walks.min())

'''
難點，五千個過程中計算到30或者-30的最小時間
'''

#先判斷這五千個過程中那些陣列穿越的30  這裡用到了any(),上一篇講過
boo_list=(np.abs(walks)>30).any(1)#生成了由五千個元素組成的一維陣列boolean型別

print(boo_list.sum())#為True的數量總和(大於30的)#3228

#然後我們從五千個過程中選出大於30的過程
boo_test=np.array([True,False])
boo_test2=np.array([[1,2,3],[4,5,6]])
a=boo_test2[boo_test]#選出為True對應的陣列
print(a)#[[1 2 3]]



#獲取存在三十的過程
one=walks[boo_list]
#獲取大於三十的過程
two=np.abs(one)>30
#我們獲取大於30的過程的第一個出現30或者-30的索引,集合
three=two.argmax(1)
print(three)#[634 406 450 ... 782 476 584]
#求算數平均數mean
fore=three.mean()
print(fore)#507.4455626715462






 

從隨機漫步中可以看出python真的是一個強大的語言

矩陣乘法上圖

每天進步一點點~