資源（Resource）

1.建立行列式，numpy與sympy指令的優比較
（1）sympy模組
■行列式值矩陣指令：A.det()
■範例：
from sympy import *
A = Matrix([
[1,2,3],
[-4,5,6],
[7,-8,9],
])
A_det = A.det()
print("A的行列式值=", A_det)

（2）numpy模組
■numpy的行列式指令：np.linalg.det(A)
■範例：
import numpy as np
A = np.array([
[1,2,3],
[-4,5,6],
[7,-8,9],
])
A_det = np.linalg.det(A)

範例4-1：計算2x2矩陣的行列式值

2.範例4-1：計算2x2矩陣的行列式值
import numpy as np
A = np.array([
[5,3],
[2,6]
])
A_det = np.linalg.det(A).round()
print("A的行列式值=", A_det)

print("A的行列式值(四捨五入)=", A_det.round())

成果圖示：
程式碼內容

範例4-2：計算3x3矩陣的行列式值

2.範例4-2：計算3x3矩陣的行列式值
import numpy as np
A = np.array([
[1,2,3],
[-4,5,6],
[7,-8,9],
])
A_det = np.linalg.det(A).round()
print("A的行列式值=", A_det)
print("A的行列式值(四捨五入)=", A_det.round())

成果圖示：
程式碼內容

範例4-3：計算4x4矩陣的行列式值

3.範例4-3：計算4x4矩陣的行列式值
import numpy as np
A = np.array([
[1,0,0,-1],
[3,1,2,2],
[1,0,-2,1],
[2,0,0,1]
])
A_det = np.linalg.det(A).round()
print("A的行列式值=", A_det)
print("A的行列式值(四捨五入)=", A_det.round())

成果圖示：
程式碼內容

範例4-4：使用sympy計算3x3矩陣的行列式值

4.範例4-4：使用sympy計算3x3矩陣的行列式值
from sympy import *
A = Matrix([
[1,2,3],
[-4,5,6],
[7,-8,9],
])
A_det = A.det()
print("A的行列式值=", A_det)
print("A的行列式值(四捨五入)=", A_det.round())

成果圖示：
程式碼內容

1.求解線性系統，numpy與sympy指令的優缺點

1.求解線性系統，numpy與sympy指令的優缺點
（1）sympy模組
指令：solve_linear_system(M, x1,x2)
注意：M矩陣的最右邊=y=轉換後座標
from sympy import *
x1,x2 = symbols('x1 x2')
M = Matrix([
[1,1,4],
[3,3,6]
])
ans = solve_linear_system(M, x1,x2)
優點1：可以自動處理唯一解，無解，無限多就解，不需要人工再去判別處理
優點2：無解，則自動顯示None
優點3：無限多解，則自動顯示通解（帶有x變數的通解）

（2）numpy模組
指令：np.linalg.solve(A, Y)
函數可計算出矩陣形式的線性方程的解
import numpy as np
A = np.array([
[4,-2],
[16,-8]
])
Y = np.array([
[1],[4]
])
X = np.linalg.solve(A, Y)

缺點1：只能處理唯一解，無法自動處理無解，無限多就解，需要人工再去判別處理
缺點2：若是無解，程式會出現錯誤訊息
缺點3：若是無限多組解，程式會出現錯誤訊息
缺點4：必須用行列式det(M)，或是rank（M)，人工方式判別分類，來處理『唯一解，無解，無限多解』

（3）結論：若要解線性系統，只能用sympy來求解
不要用numpy模組求解，因為無法處理『無解，無限多組的通解』

範例5-1：解聯立方程式

2.範例5-1：解聯立方程式
#x-y=1
#2x+y=6
import numpy as np
A = np.array([
[1,-1],
[2,1]
])
#注意：y矩陣，是以row為單位
Y = np.array([
[1],[6]
])
X = np.linalg.solve(A, Y)
print('X=\n', X)

成果圖示：
程式碼內容

範例5-2：解聯立方程式

2.範例5-2：解聯立方程式
#x+y=4
#1x+3y=6
import numpy as np
A = np.array([
[1,1],
[3,3]
])
#注意：y矩陣，是以row為單位
Y = np.array([
[4],[6]
])
try:
X = np.linalg.solve(A, Y)
print('X=\n', X)
except:
print('方程式無解')

成果圖示：
程式碼內容

範例5-3：解聯立方程式先用行列式，判別，是否有唯一解，無解，或無限多解

3.範例5-3：解聯立方程式先用行列式，判別，是否有唯一解，無解，或無限多解
#若det(A)≠0，則系統有唯一解
#若det(A)＝0，且det(A|B)=0，則無限多組解
#若det(A)＝0，且det(A|B)≠0，則無解

import numpy as np
A = np.array([
[1,1],
[3,3]
])
#注意：y矩陣，是以row為單位
Y = np.array([
[4],[6]
])
#計算行列式det(A)
AY= np.array([
[1,4],
[3,6]
])
A_det = np.linalg.det(A).round()
AY_det = np.linalg.det(AY).round()
if A_det !=0: #有唯一解
X = np.linalg.solve(A, Y)
print('方程式，有唯一解，X=\n', X)
elif A_det ==0 and AY_det==0:
print('方程式，無限多解')
elif A_det ==0 and AY_det !=0:
print('方程式，無解')

成果圖示：
程式碼內容

範例5-4：解聯立方程式先用行列式，判別，是否有唯一解，無解，或無限多解

4.範例5-4：解聯立方程式先用行列式，判別，是否有唯一解，無解，或無限多解
#若det(A)≠0，則系統有唯一解
#若det(A)＝0，且det(A|B)=0，則無限多組解
#若det(A)＝0，且det(A|B)≠0，則無解
import numpy as np
A = np.array([
[1,-1,2],
[2,-2,4],
[3,-3,6]
])
#注意：y矩陣，是以row為單位
Y = np.array([
[5],[10],[15]
])
#計算行列式det(A)
AY= np.array([
[-1,2,5],
[-2,4,10],
[-3,6,15],
])
A_det = np.linalg.det(A).round()
AY_det = np.linalg.det(AY).round()
if A_det !=0: #有唯一解
X = np.linalg.solve(A, Y)
print('方程式，有唯一解，X=\n', X)
elif A_det ==0 and AY_det==0:
print('方程式，無限多解')
elif A_det ==0 and AY_det !=0:
print('方程式，無解')

成果圖示：
程式碼內容

範例5-5：用反矩陣解力量方程式

5.範例5-5：用反矩陣解力量方程式
#x-y=1
#2x+y=6
import numpy as np
A=np.array([
[1,-1],
[2,1]
])
A_inv = np.linalg.inv(A)
Y = np.array([
[1],[6]
])
X = A_inv @ Y
print('(1).反矩陣inv()，求解X=\n', X)
X = np.linalg.solve(A, Y)
print('(2).solve()，求解X=\n', X)

成果圖示：
程式碼內容

範例5-6：用反矩陣解力量方程式，先判別有唯一解，無解，或無限多組解

6.範例5-6：用反矩陣解力量方程式，先判別有唯一解，無解，或無限多組解
#x+y=4
#1x+3y=6
import numpy as np
A = np.array([
[1,1],
[3,3]
])
#注意：y矩陣，是以row為單位
Y = np.array([
[4],[6]
])
AY = np.array([
[1,4],
[3,6]
])
#計算行列式值
A_det = np.linalg.det(A).round()
AY_det = np.linalg.det(AY).round()
#先判別有唯一解，無解，或無限多組解
if A_det !=0: #有唯一解
A_inv = np.linalg.inv(A)
X = A_inv @ Y
print('方程式，有唯一解，X=\n', X)
elif A_det ==0 and AY_det==0:
print('方程式，無限多解')
elif A_det ==0 and AY_det !=0:
print('方程式，無解')

成果圖示：
程式碼內容

範例5-7：用rank來判別，是否有唯一解，無解，或無限多解

7.範例5-7：用rank來判別，是否有唯一解，無解，或無限多解
#若rank(A)=n，表示full rank 表示有唯一解
#若 n > rank(A) 且 n > rank(AY) 表示有降階，為無限多組解
#若 n > rank(A) 且 n = rank(AY) 表示A降階，AY不降階，為無解
import numpy as np

A = np.array(
[
[-5, 4 ,2],
[4, -5 ,2],
[2, 2,-8]
])
#注意：y
#注意：y矩陣，是以row為單位
Y = np.array([
[0],[0],[0]
])
#計算行列式det(A)
AY = np.array(
[
[0,-5, 4],
[0,4, -5],
[0,2, 2]
])

#A的維度 =n個輸入變數
n = np.shape(A)[1]
print('n=',n)
A_rank = np.linalg.matrix_rank(A)
print('A_rank=',A_rank)
AY_rank = np.linalg.matrix_rank(AY)
print('AY_rank=',AY_rank)
if n == A_rank: #有唯一解
X = np.linalg.solve(A, Y)
print('方程式，有唯一解，X=\n', X)
elif n > A_rank and n > AY_rank:
print('方程式，無限多解')
elif n > A_rank and n == AY_rank:
print('方程式，無解')

成果圖示：
程式碼內容

範例5-8：用rank來判別，是否有唯一解，無解，或無限多解

8-範例5-8：用rank來判別，是否有唯一解，無解，或無限多解
#若rank(A)=n，表示full rank 表示有唯一解
#若 n > rank(A) 且 n > rank(AY) 表示有降階，為無限多組解
#若 n > rank(A) 且 n = rank(AY) 表示A降階，AY不降階，為無解

import numpy as np
A = np.array([
[1,1],
[3,3]
])
#注意：y矩陣，是以row為單位
Y = np.array([
[4],[6]
])
#計算行列式det(A)
AY= np.array([
[1,4],
[3,6]
])
#A的維度 =n個輸入變數
n = np.shape(A)[1]
print('n=',n)
A_rank = np.linalg.matrix_rank(A)
print('A_rank=',A_rank)
AY_rank = np.linalg.matrix_rank(AY)
print('AY_rank=',AY_rank)
if n == A_rank: #有唯一解
X = np.linalg.solve(A, Y)
print('方程式，有唯一解，X=\n', X) elif n > A_rank and n > AY_rank:
print('方程式，無限多解')
elif n > A_rank and n == AY_rank:
print('方程式，無解')

成果圖示：
程式碼內容

範例5-9：用sympy模組解聯立方程式

9.範例5-9：用sympy模組解聯立方程式
#x-y=1
#2x+y=6
from sympy import *
x1,x2 = symbols('x1 x2')
#注意：M矩陣的最右邊=y=轉換後座標
A = Matrix([
[1,-1,1,],
[2,1,6]
])
ans = solve_linear_system(A, x1, x2)
print('X=', ans)

成果圖示：
程式碼內容

範例5-10：用sympy解聯立方程式

10.範例5-10：用sympy解聯立方程式
#x+y=4
#1x+3y=6
from sympy import *
x1,x2 = symbols('x1 x2')
#注意：M矩陣的最右邊=y=轉換後座標
A = Matrix([
[1,1,4],
[3,3,6]
])
ans = solve_linear_system(A, x1, x2)
print('X=', ans)

成果圖示：
程式碼內容

範例5-11：用sympy解聯立方程式，求無限多組解的通解

11.範例5-11：用sympy解聯立方程式，求無限多組解的通解
from sympy import *
x1,x2,x3 = symbols('x1 x2 x3')
#注意：M矩陣的最右邊=y=轉換後座標
A = Matrix([
[1,-1,2,5],
[2,-2,4,10],
[3,-3,6,15]
])
ans = solve_linear_system(A, x1, x2, x3)
print('X=', ans)

成果圖示：
程式碼內容

範例5-12：用sympy解聯立方程式，求無限多組解的通解

12.範例5-12：用sympy解聯立方程式，求無限多組解的通解
from sympy import *
x1,x2,x3,x4,x5,x6 = symbols('x1 x2 x3 x4 x5 x6')
#注意：M矩陣的最右邊=y=轉換後座標
A = Matrix([
[1,3,-2,0,2,0,0],
[2,6,-5,-2,4,-3,-1],
[0,0,5,10,0,15,5],
[2,6,0,8,4,18,6]
])
ans = solve_linear_system(A, x1, x2, x3, x4,x5,x6)
print('X=', ans)

成果圖示：
程式碼內容

範例5-13：用sympy解聯立方程式，求唯一解

13.範例5-13：用sympy解聯立方程式，求唯一解
from sympy import *
x1,x2,x3,x4 = symbols('x1 x2 x3 x4')
#注意：M矩陣的最右邊=y=轉換後座標
A = Matrix([
[1,3,7,2,5],
[0,1,2,-4,1],
[0,0,1,6,9],
[1,0,0,0,1]
])
ans = solve_linear_system(A, x1, x2, x3, x4)
print('X=', ans)

成果圖示：
程式碼內容

範例5-14：sympy把A做LU分解

13.範例5-14：sympy把A做LU分解
from sympy import *
x1,x2 = symbols('x1 x2')
A = Matrix([
[2,6,2],
[-3,-8,0],
[4,9,2]
])
L, U, _ = A.LUdecomposition()
print(L)
print(U)

成果圖示：
程式碼內容

範例6-1：若向量 a=(3,−1) ，b=(2,1) ，求二者如何组合成向量c

1.範例6-1：若向量 a=(3,−1) ，b=(2,1) ，求二者如何组合成向量c
import numpy as np
#比較：矩陣與向量
#矩陣：np.array([ [1,-1], [2,1] ])
#向量：np.array([3,-1])
a = np.array([3,-1])
b = np.array([2,1])
c = a+b
print('c=a+b=\n', c)

成果圖示：
程式碼內容

2.範例6-2：若向量 a=(3,−1) 係數乘法，求3a
#比較：矩陣與向量
#矩陣：np.array([ [1,-1], [2,1] ])
#向量：np.array([3,-1])
import numpy as np
a = np.array([3,-1])
c = 3*a
print('c=3a=\n', c)

成果圖示：
程式碼內容

範例6-3：求向量的點積:a.dot(b)

3.範例6-3：求向量的點積:a.dot(b)
#從幾何的角度來說，向量的點積與向量間夾角 θ 的餘弦有關：
a⃗ ⋅b⃗ =∥a⃗ ∥*∥b⃗ ∥*cosθ
#故向量點積=向量的點積其實反映了向量 a⃗ 在向量 b⃗ 上的 投影
#向量 a=(3,5,2)， b=(1,4,7)
import numpy as np
a = np.array([3,5,2])
b = np.array([1,4,7])

print('向量點積有三種指令：')
print('a.dot(b)=', a.dot(b))
print('np.dot(a,b)=', np.dot(a,b))
print('a @ b=', a @ b)

成果圖示：
程式碼內容

範例6-4：求向量的外積： np.cross(a,b)

4.範例6-4：求向量的外積： np.cross(a,b)
#向量外積=叉乘、向量積、叉積
#外積的一個重要作用：是可以得到一個和 a⃗ 、b⃗ 兩個原向量垂直正交的新向量 c⃗ ，且可以通過右手法則來確定新向量的方向
#向量的外積，反映了向量 a⃗ 與向量 b⃗ 的垂直正交程度：當兩向量平行時，sinθ 的值為0，外積的值為0，正交程度最小。
#當兩向量垂直正交時：sinθ 的值為1，外積值最大，正交程度最大
#向量 a=(3,5,2)， b=(1,4,7)
import numpy as np
a = np.array([3,5,2])
b = np.array([1,4,7])
print('外積=np.croos(a,b)=', np.cross(a,b))

成果圖示：
程式碼內容

1.張量tensor的定義有兩種

1.張量tensor的定義有兩種
(1)用多維度陣列的數組來做解釋（X)
這些是純粹用陣列數字的方式來解釋張量tensor
但是這不是張量的原始定義

(2).張量是描述幾何geometry坐標的方法

https://www.youtube.com/watch?v=TvxmkZmBa-k
第2：00部分解釋
https://www.youtube.com/watch?v=sNrJ3l6mK3Y
5：00的解釋
https://www.itread01.com/content/1547313962.html

2.python裡面的張量

2.python裡面的張量
# a rank 0 tensor; this is a scalar with shape []
3
# a rank 1 tensor; this is a vector with shape [3]
[1. ,2., 3.]
# a rank 2 tensor; a matrix with shape [2, 3]
[[1., 2., 3.], [4., 5., 6.]]
# a rank 3 tensor with shape [2, 1, 3] 常說的張量就是3階張量
[[[1., 2., 3.]], [[7., 8., 9.]]]

3.張量是矩陣的擴展與延伸

3.張量是矩陣的擴展與延伸
標量：只有大小
向量：有大小和方向
矩陣：由行列兩個向量組成
3階張量：由行列高三個向量組成
n階張量：由N個互相垂直的向量組成

4.Tensor的對像有三個屬性

4.Tensor的對像有三個屬性：
（1）rank：number of dimensions
（2）shape： number of rows and columns
（3）type：data type of tensor's elements

6.張量的階數有時候也稱為維度，或者軸

6.張量的階數有時候也稱為維度，或者軸
譬如一個矩陣[[1,2],[3,4]]，是一個2階張量，有兩個維度或軸，
沿著第0個軸（為了與python的計數方式一致）你看到的是[1,2]，[3,4]兩個向量，
沿著第1個軸你看到的是[1,3]，[2,4]兩個向量。

範例7-1：張量tensor

7.範例7-1：下面的程式碼可以幫助理解張量tensor“沿着某個軸”是什麼意思
import numpy as np
a = np.array([[1,2],[3,4]])
sum0 = np.sum(a, axis=0)
sum1 = np.sum(a, axis=1)
print('矩陣a=\n', a)
#2 階張量，有兩個維度或軸，沿著第 0 個軸= [1,2]、[3,4] 兩個向量
print('2 階張量，有兩個維度或軸，沿著第0個軸==', a[0,:],a[1,:])
print('2 階張量，有兩個維度或軸，沿著第1個軸==', a[:,0],a[:,1])
#2 階張量，有兩個維度或軸，沿著第 0 個軸= [1,2]、[3,4] 兩個向量
print('2 階張量，有兩個維度或軸，沿著第 0 個軸，總和=', sum0)
#2 階張量，有兩個維度或軸，沿著第 1 個軸= [1,3]、[2,4] 兩個向量
print('2 階張量，有兩個維度或軸，沿著第 1 個軸，總和=', sum1)

成果圖示：
程式碼內容

8.python裡面的張量tensor，向量vector，純量scalar

8.python裡面的張量tensor，向量vector，純量scalar
(1).定義：python裡面的張量tensor，向量vector，純量scalar，是根據多維陣列的數組型態來定義的。
這些定義只是方便python的計算方便，但並不是張量的原始物理意義。
張量的原始物理意義：乃是在線性代數(linear algebra)描述不同坐標系統的某個幾何物體的方式，

(2)從陣列的數組角度來定義
圖示：
圖示：

範例7-2：python裡面的張量tensor，向量vector，純量scalar

9.範例7-2：python裡面的張量tensor，向量vector，純量scalar
import numpy as np
#1- 純量scalar (rank=0)
a1 = 5
print('純量scalar=', a1)

#2-python 向量vector（rank=1）
a2 = [1,5,7]
print('python向量vector(不適合做矩陣運算)=', a2)

#3-numpy向量vector（rank=1）
a3 = np.array([5,6,7])
print('numpy向量vector(適合做矩陣運算)=', a3)

#4-nump矩陣Matrix（rank=2）
a4 = np.array([[5,6,7],[2,8,9]])
print('nump矩陣Matrix（rank=2）=\n', a4)

#5-nump張量tensor（rank=3）
a5 = np.array([[[5,6,7],[2,8,9]],[[15,16,17],[12,18,19]]])
print('nump張量tensor（rank=3）=\n', a5)

成果圖示：
程式碼內容

1.rank：numpy與sympy指令的優比較

1.rank：numpy與sympy指令的優比較
（1）sympy模組
■rank指令：A.rank()
■範例：
from sympy import *
A = Matrix([
[1,2,3],
[-4,5,6],
[7,-8,9],
])
A_rank = rank()
print("A的rank=", A_rank)


（2）numpy模組
■rank指令：np.linalg.matrix_rank(A)
■範例：
import numpy as np
A = np.array([
[1,2,3],
[-4,5,6],
[7,-8,9],
])
A_rank = np.linalg.matrix_rank(A)
print("A的rank=", A_rank)

2.範例8-1：求矩陣的rank

2.範例8-1：求矩陣的rank
#線性代數的rank=秩
#注意：在 Numpy 中的秩和線性代數里的秩是不同的概念。在NumPy中維度（dimensions）叫做軸（axes）
#矩陣A的維度=', A.shape
#矩陣A的變數n數目=', A.shape[1]
import numpy as np
A = np.array([
[-1,2,0,4,5,-3],
[3,-7,2,0,1,4],
[2,-5,2,4,6,1],
[4,-9,2,-4,-4,7]
])
rankA = np.linalg.matrix_rank(A)
print('矩陣A的rank=',rankA)
print('矩陣A的維度=',A.ndim)
print('矩陣A的維度=', A.shape)
print('矩陣A的變數n數目=', A.shape[1])

成果圖示：
程式碼內容

範例8-2：求矩陣的跡tracer

2.範例8-2：求矩陣的跡tracer
#跡tracer=對角線值相乘指令=np.trace(A)
import numpy as np
A = np.array([
[-1,2,7,0],
[3,5,-8,4],
[1,2,7,-3],
[4,-2,1,0]
])
print('A的跡tracer=',np.trace(A))

成果圖示：
程式碼內容

範例8-3：用sympy求矩陣的rank

3.範例8-3：用sympy求矩陣的rank
#線性代數的rank=秩 = A.rank()
#矩陣A的變數n數目=', A.shape[1]
from sympy import *
A = Matrix([
[-1,2,0,4,5,-3],
[3,-7,2,0,1,4],
[2,-5,2,4,6,1],
[4,-9,2,-4,-4,7]
])
rankA = A.rank()
print('矩陣A的rank=',rankA)
print('矩陣A的變數n數目=', A.shape[1])

成果圖示：
程式碼內容

1.判別向量之間是線性獨立，或線性相依的方法，有3種

1.判別向量之間是線性獨立，或線性相依的方法，有3種：

證明向量v1=(1,2,1),v2=(2,9,0)和v3=(3,3,4)可為 R3 的基底
(1).判別向量是否為線性獨立，方法1：
三個向量必須是線性獨立，
故C1v1+C2v2 +C3v3=0，C除了0外無解
解 C 的聯立方程式。
若存在c向量合成𝟎（C有解），則線性相依
若不存在C向量合成𝟎（C無解），則線性獨立

(2).判別向量是否為線性獨立，方法2：
先計算系統的輸入變數數量n
再計算系統矩陣的秩rank
若n > rank，則表示系統有降階，表示向量之間有線性相依
若n = rank，則表示full rank，表示系統沒有降階，表示向量之間有線性獨立

(3).方法3：用sympy的化簡成梯形矩陣指令
會傳回線性獨立的行向量index
指令：A_reduced_form, inds = A.rref()
inds = 記錄線性獨立的行向量index（culumn index)
#注意：若是三個向量，就會有三個輸入變數k1,k2,k3
#所以k1的行向量=v1=(1,-2,3)
範例：
from sympy import *
A = Matrix(
[
[1, 5 ,3],
[-2, 6 ,2],
[3, -1 ,1]
])
A_reduced_form, inds = A.rref()
print('簡化後的梯形Am=', A_reduced_form)
n = A.shape[1]
n_independent = len(inds)
if n == n_independent:
print('三個向量彼此線性獨立')
else:
print('三個向量彼此線性相依')

範例9-1：判別幾個向量之間，是線性獨立，或線性相依？

2.範例9-1：判別幾個向量之間，是線性獨立，或線性相依？
#三個向量：v1=(1,–2,3),v2=(5,6,–1),v3=(3,2,1)
#判別向量是否為線性獨立，方法2：
#先計算系統的輸入變數數量n
#再計算系統矩陣的秩rank
#若n > rank，則表示系統有降階，表示向量之間有線性相依
#若n = rank，則表示full rank，表示系統沒有降階，表示向量之間有線性獨立
import numpy as np
A = np.array(
[
[1, -2 ,3],
[5, 6 ,-1],
[3, 2 ,1]
])
#full rank就是linear independence線性獨立
# n =輸入向量數目
n = np.shape(A)[1]
print('A的輸入變數數目m=', n)
A_rank = np.linalg.matrix_rank(A)
print('rank=',A_rank)

if n > A_rank:
print('有降階，表示向量是線性相依')
else:
print('沒有降階，full rank， 表示向量是線性獨立')

成果圖示：
程式碼內容

範例9-2：判別幾個向量之間，是線性獨立，或線性相依？

2.範例9-2：判別幾個向量之間，是線性獨立，或線性相依？
#三個向量：v1=(1,2,2,–1), v2=(4,9,9,–4), v3=(5,8,9,–5)
#判別幾個向量之間，是線性獨立，或線性相依？
import numpy as np
A = np.array(
[
[1, 2 ,2,-1],
[4, 9 ,9,-4],
[5, 8 ,9,-5]
])

#full rank就是linear independence線性獨立
# m =輸入向量數目
m = np.shape(A)[0]
print('A的輸入變數數目m=三個向量，三個k=3=', m)
A_rank = np.linalg.matrix_rank(A)
print('rank=',A_rank)

if m > A_rank:
print('有降階，表示向量是線性相依')
else:
print('沒有降階，full rank， 表示向量是線性獨立')

成果圖示：
程式碼內容

3.範例9-3：判別幾個多項式之間，是線性獨立，或線性相依？
#三個多項式：p1=1-x, p2=5+3x-2x**2, p3=1+3x-x**2
#判別幾個多項式向量之間，是線性獨立，或線性相依？
#三個向量：v1=(1,–1,0),v2=(5,3,–2),v3=(1,3,-1)
import numpy as np
A = np.array(
[
[1, -1 ,0],
[5, 3 ,-2],
[1, 3 ,-1]
])

#full rank就是linear independence線性獨立
# n =輸入向量數目
n = np.shape(A)[0]
print('A的輸入變數數目m=', n)
A_rank = np.linalg.matrix_rank(A)
print('rank=',A_rank)

if n > A_rank:
print('有降階，表示向量是線性相依')
else:
print('沒有降階，full rank， 表示向量是線性獨立')

成果圖示：
程式碼內容

4.範例9-4：判別幾個向量之間，是線性獨立，或線性相依？
#三個向量：v1=(1,–2,3),v2=(5,6,–1),v3=(3,2,1)
import numpy as np
A = np.array(
[
[1, 2 ,1],
[2, 9 ,0],
[3, 3 ,4]
])

#full rank就是linear independence線性獨立
# n =輸入向量數目
n = np.shape(A)[0]
print('A的輸入變數數目m=', n)
A_rank = np.linalg.matrix_rank(A)
print('rank=',A_rank)

if n > A_rank:
print('有降階，表示向量是線性相依')
else:
print('沒有降階，full rank， 表示向量是線性獨立')

成果圖示：
程式碼內容

範例9-5：判別幾個多項式之間，是線性獨立，或線性相依？

5.範例9-5：判別幾個多項式之間，是線性獨立，或線性相依？
#三個多項式：p1=1-x**2, p2=2-x**2, p3=x**3
#判別幾個多項式向量之間，是線性獨立，或線性相依？
#三個向量：v1=(1,0,–1,0),v2=(2,0,-1,0),v3=(0,0,0,1)
import numpy as np
A = np.array(
[
[1, 0 ,-1,0],
[2, 0 ,-1,0],
[0, 0 ,0,1]
])
#full rank就是linear independence線性獨立
# m =輸入向量數目
m = np.shape(A)[0]
print('A的輸入變數數目m=三個多項式=', m)
A_rank = np.linalg.matrix_rank(A)
print('rank=',A_rank)

if m > A_rank:
print('有降階，表示向量是線性相依')
else:
print('沒有降階，full rank， 表示多項式向量是線性獨立')

成果圖示：
程式碼內容

6.範例9-6：判別幾個向量可否成為R2的基底向量？
#二個向量：v1=(–3,7),v2=(5,5)
#判別向量之間，是線性獨立，或線性相依？

import numpy as np
A = np.array(
[
[-3, 7],
[5,5]
])

#full rank就是linear independence線性獨立
# n =輸入向量數目
n = np.shape(A)[0]
print('A的輸入變數數目m=', n)
A_rank = np.linalg.matrix_rank(A)
print('rank=',A_rank)

if n > A_rank:
print('有降階，表示向量是線性相依')
else:
print('沒有降階，full rank， 表示向量是線性獨立')

成果圖示：
程式碼內容

範例9-7：判別幾個向量可否成為R2的基底向量？

7.範例9-7：判別幾個向量可否成為R2的基底向量？
#二個向量：v1=(2,0,-1),v2=(4,0,7),v3=(-1,1,4)
#注意：因為三個向量，所以三個輸入變數k1,k2,k3
#判別向量之間，是線性獨立，或線性相依？

import numpy as np
A = np.array(
[
[2, 0 ,-1],
[2, 0 ,7],
[-1,1 ,4]
])

#full rank就是linear independence線性獨立
# n =輸入向量數目
n = np.shape(A)[0]
print('A的輸入變數數目m=', n)
A_rank = np.linalg.matrix_rank(A)
print('rank=',A_rank)

if n > A_rank:
print('有降階，表示向量是線性相依')
else:
print('沒有降階，full rank， 表示向量是線性獨立')

成果圖示：
程式碼內容

範例9-8：用sympy判別三個向量之間，是線性獨立，或線性相依？

8.範例9-8：用sympy判別三個向量之間，是線性獨立，或線性相依？
#三個向量：v1=(1,–2,3),v2=(5,6,–1),v3=(3,2,1)
#注意：因為三個向量，所以三個輸入變數k1,k2,k3
#所以k1的行向量=v1=(1,-2,3)
#判別向量是否為線性獨立，方法3：A_reduced_form, inds = A.rref()
#inds = 記錄線性獨立的行向量index（culumn index)
from sympy import *
A = Matrix(
[
[1, 5 ,3],
[-2, 6 ,2],
[3, -1 ,1]
])
A_reduced_form, inds = A.rref()
print('簡化後的梯形Am=', A_reduced_form)
n = A.shape[1]
n_independent = len(inds)
if n == n_independent:
print('三個向量彼此線性獨立')
else:
print('三個向量彼此線性相依')

print('彼此線性獨立的行數m=', inds)
c1 = inds[0]
c2 = inds[1]
print('印出線性獨立的向量=', A[:,c1])
print('印出線性獨立的向量=', A[:,c2])

成果圖示：
程式碼內容

範例9-9：用sympy判別三個向量之間，是線性獨立，或線性相依？

9.範例9-9：用sympy判別三個向量之間，是線性獨立，或線性相依？
#三個向量：v1=(1,2,–2,-1),v2=(4,9,9,–4),v3=(5,8,9,-5)
#注意：因為三個向量，所以三個輸入變數k1,k2,k3
#所以k1的行向量=v1=(1,2,–2,-1)
#判別向量是否為線性獨立，方法3：A_reduced_form, inds = A.rref()
#inds = 記錄線性獨立的行向量index（culumn index)
from sympy import *
A = Matrix(
[
[1, 4 ,8],
[2, 9 ,8],
[-2, 9 ,9],
[-1, -4 ,-5]
])
A_reduced_form, inds = A.rref()
print('簡化後的梯形Am=', A_reduced_form)
n = A.shape[1]
n_independent = len(inds)
if n == n_independent:
print('三個向量彼此線性獨立')
else:
print('三個向量彼此線性相依')

print('彼此線性獨立的行數m=', inds)
c1 = inds[0]
c2 = inds[1]
c3 = inds[2]
print('印出線性獨立的向量=', A[:,c1])
print('印出線性獨立的向量=', A[:,c2])
print('印出線性獨立的向量=', A[:,c3])

成果圖示：
程式碼內容

範例9-10：用sympy判別三個多項式向量之間，是線性獨立，或線性相依？

10.範例9-10：用sympy判別三個多項式向量之間，是線性獨立，或線性相依？
#三個多項式：p1=1-x, p2=5+3x-2x^2, p3=1+3x-x^2
#注意：因為三個多項式向量，所以三個輸入變數k1,k2,k3
#所以k1的行向量=v2=(5,3,–2)
#v1=(1,–1,0),v2=(5,3,–2),v3=(1,3,–1)
#判別向量是否為線性獨立，方法3：A_reduced_form, inds = A.rref()
#inds = 記錄線性獨立的行向量index（culumn index)
from sympy import *
A = Matrix(
[
[1, 5 ,1],
[-1, 3 ,3],
[0, -2,-1]
])
A_reduced_form, inds = A.rref()
print('簡化後的梯形Am=', A_reduced_form)
n = A.shape[1]
n_independent = len(inds)
if n == n_independent:
print('三個向量彼此線性獨立')
else:
print('三個向量彼此線性相依')

print('彼此線性獨立的行數m=', inds)
c1 = inds[0]
c2 = inds[1]
print('印出線性獨立的向量=', A[:,c1])
print('印出線性獨立的向量=', A[:,c2])

成果圖示：
程式碼內容

1.建立特徵向量，numpy與sympy指令的優比較

1.建立特徵向量，numpy與sympy指令的優比較
（1）sympy模組
■特徵向量指令：M.eigenvects()
■特徵值指令：M.eigenvals()
■範例：
from sympy import *
A = Matrix([
[3,0],
[8,-1]
])
eigval = A.eigenvals()
eigvec = A.eigenvects()
print('特徵值=', eigval)
print('特徵向量=', eigvec)
print('第一個特徵值=', eigvec[0][0],'第一個特徵向量=',eigvec[0][2])
print('第二個特徵值=', eigvec[1][0],'第二個特徵向量=',eigvec[1][2])


（2）numpy模組
■numpy計算特徵值指令：numpy.linalg.eig
(1).numpy.linalg.eigvals方法：求解一個方陣的特徵值
(2).numpy.linalg.eig 方法：求解方阵的特征值和特征向量
■範例：
import numpy as np
A = np.array([
[3,0],
[8,-1]
])
eigval = np.linalg.eigvals(A)
eigvec = np.linalg.eig(A)
print('特徵值=', eigval)
print('特徵向量=', eigvec)
print('特徵值=', eigvec[0])
print('特徵向量=', eigvec[1])
print('第1個特徵值=', eigval[0],'第1個特徵向量=',eigvec[1][:,0])
print('第2個特徵值=', eigval[1],'第2個特徵向量=',eigvec[1][:,1]/eigvec[1][:,1][0])

2.特徵向量，特徵值

2.特徵向量，特徵值
A𝒗 =λ𝒗 ⃑
𝒗：特徵向量，Eigenvectors
λ：特徵值，Eigenvalues
(1).A𝒗 ⃑轉換後的向量p = 原本的向量𝒗 的縮放λ倍
(2).也就是v經過A轉換後的向量，就是v它自己，只是縮放λ倍

範例10-1：計算特徵值，特徵向量

3.範例10-1：計算特徵值，特徵向量
#(1).numpy.linalg.eigvals方法：求解一個方陣的特徵值
#(2).numpy.linalg.eig 方法：求解方阵的特徵值和特徵向量
import numpy as np
A = np.array([
[3,0],
[8,-1]
])
eigval = np.linalg.eigvals(A)
eigvec = np.linalg.eig(A)
print('特徵值=', eigval)
print('特徵向量=', eigvec)
print('特徵值=', eigvec[0])
print('特徵向量=', eigvec[1])
print('第1個特徵值=', eigval[0],'第1個特徵向量=',eigvec[1][:,0])
print('第2個特徵值=', eigval[1],'第2個特徵向量=',eigvec[1][:,1]/eigvec[1][:,1][0])

成果圖示：
程式碼內容

範例10-2：計算特徵值，特徵向量

4.範例10-2：計算特徵值，特徵向量
#(1).numpy.linalg.eigvals方法：求解一個方陣的特徵值
#(2).numpy.linalg.eig 方法：求解方阵的特徵值和特徵向量
import numpy as np
A = np.array([
[3,1],
[0,2]
])
eigval = np.linalg.eigvals(A)
eigvec = np.linalg.eig(A)
print('特徵值=', eigval)
print('特徵向量=', eigvec)
print('特徵值=', eigvec[0])
print('特徵向量=', eigvec[1])
print('第1個特徵值=', eigval[0],'第1個特徵向量=',eigvec[1][:,0])
print('第2個特徵值=', eigval[1],'第2個特徵向量=',eigvec[1][:,1]/eigvec[1][:,1][0])

成果圖示：
程式碼內容

範例10-3：計算3x3矩陣的特徵值，特徵向量

5.範例10-3：計算3x3矩陣的特徵值，特徵向量
#(1).numpy.linalg.eigvals方法：求解一個方陣的特徵值
#(2).numpy.linalg.eig 方法：求解方阵的特徵值和特徵向量
import numpy as np
A = np.array([
[0,1,0],
[0,0,1],
[4,-17,8]
])
eigval = np.linalg.eigvals(A)
eigvec = np.linalg.eig(A)
print('特徵值=', eigval)
print('特徵向量=', eigvec)
print('特徵值=', eigvec[0])
print('特徵向量=', eigvec[1])
print('第1個特徵值=', eigval[0],'第1個特徵向量=',eigvec[1][:,0]/eigvec[1][:,0][0])
print('第2個特徵值=', eigval[1],'第2個特徵向量=',eigvec[1][:,1]/eigvec[1][:,1][0])
print('第3個特徵值=', eigval[2],'第3個特徵向量=',eigvec[1][:,2]/eigvec[1][:,2][0])

成果圖示：
程式碼內容

範例10-4：計算特特徵空間的結構（基底向量）

6.範例10-4：計算特特徵空間的結構（基底向量）
#(1).numpy.linalg.eigvals方法：求解一個方陣的特徵值
#(2).numpy.linalg.eig 方法：求解方阵的特徵值和特徵向量
import numpy as np
A = np.array([
[0,0,-2],
[1,2,1],
[1,0,3]
])
eigval = np.linalg.eigvals(A)
eigvec = np.linalg.eig(A)
print('特徵值=', eigval)
print('特徵向量=', eigvec)
print('特徵值=', eigvec[0])
print('特徵向量=', eigvec[1])
print('第1個特徵值=', eigval[0],'第1個特徵向量=',eigvec[1][:,0])
print('第2個特徵值=', eigval[1],'第2個特徵向量=',eigvec[1][:,1]/eigvec[1][:,1][0])
print('第3個特徵值=', eigval[2],'第3個特徵向量=',eigvec[1][:,2]/eigvec[1][:,2][0])

成果圖示：
程式碼內容

範例10-5：計算特特徵空間的結構（基底向量）

7.範例10-5：計算特特徵空間的結構（基底向量）
#(1).numpy.linalg.eigvals方法：求解一個方陣的特徵值
#(2).numpy.linalg.eig 方法：求解方阵的特徵值和特徵向量
import numpy as np
A = np.array([
[2,1,0],
[0,2,0],
[0,0,2]
])
#eigval = np.linalg.eigvals(A)
eigval, eigvec = np.linalg.eig(A)
print('特徵值=', eigval)
print('特徵向量=', eigvec)
print('第1個特徵值=', eigval[0],'第1個特徵向量=',eigvec[:,0])
print('第2個特徵值=', eigval[1],'第2個特徵向量=',(eigvec[:,1]/eigvec[:,1][0]).round())
print('第3個特徵值=', eigval[2],'第3個特徵向量=',eigvec[:,2])

成果圖示：
程式碼內容

範例10-6：計算特特徵空間的結構（基底向量）

8.範例10-6：計算特特徵空間的結構（基底向量）
#(1).numpy.linalg.eigvals方法：求解一個方陣的特徵值
#(2).numpy.linalg.eig 方法：求解方阵的特徵值和特徵向量
import numpy as np
A = np.array([
[5,4,2],
[4,5,2],
[2,2,2]
])
#eigval = np.linalg.eigvals(A)
eigval, eigvec = np.linalg.eig(A)
print('特徵值=', eigval)
print('特徵向量=', eigvec)
print('第1個特徵值=', eigval[0],'第1個特徵向量=',eigvec[:,0]/eigvec[:,0][0])
print('第2個特徵值=', eigval[1],'第2個特徵向量=',eigvec[:,1]/eigvec[:,1][0])
print('第3個特徵值=', eigval[2],'第3個特徵向量=',eigvec[:,2]/eigvec[:,2][1])

成果圖示：
程式碼內容

範例10-7：計算A的13次方

9.範例10-7：計算A的13次方
#(1).A的 n次方：np.linalg.matrix_power(A,n)
#(2).A的 3次方= A @ A @ A
import numpy as np
A = np.array([
[0,0,-2],
[1,2,1],
[1,0,3]
])
A_power = np.linalg.matrix_power(A,13)
print('A的 13次方=\n',A_power)
print('A的 3次方=\n',A @ A @ A)

成果圖示：
程式碼內容

範例10-8：用sympy計算特徵值，特徵向量

10.範例10-8：用sympy計算特徵值，特徵向量
#■特徵向量指令：M.eigenvects()
#■特徵值指令：M.eigenvals()
from sympy import *
A = Matrix([
[3,0],
[8,-1]
])
eigval = A.eigenvals()
eigvec = A.eigenvects()
print('特徵值=', eigval)
print('特徵向量=', eigvec)
print('第一個特徵值=', eigvec[0][0],'第一個特徵向量=',eigvec[0][2])
print('第二個特徵值=', eigvec[1][0],'第二個特徵向量=',eigvec[1][2])

成果圖示：
程式碼內容

1.傅立葉級數的應用

1.線性轉換=線性映射
公式：W=TA x= [T]x = 0

範例11-1：求 x=(1,1)逆時針旋轉30°的像

2.範例11-1：求 x=(1,1)逆時針旋轉30°的像
#[T]標準矩陣=[■8(𝒄𝒐𝒔(𝜽)&−𝒔𝒊𝒏(𝜽)@𝒔𝒊𝒏(𝜽)&𝒄𝒐𝒔(𝜽))]=
# π = np.pi
# cos() = np.cos()
#np.degrees(x)： 傳回弧度 x 的角度 (degree)
#np.radians(x)： 傳回角度 x 的弧度 (radian)
#numpy.deg2rad(x)：度轉換為弧度。
#numpy.rad2deg(x)：弧度轉換為度。
import numpy as np
rad = np.radians(30)
T1 = np.array([
[np.cos(rad), -np.sin(rad)],
[np.sin(rad), np.cos(rad)]
])
x = np.array([
[1],
[1]
])
y = T1 @ x
print('旋轉後的像=\n', y)

成果圖示：
程式碼內容

範例11-2：求 x=(2,3)，以原點逆時針旋轉90°，再施加水平向1剪力變換shear的像

3.範例11-2：求 x=(2,3)，以原點逆時針旋轉90°，再施加水平向1剪力變換shear的像
import numpy as np
rad = np.radians(90)
T1 = np.array([
[np.cos(rad),-np.sin(rad)],
[np.sin(rad),np.cos(rad)]
])
T2 = np.array([
[1, 1],
[0, 1]
])
x = np.array([
[2],[3]
])
y = T2 @ T1 @ x
print("兩次座標轉換後的像=\n", y)

成果圖示：
程式碼內容

範例11-3：求點 (3,4,5) 對xz平面鏡射後的像

4.範例11-3：求點 (3,4,5) 對xz平面鏡射後的像
import numpy as np
T1 = np.array([
[1,0,0],
[0,-1,0],
[0,0,1]
])
x = np.array([
[3],[4],[5]
])

y = T1 @ x
print("對xz平面鏡射後的像\n", y)

成果圖示：
程式碼內容

範例11-4：求點(-3,1)對x軸的正交投影

5.範例11-4：求點(-3,1)對x軸的正交投影
import numpy as np
T1 = np.array([
[1,0],
[0,0]
])
x = np.array([
[-3],[1]
])
y = T1 @ x
print('對x軸的正交投影=\n', y)

成果圖示：
程式碼內容

範例11-5：求點(-2,1,2)，以y軸為中心旋轉45°旋轉後的像

6.範例11-5：求點(-2,1,2)，以y軸為中心旋轉45°旋轉後的像
import numpy as np
rad = np.radians(45)
T1 = np.array([
[np.cos(rad),0,np.sin(rad)],
[0,1,0],
[-np.sin(rad), 0, np.cos(rad)]
])
x = np.array([
[-2],[1],[2]
])
y = T1 @ x
print('以y軸為中心旋轉45°旋轉後的像=\n', y)

成果圖示：
程式碼內容

1.python的sympy模組才有提供把矩陣簡化為echelon form梯形矩陣

1.python的sympy模組才有提供把矩陣簡化為echelon form梯形矩陣
有兩種指令與方法
(1).指令：M.echelon_form()
from sympy import *
M = Matrix([
[1,1,2,9],
[2,4,-3,1],
[3,6,-5,0]
])
print('echelon form =\n', M.echelon_form())

(2).指令：
from sympy import *
M = Matrix([
[1,1,2,9],
[2,4,-3,1],
[3,6,-5,0]
])
print('echelon form =\n', M.rref())

(3).numpy模組沒有類似的指令

2.sympy的線性代數指令

2.sympy的線性代數指令
https://docs.sympy.org/latest/tutorial/matrices.html
sympy線性代數完整教學：
http://www.cfm.brown.edu/people/dobrush/cs52/sympy/

3.範例12-1：高斯喬丹消去法最後化簡的梯形矩陣

3.範例12-1：高斯喬丹消去法最後化簡的梯形矩陣
#指令：M.rref()
from sympy import *
M = Matrix([
[1,1,2,9],
[2,4,-3,1],
[3,6,-5,0]
])
M_echelon = M.echelon_form()
print('簡化的梯形矩陣的echelon form =\n', M_echelon)
M_simple = M.rref()
print('簡化的梯形矩陣的echelon form =\n', M_simple)
print(M_simple[0].col(0))
print(M_simple[0].col(1))
print(M_simple[0].col(2))

成果圖示：
程式碼內容

範例12-2：高斯喬丹消去法最後化簡的梯形矩陣

4.範例12-2：高斯喬丹消去法最後化簡的梯形矩陣
#指令：M.rref()
#3x+y=1
#X+2y=0

from sympy import *
M = Matrix([
[3,1,1],
[1,2,0]
])
M_simple = M.rref()
print('簡化的梯形矩陣的echelon form =\n', M_simple)

成果圖示：
程式碼內容

範例12-3：高斯喬丹消去法最後化簡的梯形矩陣

5.範例12-3：高斯喬丹消去法最後化簡的梯形矩陣
#指令：M.rref()
from sympy import *
M = Matrix([
[1,3,-2,0,2,0,0],
[2,6,-5,-2,4,-3,-1],
[0,0,5,10,0,15,5],
[2,6,0,8,4,18,6]
])
M_simple = M.rref()
print('簡化的梯形矩陣的echelon form =\n', M_simple)

成果圖示：
程式碼內容

範例12-4：高斯喬丹消去法最後化簡的梯形矩陣

6.範例12-4：高斯喬丹消去法最後化簡的梯形矩陣
#指令：M.rref()
from sympy import *
M = Matrix([
[1,2,-3,6],
[2,-1,4,1],
[1,-1,1,3]
])
M_simple = M.rref()
print('簡化的梯形矩陣的echelon form =\n', M_simple)

成果圖示：
程式碼內容

範例12-5：高斯喬丹消去法最後化簡的梯形矩陣

7.範例12-5：高斯喬丹消去法最後化簡的梯形矩陣
#指令：M.rref()
from sympy import *
M = Matrix([
[-1,1,2,2],
[3,-1,1,6],
[-1,3,4,4]
])
M_simple = M.rref()
print('簡化的梯形矩陣的echelon form =\n', M_simple)

成果圖示：
程式碼內容

1.只有sympy可以解出核空間（null space)

1.只有sympy可以解出核空間（null space)
核空間向量集合 = null space = M.nullspace()
輸入空間維度 = input dimension of M= M.shape[1]
輸出空間維度 = rank(M) = M.rank()
核空間維度 = 被轉換壓縮的空間維度 = nullity =M.shape[1] - M.rank()
前的日期

2.範例13-1：像空間，核空間，rank，nullity

2.範例13-1：像空間，核空間，rank，nullity
from sympy import *
M = Matrix([
[3,1],
[1,2]
])
M_nullsapce = M.nullspace()
M_columnspace = M.columnspace()
M_rank = M.rank()
M_dim = M.shape[1]
M_nullity = M_dim - M_rank
print('線性轉換後有壓縮空間 = 核空間向量集合 = null space=\n', M_nullsapce)
print('輸出空間的向量之線性組和= column space= \n', M_columnspace)
print('輸入空間維度 = input dimension of M=', M_dim)
print('輸出空間維度 = rank(M)=', M_rank)
print('核空間維度 = 被轉換壓縮的空間維度 = nullity=', M_nullity)

成果圖示：
程式碼內容

3.範例13-2：像空間，核空間，rank，nullity

3.範例13-2：像空間，核空間，rank，nullity
from sympy import *
M = Matrix([
[3,6],
[1,2]
])
M_nullsapce = M.nullspace()
M_columnspace = M.columnspace()
M_rank = M.rank()
M_dim = M.shape[1]
M_nullity = M_dim - M_rank
print('線性轉換後有壓縮空間 = 核空間向量集合 = null space=\n', M_nullsapce)
print('輸出空間的向量之線性組和= column space= \n', M_columnspace)
print('輸入空間維度 = input dimension of M=', M_dim)
print('輸出空間維度 = rank(M)=', M_rank)
print('核空間維度 = 被轉換壓縮的空間維度 = nullity=', M_nullity)

成果圖示：
程式碼內容

4.範例13-3：像空間，核空間，rank，nullity

4.範例13-3：像空間，核空間，rank，nullity
from sympy import *
M = Matrix([
[1,0],
[0,1],
[0,0]
])
M_nullsapce = M.nullspace()
M_columnspace = M.columnspace()
M_rank = M.rank()
M_dim = M.shape[1]
M_nullity = M_dim - M_rank
print('線性轉換後有壓縮空間 = 核空間向量集合 = null space=\n', M_nullsapce)
print('輸出空間的向量之線性組和= column space= \n', M_columnspace)
print('輸入空間維度 = input dimension of M=', M_dim)
print('輸出空間維度 = rank(M)=', M_rank)
print('核空間維度 = 被轉換壓縮的空間維度 = nullity=', M_nullity)

成果圖示：
程式碼內容

範例13-4:傳回自1970年1月1日凌晨0：0：0開始至今的秒數

5.範例13-4：像空間，核空間，rank，nullity
from sympy import *
M = Matrix([
[1,0,3,1],
[0,1,1,2]
])
M_nullsapce = M.nullspace()
M_columnspace = M.columnspace()
M_rank = M.rank()
M_dim = M.shape[1]
M_nullity = M_dim - M_rank
print('線性轉換後有壓縮空間 = 核空間向量集合 = null space=\n', M_nullsapce)
print('輸出空間的向量之線性組和= column space= \n', M_columnspace)
print('輸入空間維度 = input dimension of M=', M_dim)
print('輸出空間維度 = rank(M)=', M_rank)
print('核空間維度 = 被轉換壓縮的空間維度 = nullity=', M_nullity)

成果圖示：
程式碼內容

1.線性系統有無限多組解的通解=特解＋齊次解

1.線性系統有無限多組解的通解=特解＋齊次解
(1).線性系統有無限多組解的完整解(通解)
= 系統特解＋齊次解
= x0常數項 ＋ 壓縮後降階的解空間
=(Xx=0)的降階核空間之解，平移x0係數

(2).特解：Ax = b
x0 為線性系統 Ax = b 之特解
☎指令：

(3).齊次解：Ax = 0
W 為滿足齊次系統 Ax = 0的齊次解集合
☎指令：M.nullspace()

(4).矩陣A的線性系統的完整解(通解）= x0 + W

2.求解線性系統，numpy與sympy指令的優缺點

2.求解線性系統，numpy與sympy指令的優缺點
（1）sympy模組
指令：solve_linear_system(M, x1,x2)
注意：M矩陣的最右邊=y=轉換後座標
from sympy import *
x1,x2 = symbols('x1 x2')
M = Matrix([
[1,1,4],
[3,3,6]
])
ans = solve_linear_system(M, x1,x2)
優點1：可以自動處理唯一解，無解，無限多就解，不需要人工再去判別處理
優點2：無解，則自動顯示None
優點3：無限多解，則自動顯示通解（帶有x變數的通解）

（2）numpy模組
指令：np.linalg.solve(A, Y)
import numpy as np
A = np.array([
[4,-2],
[16,-8]
])
Y = np.array([
[1],[4]
])
X = np.linalg.solve(A, Y)

缺點1：只能處理唯一解，無法自動處理無解，無限多就解，需要人工再去判別處理
缺點2：若是無解，程式會出現錯誤訊息
缺點3：若是無限多組解，程式會出現錯誤訊息
缺點4：必須用行列式det(M)，或是rank（M)，人工方式判別分類，來處理『唯一解，無解，無限多解』

（3）結論：若要解線性系統，只能用sympy來求解
不要用numpy模組求解，因為無法處理『無解，無限多組的通解』

3.計算矩陣的解空間的基底

3.計算矩陣的解空間的基底
有兩種：
(1).計算矩陣的『列』空間或行空間的基底
☎指令： M.nullspace()

(2).計算矩陣的『行』空間或行空間的基底
☎指令：M.columnspace()

範例14-1：求線性系統的解(比較sympy模組，numpy模組的解法)

4.範例14-1：求線性系統的解(比較sympy模組，numpy模組的解法)
# -1x1+3x2+2x3 = 1
# x1+2x2-3x3 = -9
# 2x1+1x2-2x3 = -3
from sympy import *
x1,x2,x3 = symbols('x1 x2 x3')
M = Matrix([
[-1,3,2,1],
[1,2,-3,-9],
[2,1,-2,-3]
])

ans = solve_linear_system(M, x1, x2, x3)
print('用sympy解聯立方程式 = ', ans)

import numpy as np
A = np.array([
[-1,3,2],
[1,2,-3],
[2,1,-2]
])
Y = np.array([
[1],[-9],[-3]
])
X = np.linalg.solve(A, Y)
print('用numpy解聯立方程式，X=\n', X)


成果圖示：
程式碼內容

範例14-2：無限多解系統的通解（齊次特解x0+非齊次解xh）

5.範例14-2：無限多解系統的通解（齊次特解x0+非齊次解xh）
#比較sympy模組，numpy模組的解法)
#（1）sympy求解
from sympy import *
x1,x2,x3,x4,x5,x6 = symbols('x1 x2 x3 x4 x5 x6')
#注意：M矩陣的最右邊=y=轉換後座標
M = Matrix([
[1,3,-2,0,2,0,0],
[2,6,-5,-2,4,-3,-1],
[0,0,5,10,0,15,5],
[2,6,0,8,4,18,6]
])
M_simple = M.rref()

print('顯示高斯消去法簡化的梯形矩陣的echelon form =\n', M_simple)
ans = solve_linear_system(M, x1,x2,x3,x4,x5,x6)
print('用sympy解聯立方程式 = ', ans)

M = Matrix([
[1,3,-2,0,2,0],
[2,6,-5,-2,4,-3],
[0,0,5,10,0,15],
[2,6,0,8,4,18]
])
M_rank = M.rank()
M_dim = M.shape[1]
M_nullity = M_dim - M_rank

print('輸入空間維度 = input dimension of M=', M_dim)
print('輸出空間維度 = rank(M)=', M_rank)
print('核空間維度 = 被轉換壓縮的空間維度 = nullity=', M_nullity)
M_nullsapce = M.nullspace()
print('線性轉換後有壓縮空間 = 核空間向量集合 = null space=\n', M_nullsapce)

#（2）numpy求解
import numpy as np
A = np.array([
[1,3,-2,0,2,0],
[2,6,-5,-2,4,-3],
[0,0,5,10,0,15],
[2,6,0,8,4,18]
])
Y = np.array([
[0],[-1],[5],[6]
])
print('用numpy解聯立方程式，X=（無法處理無限多組解）')
X = np.linalg.solve(A, Y)
print(X)

結論：
（1）可以發現，無限多組解的通解=齊次項通解（(Ax=0)的null space)＋常數項係數x0)
（2）常數項係數x0的算法有兩種：
1.高斯消去法，最後得到的常數值（例如，本題為x6=1/3)
2.null sapce的通解(Ax=0)裡面的所有變數=0代入後的值（本題目為x1~x5=0)

成果圖示：
程式碼內容

範例14-3：求矩陣核空間的基底

6.範例14-3：求矩陣核空間的基底
#（1）sympy求解
from sympy import *
M = Matrix([
[1,3,-2,0,2,0],
[2,6,-5,-2,4,-3],
[0,0,5,10,0,15],
[2,6,0,8,4,18]
])
M_simple = M.rref()
print('顯示高斯消去法簡化的梯形矩陣的echelon form =\n', M_simple)
M_rank = M.rank()
M_dim = M.shape[1]
M_nullity = M_dim - M_rank

print('輸入空間維度 = input dimension of M=', M_dim)
print('輸出空間維度 = rank(M)=', M_rank)
print('核空間維度 = 被轉換壓縮的空間維度 = nullity=', M_nullity)
M_nullsapce = M.nullspace()
M_columnspace = M.columnspace()
print('線性轉換後有壓縮空間 = 核空間向量集合 = null space=\n', M_nullsapce)
print('輸出行空間的向量之線性組和= column space= \n', M_columnspace)

成果圖示：
程式碼內容

範例14-4：求矩陣核空間的基底

7.範例14-4：求矩陣核空間的基底
#（1）sympy求解
from sympy import *
M = Matrix([
[1,-2,5,0,3],
[0,1,3,0,0],
[0,0,0,1,3],
[0,0,0,0,0]
])
M_simple = M.rref()
print('顯示高斯消去法簡化的梯形矩陣的echelon form =\n', M_simple)
M_rowspace = M.rowspace()
M_columnspace = M.columnspace()
print('輸出列空間的向量之線性組和= row space= \n', M_rowspace)
print('輸出行空間的向量之線性組和= column space= \n', M_columnspace)

M_rank = M.rank()
M_dim = M.shape[1]
M_nullity = M_dim - M_rank
print('輸入空間維度 = input dimension of M=', M_dim)
print('輸出空間維度 = rank(M)=', M_rank)
print('核空間維度 = 被轉換壓縮的空間維度 = nullity=', M_nullity)
M_nullsapce = M.nullspace()
print('線性轉換後有壓縮空間 = 核空間向量集合 = null space=\n', M_nullsapce)

成果圖示：
程式碼內容

範例14-5：求矩陣列空間的基底

8.範例14-5：求矩陣列空間的基底
from sympy import *
M = Matrix([
[1,-3,4,-2,5,4],
[2,-6,9,-1,8,2],
[2,-6,9,-1,9,7],
[-1,3,-4,2,-5,-4]
])
M_simple = M.rref()
print('顯示高斯消去法簡化的梯形矩陣的echelon form =\n', M_simple)
M_rowspace = M.rowspace()
M_columnspace = M.columnspace()
print('輸出列空間的向量之線性組和= row space= \n', M_rowspace)
print('輸出行空間的向量之線性組和= column space= \n', M_columnspace)

成果圖示：
程式碼內容

範例14-6：求四個列向量所生產列空間的基底

9.範例14-6：求四個列向量所生產列空間的基底
from sympy import *
# v1=(1,-2,0,0,3)
# v2=(2,-5,-3,-2,6)
# v3=(0,5,15,10,0)
# v4=(2,6,18,8,6)
M = Matrix([
[1,-2,0,0,3],
[2,-5,-3,-2,6],
[0,5,15,10,0],
[2,6,18,8,6]
])
M_simple = M.rref()
print('顯示高斯消去法簡化的梯形矩陣的echelon form =\n', M_simple)
M_rowspace = M.rowspace()
M_columnspace = M.columnspace()
print('輸出列空間的向量之線性組和= row space= \n', M_rowspace)
print('輸出行空間的向量之線性組和= column space= \n', M_columnspace)

成果圖示：
程式碼內容

範例14-7：求四個『行向量』所生產行空間的基底

10.範例14-7：求四個『行向量』所生產行空間的基底
from sympy import *
# v1=(1,-2,0,3)
# v2=(2,-5,-3,6)
# v3=(0,1,3,0)
# v4=(2,-1,4,-7)
# v5=(5,-8,1,2)
M = Matrix([
[1,2,0,2,5],
[-2,-5,1,-1,-8],
[0,-3,3,4,1],
[3,6,0,-7,2]
])
M_simple = M.rref()
print('顯示高斯消去法簡化的梯形矩陣的echelon form =\n', M_simple)
M_rowspace = M.rowspace()
M_columnspace = M.columnspace()
print('輸出列空間的向量之線性組和= row space= \n', M_rowspace)
print('輸出行空間的向量之線性組和= column space= \n', M_columnspace)

成果圖示：
程式碼內容

範例14-8：證明A 的核空間和 A 的列空間彼此正交(垂直)p

11.範例14-8：證明A 的核空間和 A 的列空間彼此正交(垂直)
from sympy import *
M = Matrix([
[1,3,-2,0,2,0],
[2,6,-5,-2,4,-3],
[0,0,5,10,0,15],
[2,6,0,8,4,18]
])
M_nullsapce = M.nullspace()
M_rowspace = M.rowspace()
print('線性轉換後有壓縮空間 = 核空間向量集合 = null space=\n', M_nullsapce)
print('輸出列空間的向量之線性組和= column space= \n', M_rowspace)
n1, n2, n3 = M.nullspace()
r1, r2, r3 = M.rowspace()
print('n1 = ', n1)
print('r1 = ', r1)
print('n1.dot(r1)=核空間和列空間彼此正交(內積=0) = ', n1.dot(r1))

成果圖示：
程式碼內容

1.如何建立單範正交基底

1.如何建立單範正交基底
(1).方法：葛蘭-史密特正交程序
gram Schmidt process
功能：可以把非正交非單範的基底，製造出『單範正交基底向量』

(2).方法：QR分解法
要先進行葛蘭-史密特正交程序運算，得出q1,q2,q3
可以把矩陣分解成QR
Q的行空間，就是單範正交基底向量

範2.sympy的指令

2.sympy的指令
（1）使用G葛蘭-史密特法：Gram-Schmidt orthogonalization
指令：GramSchmidt(M)
指令：GramSchmidt(M, True)

（2）QR分解法
指令：Q, R = A.QRdecomposition()

（3）建議使用：QR分解法
優點1：matrix格式不用改變
優點2：直接說正則基底，不用再正規化
優點3：程式碼簡短

範例15-1：使用葛蘭-史密特正交程序，把矩陣向量，製造出單範正交基底

3.範例15-1：使用葛蘭-史密特正交程序，把矩陣向量，製造出單範正交基底
#指令：GramSchmidt(M)
#缺點1：GramSchmidt(M)是正交基底，長度不為1，還需要再正規化，轉成正則基底
#改善：GramSchmidt(M, True)則會正規化，變成正則基底（長度=1）
#缺點2：matrix輸入的格式與一般格式不同
from sympy import *
#錯誤的矩陣格式
M = Matrix([
[1,0,0],
[1,1,0],
[1,1,1]
])
#注意：GramSchmidt(M)方法的矩陣，必須以行向量的方式輸入，外圍用[]list串列包圍
M = [Matrix([1,1,1]), Matrix([0,1,1]), Matrix([0,0,1])]
#若要建立正交基底（沒有正規化）：M_GS = GramSchmidt(M, False)= GramSchmidt(M)
#若要建立正則基底（有正規化）：M_GS = GramSchmidt(M, True)
M_GS = GramSchmidt(M, True)
q1,q2,q3 = GramSchmidt(M, True)
print('1.把M矩陣製造出正則基底=\n', M_GS)
print('q1正則基底 = ', q1)
print('q2正則基底 = ', q2)
print('q3正則基底 = ', q3)

成果圖示：
程式碼內容

範例15-2：使用QR分解法，把矩陣向量，製造出單範正交基底

4.範例15-2：使用QR分解法，把矩陣向量，製造出單範正交基底
#指令：GramSchmidt(M)
#優點：Q就是正則基底，長度為1，不需要再正規化了
from sympy import *
M = Matrix([
[1,0,0],
[1,1,0],
[1,1,1]
])
Q,R = M.QRdecomposition()
print("用QR分解法，求出正則基底=\n", Q)
q1 = Q.col(0)
q2 = Q.col(1)
q3 = Q.col(2)
print('q1 = ', q1)
print('q2 = ', q2)
print('q3 = ', q3)

成果圖示：
程式碼內容