np.eye(10)*10
# 10階方陣，當對角線值為1時為對角矩陣
np.eye(5)

array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

a = np.arange(10)
print(a)
print(a.shape)
# 行向量
a = np.arange(10).reshape(10,1)
print(a)
print(a.shape)
# 列向量
 

[0 1 2 3 4 5 6 7 8 9]
(10,)

[[0]
 [1]
 [2]
 [3]
 [4]
 [5]
 [6]
 [7]
 [8]
 [9]]
(10, 1)

ar1 = np.arange(12).reshape(3,4)
ar2 = np.arange(10,22).reshape(3,4)
ar3 = np.ones((3,4))
ar4 = np.ones((3,5))
矩陣加法
print(ar1+ar2)
print(ar1+ar2+ar3)
#print(ar1+ar4)
# shape需要相同
# 數與矩陣相乘
ar1 * 10

# 陣列與矩陣相乘

print(ar1*ar2) 
#print(ar1*ar4)
print('------')
# 陣列相乘 → numpy裡面兩個shape相同的陣列可以直接相乘，對應位置的值的乘積為結果
# 如果shape不同，則報錯

a1 = np.array([2,3,4])
b1 = np.array([5,6,7]).reshape(3,1)  # 轉換為列向量
c1 = np.dot(a1,b1)
print(a1.shape,b1.shape,c1.shape)
print(c1,type(c1))

a2 = np.array([
        [1,2,3],
        [2,3,4]
    ])
b2 = np.array([
        [4,4],
        [5,5],
        [6,6]
    ])
c2 = np.dot(a2,b2)
print(a2.shape,b2.shape,c2.shape)
print(c2)
# 矩陣乘法，需要保證第一個矩陣的列數（column）和第二個矩陣的行數（row）相同
# 設 A = (aij) 是一個m×s 矩陣, B = (bij)是一個s×n矩陣，那麼規定矩陣A與矩陣B的乘積是一個m×n的矩陣
# 矩陣相乘結果仍為矩陣
# numpy中用.dop()來計算矩陣乘法
 

# 矩陣乘法：A*B 與 B*A

a3 = np.array([
        [-2,4],
        [1,-2]
    ])
b3 = np.array([
        [2,4],
        [-3,-6]
    ])
print(np.dot(a3,b3))
print(np.dot(b3,a3))

# 矩陣的轉置

A = np.array([
        [2,0,-1],
        [1,3,2]
    ])
B = np.array([
        [1,7,-1],
        [4,2,3],
        [2,0,1]
    ])
np.dot(A,B).T
 

逆矩陣

• 設A是數域上的一個n階矩陣，若在相同數域上存在另一個n階矩陣B，使得： AB=BA=E ，則我們稱B是A的逆矩陣，而A則被稱為可逆矩陣。注：E為單位矩陣 → 單位矩陣值為1
• 唯一性：若矩陣A是可逆的，則A的逆矩陣是唯一的
• A的逆矩陣的逆矩陣還是A。記作（A-1）-1=A
• 可逆矩陣A的轉置矩陣AT也可逆，並且（AT）-1=（A-1）T (轉置的逆等於逆的轉置）
• 兩個可逆矩陣的乘積依然可逆

• # 建立A矩陣
  
  A = np.array([
          [1,2,3],
          [2,2,1],
          [3,4,3]
      ])
  print(A)
  print(np.linalg.det(A))
  # numpy求逆矩陣B → np.linalg.inv()
  
  B = np.linalg.inv(A)
  print(B)
  print(np.linalg.det(B))
  # A*B = E，單位矩陣
  
  E = np.dot(A,B)
  print(E)
  print(np.linalg.det(E))
  #np.eye(3)
  
  # 伴隨矩陣
  
  A_bs = B*np.linalg.det(A)
  print(A_bs)
  print(np.linalg.det(A_bs))