LAch7

Size: px

Start display at page:

Download "LAch7"

译臣戴
5 years ago
Views:

1 Maxima 在線性代數上之應用正準形式國立屏東教育大學應用數學系研究助理徐偉玲日期 :2009/9/8 除另有說明外, 本文件採用創用 CC 姓名標示非商業性 2.5 台灣條款

2 第七章正準形式 7.1 Jordan 正準形式 Ⅰ 2. 對每一個矩陣 A, 對 L A 的每一個廣義特徵空間找一組由不相交的廣義特徵向量循環集之聯集所組成之基底, 再求 A 的一 Jordan 正準形式 J 1 (a) (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan canonical form // 讀取 diag 模組 (%i2) A:matrix([1,1],[-1,3]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 1, 1, 第二列元素有 -1, 3 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出 1 (b)a= (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為

3 什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan (%i2) A:matrix([1,2],[3,2])$ // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 1, 2, 第二列元素有 3, 2 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出 11 (a) A= (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan (%i2) A:matrix([11,-4,-5],[21,-8,-11],[3,-1,0])$ // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 11, -4, -5, 第二列元素有 21, -8, -11, 第三列元素有 3, -1, 0

4 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出 2 0 (b) A= (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan (%i2) A:matrix([2,1,0,0],[0,2,1,0],[0,0,3,0],[0,1,-1,3])$ // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 2, 1, 0, 0, 第二列元素有 0, 2, 1, 0, 第三列元素有 0, 0, 3, 0, 第四列元素有 0, 1, -1, 3 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出

5 3. 對每一個線性算子 T, 對 T 的每一個廣義特徵空間找一組由不相交之廣義特徵向量循環集之聯集所組成的基底, 再求 T 的一 Jordan 正準形式 (a) T 為 P 2 (R) 上的線性算子定義為 T ( f ( x)) = 2 f ( x) f ( x) (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan (%i2) A:matrix([2,-1,0],[0,2,-2],[0,0,2])$ // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 2, -1, 0, 第二列元素有 0, 2, -2, 第三列元素有 0, 0, 2 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出所生成的函數實向量空間, 且 T 為 V 上的線性算子定義為 T ( f ) = f (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可 2 (b) V 為由實值函數 { 1, t, t, e t, te t } 以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan

6 (%i2) A:matrix([0,0,0,0,0],[1,0,0,0,0],[0,2,0,0,0],[0,0,0,1,0],[0,1,0,0,1])$ // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 0, 0, 0, 0, 0, 第二列元素有 1,,0,,0,,0,,0, 第三列元素有 0, 2, 0, 0, 0, 第四列元素有 0, 0, 0, 1, 0, 第五列元素有 0, 1, 0, 0, 1 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出 1 1 (c) T 為 M 2 2 (R) 上的線性算子定義為 T(A)= A, A M 2 2 (R) 0 1 (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan (%i2) B:matrix([1,1],[0,1]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 1, 1, 第二列元素有 0, 1

7 1 0 (%i3) B.matrix([1,0],[0,0]); // 計算矩陣 B 乘上矩陣 (%i4) B.matrix([0,0],[1,0]); // 計算矩陣 B 乘上矩陣 (%i5) B.matrix([0,1],[0,0]); // 計算矩陣 B 乘上矩陣 (%i6) B.matrix([0,0],[0,1]); // 計算矩陣 B 乘上矩陣 = 0 1 (%i7) A:matrix([1,0,0,0],[1,1,0,0],[0,0,1,0],[0,0,1,1])$ // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 1, 0, 0, 0, 第二列元素有 1, 1, 0, 0, 第三列元素有 0, 0, 1, 0, 第四列元素有 0, 0, 1, 1 Jordan form 指令 :jordan( 矩陣 ), 但 jordan 指令只會把算出的數字在 Maxima 上分類列舉出來 // 求矩陣 A 的正準形式 (%i8) jordan(a); Jordan form 指令 :jordan( 矩陣 ), 但 jordan 指令只會把算出的數字在 Maxima 上分類列舉出來 // 求矩陣 A 的正準形式 (%i9) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出

8 t (c) T(A)= 2 A + A, M 2 R) A 2 ( (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan (%i2) A:matrix([3,0,0,0],[0,2,1,0],[0,1,2,0],[0,0,0,3])$ // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 3, 0, 0, 0, 第二列元素有 0, 2, 1, 0, 第三列元素有 0, 1, 2, 0, 第四列元素有 0, 0, 0, 3 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出 7.2 Jordan 正準形式 Ⅱ

9 3. 設 T 為有限維度向量空間 V 上的一線性算子, 使 T 的 Jordan 正準形式為 (a) 求 T 的特徵多項式 (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan (%i2) T:matrix([2,1,0,0,0,0,0],[0,2,1,0,0,0,0],[0,0,2,0,0,0,0],[0,0,0,2,1,0,0],[0,0,0,0,2,0,0],[0, 0,0,0,0,3,0],[0,0,0,0,0,0,3]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 2, 1, 0, 0, 0, 0, 0, 第二列元素有 0, 2, 1, 0, 0, 0, 0, 第三列元素有 0, 0, 2, 0, 0, 0, 0, 第四列元素有 0, 0, 0, 2, 1, 0, 0, 第五列元素有 0, 0, 0, 0, 2, 0, 0, 第六列元素有 0, 0, 0, 0, 0, 3, 0, 第七列元素有 0, 0, 0, 0, 0, 0, 3

10 (%i3) f:charpoly(t,t); 特徵多項式指令 :charpoly( 矩陣, 變數 ) // 求矩陣 T 的特徵多項式, 名稱訂為 f (b) 求對應 T 每一特徵值的點圖 (c) 使 E λ = K λ 的特徵值 λ i 為何? i i (d) 對每一特徵值 λ i, 求最小正整數 p 使 K = N(( T λ )) i λ i i I p i (e) 令 U i 表示 T λi I 在 K λ 上的限制變換, i, 試求下列 : i ( Ⅰ) rank( U ) i ( Ⅱ) rank( U ) 2 i ( Ⅲ) nullity( U ) i ( Ⅳ) nullity( U ) 2 i 4. 對下列各矩陣 A, 求 Jordan 正準形式 J 及可逆矩陣 Q, 使 J=Q 1 AQ, 注意 (a), (b) 及 (c) 的矩陣即例 5 中使用的矩陣 3 (a) A= (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan

11 (%i2) A:matrix([-3,3,-2],[-7,6,-3],[1,-1,2]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 -3, 3, -2, 第二列元素有 -7, 6, -3, 第三列元素有 1, -1, 2 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出 0 (b) A= (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan (%i2) A:matrix([0,1,-1],[-4,4,-2],[-2,1,1]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 0, 1, -1, 第二列元素有 -4, 4, -2, 第三列元素有 -2, 1, 1

12 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出 0 (c) A= (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan (%i2) A:matrix([0,-1,-1],[-3,-1,-2],[7,5,6]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 0, -1, -1, 第二列元素有 -3, -1, -2, 第三列元素有 7, 5, 6 (%i3) jordan(a); Jordan form 指令 :jordan( 矩陣 ), 但 jordan 指令只會把算出的數字在 Maxima 上分類列舉出來 // 求矩陣 A 的正準形式

13 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出 0 2 (d) A= (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan (%i2) A:matrix([0,-3,1,2],[-2,1,-1,2],[-2,1,-1,2],[-2,-3,1,4]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 0, -3, 1, 2, 第二列元素有 -2, 1, -1, 2, 第三列元素有 -2, 1, -1, 2, 第四列元素有 -2, -3, 1, 4

14 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出 5. 對下列各線性算子 T, 求 T 的 Jordan 的正準形式及 T 的一組 Jordan 正準基底 β t t 2 t 2t (a) V 為由實值函數集 { e, te, t e, e } 所生成的函數之實向量空間, 且 T 為 V 上的線性算子定義為 T ( f ) = f (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan (%i2) A:matrix([1,1,0,0],[0,1,2,0],[0,0,1,0],[0,0,0,2]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 1, 1, 0, 0, 第二列元素有 0, 1, 2, 0, 第三列元素有 0, 0, 1, 0, 第四列元素有 0, 0, 0, 2

15 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出 (b) T 為 P 3 (R) 上的線性算子定義為 T ( f ( x)) = xf ( x) (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan (%i2) A:matrix([0,0,0,0],[0,0,0,0],[0,2,0,0],[0,0,6,0]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 0, 0, 0, 0, 第二列元素有 0, 0, 0, 0, 第三列元素有 0, 2, 0, 0, 第四列元素有 0, 0, 6, 0

16 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出 (c) T 為 P 3 (R) 上的線性算子定義為 T ( f ( x)) = f ( x) + 2 f ( x) (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan (%i2) A:matrix([2,0,0,0],[0,2,0,0],[2,0,2,0],[0,6,0,2]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 2, 0, 0, 0, 第二列元素有 0, 2, 0, 0, 第三列元素有 2, 0, 2, 0, 第四列元素有 0, 6, 0, 2

17 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出 3 1 t (d) T 為 M 2 2 (R) 上的線性算子定義為 T(A)= A A 0 3 (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan canonical form // 讀取 diag 模組 (%i2) A:matrix([2,0,0,0],[0,3,-1,0],[1,-1,3,0],[0,1,0,2]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 2, 0, 0, 0, 第二列元素有 0, 3, -1, 0, 第三列元素有 1, -1, 3, 0, 第四列元素有 0, 1, 0, 2

18 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出 3 1 t (d) T 為 M 2 2 (R) 上的線性算子定義為 T(A)= ( A A ) 0 3 (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 disjordan 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算正準形式 // 我們要算一矩陣的 jordan 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan (%i2) A:matrix([0,0,0,0],[-1,3,-3,0],[1,-3,3,0],[0,0,0,0]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 0, 0, 0, 0, 第二列元素有 -1, 3, -3, 0, 第三列元素有 1, -3, 3, 0, 第四列元素有 0, 0, 0, 0 (%i3) jordan(a); Jordan form 指令 :jordan( 矩陣 ), 但 jordan 指令只會把算出的數字在 Maxima 上分類列舉出來 // 求矩陣 A 的正準形式

19 (%i4) dispjordan(%); disjordan 指令是將上列所算出 jodan form 以矩陣形式表現出來,% 是引用前面計算出來的結果 //A 的正準形式矩陣的輸出 (e) V 為項數至多為 2 的兩變數 x 及 y 之多項式函數所成的向量空間, 如例 4 所 δ δ 定義, 且 T 為 V 上的線性算子定義為 T ( f ( x, y)) = f ( x, y) + f ( x, y) δx δy 24. 利用 23 求下列各微分方程組的通解, 其中 x,y, 及 z 是實變數 t 的實值可微分函數 (a) x = 2x + y y = 2y z z = 3z x = 2x + y (b) y = 2y + z z = 2z 7.3 最小多項式 2. 求下列各矩陣的最小多項式 (a) (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 minimal polynomial 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的

20 jordanc minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令和 minimalpoly 指令去計算正準形式跟最小多項式 // 我們要算一矩陣的 jordan 和 minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan canonical form 和 minimalpoly 指令去算最小多項式 (%i2) A:matrix([2,1],[1,2]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 2, 1, 第二列元素有 1, 2 (%i4) minimalpoly(%); 最小多項式指令 :minimalpoly( 矩陣 ) // 求矩陣 A 的最小多項式,% 是表示引用前面所計算出來的結果 1 (b) (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 minimal polynomial 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordanc minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令和 minimalpoly 指令去計算正準形式跟最小多項式 // 我們要算一矩陣的 jordan 和 minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan canonical form 和 minimalpoly 指令去算最小多項式 (%i2) A:matrix([1,1],[0,1]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 1, 1, 第二列元素有 0, 1

21 (%i4) minimalpoly(%); 最小多項式指令 :minimalpoly( 矩陣 ) // 求矩陣 A 的最小多項式,% 是表示引用前面所計算出來的結果 4 (c) (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 minimal polynomial 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordanc minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令和 minimalpoly 指令去計算正準形式跟最小多項式 // 我們要算一矩陣的 jordan 和 minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan canonical form 和 minimalpoly 指令去算最小多項式 (%i2) A:matrix([4,-14,5],[1,-4,2],[1,-6,4]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 4, -14, 5, 第二列元素有 1, -4, 2, 第三列元素有 1, -6, 4

22 (%i4) minimalpoly(%); 最小多項式指令 :minimalpoly( 矩陣 ) // 求矩陣 A 的最小多項式,% 是表示引用前面所計算出來的結果 3 (d) (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 minimal polynomial 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordanc minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令和 minimalpoly 指令去計算正準形式跟最小多項式 // 我們要算一矩陣的 jordan 和 minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan canonical form 和 minimalpoly 指令去算最小多項式 (%i2) A:matrix([3,0,1],[2,2,2],[-1,0,1]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 3, 0, 1, 第二列元素有 2, 2, 2, 第三列元素有 -1, 0, 1 (%i4) minimalpoly(%); 最小多項式指令 :minimalpoly( 矩陣 ) // 求矩陣 A 的最小多項式,% 是表示引用前面所計算出來的結果 3. 對下列 V 上的各線性算子 T, 求 T 的最小多項式 (a) V=R 3, 且 T(a, b)=(a+b, a-b)

23 (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 minimal polynomial 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordanc minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令和 minimalpoly 指令去計算正準形式跟最小多項式 // 我們要算一矩陣的 jordan 和 minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan canonical form 和 minimalpoly 指令去算最小多項式 (%i2) A:matrix([1,1],[1,-1]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 1, 1, 第二列元素有 1, -1 (%i4) minimalpoly(%); 最小多項式指令 :minimalpoly( 矩陣 ) // 求矩陣 A 的最小多項式,% 是表示引用前面所計算出來的結果 (b) V=P 2 (R), 且 T ( g( x)) = g ( x) + 2g( x) (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 minimal polynomial 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordanc minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令和 minimalpoly 指令去計算正準形式跟最小多項式 // 我們要算一矩陣的 jordan 和 minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan canonical form 和 minimalpoly 指令去算最小多項式

24 (%i2) A:matrix([2,1,0],[0,2,2],[0,0,2]); 素有 2, 1, 0, 第二列元素有 0, 2, 2, 第三列元素有 0, 0, 2 // 定義一矩陣, 矩陣名稱叫作 A, 第一列元 (%i3) jordan(a); Jordan form 指令 :jordan( 矩陣 ), 但 jordan 指令只會把算出的數字在 Maxima 上分類列舉出來 // 求矩陣 A 的正準形式 (%i4) minimalpoly(%); 最小多項式指令 :minimalpoly( 矩陣 ) // 求矩陣 A 的最小多項式,% 是表示引用前面所計算出來的結果 (c) V=P 2 (R), 且 T ( f ( x)) = xf ( x) + f ( x) + 2 f ( x) (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 minimal polynomial 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordanc minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令和 minimalpoly 指令去計算正準形式跟最小多項式 // 我們要算一矩陣的 jordan 和 minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan canonical form 和 minimalpoly 指令去算最小多項式 (%i2) A:matrix([2,1,0],[0,2,0],[0,0,2]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 2, 1, 0, 第二列元素有 0, 2, 0, 第三列元素有 0, 0, 2

25 (%i4) minimalpoly(%); 最小多項式指令 :minimalpoly( 矩陣 ) // 求矩陣 A 的最小多項式,% 是表示引用前面所計算出來的結果 (d) V=M n n (R), 且 T(A)=A t, 提示 : 注意 T 2 =I 7.4 有理正準形式 2. 對下面的每一個矩陣 A M n n (F), 求矩陣 A 的有理正準形式 C 及矩陣, 1 Q M n n (F), 使 Q AQ = C 3 (a) A= ,F=R 3 (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 minimal polynomial 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordanc minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令和 minimalpoly 指令去計算正準形式跟最小多項式 // 我們要算一矩陣的 jordan 和 minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan canonical form 和 minimalpoly 指令去算最小多項式

26 (%i2) A:matrix([3,1,0],[0,3,1],[0,0,3]); 素有 3, 1, 0, 第二列元素有 0, 3, 1, 第三列元素有 0, 0, 3 // 定義一矩陣, 矩陣名稱叫作 A, 第一列元 (%i4) f:minimalpoly(%); 最小多項式指令 :minimalpoly( 矩陣 ) // 求矩陣 A 的最小多項式,% 是表示引用前面所計算出來的結果 (%i5) expand(f); 多項式展開指令 :expand( 多項式名稱 ) // 將最小多項式 f 展開 (%i6) C:matrix([0,0,27],[1,0,-27],[0,1,9]); //// 定義一矩陣, 矩陣名稱叫作 C, 第一列元素有 0, 0, 27, 第二列元素有 1, 0, -27, 第三列元素有 0, 1, 9 0 (b) A= 1 1,F=R 1 0 (c) A= 1 1,F=C 1 (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 minimal polynomial 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些

27 指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordanc minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令和 minimalpoly 指令去計算正準形式跟最小多項式 // 我們要算一矩陣的 jordan 和 minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan canonical form 和 minimalpoly 指令去算最小多項式 (%i2) A:matrix([0,-1],[1,-1]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 0, -1, 第二列元素有 1, -1 (%i4) f:minimalpoly(%); 最小多項式指令 :minimalpoly( 矩陣 ) // 求矩陣 A 的最小多項式,% 是表示引用前面所計算出來的結果 (%i5) expand(f); 多項式展開指令 :expand( 多項式名稱 ) // 將最小多項式 f 展開 (%i6) C:matrix([-(sqrt(3)*%i-1)/2,0],[0,(sqrt(3)*%i+1)/2]); // 定義一矩陣, 矩陣名 1 3i 稱叫作 C, 第一列元素有 2, 0, 第二列元素有 0, 3 i +1 2

28 0 1 (d) A= ,F=R 4 5 (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 minimal polynomial 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordanc minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令和 minimalpoly 指令去計算正準形式跟最小多項式 // 我們要算一矩陣的 jordan 和 minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan canonical form 和 minimalpoly 指令去算最小多項式 (%i2) A:matrix([0,-7,14,-6],[1,-4,6,-3],[0,-4,9,-4],[0,-4,11,-5]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 0, -7, 14, -6, 第二列元素有 1, -4, 6, -3, 第三列元素有 0, -4, 9, -4, 第四列元素有 0, -4, 11, -5 (%i3) jordan(a); Jordan form 指令 :jordan( 矩陣 ), 但 jordan 指令只會把算出的數字在 Maxima 上分類列舉出來 // 求矩陣 A 的正準形式 (%i4) f:minimalpoly(%); 最小多項式指令 :minimalpoly( 矩陣 ) // 求矩陣 A 的最小多項式,% 是表示引用前面所計算出來的結果 (%i5) expand(f); 多項式展開指令 :expand( 多項式名稱 ) // 將最小多項式 f 展開 (%i6) C:matrix([0,-1,0,0],[1,0,0,0],[0,0,0,-1],[0,0,1,0]); // 定義一矩陣, 矩陣名稱叫作 C, 第一列元素有 0, -1, 0, 0, 第二列元素有 1, 0, 0, 0, 第三列元素有 0, 0, 0, -1,

29 第四列元素有 0, 0, 1, (e)a= ,F=R 4 5 (%i1) load("diag")$ Maxima 本身是不會算 jordan 跟 minimal polynomial 的, 我們可以用適當的模組來做這件事, 所謂模組就是一段小程式, 通常是增加一些指令, 為什麼 Maxima 一開始就把這些模組都加進來? 那是因為一來太佔記憶體, 一來是很多對某些人很重要的指令也許你永遠也沒用到我們要算一矩陣的 jordanc minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令和 minimalpoly 指令去計算正準形式跟最小多項式 // 我們要算一矩陣的 jordan 和 minimalpoly 要使用 diag 這個模組, 此模組提供了 jordan 指令去計算 jordan canonical form 和 minimalpoly 指令去算最小多項式 (%i2) A:matrix([0,-4,12,-7],[1,-1,3,-3],[0,-1,6,-4],[0,-1,8,-5]); // 定義一矩陣, 矩陣名稱叫作 A, 第一列元素有 0, -4, 12, -7, 第二列元素有 1, -1, 3, -3, 第三列元素有 0, -1, 6, -4, 第四列元素有 0, -1, 8, -5 (%i4) f:minimalpoly(%); 最小多項式指令 :minimalpoly( 矩陣 ) // 求矩陣 A 的最小多項式,% 是表示引用前面所計算出來的結果

30 (%i5) expand(f); 多項式展開指令 :expand( 多項式名稱 ) // 將最小多項式 f 展開 (%i6) C:matrix([0,-2,0,0],[1,0,0,0],[0,0,0,-3],[0,0,1,0]); // 定義一矩陣, 矩陣名稱叫作 C, 第一列元素有 0, -2, 0, 0, 第二列元素有 1, 0, 0, 0, 第三列元素有 0, 0, 0,-3, 第四列元素有 0, 0, 1, 0 3. 對下面各線性算子 T, 求其基本約式, 有理正準形式 C, 及一組有理正準基底 β (a) T 為 P 3 (R) 上的線性算子定義為 T ( f ( x)) = f (0) x f (1) (b) 令 S={sinx,cosx,xsinx,xcosx} 為 F(R,R) 的一子集合, 且令 V=span(S), 定義 T 為 V 上的線性算子滿足 T ( f ) = f 0 1 (c) T 為 M 2 2 (R) 上的線性算子定義為 T (A) = A 1 1 (d) 令 S={sinxsiny,sinxcosy,cosxsiny,cosxcosy} 為 F(R R,R) 的一子集合, 且 f ( x, y) f ( x, y) 令 V=span(S), 定義 T 為 V 上的線性算子滿足 T ( f )( x, y) = + x y