1. 벡터와 행렬

In [2]:

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits import mplot3d

1. 기본 개념¶

1) 벡터¶

In [134]:

# (1) 수를 나열한것을 벡터라고 부른다.

x_2 = np.array([2,5]) # 2차원 벡터
x_3 = np.array([6,3,3]) #3차원 벡터
x_4 = np.array([2.9,0.3,1/7,4,42]) #5차원 벡터

In [17]:

# (2) 벡터의 공간은 자유롭게 활용 가능하다.
print(x_2)
print(x_2.T)

[2 5]
[2 5]

In [133]:

# (3) 벡터끼리는 덧셈과 뺄셈 그리고 정수배가 가능하다.

x_3_2 = np.array([2,5,6])

print(x_3)
print(x_3 + x_3_2)
print(x_3 - x_3_2)
print(3 * x_3)

[12  9 12]
[14 14 18]
[10  4  6]
[36 27 36]

In [116]:

## -  3차원 벡터공간

fig = plt.figure(figsize=(5,5))
ax = plt.axes(projection='3d')

x_line = np.linspace(0,x_3[0],1000)
y_line = np.linspace(0,x_3[1],1000)
z_line = np.linspace(0,x_3[2],1000)

fig = ax.plot3D(x_line,y_line,z_line)
fig = ax.scatter3D(x_3[0],x_3[1],x_3[2],marker=(3,0,50))
fig = ax.scatter3D(x_3[0]+0.1, x_3[1]+0.1, x_3[2]+0.1, marker = "o")

fig = ax.set_xlim(0,10)
fig = ax.set_ylim(0,5)
fig = ax.set_zlim(0,5)
fig = ax.set_cursor_props

fig = plt.legend(["Vector [6 3 3]"])

plt.show()

In [152]:

# (4) 만약 표준좌표계로 나타낸다면, 이는 다음과같이 표현이 가능하다.

x_e1 = np.array([1,0,0])
x_e2 = np.array([0,1,0])
x_e3 = np.array([0,0,1])

e_standard = np.matrix([x_e1,x_e2,x_e3])

print("=======표준 기저 행렬=======")
print(e_standard) # 표준 기저를 정의하는 기저행렬
print("======== 좌 표 =======")
print(x_3)
x_3 = np.dot(e_standard,x_3)# 표준 기저에서의 벡터[6,3,3]의 좌표
print("========기저 행렬과 벡터(좌표)의 내적=======")
print(x_3)
x_3 = np.array(x_3)[0]

print("=========벡터 공간=========")

fig = plt.figure(figsize=(5,5))
ax = plt.axes(projection='3d')

x_line = np.linspace(0,x_3[0],1000)
y_line = np.linspace(0,x_3[1],1000)
z_line = np.linspace(0,x_3[2],1000)

fig = ax.plot3D(x_line,y_line,z_line)
fig = ax.scatter3D(x_3[0],x_3[1],x_3[2],marker=(3,0,50))
fig = ax.scatter3D(x_3[0]+0.1, x_3[1]+0.1, x_3[2]+0.1, marker = "o")

fig = ax.set_xlim(0,10)
fig = ax.set_ylim(0,5)
fig = ax.set_zlim(0,5)
fig = ax.set_cursor_props

fig = plt.legend(["Vector on standard basis"])

plt.show()

=======표준 기저 행렬=======
[[1 0 0]
 [0 1 0]
 [0 0 1]]
======== 좌 표 =======
[6 3 3]
========기저 행렬과 벡터(좌표)의 내적=======
[[6 3 3]]
=========벡터 공간=========

In [153]:

## - 같은 좌표라도, 기저가 다르면 다른 위치로 변환된다.
## - 즉, 행렬의 내적은 기저의 전환이다.

# (4) 만약 표준좌표계로 나타낸다면, 이는 다음과같이 표현이 가능하다.

x_e1 = np.array([1,0,0])
x_e2 = np.array([0,2,0])
x_e3 = np.array([0,0,2])

e_nonstd = np.matrix([x_e1,x_e2,x_e3])

print("=======기저 행렬=======")
print(e_nonstd) # 표준 기저를 정의하는 기저행렬
print("======== 좌 표 =======")
print(x_3)
x_3_nonstd = np.dot(e_nonstd,x_3)# 표준 기저에서의 벡터[6,3,3]의 좌표
print("========기저 행렬과 벡터(좌표)의 내적=======")
print(x_3_nonstd)
x_3_nonstd = np.array(x_3_nonstd)[0]

print("=========벡터 공간=========")

fig = plt.figure(figsize=(5,5))
ax = plt.axes(projection='3d')

x_line = np.linspace(0,x_3_nonstd[0],1000)
y_line = np.linspace(0,x_3_nonstd[1],1000)
z_line = np.linspace(0,x_3_nonstd[2],1000)

fig = ax.plot3D(x_line,y_line,z_line)
fig = ax.scatter3D(x_3_nonstd[0],x_3_nonstd[1],x_3_nonstd[2],marker=(3,0,50),label = "Vector on non-standard basis")
fig = ax.scatter3D(x_3_nonstd[0], x_3_nonstd[1], x_3_nonstd[2], marker = "o")

fig = plt.legend()

x_line_2 = np.linspace(0,x_3[0],1000)
y_line_2 = np.linspace(0,x_3[1],1000)
z_line_2 = np.linspace(0,x_3[2],1000)

fig = ax.plot3D(x_line_2,y_line_2,z_line_2)
fig = ax.scatter3D(x_3[0],x_3[1],x_3[2],marker=(3,0,50))
fig = ax.scatter3D(x_3[0], x_3[1], x_3[2], marker = "o",label = "Vector on standard basis")

fig = plt.legend()

fig = ax.set_xlim(0,10)
fig = ax.set_ylim(0,10)
fig = ax.set_zlim(0,10)

plt.show()

=======기저 행렬=======
[[1 0 0]
 [0 2 0]
 [0 0 2]]
======== 좌 표 =======
[6 3 3]
========기저 행렬과 벡터(좌표)의 내적=======
[[6 6 6]]
=========벡터 공간=========

In [149]:

# (5) 위치벡터를 활용하면, 벡터끼리의 덧셈은 이렇게 개념화가 가능하다.

fig = plt.figure(figsize=(5,5))
ax = plt.axes(projection='3d')

x_line = np.linspace(0,x_3[0],1000)
y_line = np.linspace(0,x_3[1],1000)
z_line = np.linspace(0,x_3[2],1000)

x_line_2 = np.linspace(x_3[0],x_3_2[0],1000)
y_line_2 = np.linspace(x_3[1],x_3_2[1],1000)
z_line_2 = np.linspace(x_3[2],x_3_2[2],1000)

fig = ax.plot3D(x_line,y_line,z_line)
fig = ax.scatter3D(x_3[0],x_3[1],x_3[2],marker=(3,0,50),label="vector [6 3 3]")
fig = ax.scatter3D(x_3[0], x_3[1], x_3[2], marker = "o")

fig = ax.plot3D(x_line_2,y_line_2,z_line_2,c="r")
fig = ax.scatter3D(x_3_2[0],x_3_2[1],x_3_2[2],marker=(3,0,40),c="r",label="vector[2 5 6]")
fig = ax.scatter3D(x_3_2[0], x_3_2[1], x_3_2[2],marker = "o")


fig = ax.set_xlim(0,10)
fig = ax.set_ylim(0,10)
fig = ax.set_zlim(0,10)
fig = ax.set_cursor_props

fig = plt.legend()

plt.show()

In [163]:

np.square(7,np.array([))

Out[163]:

array([49])

2) 행렬¶

In [29]:

#(1) 수를 사각형 형태로 나타낸것을 행렬이라고 한다.
# 모양을 지칭할때, 행 -> 열 순서로 mXn 행렬이라고 표현한다.

mat_2_2 = np.matrix([[2,0],[0,3]]) # 
mat_2_3 = np.matrix([[2.2,-9,1/7],[7**(1/2),np.pi,42]])

print(mat_2_2)
print(mat_2_3)

[[2 0]
 [0 3]]
[[ 2.2        -9.          0.14285714]
 [ 2.64575131  3.14159265 42.        ]]

In [37]:

#(2) 행렬과 벡터는 행렬곱셈이 가능하다.

x_3 = np.array(["a","b"])
print("=====2차원 벡터=======")
print(x_3)
print("======2차원 벡터과 2X2 행렬의 곱셈=====")
print(np.matrix([["a*2 + b*0"],["a*0 + b*3"]]))
print("======2차원 벡터과 2X3 행렬의 곱셈======")
try:
    print(np.dot(mat_2_3,x_3))
except: print("ValueError : 이런 곱셈은 가능하지 않다. 열이 3개인데, 벡터는 2차원이기 때문이다.")

=====2차원 벡터=======
['a' 'b']
======2차원 벡터과 2X2 행렬의 곱셈=====
[['a*2 + b*0']
 ['a*0 + b*3']]
======2차원 벡터과 2X3 행렬의 곱셈======
ValueError : 이런 곱셈은 가능하지 않다. 열이 3개인데, 벡터는 2차원이기 때문이다.

In [32]:

#(3) 행렬과 행렬도 행렬곱셈이 가능하다
# - 이때의 의미는, A dot B일때 A연산을 수행하고 뒤이어 B연산을 수행한다는 의미이다.

print("===== 2X2 행렬======")
mat_2_2 = np.matrix([["a","b"],["c","d"]])
print(mat_2_2)
print("===== 2X3 행렬 =====")
mat_2_3 = np.matrix([["e","f","g"],["h","i","j"]])
print(mat_2_3)
print("===== 두 행렬의 곱셈====")
print(np.matrix([["a*e + b*h","a*f + b*i","a*g + b*j"],["c*e + d*h","c*f + d*i","c*g + d*j"]]))

===== 2X2 행렬======
[['a' 'b']
 ['c' 'd']]
===== 2X3 행렬 =====
[['e' 'f' 'g']
 ['h' 'i' 'j']]
===== 두 행렬의 곱셈====
[['a*e + b*h' 'a*f + b*i' 'a*g + b*j']
 ['c*e + d*h' 'c*f + d*i' 'c*g + d*j']]

In [73]:

# (4) 행렬 연산의 성질

## - 행렬,벡터 곱샘에서는 교환법칙이 성립한다.(단, 행렬,행렬 곱셈에서는 교환법칙이 성립하지 않는다.)
A = np.matrix([[2,9],[4,7]])
x = np.array([3,1])

print("=====2X2행렬======")
print(A)
print("=====2차원벡터====")
print(x)

print("=====c(A*x)")
a = 3 * np.dot(A,x)
print(a)

print("=====(cA)*x====")
a = 3 * A
print(np.dot(a,x))

print("===== A*(cx) ====")
a = 3 * x
print(np.dot(A,a))

=====2X2행렬======
[[2 9]
 [4 7]]
=====2차원벡터====
[3 1]
=====c(A*x)
[[45 57]]
=====(cA)*x====
[[45 57]]
===== A*(cx) ====
[[45 57]]

In [76]:

## - 행렬곱셈은 일반적으로 결합,분배 법칙이 성립한다.
B = np.matrix([[3,1],[4,3]])
C = np.matrix([[4,5],[3,3]])

print("=====(A + B) * x====")
print(np.dot(A+B,x))

print("=====A*x + B*x =====")
a = np.dot(A,x)
b = np.dot(B,x)
print(a + b)

=====(A + B) * x====
[[25 34]]
=====A*x + B*x =====
[[25 34]]

In [84]:

print("=====C * ( A + B )======")
print(np.dot(C,A+B))

print("=====C*A + C*B=======")
a = np.dot(C,A)
b = np.dot(C,B)
print(a + b)

=====C * ( A + B )======
[[60 90]
 [39 60]]
=====C*A + C*B=======
[[60 90]
 [39 60]]

In [82]:

print("=====(A + B) * C====")
print(np.dot(A+B,C))

print("==== A*C + B*C=====")
a = np.dot(A,C)
b = np.dot(B,C)
print(a + b)

=====(A + B) * C====
[[50 55]
 [62 70]]
==== A*C + B*C=====
[[50 55]
 [62 70]]

In [83]:

print("=====c(A*B)=======")
print(3 * np.dot(A,B))

print("=====A*(cB)=======")
print(np.dot(A,3*B))

print("=====(cA)*B=======")
print(np.dot(3*A,B))

=====c(A*B)=======
[[126  87]
 [120  75]]
=====A*(cB)=======
[[126  87]
 [120  75]]
=====(cA)*B=======
[[126  87]
 [120  75]]

In [86]:

# - 주의할점. 행렬은 일반적으로 교환법칙이 성립하지 않는다.

print("===== A * B ======")
print(np.dot(A,B))

print("===== B * A ======")
print(np.dot(B,A))

# 이는, 기본적으로 행렬간의 곱셈은 연산의 결합이기 때문에, 연산의 순서에 결괏값이 의존하기 때문이다.

===== A * B ======
[[42 29]
 [40 25]]
===== B * A ======
[[10 34]
 [20 57]]